#ifndef MC99P1_H
#define MC99P1_H

#include <mc32-common.h>

//
// Register addresses.
//
#define LCDR0_ADDR      	0x0100
#define LCDR1_ADDR      	0x0101
#define LCDR2_ADDR      	0x0102
#define LCDR3_ADDR      	0x0103
#define LCDR4_ADDR      	0x0104
#define LCDR5_ADDR      	0x0105
#define LCDR6_ADDR      	0x0106
#define LCDR7_ADDR      	0x0107
#define LCDR8_ADDR      	0x0108
#define LCDR9_ADDR      	0x0109
#define LCDR10_ADDR     	0x010A
#define LCDR11_ADDR     	0x010B
#define LCDR12_ADDR     	0x010C
#define LCDR13_ADDR     	0x010D
#define LCDR14_ADDR     	0x010E
#define LCDR15_ADDR     	0x010F
#define LCDR16_ADDR     	0x0110
#define LCDR17_ADDR     	0x0111
#define LCDR18_ADDR     	0x0112
#define INDF0_ADDR      	0x0180
#define INDF1_ADDR      	0x0181
#define INDF2_ADDR      	0x0182
#define HIBYTE_ADDR     	0x0183
#define FSR0_ADDR       	0x0184
#define FSR1_ADDR       	0x0185
#define PCL_ADDR        	0x0186
#define PFLAG_ADDR      	0x0187
#define MCR_ADDR        	0x0188
#define INDF3_ADDR      	0x0189
#define INTE0_ADDR      	0x018A
#define INTF0_ADDR      	0x018B
#define OSCMR_ADDR      	0x018C
#define LVDCR_ADDR      	0x018D
#define INTE1_ADDR      	0x018E
#define INTF1_ADDR      	0x018F
#define IOP0_ADDR       	0x0190
#define OEP0_ADDR       	0x0191
#define PUP0_ADDR       	0x0192
#define PDP0_ADDR       	0x0193
#define IOP1_ADDR       	0x0194
#define OEP1_ADDR       	0x0195
#define PUP1_ADDR       	0x0196
#define PDP1_ADDR       	0x0197
#define IOP2_ADDR       	0x0198
#define OEP2_ADDR       	0x0199
#define PUP2_ADDR       	0x019A
#define PDP2_ADDR       	0x019B
#define IOP3_ADDR       	0x019C
#define OEP3_ADDR       	0x019D
#define PUP3_ADDR       	0x019E
#define PDP3_ADDR       	0x019F
#define T0CR_ADDR       	0x01A0
#define T0CNT_ADDR      	0x01A1
#define T0LOAD_ADDR     	0x01A2
#define T1CR_ADDR       	0x01A3
#define T1CNT_ADDR      	0x01A4
#define T1LOAD_ADDR     	0x01A5
#define T1DATA_ADDR     	0x01A6
#define PWM1CR_ADDR     	0x01A7
#define T2CR_ADDR       	0x01A8
#define T2CNT_ADDR      	0x01A9
#define T2LOAD_ADDR     	0x01AA
#define T2DATA_ADDR     	0x01AB
#define T2DATB_ADDR     	0x01AC
#define PWM2CR_ADDR     	0x01AD
#define T3CR_ADDR       	0x01B0
#define T3CNTH_ADDR     	0x01B1
#define T3CNTL_ADDR     	0x01B2
#define T3LOADH_ADDR    	0x01B3
#define T3LOADL_ADDR    	0x01B4
#define P2ADCR_ADDR     	0x01B6
#define P3ADCR_ADDR     	0x01B7
#define DKSCR_ADDR      	0x01B8
#define P0DKCR_ADDR     	0x01B9
#define P1DKCR_ADDR     	0x01BA
#define P2DKCR_ADDR     	0x01BB
#define P3DKCR_ADDR     	0x01BC
#define XTALCR_ADDR     	0x01BE
#define XTICCAL_ADDR    	0x01BF
#define LCDCR0_ADDR     	0x01C0
#define LCDCR1_ADDR     	0x01C1
#define P0LCDCR_ADDR    	0x01C2
#define P1LCDCR_ADDR    	0x01C3
#define P2LCDCR_ADDR    	0x01C4
#define HIRCCAL_ADDR    	0x01C6
#define LIRCCAL_ADDR    	0x01C7
#define IICCR0_ADDR     	0x01C8
#define IICCR1_ADDR     	0x01C9
#define IICCR2_ADDR     	0x01CA
#define IICDR_ADDR      	0x01CB
#define IICAR_ADDR      	0x01CC
#define IICAAR_ADDR     	0x01CD
#define IICAMR_ADDR     	0x01CE
#define URTCR0_ADDR     	0x01D0
#define URTCR1_ADDR     	0x01D1
#define URTCR2_ADDR     	0x01D2
#define URTSR_ADDR      	0x01D3
#define URTBR_ADDR      	0x01D4
#define URTDR_ADDR      	0x01D5
#define URTAR_ADDR      	0x01D6
#define URTMR_ADDR      	0x01D7

//----- Register Files -----------------------------------------------------

extern __sfr __at (LCDR0_ADDR)    	LCDR0;
extern __sfr __at (LCDR1_ADDR)    	LCDR1;
extern __sfr __at (LCDR2_ADDR)    	LCDR2;
extern __sfr __at (LCDR3_ADDR)    	LCDR3;
extern __sfr __at (LCDR4_ADDR)    	LCDR4;
extern __sfr __at (LCDR5_ADDR)    	LCDR5;
extern __sfr __at (LCDR6_ADDR)    	LCDR6;
extern __sfr __at (LCDR7_ADDR)    	LCDR7;
extern __sfr __at (LCDR8_ADDR)    	LCDR8;
extern __sfr __at (LCDR9_ADDR)    	LCDR9;
extern __sfr __at (LCDR10_ADDR)   	LCDR10;
extern __sfr __at (LCDR11_ADDR)   	LCDR11;
extern __sfr __at (LCDR12_ADDR)   	LCDR12;
extern __sfr __at (LCDR13_ADDR)   	LCDR13;
extern __sfr __at (LCDR14_ADDR)   	LCDR14;
extern __sfr __at (LCDR15_ADDR)   	LCDR15;
extern __sfr __at (LCDR16_ADDR)   	LCDR16;
extern __sfr __at (LCDR17_ADDR)   	LCDR17;
extern __sfr __at (LCDR18_ADDR)   	LCDR18;
extern __sfr __at (INDF0_ADDR)    	INDF0;
extern __sfr __at (INDF1_ADDR)    	INDF1;
extern __sfr __at (INDF2_ADDR)    	INDF2;
extern __sfr __at (HIBYTE_ADDR)   	HIBYTE;
extern __sfr __at (FSR0_ADDR)     	FSR0;
extern __sfr __at (FSR1_ADDR)     	FSR1;
extern __sfr __at (PCL_ADDR)      	PCL;
extern __sfr __at (PFLAG_ADDR)    	PFLAG;
extern __sfr __at (MCR_ADDR)      	MCR;
extern __sfr __at (INDF3_ADDR)    	INDF3;
extern __sfr __at (INTE0_ADDR)    	INTE0;
extern __sfr __at (INTF0_ADDR)    	INTF0;
extern __sfr __at (OSCMR_ADDR)    	OSCMR;
extern __sfr __at (LVDCR_ADDR)    	LVDCR;
extern __sfr __at (INTE1_ADDR)    	INTE1;
extern __sfr __at (INTF1_ADDR)    	INTF1;
extern __sfr __at (IOP0_ADDR)     	IOP0;
extern __sfr __at (OEP0_ADDR)     	OEP0;
extern __sfr __at (PUP0_ADDR)     	PUP0;
extern __sfr __at (PDP0_ADDR)     	PDP0;
extern __sfr __at (IOP1_ADDR)     	IOP1;
extern __sfr __at (OEP1_ADDR)     	OEP1;
extern __sfr __at (PUP1_ADDR)     	PUP1;
extern __sfr __at (PDP1_ADDR)     	PDP1;
extern __sfr __at (IOP2_ADDR)     	IOP2;
extern __sfr __at (OEP2_ADDR)     	OEP2;
extern __sfr __at (PUP2_ADDR)     	PUP2;
extern __sfr __at (PDP2_ADDR)     	PDP2;
extern __sfr __at (IOP3_ADDR)     	IOP3;
extern __sfr __at (OEP3_ADDR)     	OEP3;
extern __sfr __at (PUP3_ADDR)     	PUP3;
extern __sfr __at (PDP3_ADDR)     	PDP3;
extern __sfr __at (T0CR_ADDR)     	T0CR;
extern __sfr __at (T0CNT_ADDR)    	T0CNT;
extern __sfr __at (T0LOAD_ADDR)   	T0LOAD;
extern __sfr __at (T1CR_ADDR)     	T1CR;
extern __sfr __at (T1CNT_ADDR)    	T1CNT;
extern __sfr __at (T1LOAD_ADDR)   	T1LOAD;
extern __sfr __at (T1DATA_ADDR)   	T1DATA;
extern __sfr __at (PWM1CR_ADDR)   	PWM1CR;
extern __sfr __at (T2CR_ADDR)     	T2CR;
extern __sfr __at (T2CNT_ADDR)    	T2CNT;
extern __sfr __at (T2LOAD_ADDR)   	T2LOAD;
extern __sfr __at (T2DATA_ADDR)   	T2DATA;
extern __sfr __at (T2DATB_ADDR)   	T2DATB;
extern __sfr __at (PWM2CR_ADDR)   	PWM2CR;
extern __sfr __at (T3CR_ADDR)     	T3CR;
extern __sfr __at (T3CNTH_ADDR)   	T3CNTH;
extern __sfr __at (T3CNTL_ADDR)   	T3CNTL;
extern __sfr __at (T3LOADH_ADDR)  	T3LOADH;
extern __sfr __at (T3LOADL_ADDR)  	T3LOADL;
extern __sfr __at (P2ADCR_ADDR)   	P2ADCR;
extern __sfr __at (P3ADCR_ADDR)   	P3ADCR;
extern __sfr __at (DKSCR_ADDR)    	DKSCR;
extern __sfr __at (P0DKCR_ADDR)   	P0DKCR;
extern __sfr __at (P1DKCR_ADDR)   	P1DKCR;
extern __sfr __at (P2DKCR_ADDR)   	P2DKCR;
extern __sfr __at (P3DKCR_ADDR)   	P3DKCR;
extern __sfr __at (XTALCR_ADDR)   	XTALCR;
extern __sfr __at (XTICCAL_ADDR)  	XTICCAL;
extern __sfr __at (LCDCR0_ADDR)   	LCDCR0;
extern __sfr __at (LCDCR1_ADDR)   	LCDCR1;
extern __sfr __at (P0LCDCR_ADDR)  	P0LCDCR;
extern __sfr __at (P1LCDCR_ADDR)  	P1LCDCR;
extern __sfr __at (P2LCDCR_ADDR)  	P2LCDCR;
extern __sfr __at (HIRCCAL_ADDR)  	HIRCCAL;
extern __sfr __at (LIRCCAL_ADDR)  	LIRCCAL;
extern __sfr __at (IICCR0_ADDR)   	IICCR0;
extern __sfr __at (IICCR1_ADDR)   	IICCR1;
extern __sfr __at (IICCR2_ADDR)   	IICCR2;
extern __sfr __at (IICDR_ADDR)    	IICDR;
extern __sfr __at (IICAR_ADDR)    	IICAR;
extern __sfr __at (IICAAR_ADDR)   	IICAAR;
extern __sfr __at (IICAMR_ADDR)   	IICAMR;
extern __sfr __at (URTCR0_ADDR)   	URTCR0;
extern __sfr __at (URTCR1_ADDR)   	URTCR1;
extern __sfr __at (URTCR2_ADDR)   	URTCR2;
extern __sfr __at (URTSR_ADDR)    	URTSR;
extern __sfr __at (URTBR_ADDR)    	URTBR;
extern __sfr __at (URTDR_ADDR)    	URTDR;
extern __sfr __at (URTAR_ADDR)    	URTAR;
extern __sfr __at (URTMR_ADDR)    	URTMR;

//==========================================================================
//
//	Configuration Bits
//
//==========================================================================

//OPBIT1

//OPBIT0

// ----- LCDR0 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char LCD0S0:1;
		unsigned char LCD1S0:1;
		unsigned char LCD2S0:1;
		unsigned char LCD3S0:1;
		unsigned char LCD4S0:1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
	};
} __LCDR0bits_t;
extern volatile __LCDR0bits_t __at(LCDR0_ADDR) LCDR0bits;

#define LCD0S0    	LCDR0bits.LCD0S0    	/* bit 0 */
#define LCD1S0    	LCDR0bits.LCD1S0    	/* bit 1 */
#define LCD2S0    	LCDR0bits.LCD2S0    	/* bit 2 */
#define LCD3S0    	LCDR0bits.LCD3S0    	/* bit 3 */
#define LCD4S0    	LCDR0bits.LCD4S0    	/* bit 4 */

// ----- LCDR1 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char LCD0S1:1;
		unsigned char LCD1S1:1;
		unsigned char LCD2S1:1;
		unsigned char LCD3S1:1;
		unsigned char LCD4S1:1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
	};
} __LCDR1bits_t;
extern volatile __LCDR1bits_t __at(LCDR1_ADDR) LCDR1bits;

#define LCD0S1    	LCDR1bits.LCD0S1    	/* bit 0 */
#define LCD1S1    	LCDR1bits.LCD1S1    	/* bit 1 */
#define LCD2S1    	LCDR1bits.LCD2S1    	/* bit 2 */
#define LCD3S1    	LCDR1bits.LCD3S1    	/* bit 3 */
#define LCD4S1    	LCDR1bits.LCD4S1    	/* bit 4 */

// ----- LCDR2 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char LCD0S2:1;
		unsigned char LCD1S2:1;
		unsigned char LCD2S2:1;
		unsigned char LCD3S2:1;
		unsigned char LCD4S2:1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
	};
} __LCDR2bits_t;
extern volatile __LCDR2bits_t __at(LCDR2_ADDR) LCDR2bits;

#define LCD0S2    	LCDR2bits.LCD0S2    	/* bit 0 */
#define LCD1S2    	LCDR2bits.LCD1S2    	/* bit 1 */
#define LCD2S2    	LCDR2bits.LCD2S2    	/* bit 2 */
#define LCD3S2    	LCDR2bits.LCD3S2    	/* bit 3 */
#define LCD4S2    	LCDR2bits.LCD4S2    	/* bit 4 */

// ----- LCDR3 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char LCD0S3:1;
		unsigned char LCD1S3:1;
		unsigned char LCD2S3:1;
		unsigned char LCD3S3:1;
		unsigned char LCD4S3:1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
	};
} __LCDR3bits_t;
extern volatile __LCDR3bits_t __at(LCDR3_ADDR) LCDR3bits;

#define LCD0S3    	LCDR3bits.LCD0S3    	/* bit 0 */
#define LCD1S3    	LCDR3bits.LCD1S3    	/* bit 1 */
#define LCD2S3    	LCDR3bits.LCD2S3    	/* bit 2 */
#define LCD3S3    	LCDR3bits.LCD3S3    	/* bit 3 */
#define LCD4S3    	LCDR3bits.LCD4S3    	/* bit 4 */

// ----- LCDR4 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char LCD0S4:1;
		unsigned char LCD1S4:1;
		unsigned char LCD2S4:1;
		unsigned char LCD3S4:1;
		unsigned char LCD4S4:1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
	};
} __LCDR4bits_t;
extern volatile __LCDR4bits_t __at(LCDR4_ADDR) LCDR4bits;

#define LCD0S4    	LCDR4bits.LCD0S4    	/* bit 0 */
#define LCD1S4    	LCDR4bits.LCD1S4    	/* bit 1 */
#define LCD2S4    	LCDR4bits.LCD2S4    	/* bit 2 */
#define LCD3S4    	LCDR4bits.LCD3S4    	/* bit 3 */
#define LCD4S4    	LCDR4bits.LCD4S4    	/* bit 4 */

// ----- LCDR5 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char LCD0S5:1;
		unsigned char LCD1S5:1;
		unsigned char LCD2S5:1;
		unsigned char LCD3S5:1;
		unsigned char LCD4S5:1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
	};
} __LCDR5bits_t;
extern volatile __LCDR5bits_t __at(LCDR5_ADDR) LCDR5bits;

#define LCD0S5    	LCDR5bits.LCD0S5    	/* bit 0 */
#define LCD1S5    	LCDR5bits.LCD1S5    	/* bit 1 */
#define LCD2S5    	LCDR5bits.LCD2S5    	/* bit 2 */
#define LCD3S5    	LCDR5bits.LCD3S5    	/* bit 3 */
#define LCD4S5    	LCDR5bits.LCD4S5    	/* bit 4 */

// ----- LCDR6 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char LCD0S6:1;
		unsigned char LCD1S6:1;
		unsigned char LCD2S6:1;
		unsigned char LCD3S6:1;
		unsigned char LCD4S6:1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
	};
} __LCDR6bits_t;
extern volatile __LCDR6bits_t __at(LCDR6_ADDR) LCDR6bits;

#define LCD0S6    	LCDR6bits.LCD0S6    	/* bit 0 */
#define LCD1S6    	LCDR6bits.LCD1S6    	/* bit 1 */
#define LCD2S6    	LCDR6bits.LCD2S6    	/* bit 2 */
#define LCD3S6    	LCDR6bits.LCD3S6    	/* bit 3 */
#define LCD4S6    	LCDR6bits.LCD4S6    	/* bit 4 */

// ----- LCDR7 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char LCD0S7:1;
		unsigned char LCD1S7:1;
		unsigned char LCD2S7:1;
		unsigned char LCD3S7:1;
		unsigned char LCD4S7:1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
	};
} __LCDR7bits_t;
extern volatile __LCDR7bits_t __at(LCDR7_ADDR) LCDR7bits;

#define LCD0S7    	LCDR7bits.LCD0S7    	/* bit 0 */
#define LCD1S7    	LCDR7bits.LCD1S7    	/* bit 1 */
#define LCD2S7    	LCDR7bits.LCD2S7    	/* bit 2 */
#define LCD3S7    	LCDR7bits.LCD3S7    	/* bit 3 */
#define LCD4S7    	LCDR7bits.LCD4S7    	/* bit 4 */

// ----- LCDR8 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char LCD0S8:1;
		unsigned char LCD1S8:1;
		unsigned char LCD2S8:1;
		unsigned char LCD3S8:1;
		unsigned char LCD4S8:1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
	};
} __LCDR8bits_t;
extern volatile __LCDR8bits_t __at(LCDR8_ADDR) LCDR8bits;

#define LCD0S8    	LCDR8bits.LCD0S8    	/* bit 0 */
#define LCD1S8    	LCDR8bits.LCD1S8    	/* bit 1 */
#define LCD2S8    	LCDR8bits.LCD2S8    	/* bit 2 */
#define LCD3S8    	LCDR8bits.LCD3S8    	/* bit 3 */
#define LCD4S8    	LCDR8bits.LCD4S8    	/* bit 4 */

// ----- LCDR9 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char LCD0S9:1;
		unsigned char LCD1S9:1;
		unsigned char LCD2S9:1;
		unsigned char LCD3S9:1;
		unsigned char LCD4S9:1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
	};
} __LCDR9bits_t;
extern volatile __LCDR9bits_t __at(LCDR9_ADDR) LCDR9bits;

#define LCD0S9    	LCDR9bits.LCD0S9    	/* bit 0 */
#define LCD1S9    	LCDR9bits.LCD1S9    	/* bit 1 */
#define LCD2S9    	LCDR9bits.LCD2S9    	/* bit 2 */
#define LCD3S9    	LCDR9bits.LCD3S9    	/* bit 3 */
#define LCD4S9    	LCDR9bits.LCD4S9    	/* bit 4 */

// ----- LCDR10 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char LCD0S10:1;
		unsigned char LCD1S10:1;
		unsigned char LCD2S10:1;
		unsigned char LCD3S10:1;
		unsigned char LCD4S10:1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
	};
} __LCDR10bits_t;
extern volatile __LCDR10bits_t __at(LCDR10_ADDR) LCDR10bits;

#define LCD0S10   	LCDR10bits.LCD0S10  	/* bit 0 */
#define LCD1S10   	LCDR10bits.LCD1S10  	/* bit 1 */
#define LCD2S10   	LCDR10bits.LCD2S10  	/* bit 2 */
#define LCD3S10   	LCDR10bits.LCD3S10  	/* bit 3 */
#define LCD4S10   	LCDR10bits.LCD4S10  	/* bit 4 */

// ----- LCDR11 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char LCD0S11:1;
		unsigned char LCD1S11:1;
		unsigned char LCD2S11:1;
		unsigned char LCD3S11:1;
		unsigned char LCD4S11:1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
	};
} __LCDR11bits_t;
extern volatile __LCDR11bits_t __at(LCDR11_ADDR) LCDR11bits;

#define LCD0S11   	LCDR11bits.LCD0S11  	/* bit 0 */
#define LCD1S11   	LCDR11bits.LCD1S11  	/* bit 1 */
#define LCD2S11   	LCDR11bits.LCD2S11  	/* bit 2 */
#define LCD3S11   	LCDR11bits.LCD3S11  	/* bit 3 */
#define LCD4S11   	LCDR11bits.LCD4S11  	/* bit 4 */

// ----- LCDR12 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char LCD0S12:1;
		unsigned char LCD1S12:1;
		unsigned char LCD2S12:1;
		unsigned char LCD3S12:1;
		unsigned char LCD4S12:1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
	};
} __LCDR12bits_t;
extern volatile __LCDR12bits_t __at(LCDR12_ADDR) LCDR12bits;

#define LCD0S12   	LCDR12bits.LCD0S12  	/* bit 0 */
#define LCD1S12   	LCDR12bits.LCD1S12  	/* bit 1 */
#define LCD2S12   	LCDR12bits.LCD2S12  	/* bit 2 */
#define LCD3S12   	LCDR12bits.LCD3S12  	/* bit 3 */
#define LCD4S12   	LCDR12bits.LCD4S12  	/* bit 4 */

// ----- LCDR13 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char LCD0S13:1;
		unsigned char LCD1S13:1;
		unsigned char LCD2S13:1;
		unsigned char LCD3S13:1;
		unsigned char LCD4S13:1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
	};
} __LCDR13bits_t;
extern volatile __LCDR13bits_t __at(LCDR13_ADDR) LCDR13bits;

#define LCD0S13   	LCDR13bits.LCD0S13  	/* bit 0 */
#define LCD1S13   	LCDR13bits.LCD1S13  	/* bit 1 */
#define LCD2S13   	LCDR13bits.LCD2S13  	/* bit 2 */
#define LCD3S13   	LCDR13bits.LCD3S13  	/* bit 3 */
#define LCD4S13   	LCDR13bits.LCD4S13  	/* bit 4 */

// ----- LCDR14 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char LCD0S14:1;
		unsigned char LCD1S14:1;
		unsigned char LCD2S14:1;
		unsigned char LCD3S14:1;
		unsigned char LCD4S14:1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
	};
} __LCDR14bits_t;
extern volatile __LCDR14bits_t __at(LCDR14_ADDR) LCDR14bits;

#define LCD0S14   	LCDR14bits.LCD0S14  	/* bit 0 */
#define LCD1S14   	LCDR14bits.LCD1S14  	/* bit 1 */
#define LCD2S14   	LCDR14bits.LCD2S14  	/* bit 2 */
#define LCD3S14   	LCDR14bits.LCD3S14  	/* bit 3 */
#define LCD4S14   	LCDR14bits.LCD4S14  	/* bit 4 */

// ----- LCDR15 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char LCD0S15:1;
		unsigned char LCD1S15:1;
		unsigned char LCD2S15:1;
		unsigned char LCD3S15:1;
		unsigned char LCD4S15:1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
	};
} __LCDR15bits_t;
extern volatile __LCDR15bits_t __at(LCDR15_ADDR) LCDR15bits;

#define LCD0S15   	LCDR15bits.LCD0S15  	/* bit 0 */
#define LCD1S15   	LCDR15bits.LCD1S15  	/* bit 1 */
#define LCD2S15   	LCDR15bits.LCD2S15  	/* bit 2 */
#define LCD3S15   	LCDR15bits.LCD3S15  	/* bit 3 */
#define LCD4S15   	LCDR15bits.LCD4S15  	/* bit 4 */

// ----- LCDR16 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char LCD0S16:1;
		unsigned char LCD1S16:1;
		unsigned char LCD2S16:1;
		unsigned char LCD3S16:1;
		unsigned char LCD4S16:1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
	};
} __LCDR16bits_t;
extern volatile __LCDR16bits_t __at(LCDR16_ADDR) LCDR16bits;

#define LCD0S16   	LCDR16bits.LCD0S16  	/* bit 0 */
#define LCD1S16   	LCDR16bits.LCD1S16  	/* bit 1 */
#define LCD2S16   	LCDR16bits.LCD2S16  	/* bit 2 */
#define LCD3S16   	LCDR16bits.LCD3S16  	/* bit 3 */
#define LCD4S16   	LCDR16bits.LCD4S16  	/* bit 4 */

// ----- LCDR17 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char LCD0S17:1;
		unsigned char LCD1S17:1;
		unsigned char LCD2S17:1;
		unsigned char LCD3S17:1;
		unsigned char LCD4S17:1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
	};
} __LCDR17bits_t;
extern volatile __LCDR17bits_t __at(LCDR17_ADDR) LCDR17bits;

#define LCD0S17   	LCDR17bits.LCD0S17  	/* bit 0 */
#define LCD1S17   	LCDR17bits.LCD1S17  	/* bit 1 */
#define LCD2S17   	LCDR17bits.LCD2S17  	/* bit 2 */
#define LCD3S17   	LCDR17bits.LCD3S17  	/* bit 3 */
#define LCD4S17   	LCDR17bits.LCD4S17  	/* bit 4 */

// ----- LCDR18 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char LCD0S18:1;
		unsigned char LCD1S18:1;
		unsigned char LCD2S18:1;
		unsigned char LCD3S18:1;
		unsigned char LCD4S18:1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
	};
} __LCDR18bits_t;
extern volatile __LCDR18bits_t __at(LCDR18_ADDR) LCDR18bits;

#define LCD0S18   	LCDR18bits.LCD0S18  	/* bit 0 */
#define LCD1S18   	LCDR18bits.LCD1S18  	/* bit 1 */
#define LCD2S18   	LCDR18bits.LCD2S18  	/* bit 2 */
#define LCD3S18   	LCDR18bits.LCD3S18  	/* bit 3 */
#define LCD4S18   	LCDR18bits.LCD4S18  	/* bit 4 */

// ----- INDF0 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char INDF00:1;
		unsigned char INDF01:1;
		unsigned char INDF02:1;
		unsigned char INDF03:1;
		unsigned char INDF04:1;
		unsigned char INDF05:1;
		unsigned char INDF06:1;
		unsigned char INDF07:1;
	};
} __INDF0bits_t;
extern volatile __INDF0bits_t __at(INDF0_ADDR) INDF0bits;

#define INDF00    	INDF0bits.INDF00    	/* bit 0 */
#define INDF01    	INDF0bits.INDF01    	/* bit 1 */
#define INDF02    	INDF0bits.INDF02    	/* bit 2 */
#define INDF03    	INDF0bits.INDF03    	/* bit 3 */
#define INDF04    	INDF0bits.INDF04    	/* bit 4 */
#define INDF05    	INDF0bits.INDF05    	/* bit 5 */
#define INDF06    	INDF0bits.INDF06    	/* bit 6 */
#define INDF07    	INDF0bits.INDF07    	/* bit 7 */

// ----- INDF1 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char INDF10:1;
		unsigned char INDF11:1;
		unsigned char INDF12:1;
		unsigned char INDF13:1;
		unsigned char INDF14:1;
		unsigned char INDF15:1;
		unsigned char INDF16:1;
		unsigned char INDF17:1;
	};
} __INDF1bits_t;
extern volatile __INDF1bits_t __at(INDF1_ADDR) INDF1bits;

#define INDF10    	INDF1bits.INDF10    	/* bit 0 */
#define INDF11    	INDF1bits.INDF11    	/* bit 1 */
#define INDF12    	INDF1bits.INDF12    	/* bit 2 */
#define INDF13    	INDF1bits.INDF13    	/* bit 3 */
#define INDF14    	INDF1bits.INDF14    	/* bit 4 */
#define INDF15    	INDF1bits.INDF15    	/* bit 5 */
#define INDF16    	INDF1bits.INDF16    	/* bit 6 */
#define INDF17    	INDF1bits.INDF17    	/* bit 7 */

// ----- INDF2 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char INDF20:1;
		unsigned char INDF21:1;
		unsigned char INDF22:1;
		unsigned char INDF23:1;
		unsigned char INDF24:1;
		unsigned char INDF25:1;
		unsigned char INDF26:1;
		unsigned char INDF27:1;
	};
} __INDF2bits_t;
extern volatile __INDF2bits_t __at(INDF2_ADDR) INDF2bits;

#define INDF20    	INDF2bits.INDF20    	/* bit 0 */
#define INDF21    	INDF2bits.INDF21    	/* bit 1 */
#define INDF22    	INDF2bits.INDF22    	/* bit 2 */
#define INDF23    	INDF2bits.INDF23    	/* bit 3 */
#define INDF24    	INDF2bits.INDF24    	/* bit 4 */
#define INDF25    	INDF2bits.INDF25    	/* bit 5 */
#define INDF26    	INDF2bits.INDF26    	/* bit 6 */
#define INDF27    	INDF2bits.INDF27    	/* bit 7 */

// ----- HIBYTE Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char HIBYTE0:1;
		unsigned char HIBYTE1:1;
		unsigned char HIBYTE2:1;
		unsigned char HIBYTE3:1;
		unsigned char HIBYTE4:1;
		unsigned char HIBYTE5:1;
		unsigned char HIBYTE6:1;
		unsigned char HIBYTE7:1;
	};
} __HIBYTEbits_t;
extern volatile __HIBYTEbits_t __at(HIBYTE_ADDR) HIBYTEbits;

#define HIBYTE0   	HIBYTEbits.HIBYTE0  	/* bit 0 */
#define HIBYTE1   	HIBYTEbits.HIBYTE1  	/* bit 1 */
#define HIBYTE2   	HIBYTEbits.HIBYTE2  	/* bit 2 */
#define HIBYTE3   	HIBYTEbits.HIBYTE3  	/* bit 3 */
#define HIBYTE4   	HIBYTEbits.HIBYTE4  	/* bit 4 */
#define HIBYTE5   	HIBYTEbits.HIBYTE5  	/* bit 5 */
#define HIBYTE6   	HIBYTEbits.HIBYTE6  	/* bit 6 */
#define HIBYTE7   	HIBYTEbits.HIBYTE7  	/* bit 7 */

// ----- FSR0 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char FSR00:1;
		unsigned char FSR01:1;
		unsigned char FSR02:1;
		unsigned char FSR03:1;
		unsigned char FSR04:1;
		unsigned char FSR05:1;
		unsigned char FSR06:1;
		unsigned char FSR07:1;
	};
} __FSR0bits_t;
extern volatile __FSR0bits_t __at(FSR0_ADDR) FSR0bits;

#define FSR00     	FSR0bits.FSR00      	/* bit 0 */
#define FSR01     	FSR0bits.FSR01      	/* bit 1 */
#define FSR02     	FSR0bits.FSR02      	/* bit 2 */
#define FSR03     	FSR0bits.FSR03      	/* bit 3 */
#define FSR04     	FSR0bits.FSR04      	/* bit 4 */
#define FSR05     	FSR0bits.FSR05      	/* bit 5 */
#define FSR06     	FSR0bits.FSR06      	/* bit 6 */
#define FSR07     	FSR0bits.FSR07      	/* bit 7 */

// ----- FSR1 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char FSR10:1;
		unsigned char FSR11:1;
		unsigned char FSR12:1;
		unsigned char FSR13:1;
		unsigned char FSR14:1;
		unsigned char FSR15:1;
		unsigned char FSR16:1;
		unsigned char FSR17:1;
	};
} __FSR1bits_t;
extern volatile __FSR1bits_t __at(FSR1_ADDR) FSR1bits;

#define FSR10     	FSR1bits.FSR10      	/* bit 0 */
#define FSR11     	FSR1bits.FSR11      	/* bit 1 */
#define FSR12     	FSR1bits.FSR12      	/* bit 2 */
#define FSR13     	FSR1bits.FSR13      	/* bit 3 */
#define FSR14     	FSR1bits.FSR14      	/* bit 4 */
#define FSR15     	FSR1bits.FSR15      	/* bit 5 */
#define FSR16     	FSR1bits.FSR16      	/* bit 6 */
#define FSR17     	FSR1bits.FSR17      	/* bit 7 */

// ----- PCL Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char PC0:1;
		unsigned char PC1:1;
		unsigned char PC2:1;
		unsigned char PC3:1;
		unsigned char PC4:1;
		unsigned char PC5:1;
		unsigned char PC6:1;
		unsigned char PC7:1;
	};
} __PCLbits_t;
extern volatile __PCLbits_t __at(PCL_ADDR) PCLbits;

#define PC0       	PCLbits.PC0         	/* bit 0 */
#define PC1       	PCLbits.PC1         	/* bit 1 */
#define PC2       	PCLbits.PC2         	/* bit 2 */
#define PC3       	PCLbits.PC3         	/* bit 3 */
#define PC4       	PCLbits.PC4         	/* bit 4 */
#define PC5       	PCLbits.PC5         	/* bit 5 */
#define PC6       	PCLbits.PC6         	/* bit 6 */
#define PC7       	PCLbits.PC7         	/* bit 7 */

// ----- PFLAG Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char C:1;
		unsigned char DC:1;
		unsigned char Z:1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
	};
} __PFLAGbits_t;
extern volatile __PFLAGbits_t __at(PFLAG_ADDR) PFLAGbits;

#define C         	PFLAGbits.C         	/* bit 0 */
#define DC        	PFLAGbits.DC        	/* bit 1 */
#define Z         	PFLAGbits.Z         	/* bit 2 */

// ----- MCR Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char KINT0M0:1;
		unsigned char KINT0M1:1;
		unsigned char KINT1M0:1;
		unsigned char KINT1M1:1;
		unsigned char PD:1;
		unsigned char TO:1;
		unsigned char :1;
		unsigned char GIE:1;
	};
} __MCRbits_t;
extern volatile __MCRbits_t __at(MCR_ADDR) MCRbits;

#define KINT0M0   	MCRbits.KINT0M0     	/* bit 0 */
#define KINT0M1   	MCRbits.KINT0M1     	/* bit 1 */
#define KINT1M0   	MCRbits.KINT1M0     	/* bit 2 */
#define KINT1M1   	MCRbits.KINT1M1     	/* bit 3 */
#define PD        	MCRbits.PD          	/* bit 4 */
#define TO        	MCRbits.TO          	/* bit 5 */
#define GIE       	MCRbits.GIE         	/* bit 7 */

// ----- INDF3 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char INDF30:1;
		unsigned char INDF31:1;
		unsigned char INDF32:1;
		unsigned char INDF33:1;
		unsigned char INDF34:1;
		unsigned char INDF35:1;
		unsigned char INDF36:1;
		unsigned char INDF37:1;
	};
} __INDF3bits_t;
extern volatile __INDF3bits_t __at(INDF3_ADDR) INDF3bits;

#define INDF30    	INDF3bits.INDF30    	/* bit 0 */
#define INDF31    	INDF3bits.INDF31    	/* bit 1 */
#define INDF32    	INDF3bits.INDF32    	/* bit 2 */
#define INDF33    	INDF3bits.INDF33    	/* bit 3 */
#define INDF34    	INDF3bits.INDF34    	/* bit 4 */
#define INDF35    	INDF3bits.INDF35    	/* bit 5 */
#define INDF36    	INDF3bits.INDF36    	/* bit 6 */
#define INDF37    	INDF3bits.INDF37    	/* bit 7 */

// ----- INTE0 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char T0IE:1;
		unsigned char T1IE:1;
		unsigned char KINT0IE:1;
		unsigned char KINT1IE:1;
		unsigned char :1;
		unsigned char LVDIE:1;
		unsigned char IICIE:1;
		unsigned char :1;
	};
} __INTE0bits_t;
extern volatile __INTE0bits_t __at(INTE0_ADDR) INTE0bits;

#define T0IE      	INTE0bits.T0IE      	/* bit 0 */
#define T1IE      	INTE0bits.T1IE      	/* bit 1 */
#define KINT0IE   	INTE0bits.KINT0IE   	/* bit 2 */
#define KINT1IE   	INTE0bits.KINT1IE   	/* bit 3 */
#define LVDIE     	INTE0bits.LVDIE     	/* bit 5 */
#define IICIE     	INTE0bits.IICIE     	/* bit 6 */

// ----- INTF0 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char T0IF:1;
		unsigned char T1IF:1;
		unsigned char KINT0IF:1;
		unsigned char KINT1IF:1;
		unsigned char :1;
		unsigned char LVDIF:1;
		unsigned char IICIF:1;
		unsigned char :1;
	};
} __INTF0bits_t;
extern volatile __INTF0bits_t __at(INTF0_ADDR) INTF0bits;

#define T0IF      	INTF0bits.T0IF      	/* bit 0 */
#define T1IF      	INTF0bits.T1IF      	/* bit 1 */
#define KINT0IF   	INTF0bits.KINT0IF   	/* bit 2 */
#define KINT1IF   	INTF0bits.KINT1IF   	/* bit 3 */
#define LVDIF     	INTF0bits.LVDIF     	/* bit 5 */
#define IICIF     	INTF0bits.IICIF     	/* bit 6 */

// ----- OSCMR Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char HFEN:1;
		unsigned char LFEN:1;
		unsigned char CLKS:1;
		unsigned char :1;
		unsigned char STBH:1;
		unsigned char STBL:1;
		unsigned char :1;
		unsigned char :1;
	};
} __OSCMRbits_t;
extern volatile __OSCMRbits_t __at(OSCMR_ADDR) OSCMRbits;

#define HFEN      	OSCMRbits.HFEN      	/* bit 0 */
#define LFEN      	OSCMRbits.LFEN      	/* bit 1 */
#define CLKS      	OSCMRbits.CLKS      	/* bit 2 */
#define STBH      	OSCMRbits.STBH      	/* bit 4 */
#define STBL      	OSCMRbits.STBL      	/* bit 5 */

// ----- LVDCR Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char LVDF:1;
		unsigned char :1;
		unsigned char LVDIS:1;
		unsigned char LVDVS0:1;
		unsigned char LVDVS1:1;
		unsigned char LVDVS2:1;
		unsigned char LVDVS3:1;
		unsigned char LVDEN:1;
	};
} __LVDCRbits_t;
extern volatile __LVDCRbits_t __at(LVDCR_ADDR) LVDCRbits;

#define LVDF      	LVDCRbits.LVDF      	/* bit 0 */
#define LVDIS     	LVDCRbits.LVDIS     	/* bit 2 */
#define LVDVS0    	LVDCRbits.LVDVS0    	/* bit 3 */
#define LVDVS1    	LVDCRbits.LVDVS1    	/* bit 4 */
#define LVDVS2    	LVDCRbits.LVDVS2    	/* bit 5 */
#define LVDVS3    	LVDCRbits.LVDVS3    	/* bit 6 */
#define LVDEN     	LVDCRbits.LVDEN     	/* bit 7 */

// ----- INTE1 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char T2IE:1;
		unsigned char T3IE:1;
		unsigned char XTFIE:1;
		unsigned char :1;
		unsigned char :1;
		unsigned char RXIE:1;
		unsigned char TBEIE:1;
		unsigned char TXIE:1;
	};
} __INTE1bits_t;
extern volatile __INTE1bits_t __at(INTE1_ADDR) INTE1bits;

#define T2IE      	INTE1bits.T2IE      	/* bit 0 */
#define T3IE      	INTE1bits.T3IE      	/* bit 1 */
#define XTFIE     	INTE1bits.XTFIE     	/* bit 2 */
#define RXIE      	INTE1bits.RXIE      	/* bit 5 */
#define TBEIE     	INTE1bits.TBEIE     	/* bit 6 */
#define TXIE      	INTE1bits.TXIE      	/* bit 7 */

// ----- INTF1 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char T2IF:1;
		unsigned char T3IF:1;
		unsigned char XTFIF:1;
		unsigned char :1;
		unsigned char :1;
		unsigned char RXIF:1;
		unsigned char TBEIF:1;
		unsigned char TXIF:1;
	};
} __INTF1bits_t;
extern volatile __INTF1bits_t __at(INTF1_ADDR) INTF1bits;

#define T2IF      	INTF1bits.T2IF      	/* bit 0 */
#define T3IF      	INTF1bits.T3IF      	/* bit 1 */
#define XTFIF     	INTF1bits.XTFIF     	/* bit 2 */
#define RXIF      	INTF1bits.RXIF      	/* bit 5 */
#define TBEIF     	INTF1bits.TBEIF     	/* bit 6 */
#define TXIF      	INTF1bits.TXIF      	/* bit 7 */

// ----- IOP0 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char P00D:1;
		unsigned char P01D:1;
		unsigned char P02D:1;
		unsigned char P03D:1;
		unsigned char P04D:1;
		unsigned char P05D:1;
		unsigned char P06D:1;
		unsigned char P07D:1;
	};
} __IOP0bits_t;
extern volatile __IOP0bits_t __at(IOP0_ADDR) IOP0bits;

#define P00D      	IOP0bits.P00D       	/* bit 0 */
#define P01D      	IOP0bits.P01D       	/* bit 1 */
#define P02D      	IOP0bits.P02D       	/* bit 2 */
#define P03D      	IOP0bits.P03D       	/* bit 3 */
#define P04D      	IOP0bits.P04D       	/* bit 4 */
#define P05D      	IOP0bits.P05D       	/* bit 5 */
#define P06D      	IOP0bits.P06D       	/* bit 6 */
#define P07D      	IOP0bits.P07D       	/* bit 7 */

// ----- OEP0 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char P00OE:1;
		unsigned char P01OE:1;
		unsigned char P02OE:1;
		unsigned char P03OE:1;
		unsigned char P04OE:1;
		unsigned char P05OE:1;
		unsigned char P06OE:1;
		unsigned char P07OE:1;
	};
} __OEP0bits_t;
extern volatile __OEP0bits_t __at(OEP0_ADDR) OEP0bits;

#define P00OE     	OEP0bits.P00OE      	/* bit 0 */
#define P01OE     	OEP0bits.P01OE      	/* bit 1 */
#define P02OE     	OEP0bits.P02OE      	/* bit 2 */
#define P03OE     	OEP0bits.P03OE      	/* bit 3 */
#define P04OE     	OEP0bits.P04OE      	/* bit 4 */
#define P05OE     	OEP0bits.P05OE      	/* bit 5 */
#define P06OE     	OEP0bits.P06OE      	/* bit 6 */
#define P07OE     	OEP0bits.P07OE      	/* bit 7 */

// ----- PUP0 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char P00PU:1;
		unsigned char P01PU:1;
		unsigned char P02PU:1;
		unsigned char P03PU:1;
		unsigned char P04PU:1;
		unsigned char P05PU:1;
		unsigned char P06PU:1;
		unsigned char P07PU:1;
	};
} __PUP0bits_t;
extern volatile __PUP0bits_t __at(PUP0_ADDR) PUP0bits;

#define P00PU     	PUP0bits.P00PU      	/* bit 0 */
#define P01PU     	PUP0bits.P01PU      	/* bit 1 */
#define P02PU     	PUP0bits.P02PU      	/* bit 2 */
#define P03PU     	PUP0bits.P03PU      	/* bit 3 */
#define P04PU     	PUP0bits.P04PU      	/* bit 4 */
#define P05PU     	PUP0bits.P05PU      	/* bit 5 */
#define P06PU     	PUP0bits.P06PU      	/* bit 6 */
#define P07PU     	PUP0bits.P07PU      	/* bit 7 */

// ----- PDP0 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char P00PD:1;
		unsigned char P01PD:1;
		unsigned char P02PD:1;
		unsigned char P03PD:1;
		unsigned char P04PD:1;
		unsigned char P05PD:1;
		unsigned char P06PD:1;
		unsigned char P07PD:1;
	};
} __PDP0bits_t;
extern volatile __PDP0bits_t __at(PDP0_ADDR) PDP0bits;

#define P00PD     	PDP0bits.P00PD      	/* bit 0 */
#define P01PD     	PDP0bits.P01PD      	/* bit 1 */
#define P02PD     	PDP0bits.P02PD      	/* bit 2 */
#define P03PD     	PDP0bits.P03PD      	/* bit 3 */
#define P04PD     	PDP0bits.P04PD      	/* bit 4 */
#define P05PD     	PDP0bits.P05PD      	/* bit 5 */
#define P06PD     	PDP0bits.P06PD      	/* bit 6 */
#define P07PD     	PDP0bits.P07PD      	/* bit 7 */

// ----- IOP1 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char P10D:1;
		unsigned char P11D:1;
		unsigned char P12D:1;
		unsigned char P13D:1;
		unsigned char P14D:1;
		unsigned char P15D:1;
		unsigned char P16D:1;
		unsigned char P17D:1;
	};
} __IOP1bits_t;
extern volatile __IOP1bits_t __at(IOP1_ADDR) IOP1bits;

#define P10D      	IOP1bits.P10D       	/* bit 0 */
#define P11D      	IOP1bits.P11D       	/* bit 1 */
#define P12D      	IOP1bits.P12D       	/* bit 2 */
#define P13D      	IOP1bits.P13D       	/* bit 3 */
#define P14D      	IOP1bits.P14D       	/* bit 4 */
#define P15D      	IOP1bits.P15D       	/* bit 5 */
#define P16D      	IOP1bits.P16D       	/* bit 6 */
#define P17D      	IOP1bits.P17D       	/* bit 7 */

// ----- OEP1 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char P10OE:1;
		unsigned char P11OE:1;
		unsigned char P12OE:1;
		unsigned char P13OE:1;
		unsigned char P14OE:1;
		unsigned char P15OE:1;
		unsigned char P16OE:1;
		unsigned char P17OE:1;
	};
} __OEP1bits_t;
extern volatile __OEP1bits_t __at(OEP1_ADDR) OEP1bits;

#define P10OE     	OEP1bits.P10OE      	/* bit 0 */
#define P11OE     	OEP1bits.P11OE      	/* bit 1 */
#define P12OE     	OEP1bits.P12OE      	/* bit 2 */
#define P13OE     	OEP1bits.P13OE      	/* bit 3 */
#define P14OE     	OEP1bits.P14OE      	/* bit 4 */
#define P15OE     	OEP1bits.P15OE      	/* bit 5 */
#define P16OE     	OEP1bits.P16OE      	/* bit 6 */
#define P17OE     	OEP1bits.P17OE      	/* bit 7 */

// ----- PUP1 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char P10PU:1;
		unsigned char P11PU:1;
		unsigned char P12PU:1;
		unsigned char P13PU:1;
		unsigned char P14PU:1;
		unsigned char P15PU:1;
		unsigned char P16PU:1;
		unsigned char P17PU:1;
	};
} __PUP1bits_t;
extern volatile __PUP1bits_t __at(PUP1_ADDR) PUP1bits;

#define P10PU     	PUP1bits.P10PU      	/* bit 0 */
#define P11PU     	PUP1bits.P11PU      	/* bit 1 */
#define P12PU     	PUP1bits.P12PU      	/* bit 2 */
#define P13PU     	PUP1bits.P13PU      	/* bit 3 */
#define P14PU     	PUP1bits.P14PU      	/* bit 4 */
#define P15PU     	PUP1bits.P15PU      	/* bit 5 */
#define P16PU     	PUP1bits.P16PU      	/* bit 6 */
#define P17PU     	PUP1bits.P17PU      	/* bit 7 */

// ----- PDP1 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char P10PD:1;
		unsigned char P11PD:1;
		unsigned char P12PD:1;
		unsigned char P13PD:1;
		unsigned char P14PD:1;
		unsigned char P15PD:1;
		unsigned char P16PD:1;
		unsigned char P17PD:1;
	};
} __PDP1bits_t;
extern volatile __PDP1bits_t __at(PDP1_ADDR) PDP1bits;

#define P10PD     	PDP1bits.P10PD      	/* bit 0 */
#define P11PD     	PDP1bits.P11PD      	/* bit 1 */
#define P12PD     	PDP1bits.P12PD      	/* bit 2 */
#define P13PD     	PDP1bits.P13PD      	/* bit 3 */
#define P14PD     	PDP1bits.P14PD      	/* bit 4 */
#define P15PD     	PDP1bits.P15PD      	/* bit 5 */
#define P16PD     	PDP1bits.P16PD      	/* bit 6 */
#define P17PD     	PDP1bits.P17PD      	/* bit 7 */

// ----- IOP2 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char P20D:1;
		unsigned char P21D:1;
		unsigned char P22D:1;
		unsigned char P23D:1;
		unsigned char P24D:1;
		unsigned char P25D:1;
		unsigned char P26D:1;
		unsigned char P27D:1;
	};
} __IOP2bits_t;
extern volatile __IOP2bits_t __at(IOP2_ADDR) IOP2bits;

#define P20D      	IOP2bits.P20D       	/* bit 0 */
#define P21D      	IOP2bits.P21D       	/* bit 1 */
#define P22D      	IOP2bits.P22D       	/* bit 2 */
#define P23D      	IOP2bits.P23D       	/* bit 3 */
#define P24D      	IOP2bits.P24D       	/* bit 4 */
#define P25D      	IOP2bits.P25D       	/* bit 5 */
#define P26D      	IOP2bits.P26D       	/* bit 6 */
#define P27D      	IOP2bits.P27D       	/* bit 7 */

// ----- OEP2 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char P20OE:1;
		unsigned char P21OE:1;
		unsigned char P22OE:1;
		unsigned char P23OE:1;
		unsigned char P24OE:1;
		unsigned char P25OE:1;
		unsigned char P26OE:1;
		unsigned char P27OE:1;
	};
} __OEP2bits_t;
extern volatile __OEP2bits_t __at(OEP2_ADDR) OEP2bits;

#define P20OE     	OEP2bits.P20OE      	/* bit 0 */
#define P21OE     	OEP2bits.P21OE      	/* bit 1 */
#define P22OE     	OEP2bits.P22OE      	/* bit 2 */
#define P23OE     	OEP2bits.P23OE      	/* bit 3 */
#define P24OE     	OEP2bits.P24OE      	/* bit 4 */
#define P25OE     	OEP2bits.P25OE      	/* bit 5 */
#define P26OE     	OEP2bits.P26OE      	/* bit 6 */
#define P27OE     	OEP2bits.P27OE      	/* bit 7 */

// ----- PUP2 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char P20PU:1;
		unsigned char P21PU:1;
		unsigned char P22PU:1;
		unsigned char P23PU:1;
		unsigned char P24PU:1;
		unsigned char P25PU:1;
		unsigned char P26PU:1;
		unsigned char P27PU:1;
	};
} __PUP2bits_t;
extern volatile __PUP2bits_t __at(PUP2_ADDR) PUP2bits;

#define P20PU     	PUP2bits.P20PU      	/* bit 0 */
#define P21PU     	PUP2bits.P21PU      	/* bit 1 */
#define P22PU     	PUP2bits.P22PU      	/* bit 2 */
#define P23PU     	PUP2bits.P23PU      	/* bit 3 */
#define P24PU     	PUP2bits.P24PU      	/* bit 4 */
#define P25PU     	PUP2bits.P25PU      	/* bit 5 */
#define P26PU     	PUP2bits.P26PU      	/* bit 6 */
#define P27PU     	PUP2bits.P27PU      	/* bit 7 */

// ----- PDP2 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char P20PD:1;
		unsigned char P21PD:1;
		unsigned char P22PD:1;
		unsigned char P23PD:1;
		unsigned char P24PD:1;
		unsigned char P25PD:1;
		unsigned char P26PD:1;
		unsigned char P27PD:1;
	};
} __PDP2bits_t;
extern volatile __PDP2bits_t __at(PDP2_ADDR) PDP2bits;

#define P20PD     	PDP2bits.P20PD      	/* bit 0 */
#define P21PD     	PDP2bits.P21PD      	/* bit 1 */
#define P22PD     	PDP2bits.P22PD      	/* bit 2 */
#define P23PD     	PDP2bits.P23PD      	/* bit 3 */
#define P24PD     	PDP2bits.P24PD      	/* bit 4 */
#define P25PD     	PDP2bits.P25PD      	/* bit 5 */
#define P26PD     	PDP2bits.P26PD      	/* bit 6 */
#define P27PD     	PDP2bits.P27PD      	/* bit 7 */

// ----- IOP3 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char P30D:1;
		unsigned char P31D:1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
	};
} __IOP3bits_t;
extern volatile __IOP3bits_t __at(IOP3_ADDR) IOP3bits;

#define P30D      	IOP3bits.P30D       	/* bit 0 */
#define P31D      	IOP3bits.P31D       	/* bit 1 */

// ----- OEP3 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char P30OE:1;
		unsigned char P31OE:1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
	};
} __OEP3bits_t;
extern volatile __OEP3bits_t __at(OEP3_ADDR) OEP3bits;

#define P30OE     	OEP3bits.P30OE      	/* bit 0 */
#define P31OE     	OEP3bits.P31OE      	/* bit 1 */

// ----- PUP3 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char P30PU:1;
		unsigned char P31PU:1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
	};
} __PUP3bits_t;
extern volatile __PUP3bits_t __at(PUP3_ADDR) PUP3bits;

#define P30PU     	PUP3bits.P30PU      	/* bit 0 */
#define P31PU     	PUP3bits.P31PU      	/* bit 1 */

// ----- PDP3 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char P30PD:1;
		unsigned char P31PD:1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
	};
} __PDP3bits_t;
extern volatile __PDP3bits_t __at(PDP3_ADDR) PDP3bits;

#define P30PD     	PDP3bits.P30PD      	/* bit 0 */
#define P31PD     	PDP3bits.P31PD      	/* bit 1 */

// ----- T0CR Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char T0PRS0:1;
		unsigned char T0PRS1:1;
		unsigned char T0PRS2:1;
		unsigned char T0CKS0:1;
		unsigned char T0CKS1:1;
		unsigned char :1;
		unsigned char :1;
		unsigned char T0EN:1;
	};
} __T0CRbits_t;
extern volatile __T0CRbits_t __at(T0CR_ADDR) T0CRbits;

#define T0PRS0    	T0CRbits.T0PRS0     	/* bit 0 */
#define T0PRS1    	T0CRbits.T0PRS1     	/* bit 1 */
#define T0PRS2    	T0CRbits.T0PRS2     	/* bit 2 */
#define T0CKS0    	T0CRbits.T0CKS0     	/* bit 3 */
#define T0CKS1    	T0CRbits.T0CKS1     	/* bit 4 */
#define T0EN      	T0CRbits.T0EN       	/* bit 7 */

// ----- T0CNT Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char T0CNT0:1;
		unsigned char T0CNT1:1;
		unsigned char T0CNT2:1;
		unsigned char T0CNT3:1;
		unsigned char T0CNT4:1;
		unsigned char T0CNT5:1;
		unsigned char T0CNT6:1;
		unsigned char T0CNT7:1;
	};
} __T0CNTbits_t;
extern volatile __T0CNTbits_t __at(T0CNT_ADDR) T0CNTbits;

#define T0CNT0    	T0CNTbits.T0CNT0    	/* bit 0 */
#define T0CNT1    	T0CNTbits.T0CNT1    	/* bit 1 */
#define T0CNT2    	T0CNTbits.T0CNT2    	/* bit 2 */
#define T0CNT3    	T0CNTbits.T0CNT3    	/* bit 3 */
#define T0CNT4    	T0CNTbits.T0CNT4    	/* bit 4 */
#define T0CNT5    	T0CNTbits.T0CNT5    	/* bit 5 */
#define T0CNT6    	T0CNTbits.T0CNT6    	/* bit 6 */
#define T0CNT7    	T0CNTbits.T0CNT7    	/* bit 7 */

// ----- T0LOAD Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char T0LOAD0:1;
		unsigned char T0LOAD1:1;
		unsigned char T0LOAD2:1;
		unsigned char T0LOAD3:1;
		unsigned char T0LOAD4:1;
		unsigned char T0LOAD5:1;
		unsigned char T0LOAD6:1;
		unsigned char T0LOAD7:1;
	};
} __T0LOADbits_t;
extern volatile __T0LOADbits_t __at(T0LOAD_ADDR) T0LOADbits;

#define T0LOAD0   	T0LOADbits.T0LOAD0  	/* bit 0 */
#define T0LOAD1   	T0LOADbits.T0LOAD1  	/* bit 1 */
#define T0LOAD2   	T0LOADbits.T0LOAD2  	/* bit 2 */
#define T0LOAD3   	T0LOADbits.T0LOAD3  	/* bit 3 */
#define T0LOAD4   	T0LOADbits.T0LOAD4  	/* bit 4 */
#define T0LOAD5   	T0LOADbits.T0LOAD5  	/* bit 5 */
#define T0LOAD6   	T0LOADbits.T0LOAD6  	/* bit 6 */
#define T0LOAD7   	T0LOADbits.T0LOAD7  	/* bit 7 */

// ----- T1CR Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char T1PRS0:1;
		unsigned char T1PRS1:1;
		unsigned char T1PRS2:1;
		unsigned char T1CKS0:1;
		unsigned char T1CKS1:1;
		unsigned char :1;
		unsigned char :1;
		unsigned char T1EN:1;
	};
} __T1CRbits_t;
extern volatile __T1CRbits_t __at(T1CR_ADDR) T1CRbits;

#define T1PRS0    	T1CRbits.T1PRS0     	/* bit 0 */
#define T1PRS1    	T1CRbits.T1PRS1     	/* bit 1 */
#define T1PRS2    	T1CRbits.T1PRS2     	/* bit 2 */
#define T1CKS0    	T1CRbits.T1CKS0     	/* bit 3 */
#define T1CKS1    	T1CRbits.T1CKS1     	/* bit 4 */
#define T1EN      	T1CRbits.T1EN       	/* bit 7 */

// ----- T1CNT Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char T1CNT0:1;
		unsigned char T1CNT1:1;
		unsigned char T1CNT2:1;
		unsigned char T1CNT3:1;
		unsigned char T1CNT4:1;
		unsigned char T1CNT5:1;
		unsigned char T1CNT6:1;
		unsigned char T1CNT7:1;
	};
} __T1CNTbits_t;
extern volatile __T1CNTbits_t __at(T1CNT_ADDR) T1CNTbits;

#define T1CNT0    	T1CNTbits.T1CNT0    	/* bit 0 */
#define T1CNT1    	T1CNTbits.T1CNT1    	/* bit 1 */
#define T1CNT2    	T1CNTbits.T1CNT2    	/* bit 2 */
#define T1CNT3    	T1CNTbits.T1CNT3    	/* bit 3 */
#define T1CNT4    	T1CNTbits.T1CNT4    	/* bit 4 */
#define T1CNT5    	T1CNTbits.T1CNT5    	/* bit 5 */
#define T1CNT6    	T1CNTbits.T1CNT6    	/* bit 6 */
#define T1CNT7    	T1CNTbits.T1CNT7    	/* bit 7 */

// ----- T1LOAD Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char T1LOAD0:1;
		unsigned char T1LOAD1:1;
		unsigned char T1LOAD2:1;
		unsigned char T1LOAD3:1;
		unsigned char T1LOAD4:1;
		unsigned char T1LOAD5:1;
		unsigned char T1LOAD6:1;
		unsigned char T1LOAD7:1;
	};
} __T1LOADbits_t;
extern volatile __T1LOADbits_t __at(T1LOAD_ADDR) T1LOADbits;

#define T1LOAD0   	T1LOADbits.T1LOAD0  	/* bit 0 */
#define T1LOAD1   	T1LOADbits.T1LOAD1  	/* bit 1 */
#define T1LOAD2   	T1LOADbits.T1LOAD2  	/* bit 2 */
#define T1LOAD3   	T1LOADbits.T1LOAD3  	/* bit 3 */
#define T1LOAD4   	T1LOADbits.T1LOAD4  	/* bit 4 */
#define T1LOAD5   	T1LOADbits.T1LOAD5  	/* bit 5 */
#define T1LOAD6   	T1LOADbits.T1LOAD6  	/* bit 6 */
#define T1LOAD7   	T1LOADbits.T1LOAD7  	/* bit 7 */

// ----- T1DATA Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char T1DATA0:1;
		unsigned char T1DATA1:1;
		unsigned char T1DATA2:1;
		unsigned char T1DATA3:1;
		unsigned char T1DATA4:1;
		unsigned char T1DATA5:1;
		unsigned char T1DATA6:1;
		unsigned char T1DATA7:1;
	};
} __T1DATAbits_t;
extern volatile __T1DATAbits_t __at(T1DATA_ADDR) T1DATAbits;

#define T1DATA0   	T1DATAbits.T1DATA0  	/* bit 0 */
#define T1DATA1   	T1DATAbits.T1DATA1  	/* bit 1 */
#define T1DATA2   	T1DATAbits.T1DATA2  	/* bit 2 */
#define T1DATA3   	T1DATAbits.T1DATA3  	/* bit 3 */
#define T1DATA4   	T1DATAbits.T1DATA4  	/* bit 4 */
#define T1DATA5   	T1DATAbits.T1DATA5  	/* bit 5 */
#define T1DATA6   	T1DATAbits.T1DATA6  	/* bit 6 */
#define T1DATA7   	T1DATAbits.T1DATA7  	/* bit 7 */

// ----- PWM1CR Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char PWM1EC:1;
		unsigned char PWM1NV:1;
		unsigned char PWM1MD0:1;
		unsigned char PWM1MD1:1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
	};
} __PWM1CRbits_t;
extern volatile __PWM1CRbits_t __at(PWM1CR_ADDR) PWM1CRbits;

#define PWM1EC    	PWM1CRbits.PWM1EC   	/* bit 0 */
#define PWM1NV    	PWM1CRbits.PWM1NV   	/* bit 1 */
#define PWM1MD0   	PWM1CRbits.PWM1MD0  	/* bit 2 */
#define PWM1MD1   	PWM1CRbits.PWM1MD1  	/* bit 3 */

// ----- T2CR Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char T2PRS0:1;
		unsigned char T2PRS1:1;
		unsigned char T2PRS2:1;
		unsigned char T2CKS0:1;
		unsigned char T2CKS1:1;
		unsigned char :1;
		unsigned char :1;
		unsigned char T2EN:1;
	};
} __T2CRbits_t;
extern volatile __T2CRbits_t __at(T2CR_ADDR) T2CRbits;

#define T2PRS0    	T2CRbits.T2PRS0     	/* bit 0 */
#define T2PRS1    	T2CRbits.T2PRS1     	/* bit 1 */
#define T2PRS2    	T2CRbits.T2PRS2     	/* bit 2 */
#define T2CKS0    	T2CRbits.T2CKS0     	/* bit 3 */
#define T2CKS1    	T2CRbits.T2CKS1     	/* bit 4 */
#define T2EN      	T2CRbits.T2EN       	/* bit 7 */

// ----- T2CNT Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char T2CNT0:1;
		unsigned char T2CNT1:1;
		unsigned char T2CNT2:1;
		unsigned char T2CNT3:1;
		unsigned char T2CNT4:1;
		unsigned char T2CNT5:1;
		unsigned char T2CNT6:1;
		unsigned char T2CNT7:1;
	};
} __T2CNTbits_t;
extern volatile __T2CNTbits_t __at(T2CNT_ADDR) T2CNTbits;

#define T2CNT0    	T2CNTbits.T2CNT0    	/* bit 0 */
#define T2CNT1    	T2CNTbits.T2CNT1    	/* bit 1 */
#define T2CNT2    	T2CNTbits.T2CNT2    	/* bit 2 */
#define T2CNT3    	T2CNTbits.T2CNT3    	/* bit 3 */
#define T2CNT4    	T2CNTbits.T2CNT4    	/* bit 4 */
#define T2CNT5    	T2CNTbits.T2CNT5    	/* bit 5 */
#define T2CNT6    	T2CNTbits.T2CNT6    	/* bit 6 */
#define T2CNT7    	T2CNTbits.T2CNT7    	/* bit 7 */

// ----- T2LOAD Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char T2LOAD0:1;
		unsigned char T2LOAD1:1;
		unsigned char T2LOAD2:1;
		unsigned char T2LOAD3:1;
		unsigned char T2LOAD4:1;
		unsigned char T2LOAD5:1;
		unsigned char T2LOAD6:1;
		unsigned char T2LOAD7:1;
	};
} __T2LOADbits_t;
extern volatile __T2LOADbits_t __at(T2LOAD_ADDR) T2LOADbits;

#define T2LOAD0   	T2LOADbits.T2LOAD0  	/* bit 0 */
#define T2LOAD1   	T2LOADbits.T2LOAD1  	/* bit 1 */
#define T2LOAD2   	T2LOADbits.T2LOAD2  	/* bit 2 */
#define T2LOAD3   	T2LOADbits.T2LOAD3  	/* bit 3 */
#define T2LOAD4   	T2LOADbits.T2LOAD4  	/* bit 4 */
#define T2LOAD5   	T2LOADbits.T2LOAD5  	/* bit 5 */
#define T2LOAD6   	T2LOADbits.T2LOAD6  	/* bit 6 */
#define T2LOAD7   	T2LOADbits.T2LOAD7  	/* bit 7 */

// ----- T2DATA Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char T2DATA0:1;
		unsigned char T2DATA1:1;
		unsigned char T2DATA2:1;
		unsigned char T2DATA3:1;
		unsigned char T2DATA4:1;
		unsigned char T2DATA5:1;
		unsigned char T2DATA6:1;
		unsigned char T2DATA7:1;
	};
} __T2DATAbits_t;
extern volatile __T2DATAbits_t __at(T2DATA_ADDR) T2DATAbits;

#define T2DATA0   	T2DATAbits.T2DATA0  	/* bit 0 */
#define T2DATA1   	T2DATAbits.T2DATA1  	/* bit 1 */
#define T2DATA2   	T2DATAbits.T2DATA2  	/* bit 2 */
#define T2DATA3   	T2DATAbits.T2DATA3  	/* bit 3 */
#define T2DATA4   	T2DATAbits.T2DATA4  	/* bit 4 */
#define T2DATA5   	T2DATAbits.T2DATA5  	/* bit 5 */
#define T2DATA6   	T2DATAbits.T2DATA6  	/* bit 6 */
#define T2DATA7   	T2DATAbits.T2DATA7  	/* bit 7 */

// ----- T2DATB Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char T2DATB0:1;
		unsigned char T2DATB1:1;
		unsigned char T2DATB2:1;
		unsigned char T2DATB3:1;
		unsigned char T2DATB4:1;
		unsigned char T2DATB5:1;
		unsigned char T2DATB6:1;
		unsigned char T2DATB7:1;
	};
} __T2DATBbits_t;
extern volatile __T2DATBbits_t __at(T2DATB_ADDR) T2DATBbits;

#define T2DATB0   	T2DATBbits.T2DATB0  	/* bit 0 */
#define T2DATB1   	T2DATBbits.T2DATB1  	/* bit 1 */
#define T2DATB2   	T2DATBbits.T2DATB2  	/* bit 2 */
#define T2DATB3   	T2DATBbits.T2DATB3  	/* bit 3 */
#define T2DATB4   	T2DATBbits.T2DATB4  	/* bit 4 */
#define T2DATB5   	T2DATBbits.T2DATB5  	/* bit 5 */
#define T2DATB6   	T2DATBbits.T2DATB6  	/* bit 6 */
#define T2DATB7   	T2DATBbits.T2DATB7  	/* bit 7 */

// ----- PWM2CR Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char PWM2AEC:1;
		unsigned char PWM2ANV:1;
		unsigned char PWM2BEC:1;
		unsigned char PWM2BNV:1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
	};
} __PWM2CRbits_t;
extern volatile __PWM2CRbits_t __at(PWM2CR_ADDR) PWM2CRbits;

#define PWM2AEC   	PWM2CRbits.PWM2AEC  	/* bit 0 */
#define PWM2ANV   	PWM2CRbits.PWM2ANV  	/* bit 1 */
#define PWM2BEC   	PWM2CRbits.PWM2BEC  	/* bit 2 */
#define PWM2BNV   	PWM2CRbits.PWM2BNV  	/* bit 3 */

// ----- T3CR Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char T3PRS0:1;
		unsigned char T3PRS1:1;
		unsigned char T3PRS2:1;
		unsigned char T3CKS0:1;
		unsigned char T3CKS1:1;
		unsigned char T3OS0:1;
		unsigned char T3OS1:1;
		unsigned char T3EN:1;
	};
} __T3CRbits_t;
extern volatile __T3CRbits_t __at(T3CR_ADDR) T3CRbits;

#define T3PRS0    	T3CRbits.T3PRS0     	/* bit 0 */
#define T3PRS1    	T3CRbits.T3PRS1     	/* bit 1 */
#define T3PRS2    	T3CRbits.T3PRS2     	/* bit 2 */
#define T3CKS0    	T3CRbits.T3CKS0     	/* bit 3 */
#define T3CKS1    	T3CRbits.T3CKS1     	/* bit 4 */
#define T3OS0     	T3CRbits.T3OS0      	/* bit 5 */
#define T3OS1     	T3CRbits.T3OS1      	/* bit 6 */
#define T3EN      	T3CRbits.T3EN       	/* bit 7 */

// ----- T3CNTH Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char T3CNT8:1;
		unsigned char T3CNT9:1;
		unsigned char T3CNT10:1;
		unsigned char T3CNT11:1;
		unsigned char T3CNT12:1;
		unsigned char T3CNT13:1;
		unsigned char T3CNT14:1;
		unsigned char T3CNT15:1;
	};
} __T3CNTHbits_t;
extern volatile __T3CNTHbits_t __at(T3CNTH_ADDR) T3CNTHbits;

#define T3CNT8    	T3CNTHbits.T3CNT8   	/* bit 0 */
#define T3CNT9    	T3CNTHbits.T3CNT9   	/* bit 1 */
#define T3CNT10   	T3CNTHbits.T3CNT10  	/* bit 2 */
#define T3CNT11   	T3CNTHbits.T3CNT11  	/* bit 3 */
#define T3CNT12   	T3CNTHbits.T3CNT12  	/* bit 4 */
#define T3CNT13   	T3CNTHbits.T3CNT13  	/* bit 5 */
#define T3CNT14   	T3CNTHbits.T3CNT14  	/* bit 6 */
#define T3CNT15   	T3CNTHbits.T3CNT15  	/* bit 7 */

// ----- T3CNTL Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char T3CNT0:1;
		unsigned char T3CNT1:1;
		unsigned char T3CNT2:1;
		unsigned char T3CNT3:1;
		unsigned char T3CNT4:1;
		unsigned char T3CNT5:1;
		unsigned char T3CNT6:1;
		unsigned char T3CNT7:1;
	};
} __T3CNTLbits_t;
extern volatile __T3CNTLbits_t __at(T3CNTL_ADDR) T3CNTLbits;

#define T3CNT0    	T3CNTLbits.T3CNT0   	/* bit 0 */
#define T3CNT1    	T3CNTLbits.T3CNT1   	/* bit 1 */
#define T3CNT2    	T3CNTLbits.T3CNT2   	/* bit 2 */
#define T3CNT3    	T3CNTLbits.T3CNT3   	/* bit 3 */
#define T3CNT4    	T3CNTLbits.T3CNT4   	/* bit 4 */
#define T3CNT5    	T3CNTLbits.T3CNT5   	/* bit 5 */
#define T3CNT6    	T3CNTLbits.T3CNT6   	/* bit 6 */
#define T3CNT7    	T3CNTLbits.T3CNT7   	/* bit 7 */

// ----- T3LOADH Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char T3LOAD8:1;
		unsigned char T3LOAD9:1;
		unsigned char T3LOAD10:1;
		unsigned char T3LOAD11:1;
		unsigned char T3LOAD12:1;
		unsigned char T3LOAD13:1;
		unsigned char T3LOAD14:1;
		unsigned char T3LOAD15:1;
	};
} __T3LOADHbits_t;
extern volatile __T3LOADHbits_t __at(T3LOADH_ADDR) T3LOADHbits;

#define T3LOAD8   	T3LOADHbits.T3LOAD8 	/* bit 0 */
#define T3LOAD9   	T3LOADHbits.T3LOAD9 	/* bit 1 */
#define T3LOAD10  	T3LOADHbits.T3LOAD10	/* bit 2 */
#define T3LOAD11  	T3LOADHbits.T3LOAD11	/* bit 3 */
#define T3LOAD12  	T3LOADHbits.T3LOAD12	/* bit 4 */
#define T3LOAD13  	T3LOADHbits.T3LOAD13	/* bit 5 */
#define T3LOAD14  	T3LOADHbits.T3LOAD14	/* bit 6 */
#define T3LOAD15  	T3LOADHbits.T3LOAD15	/* bit 7 */

// ----- T3LOADL Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char T3LOAD0:1;
		unsigned char T3LOAD1:1;
		unsigned char T3LOAD2:1;
		unsigned char T3LOAD3:1;
		unsigned char T3LOAD4:1;
		unsigned char T3LOAD5:1;
		unsigned char T3LOAD6:1;
		unsigned char T3LOAD7:1;
	};
} __T3LOADLbits_t;
extern volatile __T3LOADLbits_t __at(T3LOADL_ADDR) T3LOADLbits;

#define T3LOAD0   	T3LOADLbits.T3LOAD0 	/* bit 0 */
#define T3LOAD1   	T3LOADLbits.T3LOAD1 	/* bit 1 */
#define T3LOAD2   	T3LOADLbits.T3LOAD2 	/* bit 2 */
#define T3LOAD3   	T3LOADLbits.T3LOAD3 	/* bit 3 */
#define T3LOAD4   	T3LOADLbits.T3LOAD4 	/* bit 4 */
#define T3LOAD5   	T3LOADLbits.T3LOAD5 	/* bit 5 */
#define T3LOAD6   	T3LOADLbits.T3LOAD6 	/* bit 6 */
#define T3LOAD7   	T3LOADLbits.T3LOAD7 	/* bit 7 */

// ----- P2ADCR Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char :1;
		unsigned char :1;
		unsigned char P22DC:1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
	};
} __P2ADCRbits_t;
extern volatile __P2ADCRbits_t __at(P2ADCR_ADDR) P2ADCRbits;

#define P22DC     	P2ADCRbits.P22DC    	/* bit 2 */

// ----- P3ADCR Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char P30DC:1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
	};
} __P3ADCRbits_t;
extern volatile __P3ADCRbits_t __at(P3ADCR_ADDR) P3ADCRbits;

#define P30DC     	P3ADCRbits.P30DC    	/* bit 0 */

// ----- DKSCR Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
		unsigned char DKLCD:1;
		unsigned char DKSSCM:1;
		unsigned char DKSEN:1;
	};
} __DKSCRbits_t;
extern volatile __DKSCRbits_t __at(DKSCR_ADDR) DKSCRbits;

#define DKLCD     	DKSCRbits.DKLCD     	/* bit 5 */
#define DKSSCM    	DKSCRbits.DKSSCM    	/* bit 6 */
#define DKSEN     	DKSCRbits.DKSEN     	/* bit 7 */

// ----- P0DKCR Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char P00KSE:1;
		unsigned char P01KSE:1;
		unsigned char P02KSE:1;
		unsigned char P03KSE:1;
		unsigned char P04KSE:1;
		unsigned char P05KSE:1;
		unsigned char P06KSE:1;
		unsigned char P07KSE:1;
	};
} __P0DKCRbits_t;
extern volatile __P0DKCRbits_t __at(P0DKCR_ADDR) P0DKCRbits;

#define P00KSE    	P0DKCRbits.P00KSE   	/* bit 0 */
#define P01KSE    	P0DKCRbits.P01KSE   	/* bit 1 */
#define P02KSE    	P0DKCRbits.P02KSE   	/* bit 2 */
#define P03KSE    	P0DKCRbits.P03KSE   	/* bit 3 */
#define P04KSE    	P0DKCRbits.P04KSE   	/* bit 4 */
#define P05KSE    	P0DKCRbits.P05KSE   	/* bit 5 */
#define P06KSE    	P0DKCRbits.P06KSE   	/* bit 6 */
#define P07KSE    	P0DKCRbits.P07KSE   	/* bit 7 */

// ----- P1DKCR Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char P10KSE:1;
		unsigned char P11KSE:1;
		unsigned char P12KSE:1;
		unsigned char P13KSE:1;
		unsigned char P14KSE:1;
		unsigned char P15KSE:1;
		unsigned char P16KSE:1;
		unsigned char P17KSE:1;
	};
} __P1DKCRbits_t;
extern volatile __P1DKCRbits_t __at(P1DKCR_ADDR) P1DKCRbits;

#define P10KSE    	P1DKCRbits.P10KSE   	/* bit 0 */
#define P11KSE    	P1DKCRbits.P11KSE   	/* bit 1 */
#define P12KSE    	P1DKCRbits.P12KSE   	/* bit 2 */
#define P13KSE    	P1DKCRbits.P13KSE   	/* bit 3 */
#define P14KSE    	P1DKCRbits.P14KSE   	/* bit 4 */
#define P15KSE    	P1DKCRbits.P15KSE   	/* bit 5 */
#define P16KSE    	P1DKCRbits.P16KSE   	/* bit 6 */
#define P17KSE    	P1DKCRbits.P17KSE   	/* bit 7 */

// ----- P2DKCR Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char P20KSE:1;
		unsigned char P21KSE:1;
		unsigned char P22KSE:1;
		unsigned char P23KSE:1;
		unsigned char P24KSE:1;
		unsigned char P25KSE:1;
		unsigned char P26KSE:1;
		unsigned char P27KSE:1;
	};
} __P2DKCRbits_t;
extern volatile __P2DKCRbits_t __at(P2DKCR_ADDR) P2DKCRbits;

#define P20KSE    	P2DKCRbits.P20KSE   	/* bit 0 */
#define P21KSE    	P2DKCRbits.P21KSE   	/* bit 1 */
#define P22KSE    	P2DKCRbits.P22KSE   	/* bit 2 */
#define P23KSE    	P2DKCRbits.P23KSE   	/* bit 3 */
#define P24KSE    	P2DKCRbits.P24KSE   	/* bit 4 */
#define P25KSE    	P2DKCRbits.P25KSE   	/* bit 5 */
#define P26KSE    	P2DKCRbits.P26KSE   	/* bit 6 */
#define P27KSE    	P2DKCRbits.P27KSE   	/* bit 7 */

// ----- P3DKCR Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char P30KSE:1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
	};
} __P3DKCRbits_t;
extern volatile __P3DKCRbits_t __at(P3DKCR_ADDR) P3DKCRbits;

#define P30KSE    	P3DKCRbits.P30KSE   	/* bit 0 */

// ----- XTALCR Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char XTVS0:1;
		unsigned char XTVS1:1;
		unsigned char XTSPD:1;
		unsigned char XTREN:1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
	};
} __XTALCRbits_t;
extern volatile __XTALCRbits_t __at(XTALCR_ADDR) XTALCRbits;

#define XTVS0     	XTALCRbits.XTVS0    	/* bit 0 */
#define XTVS1     	XTALCRbits.XTVS1    	/* bit 1 */
#define XTSPD     	XTALCRbits.XTSPD    	/* bit 2 */
#define XTREN     	XTALCRbits.XTREN    	/* bit 3 */

// ----- XTICCAL Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char XTICCAL0:1;
		unsigned char XTICCAL1:1;
		unsigned char XTICCAL2:1;
		unsigned char XTICCAL3:1;
		unsigned char XTICCAL4:1;
		unsigned char XTICCAL5:1;
		unsigned char XTICCAL6:1;
		unsigned char XTICCAL7:1;
	};
} __XTICCALbits_t;
extern volatile __XTICCALbits_t __at(XTICCAL_ADDR) XTICCALbits;

#define XTICCAL0  	XTICCALbits.XTICCAL0	/* bit 0 */
#define XTICCAL1  	XTICCALbits.XTICCAL1	/* bit 1 */
#define XTICCAL2  	XTICCALbits.XTICCAL2	/* bit 2 */
#define XTICCAL3  	XTICCALbits.XTICCAL3	/* bit 3 */
#define XTICCAL4  	XTICCALbits.XTICCAL4	/* bit 4 */
#define XTICCAL5  	XTICCALbits.XTICCAL5	/* bit 5 */
#define XTICCAL6  	XTICCALbits.XTICCAL6	/* bit 6 */
#define XTICCAL7  	XTICCALbits.XTICCAL7	/* bit 7 */

// ----- LCDCR0 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char LCDCT0:1;
		unsigned char LCDCT1:1;
		unsigned char LCDCT2:1;
		unsigned char LCDCT3:1;
		unsigned char LCDTYP:1;
		unsigned char LCDFS:1;
		unsigned char LCDMD:1;
		unsigned char LCDEN:1;
	};
} __LCDCR0bits_t;
extern volatile __LCDCR0bits_t __at(LCDCR0_ADDR) LCDCR0bits;

#define LCDCT0    	LCDCR0bits.LCDCT0   	/* bit 0 */
#define LCDCT1    	LCDCR0bits.LCDCT1   	/* bit 1 */
#define LCDCT2    	LCDCR0bits.LCDCT2   	/* bit 2 */
#define LCDCT3    	LCDCR0bits.LCDCT3   	/* bit 3 */
#define LCDTYP    	LCDCR0bits.LCDTYP   	/* bit 4 */
#define LCDFS     	LCDCR0bits.LCDFS    	/* bit 5 */
#define LCDMD     	LCDCR0bits.LCDMD    	/* bit 6 */
#define LCDEN     	LCDCR0bits.LCDEN    	/* bit 7 */

// ----- LCDCR1 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char P15CE:1;
		unsigned char P16CE:1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
	};
} __LCDCR1bits_t;
extern volatile __LCDCR1bits_t __at(LCDCR1_ADDR) LCDCR1bits;

#define P15CE     	LCDCR1bits.P15CE    	/* bit 0 */
#define P16CE     	LCDCR1bits.P16CE    	/* bit 1 */

// ----- P0LCDCR Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char P00LCDE:1;
		unsigned char P01LCDE:1;
		unsigned char P02LCDE:1;
		unsigned char P03LCDE:1;
		unsigned char P04LCDE:1;
		unsigned char P05LCDE:1;
		unsigned char P06LCDE:1;
		unsigned char P07LCDE:1;
	};
} __P0LCDCRbits_t;
extern volatile __P0LCDCRbits_t __at(P0LCDCR_ADDR) P0LCDCRbits;

#define P00LCDE   	P0LCDCRbits.P00LCDE 	/* bit 0 */
#define P01LCDE   	P0LCDCRbits.P01LCDE 	/* bit 1 */
#define P02LCDE   	P0LCDCRbits.P02LCDE 	/* bit 2 */
#define P03LCDE   	P0LCDCRbits.P03LCDE 	/* bit 3 */
#define P04LCDE   	P0LCDCRbits.P04LCDE 	/* bit 4 */
#define P05LCDE   	P0LCDCRbits.P05LCDE 	/* bit 5 */
#define P06LCDE   	P0LCDCRbits.P06LCDE 	/* bit 6 */
#define P07LCDE   	P0LCDCRbits.P07LCDE 	/* bit 7 */

// ----- P1LCDCR Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char P10LCDE:1;
		unsigned char P11LCDE:1;
		unsigned char P12LCDE:1;
		unsigned char P13LCDE:1;
		unsigned char P14LCDE:1;
		unsigned char P15LCDE:1;
		unsigned char P16LCDE:1;
		unsigned char P17LCDE:1;
	};
} __P1LCDCRbits_t;
extern volatile __P1LCDCRbits_t __at(P1LCDCR_ADDR) P1LCDCRbits;

#define P10LCDE   	P1LCDCRbits.P10LCDE 	/* bit 0 */
#define P11LCDE   	P1LCDCRbits.P11LCDE 	/* bit 1 */
#define P12LCDE   	P1LCDCRbits.P12LCDE 	/* bit 2 */
#define P13LCDE   	P1LCDCRbits.P13LCDE 	/* bit 3 */
#define P14LCDE   	P1LCDCRbits.P14LCDE 	/* bit 4 */
#define P15LCDE   	P1LCDCRbits.P15LCDE 	/* bit 5 */
#define P16LCDE   	P1LCDCRbits.P16LCDE 	/* bit 6 */
#define P17LCDE   	P1LCDCRbits.P17LCDE 	/* bit 7 */

// ----- P2LCDCR Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char P20LCDE:1;
		unsigned char P21LCDE:1;
		unsigned char P22LCDE:1;
		unsigned char P23LCDE:1;
		unsigned char P24LCDE:1;
		unsigned char P25LCDE:1;
		unsigned char P26LCDE:1;
		unsigned char P27LCDE:1;
	};
} __P2LCDCRbits_t;
extern volatile __P2LCDCRbits_t __at(P2LCDCR_ADDR) P2LCDCRbits;

#define P20LCDE   	P2LCDCRbits.P20LCDE 	/* bit 0 */
#define P21LCDE   	P2LCDCRbits.P21LCDE 	/* bit 1 */
#define P22LCDE   	P2LCDCRbits.P22LCDE 	/* bit 2 */
#define P23LCDE   	P2LCDCRbits.P23LCDE 	/* bit 3 */
#define P24LCDE   	P2LCDCRbits.P24LCDE 	/* bit 4 */
#define P25LCDE   	P2LCDCRbits.P25LCDE 	/* bit 5 */
#define P26LCDE   	P2LCDCRbits.P26LCDE 	/* bit 6 */
#define P27LCDE   	P2LCDCRbits.P27LCDE 	/* bit 7 */

// ----- HIRCCAL Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char HIRCCAL0:1;
		unsigned char HIRCCAL1:1;
		unsigned char HIRCCAL2:1;
		unsigned char HIRCCAL3:1;
		unsigned char HIRCCAL4:1;
		unsigned char HIRCCAL5:1;
		unsigned char HIRCCAL6:1;
		unsigned char HIRCCAL7:1;
	};
} __HIRCCALbits_t;
extern volatile __HIRCCALbits_t __at(HIRCCAL_ADDR) HIRCCALbits;

#define HIRCCAL0  	HIRCCALbits.HIRCCAL0	/* bit 0 */
#define HIRCCAL1  	HIRCCALbits.HIRCCAL1	/* bit 1 */
#define HIRCCAL2  	HIRCCALbits.HIRCCAL2	/* bit 2 */
#define HIRCCAL3  	HIRCCALbits.HIRCCAL3	/* bit 3 */
#define HIRCCAL4  	HIRCCALbits.HIRCCAL4	/* bit 4 */
#define HIRCCAL5  	HIRCCALbits.HIRCCAL5	/* bit 5 */
#define HIRCCAL6  	HIRCCALbits.HIRCCAL6	/* bit 6 */
#define HIRCCAL7  	HIRCCALbits.HIRCCAL7	/* bit 7 */

// ----- LIRCCAL Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char LIRCCAL0:1;
		unsigned char LIRCCAL1:1;
		unsigned char LIRCCAL2:1;
		unsigned char LIRCCAL3:1;
		unsigned char LIRCCAL4:1;
		unsigned char LIRCCAL5:1;
		unsigned char LIRCCAL6:1;
		unsigned char LIRCCAL7:1;
	};
} __LIRCCALbits_t;
extern volatile __LIRCCALbits_t __at(LIRCCAL_ADDR) LIRCCALbits;

#define LIRCCAL0  	LIRCCALbits.LIRCCAL0	/* bit 0 */
#define LIRCCAL1  	LIRCCALbits.LIRCCAL1	/* bit 1 */
#define LIRCCAL2  	LIRCCALbits.LIRCCAL2	/* bit 2 */
#define LIRCCAL3  	LIRCCALbits.LIRCCAL3	/* bit 3 */
#define LIRCCAL4  	LIRCCALbits.LIRCCAL4	/* bit 4 */
#define LIRCCAL5  	LIRCCALbits.LIRCCAL5	/* bit 5 */
#define LIRCCAL6  	LIRCCALbits.LIRCCAL6	/* bit 6 */
#define LIRCCAL7  	LIRCCALbits.LIRCCAL7	/* bit 7 */

// ----- IICCR0 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char MRDAT:1;
		unsigned char MTDAT:1;
		unsigned char MTSTP:1;
		unsigned char MTSAA:1;
		unsigned char ACKTS:1;
		unsigned char IICSPD:1;
		unsigned char IICMD:1;
		unsigned char IICEN:1;
	};
} __IICCR0bits_t;
extern volatile __IICCR0bits_t __at(IICCR0_ADDR) IICCR0bits;

#define MRDAT     	IICCR0bits.MRDAT    	/* bit 0 */
#define MTDAT     	IICCR0bits.MTDAT    	/* bit 1 */
#define MTSTP     	IICCR0bits.MTSTP    	/* bit 2 */
#define MTSAA     	IICCR0bits.MTSAA    	/* bit 3 */
#define ACKTS     	IICCR0bits.ACKTS    	/* bit 4 */
#define IICSPD    	IICCR0bits.IICSPD   	/* bit 5 */
#define IICMD     	IICCR0bits.IICMD    	/* bit 6 */
#define IICEN     	IICCR0bits.IICEN    	/* bit 7 */

// ----- IICCR1 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char BSTPF:1;
		unsigned char ACKRF:1;
		unsigned char SDEDF:1;
		unsigned char SCMDF:1;
		unsigned char SADMF:1;
		unsigned char BSTRF:1;
		unsigned char BABER:1;
		unsigned char :1;
	};
} __IICCR1bits_t;
extern volatile __IICCR1bits_t __at(IICCR1_ADDR) IICCR1bits;

#define BSTPF     	IICCR1bits.BSTPF    	/* bit 0 */
#define ACKRF     	IICCR1bits.ACKRF    	/* bit 1 */
#define SDEDF     	IICCR1bits.SDEDF    	/* bit 2 */
#define SCMDF     	IICCR1bits.SCMDF    	/* bit 3 */
#define SADMF     	IICCR1bits.SADMF    	/* bit 4 */
#define BSTRF     	IICCR1bits.BSTRF    	/* bit 5 */
#define BABER     	IICCR1bits.BABER    	/* bit 6 */

// ----- IICCR2 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char IICRUS:1;
		unsigned char IICCHS:1;
		unsigned char IICSYN:1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
	};
} __IICCR2bits_t;
extern volatile __IICCR2bits_t __at(IICCR2_ADDR) IICCR2bits;

#define IICRUS    	IICCR2bits.IICRUS   	/* bit 0 */
#define IICCHS    	IICCR2bits.IICCHS   	/* bit 1 */
#define IICSYN    	IICCR2bits.IICSYN   	/* bit 2 */

// ----- IICDR Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char IICD0:1;
		unsigned char IICD1:1;
		unsigned char IICD2:1;
		unsigned char IICD3:1;
		unsigned char IICD4:1;
		unsigned char IICD5:1;
		unsigned char IICD6:1;
		unsigned char IICD7:1;
	};
} __IICDRbits_t;
extern volatile __IICDRbits_t __at(IICDR_ADDR) IICDRbits;

#define IICD0     	IICDRbits.IICD0     	/* bit 0 */
#define IICD1     	IICDRbits.IICD1     	/* bit 1 */
#define IICD2     	IICDRbits.IICD2     	/* bit 2 */
#define IICD3     	IICDRbits.IICD3     	/* bit 3 */
#define IICD4     	IICDRbits.IICD4     	/* bit 4 */
#define IICD5     	IICDRbits.IICD5     	/* bit 5 */
#define IICD6     	IICDRbits.IICD6     	/* bit 6 */
#define IICD7     	IICDRbits.IICD7     	/* bit 7 */

// ----- IICAR Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char IICWR:1;
		unsigned char IICA0:1;
		unsigned char IICA1:1;
		unsigned char IICA2:1;
		unsigned char IICA3:1;
		unsigned char IICA4:1;
		unsigned char IICA5:1;
		unsigned char IICA6:1;
	};
} __IICARbits_t;
extern volatile __IICARbits_t __at(IICAR_ADDR) IICARbits;

#define IICWR     	IICARbits.IICWR     	/* bit 0 */
#define IICA0     	IICARbits.IICA0     	/* bit 1 */
#define IICA1     	IICARbits.IICA1     	/* bit 2 */
#define IICA2     	IICARbits.IICA2     	/* bit 3 */
#define IICA3     	IICARbits.IICA3     	/* bit 4 */
#define IICA4     	IICARbits.IICA4     	/* bit 5 */
#define IICA5     	IICARbits.IICA5     	/* bit 6 */
#define IICA6     	IICARbits.IICA6     	/* bit 7 */

// ----- IICAAR Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char :1;
		unsigned char IICAA0:1;
		unsigned char IICAA1:1;
		unsigned char IICAA2:1;
		unsigned char IICAA3:1;
		unsigned char IICAA4:1;
		unsigned char IICAA5:1;
		unsigned char IICAA6:1;
	};
} __IICAARbits_t;
extern volatile __IICAARbits_t __at(IICAAR_ADDR) IICAARbits;

#define IICAA0    	IICAARbits.IICAA0   	/* bit 1 */
#define IICAA1    	IICAARbits.IICAA1   	/* bit 2 */
#define IICAA2    	IICAARbits.IICAA2   	/* bit 3 */
#define IICAA3    	IICAARbits.IICAA3   	/* bit 4 */
#define IICAA4    	IICAARbits.IICAA4   	/* bit 5 */
#define IICAA5    	IICAARbits.IICAA5   	/* bit 6 */
#define IICAA6    	IICAARbits.IICAA6   	/* bit 7 */

// ----- IICAMR Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char IICABE:1;
		unsigned char IICAM0:1;
		unsigned char IICAM1:1;
		unsigned char IICAM2:1;
		unsigned char IICAM3:1;
		unsigned char IICAM4:1;
		unsigned char IICAM5:1;
		unsigned char IICAM6:1;
	};
} __IICAMRbits_t;
extern volatile __IICAMRbits_t __at(IICAMR_ADDR) IICAMRbits;

#define IICABE    	IICAMRbits.IICABE   	/* bit 0 */
#define IICAM0    	IICAMRbits.IICAM0   	/* bit 1 */
#define IICAM1    	IICAMRbits.IICAM1   	/* bit 2 */
#define IICAM2    	IICAMRbits.IICAM2   	/* bit 3 */
#define IICAM3    	IICAMRbits.IICAM3   	/* bit 4 */
#define IICAM4    	IICAMRbits.IICAM4   	/* bit 5 */
#define IICAM5    	IICAMRbits.IICAM5   	/* bit 6 */
#define IICAM6    	IICAMRbits.IICAM6   	/* bit 7 */

// ----- URTCR0 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char UPRS0:1;
		unsigned char UPRS1:1;
		unsigned char UPRS2:1;
		unsigned char :1;
		unsigned char UPMD:1;
		unsigned char UPEN:1;
		unsigned char UREN:1;
		unsigned char URTEN:1;
	};
} __URTCR0bits_t;
extern volatile __URTCR0bits_t __at(URTCR0_ADDR) URTCR0bits;

#define UPRS0     	URTCR0bits.UPRS0    	/* bit 0 */
#define UPRS1     	URTCR0bits.UPRS1    	/* bit 1 */
#define UPRS2     	URTCR0bits.UPRS2    	/* bit 2 */
#define UPMD      	URTCR0bits.UPMD     	/* bit 4 */
#define UPEN      	URTCR0bits.UPEN     	/* bit 5 */
#define UREN      	URTCR0bits.UREN     	/* bit 6 */
#define URTEN     	URTCR0bits.URTEN    	/* bit 7 */

// ----- URTCR1 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char USTPF:1;
		unsigned char TXB8:1;
		unsigned char UDATF:1;
		unsigned char UAEN:1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
	};
} __URTCR1bits_t;
extern volatile __URTCR1bits_t __at(URTCR1_ADDR) URTCR1bits;

#define USTPF     	URTCR1bits.USTPF    	/* bit 0 */
#define TXB8      	URTCR1bits.TXB8     	/* bit 1 */
#define UDATF     	URTCR1bits.UDATF    	/* bit 2 */
#define UAEN      	URTCR1bits.UAEN     	/* bit 3 */

// ----- URTCR2 Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char URTMOD:1;
		unsigned char URTPTS:1;
		unsigned char URTCHS:1;
		unsigned char URTLNV:1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
	};
} __URTCR2bits_t;
extern volatile __URTCR2bits_t __at(URTCR2_ADDR) URTCR2bits;

#define URTMOD    	URTCR2bits.URTMOD   	/* bit 0 */
#define URTPTS    	URTCR2bits.URTPTS   	/* bit 1 */
#define URTCHS    	URTCR2bits.URTCHS   	/* bit 2 */
#define URTLNV    	URTCR2bits.URTLNV   	/* bit 3 */

// ----- URTSR Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char RXB8:1;
		unsigned char PERR:1;
		unsigned char TCOL:1;
		unsigned char ROVF:1;
		unsigned char FERR:1;
		unsigned char :1;
		unsigned char :1;
		unsigned char :1;
	};
} __URTSRbits_t;
extern volatile __URTSRbits_t __at(URTSR_ADDR) URTSRbits;

#define RXB8      	URTSRbits.RXB8      	/* bit 0 */
#define PERR      	URTSRbits.PERR      	/* bit 1 */
#define TCOL      	URTSRbits.TCOL      	/* bit 2 */
#define ROVF      	URTSRbits.ROVF      	/* bit 3 */
#define FERR      	URTSRbits.FERR      	/* bit 4 */

// ----- URTBR Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char URTB0:1;
		unsigned char URTB1:1;
		unsigned char URTB2:1;
		unsigned char URTB3:1;
		unsigned char URTB4:1;
		unsigned char URTB5:1;
		unsigned char URTB6:1;
		unsigned char URTB7:1;
	};
} __URTBRbits_t;
extern volatile __URTBRbits_t __at(URTBR_ADDR) URTBRbits;

#define URTB0     	URTBRbits.URTB0     	/* bit 0 */
#define URTB1     	URTBRbits.URTB1     	/* bit 1 */
#define URTB2     	URTBRbits.URTB2     	/* bit 2 */
#define URTB3     	URTBRbits.URTB3     	/* bit 3 */
#define URTB4     	URTBRbits.URTB4     	/* bit 4 */
#define URTB5     	URTBRbits.URTB5     	/* bit 5 */
#define URTB6     	URTBRbits.URTB6     	/* bit 6 */
#define URTB7     	URTBRbits.URTB7     	/* bit 7 */

// ----- URTDR Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char URTD0:1;
		unsigned char URTD1:1;
		unsigned char URTD2:1;
		unsigned char URTD3:1;
		unsigned char URTD4:1;
		unsigned char URTD5:1;
		unsigned char URTD6:1;
		unsigned char URTD7:1;
	};
} __URTDRbits_t;
extern volatile __URTDRbits_t __at(URTDR_ADDR) URTDRbits;

#define URTD0     	URTDRbits.URTD0     	/* bit 0 */
#define URTD1     	URTDRbits.URTD1     	/* bit 1 */
#define URTD2     	URTDRbits.URTD2     	/* bit 2 */
#define URTD3     	URTDRbits.URTD3     	/* bit 3 */
#define URTD4     	URTDRbits.URTD4     	/* bit 4 */
#define URTD5     	URTDRbits.URTD5     	/* bit 5 */
#define URTD6     	URTDRbits.URTD6     	/* bit 6 */
#define URTD7     	URTDRbits.URTD7     	/* bit 7 */

// ----- URTAR Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char URTA0:1;
		unsigned char URTA1:1;
		unsigned char URTA2:1;
		unsigned char URTA3:1;
		unsigned char URTA4:1;
		unsigned char URTA5:1;
		unsigned char URTA6:1;
		unsigned char URTA7:1;
	};
} __URTARbits_t;
extern volatile __URTARbits_t __at(URTAR_ADDR) URTARbits;

#define URTA0     	URTARbits.URTA0     	/* bit 0 */
#define URTA1     	URTARbits.URTA1     	/* bit 1 */
#define URTA2     	URTARbits.URTA2     	/* bit 2 */
#define URTA3     	URTARbits.URTA3     	/* bit 3 */
#define URTA4     	URTARbits.URTA4     	/* bit 4 */
#define URTA5     	URTARbits.URTA5     	/* bit 5 */
#define URTA6     	URTARbits.URTA6     	/* bit 6 */
#define URTA7     	URTARbits.URTA7     	/* bit 7 */

// ----- URTMR Bits --------------------------------------------
typedef union {
	 struct {
		unsigned char URTM0:1;
		unsigned char URTM1:1;
		unsigned char URTM2:1;
		unsigned char URTM3:1;
		unsigned char URTM4:1;
		unsigned char URTM5:1;
		unsigned char URTM6:1;
		unsigned char URTM7:1;
	};
} __URTMRbits_t;
extern volatile __URTMRbits_t __at(URTMR_ADDR) URTMRbits;

#define URTM0     	URTMRbits.URTM0     	/* bit 0 */
#define URTM1     	URTMRbits.URTM1     	/* bit 1 */
#define URTM2     	URTMRbits.URTM2     	/* bit 2 */
#define URTM3     	URTMRbits.URTM3     	/* bit 3 */
#define URTM4     	URTMRbits.URTM4     	/* bit 4 */
#define URTM5     	URTMRbits.URTM5     	/* bit 5 */
#define URTM6     	URTMRbits.URTM6     	/* bit 6 */
#define URTM7     	URTMRbits.URTM7     	/* bit 7 */

#endif
