//
// Register Declarations for Microchip 16F1783 Processor
//
//
// This header file was automatically generated by:
//
//	inc2h.pl
//
//	Copyright (c) 2002, Kevin L. Pauba, All Rights Reserved
//
//	SDCC is licensed under the GNU Public license (GPL) v2.  Note that
//	this license covers the code to the compiler and other executables,
//	but explicitly does not cover any code or objects generated by sdcc.
//	We have not yet decided on a license for the run time libraries, but
//	it will not put any requirements on code linked against it. See:
// 
//	http://www.gnu.org/copyleft/gpl/html
//
//	See http://sdcc.sourceforge.net/ for the latest information on sdcc.
//
// 
#ifndef P16F1783_H
#define P16F1783_H

//
// Register addresses.
//
#define INDF0_ADDR	0x0000
#define INDF1_ADDR	0x0001
#define PCL_ADDR	0x0002
#define STATUS_ADDR	0x0003
#define FSR0_ADDR	0x0004
#define FSR0L_ADDR	0x0004
#define FSR0H_ADDR	0x0005
#define FSR1_ADDR	0x0006
#define FSR1L_ADDR	0x0006
#define FSR1H_ADDR	0x0007
#define BSR_ADDR	0x0008
#define WREG_ADDR	0x0009
#define PCLATH_ADDR	0x000A
#define INTCON_ADDR	0x000B
#define PORTA_ADDR	0x000C
#define PORTB_ADDR	0x000D
#define PORTC_ADDR	0x000E
#define PORTE_ADDR	0x0010
#define PIR1_ADDR	0x0011
#define PIR2_ADDR	0x0012
#define PIR4_ADDR	0x0014
#define TMR0_ADDR	0x0015
#define TMR1_ADDR	0x0016
#define TMR1L_ADDR	0x0016
#define TMR1H_ADDR	0x0017
#define T1CON_ADDR	0x0018
#define T1GCON_ADDR	0x0019
#define TMR2_ADDR	0x001A
#define PR2_ADDR	0x001B
#define T2CON_ADDR	0x001C
#define TRISA_ADDR	0x008C
#define TRISB_ADDR	0x008D
#define TRISC_ADDR	0x008E
#define TRISE_ADDR	0x0090
#define PIE1_ADDR	0x0091
#define PIE2_ADDR	0x0092
#define PIE4_ADDR	0x0094
#define OPTION_REG_ADDR	0x0095
#define PCON_ADDR	0x0096
#define WDTCON_ADDR	0x0097
#define OSCTUNE_ADDR	0x0098
#define OSCCON_ADDR	0x0099
#define OSCSTAT_ADDR	0x009A
#define ADRES_ADDR	0x009B
#define ADRESL_ADDR	0x009B
#define ADRESH_ADDR	0x009C
#define ADCON0_ADDR	0x009D
#define ADCON1_ADDR	0x009E
#define ADCON2_ADDR	0x009F
#define LATA_ADDR	0x010C
#define LATB_ADDR	0x010D
#define LATC_ADDR	0x010E
#define CM1CON0_ADDR	0x0111
#define CM1CON1_ADDR	0x0112
#define CM2CON0_ADDR	0x0113
#define CM2CON1_ADDR	0x0114
#define CMOUT_ADDR	0x0115
#define BORCON_ADDR	0x0116
#define FVRCON_ADDR	0x0117
#define DACCON0_ADDR	0x0118
#define DACCON1_ADDR	0x0119
#define APFCON_ADDR	0x011D
#define APFCON0_ADDR	0x011D
#define CM3CON0_ADDR	0x011E
#define CM3CON1_ADDR	0x011F
#define ANSELA_ADDR	0x018C
#define ANSELB_ADDR	0x018D
#define EEADR_ADDR	0x0191
#define EEADRL_ADDR	0x0191
#define EEADRH_ADDR	0x0192
#define EEDAT_ADDR	0x0193
#define EEDATL_ADDR	0x0193
#define EEDATH_ADDR	0x0194
#define EECON1_ADDR	0x0195
#define EECON2_ADDR	0x0196
#define VREGCON_ADDR	0x0197
#define RC1REG_ADDR	0x0199
#define RCREG_ADDR	0x0199
#define RCREG1_ADDR	0x0199
#define TX1REG_ADDR	0x019A
#define TXREG_ADDR	0x019A
#define TXREG1_ADDR	0x019A
#define SP1BRG_ADDR	0x019B
#define SP1BRGL_ADDR	0x019B
#define SPBRG_ADDR	0x019B
#define SPBRG1_ADDR	0x019B
#define SPBRGL_ADDR	0x019B
#define SP1BRGH_ADDR	0x019C
#define SPBRGH_ADDR	0x019C
#define SPBRGH1_ADDR	0x019C
#define RC1STA_ADDR	0x019D
#define RCSTA_ADDR	0x019D
#define RCSTA1_ADDR	0x019D
#define TX1STA_ADDR	0x019E
#define TXSTA_ADDR	0x019E
#define TXSTA1_ADDR	0x019E
#define BAUD1CON_ADDR	0x019F
#define BAUDCON_ADDR	0x019F
#define BAUDCON1_ADDR	0x019F
#define BAUDCTL_ADDR	0x019F
#define BAUDCTL1_ADDR	0x019F
#define WPUA_ADDR	0x020C
#define WPUB_ADDR	0x020D
#define WPUC_ADDR	0x020E
#define WPUE_ADDR	0x0210
#define SSP1BUF_ADDR	0x0211
#define SSPBUF_ADDR	0x0211
#define SSP1ADD_ADDR	0x0212
#define SSPADD_ADDR	0x0212
#define SSP1MSK_ADDR	0x0213
#define SSPMSK_ADDR	0x0213
#define SSP1STAT_ADDR	0x0214
#define SSPSTAT_ADDR	0x0214
#define SSP1CON_ADDR	0x0215
#define SSPCON_ADDR	0x0215
#define SSPCON1_ADDR	0x0215
#define SSP1CON2_ADDR	0x0216
#define SSPCON2_ADDR	0x0216
#define SSP1CON3_ADDR	0x0217
#define SSPCON3_ADDR	0x0217
#define ODCONA_ADDR	0x028C
#define ODCONB_ADDR	0x028D
#define ODCONC_ADDR	0x028E
#define CCPR1_ADDR	0x0291
#define CCPR1L_ADDR	0x0291
#define CCPR1H_ADDR	0x0292
#define CCP1CON_ADDR	0x0293
#define CCPR2_ADDR	0x0298
#define CCPR2L_ADDR	0x0298
#define CCPR2H_ADDR	0x0299
#define CCP2CON_ADDR	0x029A
#define SLRCONA_ADDR	0x030C
#define SLRCONB_ADDR	0x030D
#define SLRCONC_ADDR	0x030E
#define INLVLA_ADDR	0x038C
#define INLVLB_ADDR	0x038D
#define INLVLC_ADDR	0x038E
#define INLVLE_ADDR	0x0390
#define IOCAP_ADDR	0x0391
#define IOCAN_ADDR	0x0392
#define IOCAF_ADDR	0x0393
#define IOCBP_ADDR	0x0394
#define IOCBN_ADDR	0x0395
#define IOCBF_ADDR	0x0396
#define IOCCP_ADDR	0x0397
#define IOCCN_ADDR	0x0398
#define IOCCF_ADDR	0x0399
#define IOCEP_ADDR	0x039D
#define IOCEN_ADDR	0x039E
#define IOCEF_ADDR	0x039F
#define OPA1CON_ADDR	0x0511
#define OPA2CON_ADDR	0x0513
#define CLKRCON_ADDR	0x051A
#define PSMC1CON_ADDR	0x0811
#define PSMC1MDL_ADDR	0x0812
#define PSMC1SYNC_ADDR	0x0813
#define PSMC1CLK_ADDR	0x0814
#define PSMC1OEN_ADDR	0x0815
#define PSMC1POL_ADDR	0x0816
#define PSMC1BLNK_ADDR	0x0817
#define PSMC1REBS_ADDR	0x0818
#define PSMC1FEBS_ADDR	0x0819
#define PSMC1PHS_ADDR	0x081A
#define PSMC1DCS_ADDR	0x081B
#define PSMC1PRS_ADDR	0x081C
#define PSMC1ASDC_ADDR	0x081D
#define PSMC1ASDL_ADDR	0x081E
#define PSMC1ASDS_ADDR	0x081F
#define PSMC1INT_ADDR	0x0820
#define PSMC1PH_ADDR	0x0821
#define PSMC1PHL_ADDR	0x0821
#define PSMC1PHH_ADDR	0x0822
#define PSMC1DC_ADDR	0x0823
#define PSMC1DCL_ADDR	0x0823
#define PSMC1DCH_ADDR	0x0824
#define PSMC1PR_ADDR	0x0825
#define PSMC1PRL_ADDR	0x0825
#define PSMC1PRH_ADDR	0x0826
#define PSMC1TMR_ADDR	0x0827
#define PSMC1TMRL_ADDR	0x0827
#define PSMC1TMRH_ADDR	0x0828
#define PSMC1DBR_ADDR	0x0829
#define PSMC1DBF_ADDR	0x082A
#define PSMC1BLKR_ADDR	0x082B
#define PSMC1BLKF_ADDR	0x082C
#define PSMC1FFA_ADDR	0x082D
#define PSMC1STR0_ADDR	0x082E
#define PSMC1STR1_ADDR	0x082F
#define PSMC2CON_ADDR	0x0831
#define PSMC2MDL_ADDR	0x0832
#define PSMC2SYNC_ADDR	0x0833
#define PSMC2CLK_ADDR	0x0834
#define PSMC2OEN_ADDR	0x0835
#define PSMC2POL_ADDR	0x0836
#define PSMC2BLNK_ADDR	0x0837
#define PSMC2REBS_ADDR	0x0838
#define PSMC2FEBS_ADDR	0x0839
#define PSMC2PHS_ADDR	0x083A
#define PSMC2DCS_ADDR	0x083B
#define PSMC2PRS_ADDR	0x083C
#define PSMC2ASDC_ADDR	0x083D
#define PSMC2ASDL_ADDR	0x083E
#define PSMC2ASDS_ADDR	0x083F
#define PSMC2INT_ADDR	0x0840
#define PSMC2PH_ADDR	0x0841
#define PSMC2PHL_ADDR	0x0841
#define PSMC2PHH_ADDR	0x0842
#define PSMC2DC_ADDR	0x0843
#define PSMC2DCL_ADDR	0x0843
#define PSMC2DCH_ADDR	0x0844
#define PSMC2PR_ADDR	0x0845
#define PSMC2PRL_ADDR	0x0845
#define PSMC2PRH_ADDR	0x0846
#define PSMC2TMR_ADDR	0x0847
#define PSMC2TMRL_ADDR	0x0847
#define PSMC2TMRH_ADDR	0x0848
#define PSMC2DBR_ADDR	0x0849
#define PSMC2DBF_ADDR	0x084A
#define PSMC2BLKR_ADDR	0x084B
#define PSMC2BLKF_ADDR	0x084C
#define PSMC2FFA_ADDR	0x084D
#define PSMC2STR0_ADDR	0x084E
#define PSMC2STR1_ADDR	0x084F
#define STATUS_SHAD_ADDR	0x0FE4
#define WREG_SHAD_ADDR	0x0FE5
#define BSR_SHAD_ADDR	0x0FE6
#define PCLATH_SHAD_ADDR	0x0FE7
#define FSR0L_SHAD_ADDR	0x0FE8
#define FSR0H_SHAD_ADDR	0x0FE9
#define FSR1L_SHAD_ADDR	0x0FEA
#define FSR1H_SHAD_ADDR	0x0FEB
#define STKPTR_ADDR	0x0FED
#define TOSL_ADDR	0x0FEE
#define TOSH_ADDR	0x0FEF

//
// Memory organization.
//



//         LIST

//==========================================================================
//  MPASM PIC16F1783 processor include
// 
//  (c) Copyright 1999-2011 Microchip Technology, All rights reserved
//==========================================================================

//         NOLIST

//==========================================================================
//  This header file defines configurations, registers, and other useful
//  bits of information for the PIC16F1783 microcontroller.  These names
//  are taken to match the data sheets as closely as possible.
//
//  Note that the processor must be selected before this file is included.
//  The processor may be selected the following ways:
//
//       1. Command line switch:
//               C:\MPASM MYFILE.ASM /PIC16F1783
//       2. LIST directive in the source file
//               LIST   P=PIC16F1783
//       3. Processor Type entry in the MPASM full-screen interface
//       4. Setting the processor in the MPLAB Project Dialog
//==========================================================================

//==========================================================================
//
//       Verify Processor
//
//==========================================================================
//        IFNDEF __16F1783
//            MESSG "Processor-header file mismatch.  Verify selected processor."
//         ENDIF



//==========================================================================
//
//       Register Definitions
//
//==========================================================================

#define W                    0x0000
#define F                    0x0001

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

//-----Bank0------------------
extern __sfr  __at (INDF0_ADDR)                   INDF0;
extern __sfr  __at (INDF1_ADDR)                   INDF1;
extern __sfr  __at (PCL_ADDR)                     PCL;
extern __sfr  __at (STATUS_ADDR)                  STATUS;
extern __sfr  __at (FSR0_ADDR)                    FSR0;
extern __sfr  __at (FSR0L_ADDR)                   FSR0L;
extern __sfr  __at (FSR0H_ADDR)                   FSR0H;
extern __sfr  __at (FSR1_ADDR)                    FSR1;
extern __sfr  __at (FSR1L_ADDR)                   FSR1L;
extern __sfr  __at (FSR1H_ADDR)                   FSR1H;
extern __sfr  __at (BSR_ADDR)                     BSR;
extern __sfr  __at (WREG_ADDR)                    WREG;
extern __sfr  __at (PCLATH_ADDR)                  PCLATH;
extern __sfr  __at (INTCON_ADDR)                  INTCON;
extern __sfr  __at (PORTA_ADDR)                   PORTA;
extern __sfr  __at (PORTB_ADDR)                   PORTB;
extern __sfr  __at (PORTC_ADDR)                   PORTC;
extern __sfr  __at (PORTE_ADDR)                   PORTE;
extern __sfr  __at (PIR1_ADDR)                    PIR1;
extern __sfr  __at (PIR2_ADDR)                    PIR2;
extern __sfr  __at (PIR4_ADDR)                    PIR4;
extern __sfr  __at (TMR0_ADDR)                    TMR0;
extern __sfr  __at (TMR1_ADDR)                    TMR1;
extern __sfr  __at (TMR1L_ADDR)                   TMR1L;
extern __sfr  __at (TMR1H_ADDR)                   TMR1H;
extern __sfr  __at (T1CON_ADDR)                   T1CON;
extern __sfr  __at (T1GCON_ADDR)                  T1GCON;
extern __sfr  __at (TMR2_ADDR)                    TMR2;
extern __sfr  __at (PR2_ADDR)                     PR2;
extern __sfr  __at (T2CON_ADDR)                   T2CON;

//-----Bank1------------------
extern __sfr  __at (TRISA_ADDR)                   TRISA;
extern __sfr  __at (TRISB_ADDR)                   TRISB;
extern __sfr  __at (TRISC_ADDR)                   TRISC;
extern __sfr  __at (TRISE_ADDR)                   TRISE;
extern __sfr  __at (PIE1_ADDR)                    PIE1;
extern __sfr  __at (PIE2_ADDR)                    PIE2;
extern __sfr  __at (PIE4_ADDR)                    PIE4;
extern __sfr  __at (OPTION_REG_ADDR)              OPTION_REG;
extern __sfr  __at (PCON_ADDR)                    PCON;
extern __sfr  __at (WDTCON_ADDR)                  WDTCON;
extern __sfr  __at (OSCTUNE_ADDR)                 OSCTUNE;
extern __sfr  __at (OSCCON_ADDR)                  OSCCON;
extern __sfr  __at (OSCSTAT_ADDR)                 OSCSTAT;
extern __sfr  __at (ADRES_ADDR)                   ADRES;
extern __sfr  __at (ADRESL_ADDR)                  ADRESL;
extern __sfr  __at (ADRESH_ADDR)                  ADRESH;
extern __sfr  __at (ADCON0_ADDR)                  ADCON0;
extern __sfr  __at (ADCON1_ADDR)                  ADCON1;
extern __sfr  __at (ADCON2_ADDR)                  ADCON2;

//-----Bank2------------------
extern __sfr  __at (LATA_ADDR)                    LATA;
extern __sfr  __at (LATB_ADDR)                    LATB;
extern __sfr  __at (LATC_ADDR)                    LATC;
extern __sfr  __at (CM1CON0_ADDR)                 CM1CON0;
extern __sfr  __at (CM1CON1_ADDR)                 CM1CON1;
extern __sfr  __at (CM2CON0_ADDR)                 CM2CON0;
extern __sfr  __at (CM2CON1_ADDR)                 CM2CON1;
extern __sfr  __at (CMOUT_ADDR)                   CMOUT;
extern __sfr  __at (BORCON_ADDR)                  BORCON;
extern __sfr  __at (FVRCON_ADDR)                  FVRCON;
extern __sfr  __at (DACCON0_ADDR)                 DACCON0;
extern __sfr  __at (DACCON1_ADDR)                 DACCON1;
extern __sfr  __at (APFCON_ADDR)                  APFCON;
extern __sfr  __at (APFCON0_ADDR)                 APFCON0;
extern __sfr  __at (CM3CON0_ADDR)                 CM3CON0;
extern __sfr  __at (CM3CON1_ADDR)                 CM3CON1;

//-----Bank3------------------
extern __sfr  __at (ANSELA_ADDR)                  ANSELA;
extern __sfr  __at (ANSELB_ADDR)                  ANSELB;
extern __sfr  __at (EEADR_ADDR)                   EEADR;
extern __sfr  __at (EEADRL_ADDR)                  EEADRL;
extern __sfr  __at (EEADRH_ADDR)                  EEADRH;
extern __sfr  __at (EEDAT_ADDR)                   EEDAT;
extern __sfr  __at (EEDATL_ADDR)                  EEDATL;
extern __sfr  __at (EEDATH_ADDR)                  EEDATH;
extern __sfr  __at (EECON1_ADDR)                  EECON1;
extern __sfr  __at (EECON2_ADDR)                  EECON2;
extern __sfr  __at (VREGCON_ADDR)                 VREGCON;
extern __sfr  __at (RC1REG_ADDR)                  RC1REG;
extern __sfr  __at (RCREG_ADDR)                   RCREG;
extern __sfr  __at (RCREG1_ADDR)                  RCREG1;
extern __sfr  __at (TX1REG_ADDR)                  TX1REG;
extern __sfr  __at (TXREG_ADDR)                   TXREG;
extern __sfr  __at (TXREG1_ADDR)                  TXREG1;
extern __sfr  __at (SP1BRG_ADDR)                  SP1BRG;
extern __sfr  __at (SP1BRGL_ADDR)                 SP1BRGL;
extern __sfr  __at (SPBRG_ADDR)                   SPBRG;
extern __sfr  __at (SPBRG1_ADDR)                  SPBRG1;
extern __sfr  __at (SPBRGL_ADDR)                  SPBRGL;
extern __sfr  __at (SP1BRGH_ADDR)                 SP1BRGH;
extern __sfr  __at (SPBRGH_ADDR)                  SPBRGH;
extern __sfr  __at (SPBRGH1_ADDR)                 SPBRGH1;
extern __sfr  __at (RC1STA_ADDR)                  RC1STA;
extern __sfr  __at (RCSTA_ADDR)                   RCSTA;
extern __sfr  __at (RCSTA1_ADDR)                  RCSTA1;
extern __sfr  __at (TX1STA_ADDR)                  TX1STA;
extern __sfr  __at (TXSTA_ADDR)                   TXSTA;
extern __sfr  __at (TXSTA1_ADDR)                  TXSTA1;
extern __sfr  __at (BAUD1CON_ADDR)                BAUD1CON;
extern __sfr  __at (BAUDCON_ADDR)                 BAUDCON;
extern __sfr  __at (BAUDCON1_ADDR)                BAUDCON1;
extern __sfr  __at (BAUDCTL_ADDR)                 BAUDCTL;
extern __sfr  __at (BAUDCTL1_ADDR)                BAUDCTL1;

//-----Bank4------------------
extern __sfr  __at (WPUA_ADDR)                    WPUA;
extern __sfr  __at (WPUB_ADDR)                    WPUB;
extern __sfr  __at (WPUC_ADDR)                    WPUC;
extern __sfr  __at (WPUE_ADDR)                    WPUE;
extern __sfr  __at (SSP1BUF_ADDR)                 SSP1BUF;
extern __sfr  __at (SSPBUF_ADDR)                  SSPBUF;
extern __sfr  __at (SSP1ADD_ADDR)                 SSP1ADD;
extern __sfr  __at (SSPADD_ADDR)                  SSPADD;
extern __sfr  __at (SSP1MSK_ADDR)                 SSP1MSK;
extern __sfr  __at (SSPMSK_ADDR)                  SSPMSK;
extern __sfr  __at (SSP1STAT_ADDR)                SSP1STAT;
extern __sfr  __at (SSPSTAT_ADDR)                 SSPSTAT;
extern __sfr  __at (SSP1CON_ADDR)                 SSP1CON;
extern __sfr  __at (SSPCON_ADDR)                  SSPCON;
extern __sfr  __at (SSPCON1_ADDR)                 SSPCON1;
extern __sfr  __at (SSP1CON2_ADDR)                SSP1CON2;
extern __sfr  __at (SSPCON2_ADDR)                 SSPCON2;
extern __sfr  __at (SSP1CON3_ADDR)                SSP1CON3;
extern __sfr  __at (SSPCON3_ADDR)                 SSPCON3;

//-----Bank5------------------
extern __sfr  __at (ODCONA_ADDR)                  ODCONA;
extern __sfr  __at (ODCONB_ADDR)                  ODCONB;
extern __sfr  __at (ODCONC_ADDR)                  ODCONC;
extern __sfr  __at (CCPR1_ADDR)                   CCPR1;
extern __sfr  __at (CCPR1L_ADDR)                  CCPR1L;
extern __sfr  __at (CCPR1H_ADDR)                  CCPR1H;
extern __sfr  __at (CCP1CON_ADDR)                 CCP1CON;
extern __sfr  __at (CCPR2_ADDR)                   CCPR2;
extern __sfr  __at (CCPR2L_ADDR)                  CCPR2L;
extern __sfr  __at (CCPR2H_ADDR)                  CCPR2H;
extern __sfr  __at (CCP2CON_ADDR)                 CCP2CON;

//-----Bank6------------------
extern __sfr  __at (SLRCONA_ADDR)                 SLRCONA;
extern __sfr  __at (SLRCONB_ADDR)                 SLRCONB;
extern __sfr  __at (SLRCONC_ADDR)                 SLRCONC;

//-----Bank7------------------
extern __sfr  __at (INLVLA_ADDR)                  INLVLA;
extern __sfr  __at (INLVLB_ADDR)                  INLVLB;
extern __sfr  __at (INLVLC_ADDR)                  INLVLC;
extern __sfr  __at (INLVLE_ADDR)                  INLVLE;
extern __sfr  __at (IOCAP_ADDR)                   IOCAP;
extern __sfr  __at (IOCAN_ADDR)                   IOCAN;
extern __sfr  __at (IOCAF_ADDR)                   IOCAF;
extern __sfr  __at (IOCBP_ADDR)                   IOCBP;
extern __sfr  __at (IOCBN_ADDR)                   IOCBN;
extern __sfr  __at (IOCBF_ADDR)                   IOCBF;
extern __sfr  __at (IOCCP_ADDR)                   IOCCP;
extern __sfr  __at (IOCCN_ADDR)                   IOCCN;
extern __sfr  __at (IOCCF_ADDR)                   IOCCF;
extern __sfr  __at (IOCEP_ADDR)                   IOCEP;
extern __sfr  __at (IOCEN_ADDR)                   IOCEN;
extern __sfr  __at (IOCEF_ADDR)                   IOCEF;

//-----Bank10------------------
extern __sfr  __at (OPA1CON_ADDR)                 OPA1CON;
extern __sfr  __at (OPA2CON_ADDR)                 OPA2CON;
extern __sfr  __at (CLKRCON_ADDR)                 CLKRCON;

//-----Bank16------------------
extern __sfr  __at (PSMC1CON_ADDR)                PSMC1CON;
extern __sfr  __at (PSMC1MDL_ADDR)                PSMC1MDL;
extern __sfr  __at (PSMC1SYNC_ADDR)               PSMC1SYNC;
extern __sfr  __at (PSMC1CLK_ADDR)                PSMC1CLK;
extern __sfr  __at (PSMC1OEN_ADDR)                PSMC1OEN;
extern __sfr  __at (PSMC1POL_ADDR)                PSMC1POL;
extern __sfr  __at (PSMC1BLNK_ADDR)               PSMC1BLNK;
extern __sfr  __at (PSMC1REBS_ADDR)               PSMC1REBS;
extern __sfr  __at (PSMC1FEBS_ADDR)               PSMC1FEBS;
extern __sfr  __at (PSMC1PHS_ADDR)                PSMC1PHS;
extern __sfr  __at (PSMC1DCS_ADDR)                PSMC1DCS;
extern __sfr  __at (PSMC1PRS_ADDR)                PSMC1PRS;
extern __sfr  __at (PSMC1ASDC_ADDR)               PSMC1ASDC;
extern __sfr  __at (PSMC1ASDL_ADDR)               PSMC1ASDL;
extern __sfr  __at (PSMC1ASDS_ADDR)               PSMC1ASDS;
extern __sfr  __at (PSMC1INT_ADDR)                PSMC1INT;
extern __sfr  __at (PSMC1PH_ADDR)                 PSMC1PH;
extern __sfr  __at (PSMC1PHL_ADDR)                PSMC1PHL;
extern __sfr  __at (PSMC1PHH_ADDR)                PSMC1PHH;
extern __sfr  __at (PSMC1DC_ADDR)                 PSMC1DC;
extern __sfr  __at (PSMC1DCL_ADDR)                PSMC1DCL;
extern __sfr  __at (PSMC1DCH_ADDR)                PSMC1DCH;
extern __sfr  __at (PSMC1PR_ADDR)                 PSMC1PR;
extern __sfr  __at (PSMC1PRL_ADDR)                PSMC1PRL;
extern __sfr  __at (PSMC1PRH_ADDR)                PSMC1PRH;
extern __sfr  __at (PSMC1TMR_ADDR)                PSMC1TMR;
extern __sfr  __at (PSMC1TMRL_ADDR)               PSMC1TMRL;
extern __sfr  __at (PSMC1TMRH_ADDR)               PSMC1TMRH;
extern __sfr  __at (PSMC1DBR_ADDR)                PSMC1DBR;
extern __sfr  __at (PSMC1DBF_ADDR)                PSMC1DBF;
extern __sfr  __at (PSMC1BLKR_ADDR)               PSMC1BLKR;
extern __sfr  __at (PSMC1BLKF_ADDR)               PSMC1BLKF;
extern __sfr  __at (PSMC1FFA_ADDR)                PSMC1FFA;
extern __sfr  __at (PSMC1STR0_ADDR)               PSMC1STR0;
extern __sfr  __at (PSMC1STR1_ADDR)               PSMC1STR1;
extern __sfr  __at (PSMC2CON_ADDR)                PSMC2CON;
extern __sfr  __at (PSMC2MDL_ADDR)                PSMC2MDL;
extern __sfr  __at (PSMC2SYNC_ADDR)               PSMC2SYNC;
extern __sfr  __at (PSMC2CLK_ADDR)                PSMC2CLK;
extern __sfr  __at (PSMC2OEN_ADDR)                PSMC2OEN;
extern __sfr  __at (PSMC2POL_ADDR)                PSMC2POL;
extern __sfr  __at (PSMC2BLNK_ADDR)               PSMC2BLNK;
extern __sfr  __at (PSMC2REBS_ADDR)               PSMC2REBS;
extern __sfr  __at (PSMC2FEBS_ADDR)               PSMC2FEBS;
extern __sfr  __at (PSMC2PHS_ADDR)                PSMC2PHS;
extern __sfr  __at (PSMC2DCS_ADDR)                PSMC2DCS;
extern __sfr  __at (PSMC2PRS_ADDR)                PSMC2PRS;
extern __sfr  __at (PSMC2ASDC_ADDR)               PSMC2ASDC;
extern __sfr  __at (PSMC2ASDL_ADDR)               PSMC2ASDL;
extern __sfr  __at (PSMC2ASDS_ADDR)               PSMC2ASDS;
extern __sfr  __at (PSMC2INT_ADDR)                PSMC2INT;
extern __sfr  __at (PSMC2PH_ADDR)                 PSMC2PH;
extern __sfr  __at (PSMC2PHL_ADDR)                PSMC2PHL;
extern __sfr  __at (PSMC2PHH_ADDR)                PSMC2PHH;
extern __sfr  __at (PSMC2DC_ADDR)                 PSMC2DC;
extern __sfr  __at (PSMC2DCL_ADDR)                PSMC2DCL;
extern __sfr  __at (PSMC2DCH_ADDR)                PSMC2DCH;
extern __sfr  __at (PSMC2PR_ADDR)                 PSMC2PR;
extern __sfr  __at (PSMC2PRL_ADDR)                PSMC2PRL;
extern __sfr  __at (PSMC2PRH_ADDR)                PSMC2PRH;
extern __sfr  __at (PSMC2TMR_ADDR)                PSMC2TMR;
extern __sfr  __at (PSMC2TMRL_ADDR)               PSMC2TMRL;
extern __sfr  __at (PSMC2TMRH_ADDR)               PSMC2TMRH;
extern __sfr  __at (PSMC2DBR_ADDR)                PSMC2DBR;
extern __sfr  __at (PSMC2DBF_ADDR)                PSMC2DBF;
extern __sfr  __at (PSMC2BLKR_ADDR)               PSMC2BLKR;
extern __sfr  __at (PSMC2BLKF_ADDR)               PSMC2BLKF;
extern __sfr  __at (PSMC2FFA_ADDR)                PSMC2FFA;
extern __sfr  __at (PSMC2STR0_ADDR)               PSMC2STR0;
extern __sfr  __at (PSMC2STR1_ADDR)               PSMC2STR1;

//-----Bank31------------------
extern __sfr  __at (STATUS_SHAD_ADDR)             STATUS_SHAD;
extern __sfr  __at (WREG_SHAD_ADDR)               WREG_SHAD;
extern __sfr  __at (BSR_SHAD_ADDR)                BSR_SHAD;
extern __sfr  __at (PCLATH_SHAD_ADDR)             PCLATH_SHAD;
extern __sfr  __at (FSR0L_SHAD_ADDR)              FSR0L_SHAD;
extern __sfr  __at (FSR0H_SHAD_ADDR)              FSR0H_SHAD;
extern __sfr  __at (FSR1L_SHAD_ADDR)              FSR1L_SHAD;
extern __sfr  __at (FSR1H_SHAD_ADDR)              FSR1H_SHAD;
extern __sfr  __at (STKPTR_ADDR)                  STKPTR;
extern __sfr  __at (TOSL_ADDR)                    TOSL;
extern __sfr  __at (TOSH_ADDR)                    TOSH;

//----- STATUS Bits -----------------------------------------------------


//----- BSR Bits -----------------------------------------------------



//----- INTCON Bits -----------------------------------------------------



//----- PORTA Bits -----------------------------------------------------



//----- PORTB Bits -----------------------------------------------------



//----- PORTC Bits -----------------------------------------------------



//----- PORTE Bits -----------------------------------------------------


//----- PIR1 Bits -----------------------------------------------------


//----- PIR2 Bits -----------------------------------------------------


//----- PIR4 Bits -----------------------------------------------------


//----- T1CON Bits -----------------------------------------------------



//----- T1GCON Bits -----------------------------------------------------



//----- T2CON Bits -----------------------------------------------------



//----- TRISA Bits -----------------------------------------------------



//----- TRISB Bits -----------------------------------------------------



//----- TRISC Bits -----------------------------------------------------



//----- TRISE Bits -----------------------------------------------------


//----- PIE1 Bits -----------------------------------------------------


//----- PIE2 Bits -----------------------------------------------------


//----- PIE4 Bits -----------------------------------------------------


//----- OPTION_REG Bits -----------------------------------------------------



//----- PCON Bits -----------------------------------------------------


//----- WDTCON Bits -----------------------------------------------------



//----- OSCTUNE Bits -----------------------------------------------------



//----- OSCCON Bits -----------------------------------------------------



//----- OSCSTAT Bits -----------------------------------------------------


//----- ADCON0 Bits -----------------------------------------------------





//----- ADCON1 Bits -----------------------------------------------------



//----- ADCON2 Bits -----------------------------------------------------



//----- LATA Bits -----------------------------------------------------



//----- LATB Bits -----------------------------------------------------



//----- LATC Bits -----------------------------------------------------



//----- CM1CON0 Bits -----------------------------------------------------


//----- CM1CON1 Bits -----------------------------------------------------



//----- CM2CON0 Bits -----------------------------------------------------


//----- CM2CON1 Bits -----------------------------------------------------



//----- CMOUT Bits -----------------------------------------------------


//----- BORCON Bits -----------------------------------------------------


//----- FVRCON Bits -----------------------------------------------------



//----- DACCON0 Bits -----------------------------------------------------



//----- DACCON1 Bits -----------------------------------------------------



//----- APFCON Bits -----------------------------------------------------


//----- APFCON0 Bits -----------------------------------------------------


//----- CM3CON0 Bits -----------------------------------------------------


//----- CM3CON1 Bits -----------------------------------------------------



//----- ANSELA Bits -----------------------------------------------------



//----- ANSELB Bits -----------------------------------------------------



//----- EECON1 Bits -----------------------------------------------------


//----- VREGCON Bits -----------------------------------------------------


//----- RC1STA Bits -----------------------------------------------------


//----- RCSTA Bits -----------------------------------------------------


//----- RCSTA1 Bits -----------------------------------------------------


//----- TX1STA Bits -----------------------------------------------------


//----- TXSTA Bits -----------------------------------------------------


//----- TXSTA1 Bits -----------------------------------------------------


//----- BAUD1CON Bits -----------------------------------------------------


//----- BAUDCON Bits -----------------------------------------------------


//----- BAUDCON1 Bits -----------------------------------------------------


//----- BAUDCTL Bits -----------------------------------------------------


//----- BAUDCTL1 Bits -----------------------------------------------------


//----- WPUA Bits -----------------------------------------------------



//----- WPUB Bits -----------------------------------------------------



//----- WPUC Bits -----------------------------------------------------



//----- WPUE Bits -----------------------------------------------------


//----- SSP1STAT Bits -----------------------------------------------------


//----- SSPSTAT Bits -----------------------------------------------------


//----- SSP1CON Bits -----------------------------------------------------



//----- SSPCON Bits -----------------------------------------------------



//----- SSPCON1 Bits -----------------------------------------------------



//----- SSP1CON2 Bits -----------------------------------------------------


//----- SSPCON2 Bits -----------------------------------------------------


//----- SSP1CON3 Bits -----------------------------------------------------


//----- SSPCON3 Bits -----------------------------------------------------


//----- ODCONA Bits -----------------------------------------------------



//----- ODCONB Bits -----------------------------------------------------



//----- ODCONC Bits -----------------------------------------------------



//----- CCP1CON Bits -----------------------------------------------------



//----- CCP2CON Bits -----------------------------------------------------



//----- SLRCONA Bits -----------------------------------------------------



//----- SLRCONB Bits -----------------------------------------------------



//----- SLRCONC Bits -----------------------------------------------------



//----- INLVLA Bits -----------------------------------------------------



//----- INLVLB Bits -----------------------------------------------------



//----- INLVLC Bits -----------------------------------------------------



//----- INLVLE Bits -----------------------------------------------------


//----- IOCAP Bits -----------------------------------------------------



//----- IOCAN Bits -----------------------------------------------------



//----- IOCAF Bits -----------------------------------------------------



//----- IOCBP Bits -----------------------------------------------------



//----- IOCBN Bits -----------------------------------------------------



//----- IOCBF Bits -----------------------------------------------------



//----- IOCCP Bits -----------------------------------------------------



//----- IOCCN Bits -----------------------------------------------------



//----- IOCCF Bits -----------------------------------------------------



//----- IOCEP Bits -----------------------------------------------------


//----- IOCEN Bits -----------------------------------------------------


//----- IOCEF Bits -----------------------------------------------------


//----- OPA1CON Bits -----------------------------------------------------



//----- OPA2CON Bits -----------------------------------------------------



//----- CLKRCON Bits -----------------------------------------------------



//----- PSMC1CON Bits -----------------------------------------------------



//----- PSMC1MDL Bits -----------------------------------------------------



//----- PSMC1SYNC Bits -----------------------------------------------------


//----- PSMC1CLK Bits -----------------------------------------------------



//----- PSMC1OEN Bits -----------------------------------------------------


//----- PSMC1POL Bits -----------------------------------------------------


//----- PSMC1BLNK Bits -----------------------------------------------------


//----- PSMC1REBS Bits -----------------------------------------------------


//----- PSMC1FEBS Bits -----------------------------------------------------


//----- PSMC1PHS Bits -----------------------------------------------------


//----- PSMC1DCS Bits -----------------------------------------------------


//----- PSMC1PRS Bits -----------------------------------------------------


//----- PSMC1ASDC Bits -----------------------------------------------------


//----- PSMC1ASDL Bits -----------------------------------------------------


//----- PSMC1ASDS Bits -----------------------------------------------------


//----- PSMC1INT Bits -----------------------------------------------------


//----- PSMC1PHL Bits -----------------------------------------------------


//----- PSMC1PHH Bits -----------------------------------------------------


//----- PSMC1DCL Bits -----------------------------------------------------


//----- PSMC1DCH Bits -----------------------------------------------------


//----- PSMC1PRL Bits -----------------------------------------------------


//----- PSMC1PRH Bits -----------------------------------------------------


//----- PSMC1TMRL Bits -----------------------------------------------------


//----- PSMC1TMRH Bits -----------------------------------------------------


//----- PSMC1DBR Bits -----------------------------------------------------


//----- PSMC1DBF Bits -----------------------------------------------------


//----- PSMC1BLKR Bits -----------------------------------------------------


//----- PSMC1BLKF Bits -----------------------------------------------------


//----- PSMC1FFA Bits -----------------------------------------------------


//----- PSMC1STR0 Bits -----------------------------------------------------


//----- PSMC1STR1 Bits -----------------------------------------------------


//----- PSMC2CON Bits -----------------------------------------------------



//----- PSMC2MDL Bits -----------------------------------------------------



//----- PSMC2SYNC Bits -----------------------------------------------------


//----- PSMC2CLK Bits -----------------------------------------------------



//----- PSMC2OEN Bits -----------------------------------------------------


//----- PSMC2POL Bits -----------------------------------------------------


//----- PSMC2BLNK Bits -----------------------------------------------------


//----- PSMC2REBS Bits -----------------------------------------------------


//----- PSMC2FEBS Bits -----------------------------------------------------


//----- PSMC2PHS Bits -----------------------------------------------------


//----- PSMC2DCS Bits -----------------------------------------------------


//----- PSMC2PRS Bits -----------------------------------------------------


//----- PSMC2ASDC Bits -----------------------------------------------------


//----- PSMC2ASDL Bits -----------------------------------------------------


//----- PSMC2ASDS Bits -----------------------------------------------------


//----- PSMC2INT Bits -----------------------------------------------------


//----- PSMC2PHL Bits -----------------------------------------------------


//----- PSMC2PHH Bits -----------------------------------------------------


//----- PSMC2DCL Bits -----------------------------------------------------


//----- PSMC2DCH Bits -----------------------------------------------------


//----- PSMC2PRL Bits -----------------------------------------------------


//----- PSMC2PRH Bits -----------------------------------------------------


//----- PSMC2TMRL Bits -----------------------------------------------------


//----- PSMC2TMRH Bits -----------------------------------------------------


//----- PSMC2DBR Bits -----------------------------------------------------


//----- PSMC2DBF Bits -----------------------------------------------------


//----- PSMC2BLKR Bits -----------------------------------------------------


//----- PSMC2BLKF Bits -----------------------------------------------------


//----- PSMC2FFA Bits -----------------------------------------------------


//----- PSMC2STR0 Bits -----------------------------------------------------


//----- PSMC2STR1 Bits -----------------------------------------------------


//----- STATUS_SHAD Bits -----------------------------------------------------



//==========================================================================
//
//       RAM Definitions
//
//==========================================================================
//        __MAXRAM  H'0FFF'
//        __BADRAM  H'000F'
//        __BADRAM  H'0013'
//        __BADRAM  H'001D'-H'001F'
//        __BADRAM  H'008F'
//        __BADRAM  H'0093'
//        __BADRAM  H'010F'-H'0110'
//        __BADRAM  H'011A'-H'011C'
//        __BADRAM  H'018E'-H'0190'
//        __BADRAM  H'0198'
//        __BADRAM  H'020F'
//        __BADRAM  H'0218'-H'021F'
//        __BADRAM  H'028F'-H'0290'
//        __BADRAM  H'0294'-H'0297'
//        __BADRAM  H'029B'-H'029F'
//        __BADRAM  H'030F'-H'031F'
//        __BADRAM  H'0330'-H'036F'
//        __BADRAM  H'038F'
//        __BADRAM  H'039A'-H'039C'
//        __BADRAM  H'03A0'-H'03EF'
//        __BADRAM  H'040C'-H'041F'
//        __BADRAM  H'0420'-H'046F'
//        __BADRAM  H'048C'-H'049F'
//        __BADRAM  H'04A0'-H'04EF'
//        __BADRAM  H'050C'-H'0510'
//        __BADRAM  H'0512'
//        __BADRAM  H'0514'-H'0519'
//        __BADRAM  H'051B'-H'051F'
//        __BADRAM  H'0520'-H'056F'
//        __BADRAM  H'058C'-H'059F'
//        __BADRAM  H'05A0'-H'05EF'
//        __BADRAM  H'060C'-H'061F'
//        __BADRAM  H'0620'-H'066F'
//        __BADRAM  H'068C'-H'069F'
//        __BADRAM  H'06A0'-H'06EF'
//        __BADRAM  H'070C'-H'071F'
//        __BADRAM  H'0720'-H'076F'
//        __BADRAM  H'078C'-H'079F'
//        __BADRAM  H'07A0'-H'07EF'
//        __BADRAM  H'080C'-H'0810'
//        __BADRAM  H'0830'
//        __BADRAM  H'0850'-H'086F'
//        __BADRAM  H'088C'-H'089F'
//        __BADRAM  H'08A0'-H'08EF'
//        __BADRAM  H'090C'-H'091F'
//        __BADRAM  H'0920'-H'096F'
//        __BADRAM  H'098C'-H'099F'
//        __BADRAM  H'09A0'-H'09EF'
//        __BADRAM  H'0A0C'-H'0A1F'
//        __BADRAM  H'0A20'-H'0A6F'
//        __BADRAM  H'0A8C'-H'0A9F'
//        __BADRAM  H'0AA0'-H'0AEF'
//        __BADRAM  H'0B0C'-H'0B1F'
//        __BADRAM  H'0B20'-H'0B6F'
//        __BADRAM  H'0B8C'-H'0B9F'
//        __BADRAM  H'0BA0'-H'0BEF'
//        __BADRAM  H'0C0C'-H'0C1F'
//        __BADRAM  H'0C20'-H'0C6F'
//        __BADRAM  H'0C8C'-H'0C9F'
//        __BADRAM  H'0CA0'-H'0CEF'
//        __BADRAM  H'0D0C'-H'0D1F'
//        __BADRAM  H'0D20'-H'0D6F'
//        __BADRAM  H'0D8C'-H'0D9F'
//        __BADRAM  H'0DA0'-H'0DEF'
//        __BADRAM  H'0E0C'-H'0E1F'
//        __BADRAM  H'0E20'-H'0E6F'
//        __BADRAM  H'0E8C'-H'0E9F'
//        __BADRAM  H'0EA0'-H'0EEF'
//        __BADRAM  H'0F0C'-H'0F1F'
//        __BADRAM  H'0F20'-H'0F6F'
//        __BADRAM  H'0F8C'-H'0FE3'
//        __BADRAM  H'0FEC'

//==========================================================================
//
//       Configuration Bits
//
//   NAME            Address
//   CONFIG1           8007h
//   CONFIG2           8008h
//
//==========================================================================

// The following is an assignment of address values for all of the
// configuration registers for the purpose of table reads
#define _CONFIG1             0x8007
#define _CONFIG2             0x8008

//----- CONFIG1 Options --------------------------------------------------
#define _FOSC_LP             0xFFF8    // LP Oscillator, Low-power crystal connected between OSC1 and OSC2 pins
#define _FOSC_XT             0xFFF9    // XT Oscillator, Crystal/resonator connected between OSC1 and OSC2 pins
#define _FOSC_HS             0xFFFA    // HS Oscillator, High-speed crystal/resonator connected between OSC1 and OSC2 pins
#define _FOSC_EXTRC          0xFFFB    // EXTRC oscillator: External RC circuit connected to CLKIN pin
#define _FOSC_INTOSC         0xFFFC    // INTOSC oscillator: I/O function on CLKIN pin
#define _FOSC_ECL            0xFFFD    // ECL, External Clock, Low Power Mode (0-0.5 MHz): device clock supplied to CLKIN pin
#define _FOSC_ECM            0xFFFE    // ECM, External Clock, Medium Power Mode (0.5-4 MHz): device clock supplied to CLKIN pin
#define _FOSC_ECH            0xFFFF    // ECH, External Clock, High Power Mode (4-32 MHz): device clock supplied to CLKIN pin

#define _WDTE_OFF            0xFFE7    // WDT disabled
#define _WDTE_SWDTEN         0xFFEF    // WDT controlled by the SWDTEN bit in the WDTCON register
#define _WDTE_NSLEEP         0xFFF7    // WDT enabled while running and disabled in Sleep
#define _WDTE_ON             0xFFFF    // WDT enabled

#define _PWRTE_ON            0xFFDF    // PWRT enabled
#define _PWRTE_OFF           0xFFFF    // PWRT disabled

#define _MCLRE_OFF           0xFFBF    // MCLR/VPP pin function is digital input
#define _MCLRE_ON            0xFFFF    // MCLR/VPP pin function is MCLR

#define _CP_ON               0xFF7F    // Program memory code protection is enabled
#define _CP_OFF              0xFFFF    // Program memory code protection is disabled

#define _CPD_ON              0xFEFF    // Data memory code protection is enabled
#define _CPD_OFF             0xFFFF    // Data memory code protection is disabled

#define _BOREN_OFF           0xF9FF    // Brown-out Reset disabled
#define _BOREN_SBODEN        0xFBFF    // Brown-out Reset controlled by the SBOREN bit in the BORCON register
#define _BOREN_NSLEEP        0xFDFF    // Brown-out Reset enabled while running and disabled in Sleep
#define _BOREN_ON            0xFFFF    // Brown-out Reset enabled

#define _CLKOUTEN_ON         0xF7FF    // CLKOUT function is enabled on the CLKOUT pin
#define _CLKOUTEN_OFF        0xFFFF    // CLKOUT function is disabled. I/O or oscillator function on the CLKOUT pin

#define _IESO_OFF            0xEFFF    // Internal/External Switchover mode is disabled
#define _IESO_ON             0xFFFF    // Internal/External Switchover mode is enabled

#define _FCMEN_OFF           0xDFFF    // Fail-Safe Clock Monitor is disabled
#define _FCMEN_ON            0xFFFF    // Fail-Safe Clock Monitor is enabled

//----- CONFIG2 Options --------------------------------------------------
#define _WRT_ALL             0xFFFC    // 000h to FFFh write protected, no addresses may be modified by EECON control
#define _WRT_HALF            0xFFFD    // 000h to 7FFh write protected, 800h to FFFh may be modified by EECON control
#define _WRT_BOOT            0xFFFE    // 000h to 1FFh write protected, 200h to FFFh may be modified by EECON control
#define _WRT_OFF             0xFFFF    // Write protection off

#define _VCAPEN0_ON          0xFFEF    // Vcap functionality is enabled on RA0 (Vddcore is connected to the pad)
#define _VCAPEN0_OFF         0xFFFF    // Vcap functionality is disabled on RA0.

#define _VCAPEN1_ON          0xFFDF    // Vcap functionality is enabled on RA6 (Vddcore is connected to the pad)
#define _VCAPEN1_OFF         0xFFFF    // Vcap finctionality is disabled on RA6

#define _PLLEN_OFF           0xFEFF    // 4x PLL disabled
#define _PLLEN_ON            0xFFFF    // 4x PLL enabled

#define _STVREN_OFF          0xFDFF    // Stack Overflow or Underflow will not cause a Reset
#define _STVREN_ON           0xFFFF    // Stack Overflow or Underflow will cause a Reset

#define _BORV_HI             0xFBFF    // Brown-out Reset Voltage (VBOR) set to 2.7V
#define _BORV_LO             0xFFFF    // Brown-out Reset Voltage (VBOR) set to 2.4V

#define _LPBOR_ON            0xF7FF    // Low power brown-out is enabled
#define _LPBOR_OFF           0xFFFF    // Low power brown-out is disabled

#define _LVP_OFF             0xDFFF    // High-voltage on MCLR/VPP must be used for programming
#define _LVP_ON              0xFFFF    // Low-voltage programming enabled

//----- DEVID Equates --------------------------------------------------
#define _DEVID1              0x8006

//----- IDLOC Equates --------------------------------------------------
#define _IDLOC0              0x8000
#define _IDLOC1              0x8001
#define _IDLOC2              0x8002
#define _IDLOC3              0x8003

//         LIST

// ----- ADCON0 bits --------------------
typedef union {
  struct {
    unsigned char ADON:1;
    unsigned char GO_NOT_DONE:1;
    unsigned char CHS0:1;
    unsigned char CHS1:1;
    unsigned char CHS2:1;
    unsigned char CHS3:1;
    unsigned char CHS4:1;
    unsigned char :1;
  };
  struct {
    unsigned char :1;
    unsigned char ADGO:1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
  };
  struct {
    unsigned char :1;
    unsigned char GO:1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
  };
  struct {
    unsigned char :1;
    unsigned char DONE:1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
  };
} __ADCON0bits_t;
extern volatile __ADCON0bits_t __at(ADCON0_ADDR) ADCON0bits;

// ----- ADCON1 bits --------------------
typedef union {
  struct {
    unsigned char ADPREF0:1;
    unsigned char ADPREF1:1;
    unsigned char ADNREF:1;
    unsigned char :1;
    unsigned char ADCS0:1;
    unsigned char ADCS1:1;
    unsigned char ADCS2:1;
    unsigned char ADFM:1;
  };
} __ADCON1bits_t;
extern volatile __ADCON1bits_t __at(ADCON1_ADDR) ADCON1bits;

// ----- ADCON2 bits --------------------
typedef union {
  struct {
    unsigned char CHSN0:1;
    unsigned char CHSN1:1;
    unsigned char CHSN2:1;
    unsigned char CHSN3:1;
    unsigned char TRIGSEL0:1;
    unsigned char TRIGSEL1:1;
    unsigned char TRIGSEL2:1;
    unsigned char TRIGSEL3:1;
  };
} __ADCON2bits_t;
extern volatile __ADCON2bits_t __at(ADCON2_ADDR) ADCON2bits;

// ----- ANSELA bits --------------------
typedef union {
  struct {
    unsigned char ANSA0:1;
    unsigned char ANSA1:1;
    unsigned char ANSA2:1;
    unsigned char ANSA3:1;
    unsigned char ANSA4:1;
    unsigned char ANSA5:1;
    unsigned char :1;
    unsigned char ANSA7:1;
  };
} __ANSELAbits_t;
extern volatile __ANSELAbits_t __at(ANSELA_ADDR) ANSELAbits;

// ----- ANSELB bits --------------------
typedef union {
  struct {
    unsigned char ANSB0:1;
    unsigned char ANSB1:1;
    unsigned char ANSB2:1;
    unsigned char ANSB3:1;
    unsigned char ANSB4:1;
    unsigned char ANSB5:1;
    unsigned char :1;
    unsigned char :1;
  };
} __ANSELBbits_t;
extern volatile __ANSELBbits_t __at(ANSELB_ADDR) ANSELBbits;

// ----- APFCON bits --------------------
typedef union {
  struct {
    unsigned char CCP2SEL:1;
    unsigned char RXSEL:1;
    unsigned char TXSEL:1;
    unsigned char SDISEL:1;
    unsigned char SCKSEL:1;
    unsigned char SDOSEL:1;
    unsigned char CCP1SEL:1;
    unsigned char C2OUTSEL:1;
  };
} __APFCONbits_t;
extern volatile __APFCONbits_t __at(APFCON_ADDR) APFCONbits;

// ----- APFCON0 bits --------------------
typedef union {
  struct {
    unsigned char CCP2SEL:1;
    unsigned char RXSEL:1;
    unsigned char TXSEL:1;
    unsigned char SDISEL:1;
    unsigned char SCKSEL:1;
    unsigned char SDOSEL:1;
    unsigned char CCP1SEL:1;
    unsigned char C2OUTSEL:1;
  };
} __APFCON0bits_t;
extern volatile __APFCON0bits_t __at(APFCON0_ADDR) APFCON0bits;

// ----- BAUD1CON bits --------------------
typedef union {
  struct {
    unsigned char ABDEN:1;
    unsigned char WUE:1;
    unsigned char :1;
    unsigned char BRG16:1;
    unsigned char SCKP:1;
    unsigned char :1;
    unsigned char RCIDL:1;
    unsigned char ABDOVF:1;
  };
} __BAUD1CONbits_t;
extern volatile __BAUD1CONbits_t __at(BAUD1CON_ADDR) BAUD1CONbits;

// ----- BAUDCON bits --------------------
typedef union {
  struct {
    unsigned char ABDEN:1;
    unsigned char WUE:1;
    unsigned char :1;
    unsigned char BRG16:1;
    unsigned char SCKP:1;
    unsigned char :1;
    unsigned char RCIDL:1;
    unsigned char ABDOVF:1;
  };
} __BAUDCONbits_t;
extern volatile __BAUDCONbits_t __at(BAUDCON_ADDR) BAUDCONbits;

// ----- BAUDCON1 bits --------------------
typedef union {
  struct {
    unsigned char ABDEN:1;
    unsigned char WUE:1;
    unsigned char :1;
    unsigned char BRG16:1;
    unsigned char SCKP:1;
    unsigned char :1;
    unsigned char RCIDL:1;
    unsigned char ABDOVF:1;
  };
} __BAUDCON1bits_t;
extern volatile __BAUDCON1bits_t __at(BAUDCON1_ADDR) BAUDCON1bits;

// ----- BAUDCTL bits --------------------
typedef union {
  struct {
    unsigned char ABDEN:1;
    unsigned char WUE:1;
    unsigned char :1;
    unsigned char BRG16:1;
    unsigned char SCKP:1;
    unsigned char :1;
    unsigned char RCIDL:1;
    unsigned char ABDOVF:1;
  };
} __BAUDCTLbits_t;
extern volatile __BAUDCTLbits_t __at(BAUDCTL_ADDR) BAUDCTLbits;

// ----- BAUDCTL1 bits --------------------
typedef union {
  struct {
    unsigned char ABDEN:1;
    unsigned char WUE:1;
    unsigned char :1;
    unsigned char BRG16:1;
    unsigned char SCKP:1;
    unsigned char :1;
    unsigned char RCIDL:1;
    unsigned char ABDOVF:1;
  };
} __BAUDCTL1bits_t;
extern volatile __BAUDCTL1bits_t __at(BAUDCTL1_ADDR) BAUDCTL1bits;

// ----- BORCON bits --------------------
typedef union {
  struct {
    unsigned char BORRDY:1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
    unsigned char BORFS:1;
    unsigned char SBOREN:1;
  };
} __BORCONbits_t;
extern volatile __BORCONbits_t __at(BORCON_ADDR) BORCONbits;

// ----- BSR bits --------------------
typedef union {
  struct {
    unsigned char BSR0:1;
    unsigned char BSR1:1;
    unsigned char BSR2:1;
    unsigned char BSR3:1;
    unsigned char BSR4:1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
  };
} __BSRbits_t;
extern volatile __BSRbits_t __at(BSR_ADDR) BSRbits;

// ----- CCP1CON bits --------------------
typedef union {
  struct {
    unsigned char CCP1M0:1;
    unsigned char CCP1M1:1;
    unsigned char CCP1M2:1;
    unsigned char CCP1M3:1;
    unsigned char DC1B0:1;
    unsigned char DC1B1:1;
    unsigned char P1M0:1;
    unsigned char P1M1:1;
  };
} __CCP1CONbits_t;
extern volatile __CCP1CONbits_t __at(CCP1CON_ADDR) CCP1CONbits;

// ----- CCP2CON bits --------------------
typedef union {
  struct {
    unsigned char CCP2M0:1;
    unsigned char CCP2M1:1;
    unsigned char CCP2M2:1;
    unsigned char CCP2M3:1;
    unsigned char DC2B0:1;
    unsigned char DC2B1:1;
    unsigned char P2M0:1;
    unsigned char P2M1:1;
  };
} __CCP2CONbits_t;
extern volatile __CCP2CONbits_t __at(CCP2CON_ADDR) CCP2CONbits;

// ----- CLKRCON bits --------------------
typedef union {
  struct {
    unsigned char CLKRDIV0:1;
    unsigned char CLKRDIV1:1;
    unsigned char CLKRDIV2:1;
    unsigned char CLKRDC0:1;
    unsigned char CLKRDC1:1;
    unsigned char CLKRSLR:1;
    unsigned char CLKROE:1;
    unsigned char CLKREN:1;
  };
} __CLKRCONbits_t;
extern volatile __CLKRCONbits_t __at(CLKRCON_ADDR) CLKRCONbits;

// ----- CM1CON0 bits --------------------
typedef union {
  struct {
    unsigned char C1SYNC:1;
    unsigned char C1HYS:1;
    unsigned char C1SP:1;
    unsigned char :1;
    unsigned char C1POL:1;
    unsigned char C1OE:1;
    unsigned char C1OUT:1;
    unsigned char C1ON:1;
  };
} __CM1CON0bits_t;
extern volatile __CM1CON0bits_t __at(CM1CON0_ADDR) CM1CON0bits;

// ----- CM1CON1 bits --------------------
typedef union {
  struct {
    unsigned char C1NCH0:1;
    unsigned char C1NCH1:1;
    unsigned char C1NCH2:1;
    unsigned char C1PCH0:1;
    unsigned char C1PCH1:1;
    unsigned char C1PCH2:1;
    unsigned char C1INTN:1;
    unsigned char C1INTP:1;
  };
} __CM1CON1bits_t;
extern volatile __CM1CON1bits_t __at(CM1CON1_ADDR) CM1CON1bits;

// ----- CM2CON0 bits --------------------
typedef union {
  struct {
    unsigned char C2SYNC:1;
    unsigned char C2HYS:1;
    unsigned char C2SP:1;
    unsigned char :1;
    unsigned char C2POL:1;
    unsigned char C2OE:1;
    unsigned char C2OUT:1;
    unsigned char C2ON:1;
  };
} __CM2CON0bits_t;
extern volatile __CM2CON0bits_t __at(CM2CON0_ADDR) CM2CON0bits;

// ----- CM2CON1 bits --------------------
typedef union {
  struct {
    unsigned char C2NCH0:1;
    unsigned char C2NCH1:1;
    unsigned char C2NCH2:1;
    unsigned char C2PCH0:1;
    unsigned char C2PCH1:1;
    unsigned char C2PCH2:1;
    unsigned char C2INTN:1;
    unsigned char C2INTP:1;
  };
} __CM2CON1bits_t;
extern volatile __CM2CON1bits_t __at(CM2CON1_ADDR) CM2CON1bits;

// ----- CM3CON0 bits --------------------
typedef union {
  struct {
    unsigned char C3SYNC:1;
    unsigned char C3HYS:1;
    unsigned char C3SP:1;
    unsigned char :1;
    unsigned char C3POL:1;
    unsigned char C3OE:1;
    unsigned char C3OUT:1;
    unsigned char C3ON:1;
  };
} __CM3CON0bits_t;
extern volatile __CM3CON0bits_t __at(CM3CON0_ADDR) CM3CON0bits;

// ----- CM3CON1 bits --------------------
typedef union {
  struct {
    unsigned char C3NCH0:1;
    unsigned char C3NCH1:1;
    unsigned char C3NCH2:1;
    unsigned char C3PCH0:1;
    unsigned char C3PCH1:1;
    unsigned char C3PCH2:1;
    unsigned char C3INTN:1;
    unsigned char C3INTP:1;
  };
} __CM3CON1bits_t;
extern volatile __CM3CON1bits_t __at(CM3CON1_ADDR) CM3CON1bits;

// ----- CMOUT bits --------------------
typedef union {
  struct {
    unsigned char MC1OUT:1;
    unsigned char MC2OUT:1;
    unsigned char MC3OUT:1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
  };
} __CMOUTbits_t;
extern volatile __CMOUTbits_t __at(CMOUT_ADDR) CMOUTbits;

// ----- DACCON0 bits --------------------
typedef union {
  struct {
    unsigned char DACNSS:1;
    unsigned char :1;
    unsigned char DACPSS0:1;
    unsigned char DACPSS1:1;
    unsigned char DACOE2:1;
    unsigned char DACOE1:1;
    unsigned char :1;
    unsigned char DACEN:1;
  };
} __DACCON0bits_t;
extern volatile __DACCON0bits_t __at(DACCON0_ADDR) DACCON0bits;

// ----- DACCON1 bits --------------------
typedef union {
  struct {
    unsigned char DACR0:1;
    unsigned char DACR1:1;
    unsigned char DACR2:1;
    unsigned char DACR3:1;
    unsigned char DACR4:1;
    unsigned char DACR5:1;
    unsigned char DACR6:1;
    unsigned char DACR7:1;
  };
} __DACCON1bits_t;
extern volatile __DACCON1bits_t __at(DACCON1_ADDR) DACCON1bits;

// ----- EECON1 bits --------------------
typedef union {
  struct {
    unsigned char RD:1;
    unsigned char WR:1;
    unsigned char WREN:1;
    unsigned char WRERR:1;
    unsigned char FREE:1;
    unsigned char LWLO:1;
    unsigned char CFGS:1;
    unsigned char EEPGD:1;
  };
} __EECON1bits_t;
extern volatile __EECON1bits_t __at(EECON1_ADDR) EECON1bits;

// ----- FVRCON bits --------------------
typedef union {
  struct {
    unsigned char ADFVR0:1;
    unsigned char ADFVR1:1;
    unsigned char CDAFVR0:1;
    unsigned char CDAFVR1:1;
    unsigned char :1;
    unsigned char :1;
    unsigned char FVRRDY:1;
    unsigned char FVREN:1;
  };
} __FVRCONbits_t;
extern volatile __FVRCONbits_t __at(FVRCON_ADDR) FVRCONbits;

// ----- INLVLA bits --------------------
typedef union {
  struct {
    unsigned char INLVLA0:1;
    unsigned char INLVLA1:1;
    unsigned char INLVLA2:1;
    unsigned char INLVLA3:1;
    unsigned char INLVLA4:1;
    unsigned char INLVLA5:1;
    unsigned char INLVLA6:1;
    unsigned char INLVLA7:1;
  };
} __INLVLAbits_t;
extern volatile __INLVLAbits_t __at(INLVLA_ADDR) INLVLAbits;

// ----- INLVLB bits --------------------
typedef union {
  struct {
    unsigned char INLVLB0:1;
    unsigned char INLVLB1:1;
    unsigned char INLVLB2:1;
    unsigned char INLVLB3:1;
    unsigned char INLVLB4:1;
    unsigned char INLVLB5:1;
    unsigned char INLVLB6:1;
    unsigned char INLVLB7:1;
  };
} __INLVLBbits_t;
extern volatile __INLVLBbits_t __at(INLVLB_ADDR) INLVLBbits;

// ----- INLVLC bits --------------------
typedef union {
  struct {
    unsigned char INLVLC0:1;
    unsigned char INLVLC1:1;
    unsigned char INLVLC2:1;
    unsigned char INLVLC3:1;
    unsigned char INLVLC4:1;
    unsigned char INLVLC5:1;
    unsigned char INLVLC6:1;
    unsigned char INLVLC7:1;
  };
} __INLVLCbits_t;
extern volatile __INLVLCbits_t __at(INLVLC_ADDR) INLVLCbits;

// ----- INLVLE bits --------------------
typedef union {
  struct {
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
    unsigned char INLVLE3:1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
  };
} __INLVLEbits_t;
extern volatile __INLVLEbits_t __at(INLVLE_ADDR) INLVLEbits;

// ----- INTCON bits --------------------
typedef union {
  struct {
    unsigned char IOCIF:1;
    unsigned char INTF:1;
    unsigned char TMR0IF:1;
    unsigned char IOCIE:1;
    unsigned char INTE:1;
    unsigned char TMR0IE:1;
    unsigned char PEIE:1;
    unsigned char GIE:1;
  };
  struct {
    unsigned char :1;
    unsigned char :1;
    unsigned char T0IF:1;
    unsigned char :1;
    unsigned char :1;
    unsigned char T0IE:1;
    unsigned char :1;
    unsigned char :1;
  };
} __INTCONbits_t;
extern volatile __INTCONbits_t __at(INTCON_ADDR) INTCONbits;

// ----- IOCAF bits --------------------
typedef union {
  struct {
    unsigned char IOCAF0:1;
    unsigned char IOCAF1:1;
    unsigned char IOCAF2:1;
    unsigned char IOCAF3:1;
    unsigned char IOCAF4:1;
    unsigned char IOCAF5:1;
    unsigned char IOCAF6:1;
    unsigned char IOCAF7:1;
  };
} __IOCAFbits_t;
extern volatile __IOCAFbits_t __at(IOCAF_ADDR) IOCAFbits;

// ----- IOCAN bits --------------------
typedef union {
  struct {
    unsigned char IOCAN0:1;
    unsigned char IOCAN1:1;
    unsigned char IOCAN2:1;
    unsigned char IOCAN3:1;
    unsigned char IOCAN4:1;
    unsigned char IOCAN5:1;
    unsigned char IOCAN6:1;
    unsigned char IOCAN7:1;
  };
} __IOCANbits_t;
extern volatile __IOCANbits_t __at(IOCAN_ADDR) IOCANbits;

// ----- IOCAP bits --------------------
typedef union {
  struct {
    unsigned char IOCAP0:1;
    unsigned char IOCAP1:1;
    unsigned char IOCAP2:1;
    unsigned char IOCAP3:1;
    unsigned char IOCAP4:1;
    unsigned char IOCAP5:1;
    unsigned char IOCAP6:1;
    unsigned char IOCAP7:1;
  };
} __IOCAPbits_t;
extern volatile __IOCAPbits_t __at(IOCAP_ADDR) IOCAPbits;

// ----- IOCBF bits --------------------
typedef union {
  struct {
    unsigned char IOCBF0:1;
    unsigned char IOCBF1:1;
    unsigned char IOCBF2:1;
    unsigned char IOCBF3:1;
    unsigned char IOCBF4:1;
    unsigned char IOCBF5:1;
    unsigned char IOCBF6:1;
    unsigned char IOCBF7:1;
  };
} __IOCBFbits_t;
extern volatile __IOCBFbits_t __at(IOCBF_ADDR) IOCBFbits;

// ----- IOCBN bits --------------------
typedef union {
  struct {
    unsigned char IOCBN0:1;
    unsigned char IOCBN1:1;
    unsigned char IOCBN2:1;
    unsigned char IOCBN3:1;
    unsigned char IOCBN4:1;
    unsigned char IOCBN5:1;
    unsigned char IOCBN6:1;
    unsigned char IOCBN7:1;
  };
} __IOCBNbits_t;
extern volatile __IOCBNbits_t __at(IOCBN_ADDR) IOCBNbits;

// ----- IOCBP bits --------------------
typedef union {
  struct {
    unsigned char IOCBP0:1;
    unsigned char IOCBP1:1;
    unsigned char IOCBP2:1;
    unsigned char IOCBP3:1;
    unsigned char IOCBP4:1;
    unsigned char IOCBP5:1;
    unsigned char IOCBP6:1;
    unsigned char IOCBP7:1;
  };
} __IOCBPbits_t;
extern volatile __IOCBPbits_t __at(IOCBP_ADDR) IOCBPbits;

// ----- IOCCF bits --------------------
typedef union {
  struct {
    unsigned char IOCCF0:1;
    unsigned char IOCCF1:1;
    unsigned char IOCCF2:1;
    unsigned char IOCCF3:1;
    unsigned char IOCCF4:1;
    unsigned char IOCCF5:1;
    unsigned char IOCCF6:1;
    unsigned char IOCCF7:1;
  };
} __IOCCFbits_t;
extern volatile __IOCCFbits_t __at(IOCCF_ADDR) IOCCFbits;

// ----- IOCCN bits --------------------
typedef union {
  struct {
    unsigned char IOCCN0:1;
    unsigned char IOCCN1:1;
    unsigned char IOCCN2:1;
    unsigned char IOCCN3:1;
    unsigned char IOCCN4:1;
    unsigned char IOCCN5:1;
    unsigned char IOCCN6:1;
    unsigned char IOCCN7:1;
  };
} __IOCCNbits_t;
extern volatile __IOCCNbits_t __at(IOCCN_ADDR) IOCCNbits;

// ----- IOCCP bits --------------------
typedef union {
  struct {
    unsigned char IOCCP0:1;
    unsigned char IOCCP1:1;
    unsigned char IOCCP2:1;
    unsigned char IOCCP3:1;
    unsigned char IOCCP4:1;
    unsigned char IOCCP5:1;
    unsigned char IOCCP6:1;
    unsigned char IOCCP7:1;
  };
} __IOCCPbits_t;
extern volatile __IOCCPbits_t __at(IOCCP_ADDR) IOCCPbits;

// ----- IOCEF bits --------------------
typedef union {
  struct {
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
    unsigned char IOCEF3:1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
  };
} __IOCEFbits_t;
extern volatile __IOCEFbits_t __at(IOCEF_ADDR) IOCEFbits;

// ----- IOCEN bits --------------------
typedef union {
  struct {
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
    unsigned char IOCEN3:1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
  };
} __IOCENbits_t;
extern volatile __IOCENbits_t __at(IOCEN_ADDR) IOCENbits;

// ----- IOCEP bits --------------------
typedef union {
  struct {
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
    unsigned char IOCEP3:1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
  };
} __IOCEPbits_t;
extern volatile __IOCEPbits_t __at(IOCEP_ADDR) IOCEPbits;

// ----- LATA bits --------------------
typedef union {
  struct {
    unsigned char LATA0:1;
    unsigned char LATA1:1;
    unsigned char LATA2:1;
    unsigned char LATA3:1;
    unsigned char LATA4:1;
    unsigned char LATA5:1;
    unsigned char LATA6:1;
    unsigned char LATA7:1;
  };
} __LATAbits_t;
extern volatile __LATAbits_t __at(LATA_ADDR) LATAbits;

// ----- LATB bits --------------------
typedef union {
  struct {
    unsigned char LATB0:1;
    unsigned char LATB1:1;
    unsigned char LATB2:1;
    unsigned char LATB3:1;
    unsigned char LATB4:1;
    unsigned char LATB5:1;
    unsigned char LATB6:1;
    unsigned char LATB7:1;
  };
} __LATBbits_t;
extern volatile __LATBbits_t __at(LATB_ADDR) LATBbits;

// ----- LATC bits --------------------
typedef union {
  struct {
    unsigned char LATC0:1;
    unsigned char LATC1:1;
    unsigned char LATC2:1;
    unsigned char LATC3:1;
    unsigned char LATC4:1;
    unsigned char LATC5:1;
    unsigned char LATC6:1;
    unsigned char LATC7:1;
  };
} __LATCbits_t;
extern volatile __LATCbits_t __at(LATC_ADDR) LATCbits;

// ----- ODCONA bits --------------------
typedef union {
  struct {
    unsigned char ODCONA0:1;
    unsigned char ODCONA1:1;
    unsigned char ODCONA2:1;
    unsigned char ODCONA3:1;
    unsigned char ODCONA4:1;
    unsigned char ODCONA5:1;
    unsigned char ODCONA6:1;
    unsigned char ODCONA7:1;
  };
} __ODCONAbits_t;
extern volatile __ODCONAbits_t __at(ODCONA_ADDR) ODCONAbits;

// ----- ODCONB bits --------------------
typedef union {
  struct {
    unsigned char ODCONB0:1;
    unsigned char ODCONB1:1;
    unsigned char ODCONB2:1;
    unsigned char ODCONB3:1;
    unsigned char ODCONB4:1;
    unsigned char ODCONB5:1;
    unsigned char ODCONB6:1;
    unsigned char ODCONB7:1;
  };
} __ODCONBbits_t;
extern volatile __ODCONBbits_t __at(ODCONB_ADDR) ODCONBbits;

// ----- ODCONC bits --------------------
typedef union {
  struct {
    unsigned char ODCONC0:1;
    unsigned char ODCONC1:1;
    unsigned char ODCONC2:1;
    unsigned char ODCONC3:1;
    unsigned char ODCONC4:1;
    unsigned char ODCONC5:1;
    unsigned char ODCONC6:1;
    unsigned char ODCONC7:1;
  };
} __ODCONCbits_t;
extern volatile __ODCONCbits_t __at(ODCONC_ADDR) ODCONCbits;

// ----- OPA1CON bits --------------------
typedef union {
  struct {
    unsigned char OPA1CH0:1;
    unsigned char OPA1CH1:1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
    unsigned char OPA1SP:1;
    unsigned char OPA1EN:1;
  };
} __OPA1CONbits_t;
extern volatile __OPA1CONbits_t __at(OPA1CON_ADDR) OPA1CONbits;

// ----- OPA2CON bits --------------------
typedef union {
  struct {
    unsigned char OPA2CH0:1;
    unsigned char OPA2CH1:1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
    unsigned char OPA2SP:1;
    unsigned char OPA2EN:1;
  };
} __OPA2CONbits_t;
extern volatile __OPA2CONbits_t __at(OPA2CON_ADDR) OPA2CONbits;

// ----- OPTION_REG bits --------------------
typedef union {
  struct {
    unsigned char PS0:1;
    unsigned char PS1:1;
    unsigned char PS2:1;
    unsigned char PSA:1;
    unsigned char TMR0SE:1;
    unsigned char TMR0CS:1;
    unsigned char INTEDG:1;
    unsigned char NOT_WPUEN:1;
  };
  struct {
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
    unsigned char T0SE:1;
    unsigned char T0CS:1;
    unsigned char :1;
    unsigned char :1;
  };
} __OPTION_REGbits_t;
extern volatile __OPTION_REGbits_t __at(OPTION_REG_ADDR) OPTION_REGbits;

// ----- OSCCON bits --------------------
typedef union {
  struct {
    unsigned char SCS0:1;
    unsigned char SCS1:1;
    unsigned char :1;
    unsigned char IRCF0:1;
    unsigned char IRCF1:1;
    unsigned char IRCF2:1;
    unsigned char IRCF3:1;
    unsigned char SPLLEN:1;
  };
} __OSCCONbits_t;
extern volatile __OSCCONbits_t __at(OSCCON_ADDR) OSCCONbits;

// ----- OSCSTAT bits --------------------
typedef union {
  struct {
    unsigned char HFIOFS:1;
    unsigned char LFIOFR:1;
    unsigned char MFIOFR:1;
    unsigned char HFIOFL:1;
    unsigned char HFIOFR:1;
    unsigned char OSTS:1;
    unsigned char PLLR:1;
    unsigned char T1OSCR:1;
  };
} __OSCSTATbits_t;
extern volatile __OSCSTATbits_t __at(OSCSTAT_ADDR) OSCSTATbits;

// ----- OSCTUNE bits --------------------
typedef union {
  struct {
    unsigned char TUN0:1;
    unsigned char TUN1:1;
    unsigned char TUN2:1;
    unsigned char TUN3:1;
    unsigned char TUN4:1;
    unsigned char TUN5:1;
    unsigned char :1;
    unsigned char :1;
  };
} __OSCTUNEbits_t;
extern volatile __OSCTUNEbits_t __at(OSCTUNE_ADDR) OSCTUNEbits;

// ----- PCON bits --------------------
typedef union {
  struct {
    unsigned char NOT_BOR:1;
    unsigned char NOT_POR:1;
    unsigned char NOT_RI:1;
    unsigned char NOT_RMCLR:1;
    unsigned char NOT_RWDT:1;
    unsigned char :1;
    unsigned char STKUNF:1;
    unsigned char STKOVF:1;
  };
} __PCONbits_t;
extern volatile __PCONbits_t __at(PCON_ADDR) PCONbits;

// ----- PIE1 bits --------------------
typedef union {
  struct {
    unsigned char TMR1IE:1;
    unsigned char TMR2IE:1;
    unsigned char CCP1IE:1;
    unsigned char SSP1IE:1;
    unsigned char TXIE:1;
    unsigned char RCIE:1;
    unsigned char ADIE:1;
    unsigned char TMR1GIE:1;
  };
} __PIE1bits_t;
extern volatile __PIE1bits_t __at(PIE1_ADDR) PIE1bits;

// ----- PIE2 bits --------------------
typedef union {
  struct {
    unsigned char CCP2IE:1;
    unsigned char C3IE:1;
    unsigned char :1;
    unsigned char BCL1IE:1;
    unsigned char EEIE:1;
    unsigned char C1IE:1;
    unsigned char C2IE:1;
    unsigned char OSFIE:1;
  };
} __PIE2bits_t;
extern volatile __PIE2bits_t __at(PIE2_ADDR) PIE2bits;

// ----- PIE4 bits --------------------
typedef union {
  struct {
    unsigned char PSMC1SIE:1;
    unsigned char PSMC2SIE:1;
    unsigned char :1;
    unsigned char :1;
    unsigned char PSMC1TIE:1;
    unsigned char PSMC2TIE:1;
    unsigned char :1;
    unsigned char :1;
  };
} __PIE4bits_t;
extern volatile __PIE4bits_t __at(PIE4_ADDR) PIE4bits;

// ----- PIR1 bits --------------------
typedef union {
  struct {
    unsigned char TMR1IF:1;
    unsigned char TMR2IF:1;
    unsigned char CCP1IF:1;
    unsigned char SSP1IF:1;
    unsigned char TXIF:1;
    unsigned char RCIF:1;
    unsigned char ADIF:1;
    unsigned char TMR1GIF:1;
  };
} __PIR1bits_t;
extern volatile __PIR1bits_t __at(PIR1_ADDR) PIR1bits;

// ----- PIR2 bits --------------------
typedef union {
  struct {
    unsigned char CCP2IF:1;
    unsigned char C3IF:1;
    unsigned char :1;
    unsigned char BCL1IF:1;
    unsigned char EEIF:1;
    unsigned char C1IF:1;
    unsigned char C2IF:1;
    unsigned char OSFIF:1;
  };
} __PIR2bits_t;
extern volatile __PIR2bits_t __at(PIR2_ADDR) PIR2bits;

// ----- PIR4 bits --------------------
typedef union {
  struct {
    unsigned char PSMC1SIF:1;
    unsigned char PSMC2SIF:1;
    unsigned char :1;
    unsigned char :1;
    unsigned char PSMC1TIF:1;
    unsigned char PSMC2TIF:1;
    unsigned char :1;
    unsigned char :1;
  };
} __PIR4bits_t;
extern volatile __PIR4bits_t __at(PIR4_ADDR) PIR4bits;

// ----- PORTA bits --------------------
typedef union {
  struct {
    unsigned char RA0:1;
    unsigned char RA1:1;
    unsigned char RA2:1;
    unsigned char RA3:1;
    unsigned char RA4:1;
    unsigned char RA5:1;
    unsigned char RA6:1;
    unsigned char RA7:1;
  };
} __PORTAbits_t;
extern volatile __PORTAbits_t __at(PORTA_ADDR) PORTAbits;

// ----- PORTB bits --------------------
typedef union {
  struct {
    unsigned char RB0:1;
    unsigned char RB1:1;
    unsigned char RB2:1;
    unsigned char RB3:1;
    unsigned char RB4:1;
    unsigned char RB5:1;
    unsigned char RB6:1;
    unsigned char RB7:1;
  };
} __PORTBbits_t;
extern volatile __PORTBbits_t __at(PORTB_ADDR) PORTBbits;

// ----- PORTC bits --------------------
typedef union {
  struct {
    unsigned char RC0:1;
    unsigned char RC1:1;
    unsigned char RC2:1;
    unsigned char RC3:1;
    unsigned char RC4:1;
    unsigned char RC5:1;
    unsigned char RC6:1;
    unsigned char RC7:1;
  };
} __PORTCbits_t;
extern volatile __PORTCbits_t __at(PORTC_ADDR) PORTCbits;

// ----- PORTE bits --------------------
typedef union {
  struct {
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
    unsigned char RE3:1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
  };
} __PORTEbits_t;
extern volatile __PORTEbits_t __at(PORTE_ADDR) PORTEbits;

// ----- PSMC1ASDC bits --------------------
typedef union {
  struct {
    unsigned char P1ASDOV:1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
    unsigned char P1ARSEN:1;
    unsigned char P1ASDEN:1;
    unsigned char P1ASE:1;
  };
} __PSMC1ASDCbits_t;
extern volatile __PSMC1ASDCbits_t __at(PSMC1ASDC_ADDR) PSMC1ASDCbits;

// ----- PSMC1ASDL bits --------------------
typedef union {
  struct {
    unsigned char P1ASDLA:1;
    unsigned char P1ASDLB:1;
    unsigned char P1ASDLC:1;
    unsigned char P1ASDLD:1;
    unsigned char P1ASDLE:1;
    unsigned char P1ASDLF:1;
    unsigned char :1;
    unsigned char :1;
  };
} __PSMC1ASDLbits_t;
extern volatile __PSMC1ASDLbits_t __at(PSMC1ASDL_ADDR) PSMC1ASDLbits;

// ----- PSMC1ASDS bits --------------------
typedef union {
  struct {
    unsigned char :1;
    unsigned char P1ASDSC1:1;
    unsigned char P1ASDSC2:1;
    unsigned char P1ASDSC3:1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
    unsigned char P1ASDSIN:1;
  };
} __PSMC1ASDSbits_t;
extern volatile __PSMC1ASDSbits_t __at(PSMC1ASDS_ADDR) PSMC1ASDSbits;

// ----- PSMC1BLKF bits --------------------
typedef union {
  struct {
    unsigned char PSMC1BLKF0:1;
    unsigned char PSMC1BLKF1:1;
    unsigned char PSMC1BLKF2:1;
    unsigned char PSMC1BLKF3:1;
    unsigned char PSMC1BLKF4:1;
    unsigned char PSMC1BLKF5:1;
    unsigned char PSMC1BLKF6:1;
    unsigned char PSMC1BLKF7:1;
  };
} __PSMC1BLKFbits_t;
extern volatile __PSMC1BLKFbits_t __at(PSMC1BLKF_ADDR) PSMC1BLKFbits;

// ----- PSMC1BLKR bits --------------------
typedef union {
  struct {
    unsigned char PSMC1BLKR0:1;
    unsigned char PSMC1BLKR1:1;
    unsigned char PSMC1BLKR2:1;
    unsigned char PSMC1BLKR3:1;
    unsigned char PSMC1BLKR4:1;
    unsigned char PSMC1BLKR5:1;
    unsigned char PSMC1BLKR6:1;
    unsigned char PSMC1BLKR7:1;
  };
} __PSMC1BLKRbits_t;
extern volatile __PSMC1BLKRbits_t __at(PSMC1BLKR_ADDR) PSMC1BLKRbits;

// ----- PSMC1BLNK bits --------------------
typedef union {
  struct {
    unsigned char P1REBM0:1;
    unsigned char P1REBM1:1;
    unsigned char :1;
    unsigned char :1;
    unsigned char P1FEBM0:1;
    unsigned char P1FEBM1:1;
    unsigned char :1;
    unsigned char :1;
  };
} __PSMC1BLNKbits_t;
extern volatile __PSMC1BLNKbits_t __at(PSMC1BLNK_ADDR) PSMC1BLNKbits;

// ----- PSMC1CLK bits --------------------
typedef union {
  struct {
    unsigned char P1CSRC0:1;
    unsigned char P1CSRC1:1;
    unsigned char :1;
    unsigned char :1;
    unsigned char P1CPRE0:1;
    unsigned char P1CPRE1:1;
    unsigned char :1;
    unsigned char :1;
  };
} __PSMC1CLKbits_t;
extern volatile __PSMC1CLKbits_t __at(PSMC1CLK_ADDR) PSMC1CLKbits;

// ----- PSMC1CON bits --------------------
typedef union {
  struct {
    unsigned char P1MODE0:1;
    unsigned char P1MODE1:1;
    unsigned char P1MODE2:1;
    unsigned char P1MODE3:1;
    unsigned char P1DBRE:1;
    unsigned char P1DBFE:1;
    unsigned char PSMC1LD:1;
    unsigned char PSMC1EN:1;
  };
} __PSMC1CONbits_t;
extern volatile __PSMC1CONbits_t __at(PSMC1CON_ADDR) PSMC1CONbits;

// ----- PSMC1DBF bits --------------------
typedef union {
  struct {
    unsigned char PSMC1DBF0:1;
    unsigned char PSMC1DBF1:1;
    unsigned char PSMC1DBF2:1;
    unsigned char PSMC1DBF3:1;
    unsigned char PSMC1DBF4:1;
    unsigned char PSMC1DBF5:1;
    unsigned char PSMC1DBF6:1;
    unsigned char PSMC1DBF7:1;
  };
} __PSMC1DBFbits_t;
extern volatile __PSMC1DBFbits_t __at(PSMC1DBF_ADDR) PSMC1DBFbits;

// ----- PSMC1DBR bits --------------------
typedef union {
  struct {
    unsigned char PSMC1DBR0:1;
    unsigned char PSMC1DBR1:1;
    unsigned char PSMC1DBR2:1;
    unsigned char PSMC1DBR3:1;
    unsigned char PSMC1DBR4:1;
    unsigned char PSMC1DBR5:1;
    unsigned char PSMC1DBR6:1;
    unsigned char PSMC1DBR7:1;
  };
} __PSMC1DBRbits_t;
extern volatile __PSMC1DBRbits_t __at(PSMC1DBR_ADDR) PSMC1DBRbits;

// ----- PSMC1DCH bits --------------------
typedef union {
  struct {
    unsigned char PSMC1DC8:1;
    unsigned char PSMC1DC9:1;
    unsigned char PSMC1DC10:1;
    unsigned char PSMC1DC11:1;
    unsigned char PSMC1DC12:1;
    unsigned char PSMC1DC13:1;
    unsigned char PSMC1DC14:1;
    unsigned char PSMC1DC15:1;
  };
} __PSMC1DCHbits_t;
extern volatile __PSMC1DCHbits_t __at(PSMC1DCH_ADDR) PSMC1DCHbits;

// ----- PSMC1DCL bits --------------------
typedef union {
  struct {
    unsigned char PSMC1DC0:1;
    unsigned char PSMC1DC1:1;
    unsigned char PSMC1DC2:1;
    unsigned char PSMC1DC3:1;
    unsigned char PSMC1DC4:1;
    unsigned char PSMC1DC5:1;
    unsigned char PSMC1DC6:1;
    unsigned char PSMC1DC7:1;
  };
} __PSMC1DCLbits_t;
extern volatile __PSMC1DCLbits_t __at(PSMC1DCL_ADDR) PSMC1DCLbits;

// ----- PSMC1DCS bits --------------------
typedef union {
  struct {
    unsigned char P1DCST:1;
    unsigned char P1DCSC1:1;
    unsigned char P1DCSC2:1;
    unsigned char P1DCSC3:1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
    unsigned char P1DCSIN:1;
  };
} __PSMC1DCSbits_t;
extern volatile __PSMC1DCSbits_t __at(PSMC1DCS_ADDR) PSMC1DCSbits;

// ----- PSMC1FEBS bits --------------------
typedef union {
  struct {
    unsigned char :1;
    unsigned char P1FEBSC1:1;
    unsigned char P1FEBSC2:1;
    unsigned char P1FEBSC3:1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
    unsigned char P1FEBSIN:1;
  };
} __PSMC1FEBSbits_t;
extern volatile __PSMC1FEBSbits_t __at(PSMC1FEBS_ADDR) PSMC1FEBSbits;

// ----- PSMC1FFA bits --------------------
typedef union {
  struct {
    unsigned char PSMC1FFA0:1;
    unsigned char PSMC1FFA1:1;
    unsigned char PSMC1FFA2:1;
    unsigned char PSMC1FFA3:1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
  };
} __PSMC1FFAbits_t;
extern volatile __PSMC1FFAbits_t __at(PSMC1FFA_ADDR) PSMC1FFAbits;

// ----- PSMC1INT bits --------------------
typedef union {
  struct {
    unsigned char P1TPRIF:1;
    unsigned char P1TDCIF:1;
    unsigned char P1TPHIF:1;
    unsigned char P1TOVIF:1;
    unsigned char P1TPRIE:1;
    unsigned char P1TDCIE:1;
    unsigned char P1TPHIE:1;
    unsigned char P1TOVIE:1;
  };
} __PSMC1INTbits_t;
extern volatile __PSMC1INTbits_t __at(PSMC1INT_ADDR) PSMC1INTbits;

// ----- PSMC1MDL bits --------------------
typedef union {
  struct {
    unsigned char P1MSRC0:1;
    unsigned char P1MSRC1:1;
    unsigned char P1MSRC2:1;
    unsigned char P1MSRC3:1;
    unsigned char :1;
    unsigned char P1MDLBIT:1;
    unsigned char P1MDLPOL:1;
    unsigned char P1MDLEN:1;
  };
} __PSMC1MDLbits_t;
extern volatile __PSMC1MDLbits_t __at(PSMC1MDL_ADDR) PSMC1MDLbits;

// ----- PSMC1OEN bits --------------------
typedef union {
  struct {
    unsigned char P1OEA:1;
    unsigned char P1OEB:1;
    unsigned char P1OEC:1;
    unsigned char P1OED:1;
    unsigned char P1OEE:1;
    unsigned char P1OEF:1;
    unsigned char :1;
    unsigned char :1;
  };
} __PSMC1OENbits_t;
extern volatile __PSMC1OENbits_t __at(PSMC1OEN_ADDR) PSMC1OENbits;

// ----- PSMC1PHH bits --------------------
typedef union {
  struct {
    unsigned char PSMC1PH8:1;
    unsigned char PSMC1PH9:1;
    unsigned char PSMC1PH10:1;
    unsigned char PSMC1PH11:1;
    unsigned char PSMC1PH12:1;
    unsigned char PSMC1PH13:1;
    unsigned char PSMC1PH14:1;
    unsigned char PSMC1PH15:1;
  };
} __PSMC1PHHbits_t;
extern volatile __PSMC1PHHbits_t __at(PSMC1PHH_ADDR) PSMC1PHHbits;

// ----- PSMC1PHL bits --------------------
typedef union {
  struct {
    unsigned char PSMC1PH0:1;
    unsigned char PSMC1PH1:1;
    unsigned char PSMC1PH2:1;
    unsigned char PSMC1PH3:1;
    unsigned char PSMC1PH4:1;
    unsigned char PSMC1PH5:1;
    unsigned char PSMC1PH6:1;
    unsigned char PSMC1PH7:1;
  };
} __PSMC1PHLbits_t;
extern volatile __PSMC1PHLbits_t __at(PSMC1PHL_ADDR) PSMC1PHLbits;

// ----- PSMC1PHS bits --------------------
typedef union {
  struct {
    unsigned char P1PHST:1;
    unsigned char P1PHSC1:1;
    unsigned char P1PHSC2:1;
    unsigned char P1PHSC3:1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
    unsigned char P1PHSIN:1;
  };
} __PSMC1PHSbits_t;
extern volatile __PSMC1PHSbits_t __at(PSMC1PHS_ADDR) PSMC1PHSbits;

// ----- PSMC1POL bits --------------------
typedef union {
  struct {
    unsigned char P1POLA:1;
    unsigned char P1POLB:1;
    unsigned char P1POLC:1;
    unsigned char P1POLD:1;
    unsigned char P1POLE:1;
    unsigned char P1POLF:1;
    unsigned char P1INPOL:1;
    unsigned char :1;
  };
} __PSMC1POLbits_t;
extern volatile __PSMC1POLbits_t __at(PSMC1POL_ADDR) PSMC1POLbits;

// ----- PSMC1PRH bits --------------------
typedef union {
  struct {
    unsigned char PSMC1PR8:1;
    unsigned char PSMC1PR9:1;
    unsigned char PSMC1PR10:1;
    unsigned char PSMC1PR11:1;
    unsigned char PSMC1PR12:1;
    unsigned char PSMC1PR13:1;
    unsigned char PSMC1PR14:1;
    unsigned char PSMC1PR15:1;
  };
} __PSMC1PRHbits_t;
extern volatile __PSMC1PRHbits_t __at(PSMC1PRH_ADDR) PSMC1PRHbits;

// ----- PSMC1PRL bits --------------------
typedef union {
  struct {
    unsigned char PSMC1PR0:1;
    unsigned char PSMC1PR1:1;
    unsigned char PSMC1PR2:1;
    unsigned char PSMC1PR3:1;
    unsigned char PSMC1PR4:1;
    unsigned char PSMC1PR5:1;
    unsigned char PSMC1PR6:1;
    unsigned char PSMC1PR7:1;
  };
} __PSMC1PRLbits_t;
extern volatile __PSMC1PRLbits_t __at(PSMC1PRL_ADDR) PSMC1PRLbits;

// ----- PSMC1PRS bits --------------------
typedef union {
  struct {
    unsigned char P1PRST:1;
    unsigned char P1PRSC1:1;
    unsigned char P1PRSC2:1;
    unsigned char P1PRSC3:1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
    unsigned char P1PRSIN:1;
  };
} __PSMC1PRSbits_t;
extern volatile __PSMC1PRSbits_t __at(PSMC1PRS_ADDR) PSMC1PRSbits;

// ----- PSMC1REBS bits --------------------
typedef union {
  struct {
    unsigned char :1;
    unsigned char P1REBSC1:1;
    unsigned char P1REBSC2:1;
    unsigned char P1REBSC3:1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
    unsigned char P1REBSIN:1;
  };
} __PSMC1REBSbits_t;
extern volatile __PSMC1REBSbits_t __at(PSMC1REBS_ADDR) PSMC1REBSbits;

// ----- PSMC1STR0 bits --------------------
typedef union {
  struct {
    unsigned char P1STRA:1;
    unsigned char P1STRB:1;
    unsigned char P1STRC:1;
    unsigned char P1STRD:1;
    unsigned char P1STRE:1;
    unsigned char P1STRF:1;
    unsigned char :1;
    unsigned char :1;
  };
} __PSMC1STR0bits_t;
extern volatile __PSMC1STR0bits_t __at(PSMC1STR0_ADDR) PSMC1STR0bits;

// ----- PSMC1STR1 bits --------------------
typedef union {
  struct {
    unsigned char P1HSMEN:1;
    unsigned char P1LSMEN:1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
    unsigned char P1SSYNC:1;
  };
} __PSMC1STR1bits_t;
extern volatile __PSMC1STR1bits_t __at(PSMC1STR1_ADDR) PSMC1STR1bits;

// ----- PSMC1SYNC bits --------------------
typedef union {
  struct {
    unsigned char P1SYNC0:1;
    unsigned char P1SYNC1:1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
  };
} __PSMC1SYNCbits_t;
extern volatile __PSMC1SYNCbits_t __at(PSMC1SYNC_ADDR) PSMC1SYNCbits;

// ----- PSMC1TMRH bits --------------------
typedef union {
  struct {
    unsigned char PSMC1TMR8:1;
    unsigned char PSMC1TMR9:1;
    unsigned char PSMC1TMR10:1;
    unsigned char PSMC1TMR11:1;
    unsigned char PSMC1TMR12:1;
    unsigned char PSMC1TMR13:1;
    unsigned char PSMC1TMR14:1;
    unsigned char PSMC1TMR15:1;
  };
} __PSMC1TMRHbits_t;
extern volatile __PSMC1TMRHbits_t __at(PSMC1TMRH_ADDR) PSMC1TMRHbits;

// ----- PSMC1TMRL bits --------------------
typedef union {
  struct {
    unsigned char PSMC1TMR0:1;
    unsigned char PSMC1TMR1:1;
    unsigned char PSMC1TMR2:1;
    unsigned char PSMC1TMR3:1;
    unsigned char PSMC1TMR4:1;
    unsigned char PSMC1TMR5:1;
    unsigned char PSMC1TMR6:1;
    unsigned char PSMC1TMR7:1;
  };
} __PSMC1TMRLbits_t;
extern volatile __PSMC1TMRLbits_t __at(PSMC1TMRL_ADDR) PSMC1TMRLbits;

// ----- PSMC2ASDC bits --------------------
typedef union {
  struct {
    unsigned char P2ASDOV:1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
    unsigned char P2ARSEN:1;
    unsigned char P2ASDEN:1;
    unsigned char P2ASE:1;
  };
} __PSMC2ASDCbits_t;
extern volatile __PSMC2ASDCbits_t __at(PSMC2ASDC_ADDR) PSMC2ASDCbits;

// ----- PSMC2ASDL bits --------------------
typedef union {
  struct {
    unsigned char P2ASDLA:1;
    unsigned char P2ASDLB:1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
  };
} __PSMC2ASDLbits_t;
extern volatile __PSMC2ASDLbits_t __at(PSMC2ASDL_ADDR) PSMC2ASDLbits;

// ----- PSMC2ASDS bits --------------------
typedef union {
  struct {
    unsigned char :1;
    unsigned char P2ASDSC1:1;
    unsigned char P2ASDSC2:1;
    unsigned char P2ASDSC3:1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
    unsigned char P2ASDSIN:1;
  };
} __PSMC2ASDSbits_t;
extern volatile __PSMC2ASDSbits_t __at(PSMC2ASDS_ADDR) PSMC2ASDSbits;

// ----- PSMC2BLKF bits --------------------
typedef union {
  struct {
    unsigned char PSMC2BLKF0:1;
    unsigned char PSMC2BLKF1:1;
    unsigned char PSMC2BLKF2:1;
    unsigned char PSMC2BLKF3:1;
    unsigned char PSMC2BLKF4:1;
    unsigned char PSMC2BLKF5:1;
    unsigned char PSMC2BLKF6:1;
    unsigned char PSMC2BLKF7:1;
  };
} __PSMC2BLKFbits_t;
extern volatile __PSMC2BLKFbits_t __at(PSMC2BLKF_ADDR) PSMC2BLKFbits;

// ----- PSMC2BLKR bits --------------------
typedef union {
  struct {
    unsigned char PSMC2BLKR0:1;
    unsigned char PSMC2BLKR1:1;
    unsigned char PSMC2BLKR2:1;
    unsigned char PSMC2BLKR3:1;
    unsigned char PSMC2BLKR4:1;
    unsigned char PSMC2BLKR5:1;
    unsigned char PSMC2BLKR6:1;
    unsigned char PSMC2BLKR7:1;
  };
} __PSMC2BLKRbits_t;
extern volatile __PSMC2BLKRbits_t __at(PSMC2BLKR_ADDR) PSMC2BLKRbits;

// ----- PSMC2BLNK bits --------------------
typedef union {
  struct {
    unsigned char P2REBM0:1;
    unsigned char P2REBM1:1;
    unsigned char :1;
    unsigned char :1;
    unsigned char P2FEBM0:1;
    unsigned char P2FEBM1:1;
    unsigned char :1;
    unsigned char :1;
  };
} __PSMC2BLNKbits_t;
extern volatile __PSMC2BLNKbits_t __at(PSMC2BLNK_ADDR) PSMC2BLNKbits;

// ----- PSMC2CLK bits --------------------
typedef union {
  struct {
    unsigned char P2CSRC0:1;
    unsigned char P2CSRC1:1;
    unsigned char :1;
    unsigned char :1;
    unsigned char P2CPRE0:1;
    unsigned char P2CPRE1:1;
    unsigned char :1;
    unsigned char :1;
  };
} __PSMC2CLKbits_t;
extern volatile __PSMC2CLKbits_t __at(PSMC2CLK_ADDR) PSMC2CLKbits;

// ----- PSMC2CON bits --------------------
typedef union {
  struct {
    unsigned char P2MODE0:1;
    unsigned char P2MODE1:1;
    unsigned char P2MODE2:1;
    unsigned char P2MODE3:1;
    unsigned char P2DBRE:1;
    unsigned char P2DBFE:1;
    unsigned char PSMC2LD:1;
    unsigned char PSMC2EN:1;
  };
} __PSMC2CONbits_t;
extern volatile __PSMC2CONbits_t __at(PSMC2CON_ADDR) PSMC2CONbits;

// ----- PSMC2DBF bits --------------------
typedef union {
  struct {
    unsigned char PSMC2DBF0:1;
    unsigned char PSMC2DBF1:1;
    unsigned char PSMC2DBF2:1;
    unsigned char PSMC2DBF3:1;
    unsigned char PSMC2DBF4:1;
    unsigned char PSMC2DBF5:1;
    unsigned char PSMC2DBF6:1;
    unsigned char PSMC2DBF7:1;
  };
} __PSMC2DBFbits_t;
extern volatile __PSMC2DBFbits_t __at(PSMC2DBF_ADDR) PSMC2DBFbits;

// ----- PSMC2DBR bits --------------------
typedef union {
  struct {
    unsigned char PSMC2DBR0:1;
    unsigned char PSMC2DBR1:1;
    unsigned char PSMC2DBR2:1;
    unsigned char PSMC2DBR3:1;
    unsigned char PSMC2DBR4:1;
    unsigned char PSMC2DBR5:1;
    unsigned char PSMC2DBR6:1;
    unsigned char PSMC2DBR7:1;
  };
} __PSMC2DBRbits_t;
extern volatile __PSMC2DBRbits_t __at(PSMC2DBR_ADDR) PSMC2DBRbits;

// ----- PSMC2DCH bits --------------------
typedef union {
  struct {
    unsigned char PSMC2DC8:1;
    unsigned char PSMC2DC9:1;
    unsigned char PSMC2DC10:1;
    unsigned char PSMC2DC11:1;
    unsigned char PSMC2DC12:1;
    unsigned char PSMC2DC13:1;
    unsigned char PSMC2DC14:1;
    unsigned char PSMC2DC15:1;
  };
} __PSMC2DCHbits_t;
extern volatile __PSMC2DCHbits_t __at(PSMC2DCH_ADDR) PSMC2DCHbits;

// ----- PSMC2DCL bits --------------------
typedef union {
  struct {
    unsigned char PSMC2DC0:1;
    unsigned char PSMC2DC1:1;
    unsigned char PSMC2DC2:1;
    unsigned char PSMC2DC3:1;
    unsigned char PSMC2DC4:1;
    unsigned char PSMC2DC5:1;
    unsigned char PSMC2DC6:1;
    unsigned char PSMC2DC7:1;
  };
} __PSMC2DCLbits_t;
extern volatile __PSMC2DCLbits_t __at(PSMC2DCL_ADDR) PSMC2DCLbits;

// ----- PSMC2DCS bits --------------------
typedef union {
  struct {
    unsigned char P2DCST:1;
    unsigned char P2DCSC1:1;
    unsigned char P2DCSC2:1;
    unsigned char P2DCSC3:1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
    unsigned char P2DCSIN:1;
  };
} __PSMC2DCSbits_t;
extern volatile __PSMC2DCSbits_t __at(PSMC2DCS_ADDR) PSMC2DCSbits;

// ----- PSMC2FEBS bits --------------------
typedef union {
  struct {
    unsigned char :1;
    unsigned char P2FEBSC1:1;
    unsigned char P2FEBSC2:1;
    unsigned char P2FEBSC3:1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
    unsigned char P2FEBSIN:1;
  };
} __PSMC2FEBSbits_t;
extern volatile __PSMC2FEBSbits_t __at(PSMC2FEBS_ADDR) PSMC2FEBSbits;

// ----- PSMC2FFA bits --------------------
typedef union {
  struct {
    unsigned char PSMC2FFA0:1;
    unsigned char PSMC2FFA1:1;
    unsigned char PSMC2FFA2:1;
    unsigned char PSMC2FFA3:1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
  };
} __PSMC2FFAbits_t;
extern volatile __PSMC2FFAbits_t __at(PSMC2FFA_ADDR) PSMC2FFAbits;

// ----- PSMC2INT bits --------------------
typedef union {
  struct {
    unsigned char P2TPRIF:1;
    unsigned char P2TDCIF:1;
    unsigned char P2TPHIF:1;
    unsigned char P2TOVIF:1;
    unsigned char P2TPRIE:1;
    unsigned char P2TDCIE:1;
    unsigned char P2TPHIE:1;
    unsigned char P2TOVIE:1;
  };
} __PSMC2INTbits_t;
extern volatile __PSMC2INTbits_t __at(PSMC2INT_ADDR) PSMC2INTbits;

// ----- PSMC2MDL bits --------------------
typedef union {
  struct {
    unsigned char P2MSRC0:1;
    unsigned char P2MSRC1:1;
    unsigned char P2MSRC2:1;
    unsigned char P2MSRC3:1;
    unsigned char :1;
    unsigned char P2MDLBIT:1;
    unsigned char P2MDLPOL:1;
    unsigned char P2MDLEN:1;
  };
} __PSMC2MDLbits_t;
extern volatile __PSMC2MDLbits_t __at(PSMC2MDL_ADDR) PSMC2MDLbits;

// ----- PSMC2OEN bits --------------------
typedef union {
  struct {
    unsigned char P2OEA:1;
    unsigned char P2OEB:1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
  };
} __PSMC2OENbits_t;
extern volatile __PSMC2OENbits_t __at(PSMC2OEN_ADDR) PSMC2OENbits;

// ----- PSMC2PHH bits --------------------
typedef union {
  struct {
    unsigned char PSMC2PH8:1;
    unsigned char PSMC2PH9:1;
    unsigned char PSMC2PH10:1;
    unsigned char PSMC2PH11:1;
    unsigned char PSMC2PH12:1;
    unsigned char PSMC2PH13:1;
    unsigned char PSMC2PH14:1;
    unsigned char PSMC2PH15:1;
  };
} __PSMC2PHHbits_t;
extern volatile __PSMC2PHHbits_t __at(PSMC2PHH_ADDR) PSMC2PHHbits;

// ----- PSMC2PHL bits --------------------
typedef union {
  struct {
    unsigned char PSMC2PH0:1;
    unsigned char PSMC2PH1:1;
    unsigned char PSMC2PH2:1;
    unsigned char PSMC2PH3:1;
    unsigned char PSMC2PH4:1;
    unsigned char PSMC2PH5:1;
    unsigned char PSMC2PH6:1;
    unsigned char PSMC2PH7:1;
  };
} __PSMC2PHLbits_t;
extern volatile __PSMC2PHLbits_t __at(PSMC2PHL_ADDR) PSMC2PHLbits;

// ----- PSMC2PHS bits --------------------
typedef union {
  struct {
    unsigned char P2PHST:1;
    unsigned char P2PHSC1:1;
    unsigned char P2PHSC2:1;
    unsigned char P2PHSC3:1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
    unsigned char P2PHSIN:1;
  };
} __PSMC2PHSbits_t;
extern volatile __PSMC2PHSbits_t __at(PSMC2PHS_ADDR) PSMC2PHSbits;

// ----- PSMC2POL bits --------------------
typedef union {
  struct {
    unsigned char P2POLA:1;
    unsigned char P2POLB:1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
    unsigned char P2INPOL:1;
    unsigned char :1;
  };
} __PSMC2POLbits_t;
extern volatile __PSMC2POLbits_t __at(PSMC2POL_ADDR) PSMC2POLbits;

// ----- PSMC2PRH bits --------------------
typedef union {
  struct {
    unsigned char PSMC2PR8:1;
    unsigned char PSMC2PR9:1;
    unsigned char PSMC2PR10:1;
    unsigned char PSMC2PR11:1;
    unsigned char PSMC2PR12:1;
    unsigned char PSMC2PR13:1;
    unsigned char PSMC2PR14:1;
    unsigned char PSMC2PR15:1;
  };
} __PSMC2PRHbits_t;
extern volatile __PSMC2PRHbits_t __at(PSMC2PRH_ADDR) PSMC2PRHbits;

// ----- PSMC2PRL bits --------------------
typedef union {
  struct {
    unsigned char PSMC2PR0:1;
    unsigned char PSMC2PR1:1;
    unsigned char PSMC2PR2:1;
    unsigned char PSMC2PR3:1;
    unsigned char PSMC2PR4:1;
    unsigned char PSMC2PR5:1;
    unsigned char PSMC2PR6:1;
    unsigned char PSMC2PR7:1;
  };
} __PSMC2PRLbits_t;
extern volatile __PSMC2PRLbits_t __at(PSMC2PRL_ADDR) PSMC2PRLbits;

// ----- PSMC2PRS bits --------------------
typedef union {
  struct {
    unsigned char P2PRST:1;
    unsigned char P2PRSC1:1;
    unsigned char P2PRSC2:1;
    unsigned char P2PRSC3:1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
    unsigned char P2PRSIN:1;
  };
} __PSMC2PRSbits_t;
extern volatile __PSMC2PRSbits_t __at(PSMC2PRS_ADDR) PSMC2PRSbits;

// ----- PSMC2REBS bits --------------------
typedef union {
  struct {
    unsigned char :1;
    unsigned char P2REBSC1:1;
    unsigned char P2REBSC2:1;
    unsigned char P2REBSC3:1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
    unsigned char P2REBSIN:1;
  };
} __PSMC2REBSbits_t;
extern volatile __PSMC2REBSbits_t __at(PSMC2REBS_ADDR) PSMC2REBSbits;

// ----- PSMC2STR0 bits --------------------
typedef union {
  struct {
    unsigned char P2STRA:1;
    unsigned char P2STRB:1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
  };
} __PSMC2STR0bits_t;
extern volatile __PSMC2STR0bits_t __at(PSMC2STR0_ADDR) PSMC2STR0bits;

// ----- PSMC2STR1 bits --------------------
typedef union {
  struct {
    unsigned char P2HSMEN:1;
    unsigned char P2LSMEN:1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
    unsigned char P2SSYNC:1;
  };
} __PSMC2STR1bits_t;
extern volatile __PSMC2STR1bits_t __at(PSMC2STR1_ADDR) PSMC2STR1bits;

// ----- PSMC2SYNC bits --------------------
typedef union {
  struct {
    unsigned char P2SYNC0:1;
    unsigned char P2SYNC1:1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
  };
} __PSMC2SYNCbits_t;
extern volatile __PSMC2SYNCbits_t __at(PSMC2SYNC_ADDR) PSMC2SYNCbits;

// ----- PSMC2TMRH bits --------------------
typedef union {
  struct {
    unsigned char PSMC2TMR8:1;
    unsigned char PSMC2TMR9:1;
    unsigned char PSMC2TMR10:1;
    unsigned char PSMC2TMR11:1;
    unsigned char PSMC2TMR12:1;
    unsigned char PSMC2TMR13:1;
    unsigned char PSMC2TMR14:1;
    unsigned char PSMC2TMR15:1;
  };
} __PSMC2TMRHbits_t;
extern volatile __PSMC2TMRHbits_t __at(PSMC2TMRH_ADDR) PSMC2TMRHbits;

// ----- PSMC2TMRL bits --------------------
typedef union {
  struct {
    unsigned char PSMC2TMR0:1;
    unsigned char PSMC2TMR1:1;
    unsigned char PSMC2TMR2:1;
    unsigned char PSMC2TMR3:1;
    unsigned char PSMC2TMR4:1;
    unsigned char PSMC2TMR5:1;
    unsigned char PSMC2TMR6:1;
    unsigned char PSMC2TMR7:1;
  };
} __PSMC2TMRLbits_t;
extern volatile __PSMC2TMRLbits_t __at(PSMC2TMRL_ADDR) PSMC2TMRLbits;

// ----- RC1STA bits --------------------
typedef union {
  struct {
    unsigned char RX9D:1;
    unsigned char OERR:1;
    unsigned char FERR:1;
    unsigned char ADDEN:1;
    unsigned char CREN:1;
    unsigned char SREN:1;
    unsigned char RX9:1;
    unsigned char SPEN:1;
  };
} __RC1STAbits_t;
extern volatile __RC1STAbits_t __at(RC1STA_ADDR) RC1STAbits;

// ----- RCSTA bits --------------------
typedef union {
  struct {
    unsigned char RX9D:1;
    unsigned char OERR:1;
    unsigned char FERR:1;
    unsigned char ADDEN:1;
    unsigned char CREN:1;
    unsigned char SREN:1;
    unsigned char RX9:1;
    unsigned char SPEN:1;
  };
} __RCSTAbits_t;
extern volatile __RCSTAbits_t __at(RCSTA_ADDR) RCSTAbits;

// ----- RCSTA1 bits --------------------
typedef union {
  struct {
    unsigned char RX9D:1;
    unsigned char OERR:1;
    unsigned char FERR:1;
    unsigned char ADDEN:1;
    unsigned char CREN:1;
    unsigned char SREN:1;
    unsigned char RX9:1;
    unsigned char SPEN:1;
  };
} __RCSTA1bits_t;
extern volatile __RCSTA1bits_t __at(RCSTA1_ADDR) RCSTA1bits;

// ----- SLRCONA bits --------------------
typedef union {
  struct {
    unsigned char SLRCONA0:1;
    unsigned char SLRCONA1:1;
    unsigned char SLRCONA2:1;
    unsigned char SLRCONA3:1;
    unsigned char SLRCONA4:1;
    unsigned char SLRCONA5:1;
    unsigned char SLRCONA6:1;
    unsigned char SLRCONA7:1;
  };
} __SLRCONAbits_t;
extern volatile __SLRCONAbits_t __at(SLRCONA_ADDR) SLRCONAbits;

// ----- SLRCONB bits --------------------
typedef union {
  struct {
    unsigned char SLRCONB0:1;
    unsigned char SLRCONB1:1;
    unsigned char SLRCONB2:1;
    unsigned char SLRCONB3:1;
    unsigned char SLRCONB4:1;
    unsigned char SLRCONB5:1;
    unsigned char SLRCONB6:1;
    unsigned char SLRCONB7:1;
  };
} __SLRCONBbits_t;
extern volatile __SLRCONBbits_t __at(SLRCONB_ADDR) SLRCONBbits;

// ----- SLRCONC bits --------------------
typedef union {
  struct {
    unsigned char SLRCONC0:1;
    unsigned char SLRCONC1:1;
    unsigned char SLRCONC2:1;
    unsigned char SLRCONC3:1;
    unsigned char SLRCONC4:1;
    unsigned char SLRCONC5:1;
    unsigned char SLRCONC6:1;
    unsigned char SLRCONC7:1;
  };
} __SLRCONCbits_t;
extern volatile __SLRCONCbits_t __at(SLRCONC_ADDR) SLRCONCbits;

// ----- SSP1CON bits --------------------
typedef union {
  struct {
    unsigned char SSPM0:1;
    unsigned char SSPM1:1;
    unsigned char SSPM2:1;
    unsigned char SSPM3:1;
    unsigned char CKP:1;
    unsigned char SSPEN:1;
    unsigned char SSPOV:1;
    unsigned char WCOL:1;
  };
} __SSP1CONbits_t;
extern volatile __SSP1CONbits_t __at(SSP1CON_ADDR) SSP1CONbits;

// ----- SSP1CON2 bits --------------------
typedef union {
  struct {
    unsigned char SEN:1;
    unsigned char RSEN:1;
    unsigned char PEN:1;
    unsigned char RCEN:1;
    unsigned char ACKEN:1;
    unsigned char ACKDT:1;
    unsigned char ACKSTAT:1;
    unsigned char GCEN:1;
  };
} __SSP1CON2bits_t;
extern volatile __SSP1CON2bits_t __at(SSP1CON2_ADDR) SSP1CON2bits;

// ----- SSP1CON3 bits --------------------
typedef union {
  struct {
    unsigned char DHEN:1;
    unsigned char AHEN:1;
    unsigned char SBCDE:1;
    unsigned char SDAHT:1;
    unsigned char BOEN:1;
    unsigned char SCIE:1;
    unsigned char PCIE:1;
    unsigned char ACKTIM:1;
  };
} __SSP1CON3bits_t;
extern volatile __SSP1CON3bits_t __at(SSP1CON3_ADDR) SSP1CON3bits;

// ----- SSP1STAT bits --------------------
typedef union {
  struct {
    unsigned char BF:1;
    unsigned char UA:1;
    unsigned char R_NOT_W:1;
    unsigned char S:1;
    unsigned char P:1;
    unsigned char D_NOT_A:1;
    unsigned char CKE:1;
    unsigned char SMP:1;
  };
} __SSP1STATbits_t;
extern volatile __SSP1STATbits_t __at(SSP1STAT_ADDR) SSP1STATbits;

// ----- SSPCON bits --------------------
typedef union {
  struct {
    unsigned char SSPM0:1;
    unsigned char SSPM1:1;
    unsigned char SSPM2:1;
    unsigned char SSPM3:1;
    unsigned char CKP:1;
    unsigned char SSPEN:1;
    unsigned char SSPOV:1;
    unsigned char WCOL:1;
  };
} __SSPCONbits_t;
extern volatile __SSPCONbits_t __at(SSPCON_ADDR) SSPCONbits;

// ----- SSPCON1 bits --------------------
typedef union {
  struct {
    unsigned char SSPM0:1;
    unsigned char SSPM1:1;
    unsigned char SSPM2:1;
    unsigned char SSPM3:1;
    unsigned char CKP:1;
    unsigned char SSPEN:1;
    unsigned char SSPOV:1;
    unsigned char WCOL:1;
  };
} __SSPCON1bits_t;
extern volatile __SSPCON1bits_t __at(SSPCON1_ADDR) SSPCON1bits;

// ----- SSPCON2 bits --------------------
typedef union {
  struct {
    unsigned char SEN:1;
    unsigned char RSEN:1;
    unsigned char PEN:1;
    unsigned char RCEN:1;
    unsigned char ACKEN:1;
    unsigned char ACKDT:1;
    unsigned char ACKSTAT:1;
    unsigned char GCEN:1;
  };
} __SSPCON2bits_t;
extern volatile __SSPCON2bits_t __at(SSPCON2_ADDR) SSPCON2bits;

// ----- SSPCON3 bits --------------------
typedef union {
  struct {
    unsigned char DHEN:1;
    unsigned char AHEN:1;
    unsigned char SBCDE:1;
    unsigned char SDAHT:1;
    unsigned char BOEN:1;
    unsigned char SCIE:1;
    unsigned char PCIE:1;
    unsigned char ACKTIM:1;
  };
} __SSPCON3bits_t;
extern volatile __SSPCON3bits_t __at(SSPCON3_ADDR) SSPCON3bits;

// ----- SSPSTAT bits --------------------
typedef union {
  struct {
    unsigned char BF:1;
    unsigned char UA:1;
    unsigned char R_NOT_W:1;
    unsigned char S:1;
    unsigned char P:1;
    unsigned char D_NOT_A:1;
    unsigned char CKE:1;
    unsigned char SMP:1;
  };
} __SSPSTATbits_t;
extern volatile __SSPSTATbits_t __at(SSPSTAT_ADDR) SSPSTATbits;

// ----- STATUS bits --------------------
typedef union {
  struct {
    unsigned char C:1;
    unsigned char DC:1;
    unsigned char Z:1;
    unsigned char NOT_PD:1;
    unsigned char NOT_TO:1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
  };
} __STATUSbits_t;
extern volatile __STATUSbits_t __at(STATUS_ADDR) STATUSbits;

// ----- STATUS_SHAD bits --------------------
typedef union {
  struct {
    unsigned char C_SHAD:1;
    unsigned char DC_SHAD:1;
    unsigned char Z_SHAD:1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
  };
} __STATUS_SHADbits_t;
extern volatile __STATUS_SHADbits_t __at(STATUS_SHAD_ADDR) STATUS_SHADbits;

// ----- T1CON bits --------------------
typedef union {
  struct {
    unsigned char TMR1ON:1;
    unsigned char :1;
    unsigned char NOT_T1SYNC:1;
    unsigned char T1OSCEN:1;
    unsigned char T1CKPS0:1;
    unsigned char T1CKPS1:1;
    unsigned char TMR1CS0:1;
    unsigned char TMR1CS1:1;
  };
} __T1CONbits_t;
extern volatile __T1CONbits_t __at(T1CON_ADDR) T1CONbits;

// ----- T1GCON bits --------------------
typedef union {
  struct {
    unsigned char T1GSS0:1;
    unsigned char T1GSS1:1;
    unsigned char T1GVAL:1;
    unsigned char T1GGO:1;
    unsigned char T1GSPM:1;
    unsigned char T1GTM:1;
    unsigned char T1GPOL:1;
    unsigned char TMR1GE:1;
  };
} __T1GCONbits_t;
extern volatile __T1GCONbits_t __at(T1GCON_ADDR) T1GCONbits;

// ----- T2CON bits --------------------
typedef union {
  struct {
    unsigned char T2CKPS0:1;
    unsigned char T2CKPS1:1;
    unsigned char TMR2ON:1;
    unsigned char T2OUTPS0:1;
    unsigned char T2OUTPS1:1;
    unsigned char T2OUTPS2:1;
    unsigned char T2OUTPS3:1;
    unsigned char :1;
  };
} __T2CONbits_t;
extern volatile __T2CONbits_t __at(T2CON_ADDR) T2CONbits;

// ----- TRISA bits --------------------
typedef union {
  struct {
    unsigned char TRISA0:1;
    unsigned char TRISA1:1;
    unsigned char TRISA2:1;
    unsigned char TRISA3:1;
    unsigned char TRISA4:1;
    unsigned char TRISA5:1;
    unsigned char TRISA6:1;
    unsigned char TRISA7:1;
  };
} __TRISAbits_t;
extern volatile __TRISAbits_t __at(TRISA_ADDR) TRISAbits;

// ----- TRISB bits --------------------
typedef union {
  struct {
    unsigned char TRISB0:1;
    unsigned char TRISB1:1;
    unsigned char TRISB2:1;
    unsigned char TRISB3:1;
    unsigned char TRISB4:1;
    unsigned char TRISB5:1;
    unsigned char TRISB6:1;
    unsigned char TRISB7:1;
  };
} __TRISBbits_t;
extern volatile __TRISBbits_t __at(TRISB_ADDR) TRISBbits;

// ----- TRISC bits --------------------
typedef union {
  struct {
    unsigned char TRISC0:1;
    unsigned char TRISC1:1;
    unsigned char TRISC2:1;
    unsigned char TRISC3:1;
    unsigned char TRISC4:1;
    unsigned char TRISC5:1;
    unsigned char TRISC6:1;
    unsigned char TRISC7:1;
  };
} __TRISCbits_t;
extern volatile __TRISCbits_t __at(TRISC_ADDR) TRISCbits;

// ----- TRISE bits --------------------
typedef union {
  struct {
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
    unsigned char TRISE3:1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
  };
} __TRISEbits_t;
extern volatile __TRISEbits_t __at(TRISE_ADDR) TRISEbits;

// ----- TX1STA bits --------------------
typedef union {
  struct {
    unsigned char TX9D:1;
    unsigned char TRMT:1;
    unsigned char BRGH:1;
    unsigned char SENDB:1;
    unsigned char SYNC:1;
    unsigned char TXEN:1;
    unsigned char TX9:1;
    unsigned char CSRC:1;
  };
} __TX1STAbits_t;
extern volatile __TX1STAbits_t __at(TX1STA_ADDR) TX1STAbits;

// ----- TXSTA bits --------------------
typedef union {
  struct {
    unsigned char TX9D:1;
    unsigned char TRMT:1;
    unsigned char BRGH:1;
    unsigned char SENDB:1;
    unsigned char SYNC:1;
    unsigned char TXEN:1;
    unsigned char TX9:1;
    unsigned char CSRC:1;
  };
} __TXSTAbits_t;
extern volatile __TXSTAbits_t __at(TXSTA_ADDR) TXSTAbits;

// ----- TXSTA1 bits --------------------
typedef union {
  struct {
    unsigned char TX9D:1;
    unsigned char TRMT:1;
    unsigned char BRGH:1;
    unsigned char SENDB:1;
    unsigned char SYNC:1;
    unsigned char TXEN:1;
    unsigned char TX9:1;
    unsigned char CSRC:1;
  };
} __TXSTA1bits_t;
extern volatile __TXSTA1bits_t __at(TXSTA1_ADDR) TXSTA1bits;

// ----- VREGCON bits --------------------
typedef union {
  struct {
    unsigned char VREGPM0:1;
    unsigned char VREGPM1:1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
  };
} __VREGCONbits_t;
extern volatile __VREGCONbits_t __at(VREGCON_ADDR) VREGCONbits;

// ----- WDTCON bits --------------------
typedef union {
  struct {
    unsigned char SWDTEN:1;
    unsigned char WDTPS0:1;
    unsigned char WDTPS1:1;
    unsigned char WDTPS2:1;
    unsigned char WDTPS3:1;
    unsigned char WDTPS4:1;
    unsigned char :1;
    unsigned char :1;
  };
} __WDTCONbits_t;
extern volatile __WDTCONbits_t __at(WDTCON_ADDR) WDTCONbits;

// ----- WPUA bits --------------------
typedef union {
  struct {
    unsigned char WPUA0:1;
    unsigned char WPUA1:1;
    unsigned char WPUA2:1;
    unsigned char WPUA3:1;
    unsigned char WPUA4:1;
    unsigned char WPUA5:1;
    unsigned char WPUA6:1;
    unsigned char WPUA7:1;
  };
} __WPUAbits_t;
extern volatile __WPUAbits_t __at(WPUA_ADDR) WPUAbits;

// ----- WPUB bits --------------------
typedef union {
  struct {
    unsigned char WPUB0:1;
    unsigned char WPUB1:1;
    unsigned char WPUB2:1;
    unsigned char WPUB3:1;
    unsigned char WPUB4:1;
    unsigned char WPUB5:1;
    unsigned char WPUB6:1;
    unsigned char WPUB7:1;
  };
} __WPUBbits_t;
extern volatile __WPUBbits_t __at(WPUB_ADDR) WPUBbits;

// ----- WPUC bits --------------------
typedef union {
  struct {
    unsigned char WPUC0:1;
    unsigned char WPUC1:1;
    unsigned char WPUC2:1;
    unsigned char WPUC3:1;
    unsigned char WPUC4:1;
    unsigned char WPUC5:1;
    unsigned char WPUC6:1;
    unsigned char WPUC7:1;
  };
} __WPUCbits_t;
extern volatile __WPUCbits_t __at(WPUC_ADDR) WPUCbits;

// ----- WPUE bits --------------------
typedef union {
  struct {
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
    unsigned char WPUE3:1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
    unsigned char :1;
  };
} __WPUEbits_t;
extern volatile __WPUEbits_t __at(WPUE_ADDR) WPUEbits;


#ifndef NO_BIT_DEFINES

#define ADON                 ADCON0bits.ADON                /* bit 0 */
#define ADGO                 ADCON0bits.ADGO                /* bit 1 */
#define DONE                 ADCON0bits.DONE                /* bit 1 */
#define GO                   ADCON0bits.GO                  /* bit 1 */
#define GO_NOT_DONE          ADCON0bits.GO_NOT_DONE         /* bit 1 */
#define CHS0                 ADCON0bits.CHS0                /* bit 2 */
#define CHS1                 ADCON0bits.CHS1                /* bit 3 */
#define CHS2                 ADCON0bits.CHS2                /* bit 4 */
#define CHS3                 ADCON0bits.CHS3                /* bit 5 */
#define CHS4                 ADCON0bits.CHS4                /* bit 6 */

#define ADPREF0              ADCON1bits.ADPREF0             /* bit 0 */
#define ADPREF1              ADCON1bits.ADPREF1             /* bit 1 */
#define ADNREF               ADCON1bits.ADNREF              /* bit 2 */
#define ADCS0                ADCON1bits.ADCS0               /* bit 4 */
#define ADCS1                ADCON1bits.ADCS1               /* bit 5 */
#define ADCS2                ADCON1bits.ADCS2               /* bit 6 */
#define ADFM                 ADCON1bits.ADFM                /* bit 7 */

#define CHSN0                ADCON2bits.CHSN0               /* bit 0 */
#define CHSN1                ADCON2bits.CHSN1               /* bit 1 */
#define CHSN2                ADCON2bits.CHSN2               /* bit 2 */
#define CHSN3                ADCON2bits.CHSN3               /* bit 3 */
#define TRIGSEL0             ADCON2bits.TRIGSEL0            /* bit 4 */
#define TRIGSEL1             ADCON2bits.TRIGSEL1            /* bit 5 */
#define TRIGSEL2             ADCON2bits.TRIGSEL2            /* bit 6 */
#define TRIGSEL3             ADCON2bits.TRIGSEL3            /* bit 7 */

#define ANSA0                ANSELAbits.ANSA0               /* bit 0 */
#define ANSA1                ANSELAbits.ANSA1               /* bit 1 */
#define ANSA2                ANSELAbits.ANSA2               /* bit 2 */
#define ANSA3                ANSELAbits.ANSA3               /* bit 3 */
#define ANSA4                ANSELAbits.ANSA4               /* bit 4 */
#define ANSA5                ANSELAbits.ANSA5               /* bit 5 */
#define ANSA7                ANSELAbits.ANSA7               /* bit 7 */

#define ANSB0                ANSELBbits.ANSB0               /* bit 0 */
#define ANSB1                ANSELBbits.ANSB1               /* bit 1 */
#define ANSB2                ANSELBbits.ANSB2               /* bit 2 */
#define ANSB3                ANSELBbits.ANSB3               /* bit 3 */
#define ANSB4                ANSELBbits.ANSB4               /* bit 4 */
#define ANSB5                ANSELBbits.ANSB5               /* bit 5 */

#define CCP2SEL              APFCONbits.CCP2SEL             /* bit 0, shadows bit in APFCON0bits */
#define RXSEL                APFCONbits.RXSEL               /* bit 1, shadows bit in APFCON0bits */
#define TXSEL                APFCONbits.TXSEL               /* bit 2, shadows bit in APFCON0bits */
#define SDISEL               APFCONbits.SDISEL              /* bit 3, shadows bit in APFCON0bits */
#define SCKSEL               APFCONbits.SCKSEL              /* bit 4, shadows bit in APFCON0bits */
#define SDOSEL               APFCONbits.SDOSEL              /* bit 5, shadows bit in APFCON0bits */
#define CCP1SEL              APFCONbits.CCP1SEL             /* bit 6, shadows bit in APFCON0bits */
#define C2OUTSEL             APFCONbits.C2OUTSEL            /* bit 7, shadows bit in APFCON0bits */

#define ABDEN                BAUD1CONbits.ABDEN             /* bit 0, shadows bit in BAUDCONbits, BAUDCON1bits, BAUDCTLbits, BAUDCTL1bits */
#define WUE                  BAUD1CONbits.WUE               /* bit 1, shadows bit in BAUDCONbits, BAUDCON1bits, BAUDCTLbits, BAUDCTL1bits */
#define BRG16                BAUD1CONbits.BRG16             /* bit 3, shadows bit in BAUDCONbits, BAUDCON1bits, BAUDCTLbits, BAUDCTL1bits */
#define SCKP                 BAUD1CONbits.SCKP              /* bit 4, shadows bit in BAUDCONbits, BAUDCON1bits, BAUDCTLbits, BAUDCTL1bits */
#define RCIDL                BAUD1CONbits.RCIDL             /* bit 6, shadows bit in BAUDCONbits, BAUDCON1bits, BAUDCTLbits, BAUDCTL1bits */
#define ABDOVF               BAUD1CONbits.ABDOVF            /* bit 7, shadows bit in BAUDCONbits, BAUDCON1bits, BAUDCTLbits, BAUDCTL1bits */

#define BORRDY               BORCONbits.BORRDY              /* bit 0 */
#define BORFS                BORCONbits.BORFS               /* bit 6 */
#define SBOREN               BORCONbits.SBOREN              /* bit 7 */

#define BSR0                 BSRbits.BSR0                   /* bit 0 */
#define BSR1                 BSRbits.BSR1                   /* bit 1 */
#define BSR2                 BSRbits.BSR2                   /* bit 2 */
#define BSR3                 BSRbits.BSR3                   /* bit 3 */
#define BSR4                 BSRbits.BSR4                   /* bit 4 */

#define CCP1M0               CCP1CONbits.CCP1M0             /* bit 0 */
#define CCP1M1               CCP1CONbits.CCP1M1             /* bit 1 */
#define CCP1M2               CCP1CONbits.CCP1M2             /* bit 2 */
#define CCP1M3               CCP1CONbits.CCP1M3             /* bit 3 */
#define DC1B0                CCP1CONbits.DC1B0              /* bit 4 */
#define DC1B1                CCP1CONbits.DC1B1              /* bit 5 */
#define P1M0                 CCP1CONbits.P1M0               /* bit 6 */
#define P1M1                 CCP1CONbits.P1M1               /* bit 7 */

#define CCP2M0               CCP2CONbits.CCP2M0             /* bit 0 */
#define CCP2M1               CCP2CONbits.CCP2M1             /* bit 1 */
#define CCP2M2               CCP2CONbits.CCP2M2             /* bit 2 */
#define CCP2M3               CCP2CONbits.CCP2M3             /* bit 3 */
#define DC2B0                CCP2CONbits.DC2B0              /* bit 4 */
#define DC2B1                CCP2CONbits.DC2B1              /* bit 5 */
#define P2M0                 CCP2CONbits.P2M0               /* bit 6 */
#define P2M1                 CCP2CONbits.P2M1               /* bit 7 */

#define CLKRDIV0             CLKRCONbits.CLKRDIV0           /* bit 0 */
#define CLKRDIV1             CLKRCONbits.CLKRDIV1           /* bit 1 */
#define CLKRDIV2             CLKRCONbits.CLKRDIV2           /* bit 2 */
#define CLKRDC0              CLKRCONbits.CLKRDC0            /* bit 3 */
#define CLKRDC1              CLKRCONbits.CLKRDC1            /* bit 4 */
#define CLKRSLR              CLKRCONbits.CLKRSLR            /* bit 5 */
#define CLKROE               CLKRCONbits.CLKROE             /* bit 6 */
#define CLKREN               CLKRCONbits.CLKREN             /* bit 7 */

#define C1SYNC               CM1CON0bits.C1SYNC             /* bit 0 */
#define C1HYS                CM1CON0bits.C1HYS              /* bit 1 */
#define C1SP                 CM1CON0bits.C1SP               /* bit 2 */
#define C1POL                CM1CON0bits.C1POL              /* bit 4 */
#define C1OE                 CM1CON0bits.C1OE               /* bit 5 */
#define C1OUT                CM1CON0bits.C1OUT              /* bit 6 */
#define C1ON                 CM1CON0bits.C1ON               /* bit 7 */

#define C1NCH0               CM1CON1bits.C1NCH0             /* bit 0 */
#define C1NCH1               CM1CON1bits.C1NCH1             /* bit 1 */
#define C1NCH2               CM1CON1bits.C1NCH2             /* bit 2 */
#define C1PCH0               CM1CON1bits.C1PCH0             /* bit 3 */
#define C1PCH1               CM1CON1bits.C1PCH1             /* bit 4 */
#define C1PCH2               CM1CON1bits.C1PCH2             /* bit 5 */
#define C1INTN               CM1CON1bits.C1INTN             /* bit 6 */
#define C1INTP               CM1CON1bits.C1INTP             /* bit 7 */

#define C2SYNC               CM2CON0bits.C2SYNC             /* bit 0 */
#define C2HYS                CM2CON0bits.C2HYS              /* bit 1 */
#define C2SP                 CM2CON0bits.C2SP               /* bit 2 */
#define C2POL                CM2CON0bits.C2POL              /* bit 4 */
#define C2OE                 CM2CON0bits.C2OE               /* bit 5 */
#define C2OUT                CM2CON0bits.C2OUT              /* bit 6 */
#define C2ON                 CM2CON0bits.C2ON               /* bit 7 */

#define C2NCH0               CM2CON1bits.C2NCH0             /* bit 0 */
#define C2NCH1               CM2CON1bits.C2NCH1             /* bit 1 */
#define C2NCH2               CM2CON1bits.C2NCH2             /* bit 2 */
#define C2PCH0               CM2CON1bits.C2PCH0             /* bit 3 */
#define C2PCH1               CM2CON1bits.C2PCH1             /* bit 4 */
#define C2PCH2               CM2CON1bits.C2PCH2             /* bit 5 */
#define C2INTN               CM2CON1bits.C2INTN             /* bit 6 */
#define C2INTP               CM2CON1bits.C2INTP             /* bit 7 */

#define C3SYNC               CM3CON0bits.C3SYNC             /* bit 0 */
#define C3HYS                CM3CON0bits.C3HYS              /* bit 1 */
#define C3SP                 CM3CON0bits.C3SP               /* bit 2 */
#define C3POL                CM3CON0bits.C3POL              /* bit 4 */
#define C3OE                 CM3CON0bits.C3OE               /* bit 5 */
#define C3OUT                CM3CON0bits.C3OUT              /* bit 6 */
#define C3ON                 CM3CON0bits.C3ON               /* bit 7 */

#define C3NCH0               CM3CON1bits.C3NCH0             /* bit 0 */
#define C3NCH1               CM3CON1bits.C3NCH1             /* bit 1 */
#define C3NCH2               CM3CON1bits.C3NCH2             /* bit 2 */
#define C3PCH0               CM3CON1bits.C3PCH0             /* bit 3 */
#define C3PCH1               CM3CON1bits.C3PCH1             /* bit 4 */
#define C3PCH2               CM3CON1bits.C3PCH2             /* bit 5 */
#define C3INTN               CM3CON1bits.C3INTN             /* bit 6 */
#define C3INTP               CM3CON1bits.C3INTP             /* bit 7 */

#define MC1OUT               CMOUTbits.MC1OUT               /* bit 0 */
#define MC2OUT               CMOUTbits.MC2OUT               /* bit 1 */
#define MC3OUT               CMOUTbits.MC3OUT               /* bit 2 */

#define DACNSS               DACCON0bits.DACNSS             /* bit 0 */
#define DACPSS0              DACCON0bits.DACPSS0            /* bit 2 */
#define DACPSS1              DACCON0bits.DACPSS1            /* bit 3 */
#define DACOE2               DACCON0bits.DACOE2             /* bit 4 */
#define DACOE1               DACCON0bits.DACOE1             /* bit 5 */
#define DACEN                DACCON0bits.DACEN              /* bit 7 */

#define DACR0                DACCON1bits.DACR0              /* bit 0 */
#define DACR1                DACCON1bits.DACR1              /* bit 1 */
#define DACR2                DACCON1bits.DACR2              /* bit 2 */
#define DACR3                DACCON1bits.DACR3              /* bit 3 */
#define DACR4                DACCON1bits.DACR4              /* bit 4 */
#define DACR5                DACCON1bits.DACR5              /* bit 5 */
#define DACR6                DACCON1bits.DACR6              /* bit 6 */
#define DACR7                DACCON1bits.DACR7              /* bit 7 */

#define RD                   EECON1bits.RD                  /* bit 0 */
#define WR                   EECON1bits.WR                  /* bit 1 */
#define WREN                 EECON1bits.WREN                /* bit 2 */
#define WRERR                EECON1bits.WRERR               /* bit 3 */
#define FREE                 EECON1bits.FREE                /* bit 4 */
#define LWLO                 EECON1bits.LWLO                /* bit 5 */
#define CFGS                 EECON1bits.CFGS                /* bit 6 */
#define EEPGD                EECON1bits.EEPGD               /* bit 7 */

#define ADFVR0               FVRCONbits.ADFVR0              /* bit 0 */
#define ADFVR1               FVRCONbits.ADFVR1              /* bit 1 */
#define CDAFVR0              FVRCONbits.CDAFVR0             /* bit 2 */
#define CDAFVR1              FVRCONbits.CDAFVR1             /* bit 3 */
#define FVRRDY               FVRCONbits.FVRRDY              /* bit 6 */
#define FVREN                FVRCONbits.FVREN               /* bit 7 */

#define INLVLA0              INLVLAbits.INLVLA0             /* bit 0 */
#define INLVLA1              INLVLAbits.INLVLA1             /* bit 1 */
#define INLVLA2              INLVLAbits.INLVLA2             /* bit 2 */
#define INLVLA3              INLVLAbits.INLVLA3             /* bit 3 */
#define INLVLA4              INLVLAbits.INLVLA4             /* bit 4 */
#define INLVLA5              INLVLAbits.INLVLA5             /* bit 5 */
#define INLVLA6              INLVLAbits.INLVLA6             /* bit 6 */
#define INLVLA7              INLVLAbits.INLVLA7             /* bit 7 */

#define INLVLB0              INLVLBbits.INLVLB0             /* bit 0 */
#define INLVLB1              INLVLBbits.INLVLB1             /* bit 1 */
#define INLVLB2              INLVLBbits.INLVLB2             /* bit 2 */
#define INLVLB3              INLVLBbits.INLVLB3             /* bit 3 */
#define INLVLB4              INLVLBbits.INLVLB4             /* bit 4 */
#define INLVLB5              INLVLBbits.INLVLB5             /* bit 5 */
#define INLVLB6              INLVLBbits.INLVLB6             /* bit 6 */
#define INLVLB7              INLVLBbits.INLVLB7             /* bit 7 */

#define INLVLC0              INLVLCbits.INLVLC0             /* bit 0 */
#define INLVLC1              INLVLCbits.INLVLC1             /* bit 1 */
#define INLVLC2              INLVLCbits.INLVLC2             /* bit 2 */
#define INLVLC3              INLVLCbits.INLVLC3             /* bit 3 */
#define INLVLC4              INLVLCbits.INLVLC4             /* bit 4 */
#define INLVLC5              INLVLCbits.INLVLC5             /* bit 5 */
#define INLVLC6              INLVLCbits.INLVLC6             /* bit 6 */
#define INLVLC7              INLVLCbits.INLVLC7             /* bit 7 */

#define INLVLE3              INLVLEbits.INLVLE3             /* bit 3 */

#define IOCIF                INTCONbits.IOCIF               /* bit 0 */
#define INTF                 INTCONbits.INTF                /* bit 1 */
#define T0IF                 INTCONbits.T0IF                /* bit 2 */
#define TMR0IF               INTCONbits.TMR0IF              /* bit 2 */
#define IOCIE                INTCONbits.IOCIE               /* bit 3 */
#define INTE                 INTCONbits.INTE                /* bit 4 */
#define T0IE                 INTCONbits.T0IE                /* bit 5 */
#define TMR0IE               INTCONbits.TMR0IE              /* bit 5 */
#define PEIE                 INTCONbits.PEIE                /* bit 6 */
#define GIE                  INTCONbits.GIE                 /* bit 7 */

#define IOCAF0               IOCAFbits.IOCAF0               /* bit 0 */
#define IOCAF1               IOCAFbits.IOCAF1               /* bit 1 */
#define IOCAF2               IOCAFbits.IOCAF2               /* bit 2 */
#define IOCAF3               IOCAFbits.IOCAF3               /* bit 3 */
#define IOCAF4               IOCAFbits.IOCAF4               /* bit 4 */
#define IOCAF5               IOCAFbits.IOCAF5               /* bit 5 */
#define IOCAF6               IOCAFbits.IOCAF6               /* bit 6 */
#define IOCAF7               IOCAFbits.IOCAF7               /* bit 7 */

#define IOCAN0               IOCANbits.IOCAN0               /* bit 0 */
#define IOCAN1               IOCANbits.IOCAN1               /* bit 1 */
#define IOCAN2               IOCANbits.IOCAN2               /* bit 2 */
#define IOCAN3               IOCANbits.IOCAN3               /* bit 3 */
#define IOCAN4               IOCANbits.IOCAN4               /* bit 4 */
#define IOCAN5               IOCANbits.IOCAN5               /* bit 5 */
#define IOCAN6               IOCANbits.IOCAN6               /* bit 6 */
#define IOCAN7               IOCANbits.IOCAN7               /* bit 7 */

#define IOCAP0               IOCAPbits.IOCAP0               /* bit 0 */
#define IOCAP1               IOCAPbits.IOCAP1               /* bit 1 */
#define IOCAP2               IOCAPbits.IOCAP2               /* bit 2 */
#define IOCAP3               IOCAPbits.IOCAP3               /* bit 3 */
#define IOCAP4               IOCAPbits.IOCAP4               /* bit 4 */
#define IOCAP5               IOCAPbits.IOCAP5               /* bit 5 */
#define IOCAP6               IOCAPbits.IOCAP6               /* bit 6 */
#define IOCAP7               IOCAPbits.IOCAP7               /* bit 7 */

#define IOCBF0               IOCBFbits.IOCBF0               /* bit 0 */
#define IOCBF1               IOCBFbits.IOCBF1               /* bit 1 */
#define IOCBF2               IOCBFbits.IOCBF2               /* bit 2 */
#define IOCBF3               IOCBFbits.IOCBF3               /* bit 3 */
#define IOCBF4               IOCBFbits.IOCBF4               /* bit 4 */
#define IOCBF5               IOCBFbits.IOCBF5               /* bit 5 */
#define IOCBF6               IOCBFbits.IOCBF6               /* bit 6 */
#define IOCBF7               IOCBFbits.IOCBF7               /* bit 7 */

#define IOCBN0               IOCBNbits.IOCBN0               /* bit 0 */
#define IOCBN1               IOCBNbits.IOCBN1               /* bit 1 */
#define IOCBN2               IOCBNbits.IOCBN2               /* bit 2 */
#define IOCBN3               IOCBNbits.IOCBN3               /* bit 3 */
#define IOCBN4               IOCBNbits.IOCBN4               /* bit 4 */
#define IOCBN5               IOCBNbits.IOCBN5               /* bit 5 */
#define IOCBN6               IOCBNbits.IOCBN6               /* bit 6 */
#define IOCBN7               IOCBNbits.IOCBN7               /* bit 7 */

#define IOCBP0               IOCBPbits.IOCBP0               /* bit 0 */
#define IOCBP1               IOCBPbits.IOCBP1               /* bit 1 */
#define IOCBP2               IOCBPbits.IOCBP2               /* bit 2 */
#define IOCBP3               IOCBPbits.IOCBP3               /* bit 3 */
#define IOCBP4               IOCBPbits.IOCBP4               /* bit 4 */
#define IOCBP5               IOCBPbits.IOCBP5               /* bit 5 */
#define IOCBP6               IOCBPbits.IOCBP6               /* bit 6 */
#define IOCBP7               IOCBPbits.IOCBP7               /* bit 7 */

#define IOCCF0               IOCCFbits.IOCCF0               /* bit 0 */
#define IOCCF1               IOCCFbits.IOCCF1               /* bit 1 */
#define IOCCF2               IOCCFbits.IOCCF2               /* bit 2 */
#define IOCCF3               IOCCFbits.IOCCF3               /* bit 3 */
#define IOCCF4               IOCCFbits.IOCCF4               /* bit 4 */
#define IOCCF5               IOCCFbits.IOCCF5               /* bit 5 */
#define IOCCF6               IOCCFbits.IOCCF6               /* bit 6 */
#define IOCCF7               IOCCFbits.IOCCF7               /* bit 7 */

#define IOCCN0               IOCCNbits.IOCCN0               /* bit 0 */
#define IOCCN1               IOCCNbits.IOCCN1               /* bit 1 */
#define IOCCN2               IOCCNbits.IOCCN2               /* bit 2 */
#define IOCCN3               IOCCNbits.IOCCN3               /* bit 3 */
#define IOCCN4               IOCCNbits.IOCCN4               /* bit 4 */
#define IOCCN5               IOCCNbits.IOCCN5               /* bit 5 */
#define IOCCN6               IOCCNbits.IOCCN6               /* bit 6 */
#define IOCCN7               IOCCNbits.IOCCN7               /* bit 7 */

#define IOCCP0               IOCCPbits.IOCCP0               /* bit 0 */
#define IOCCP1               IOCCPbits.IOCCP1               /* bit 1 */
#define IOCCP2               IOCCPbits.IOCCP2               /* bit 2 */
#define IOCCP3               IOCCPbits.IOCCP3               /* bit 3 */
#define IOCCP4               IOCCPbits.IOCCP4               /* bit 4 */
#define IOCCP5               IOCCPbits.IOCCP5               /* bit 5 */
#define IOCCP6               IOCCPbits.IOCCP6               /* bit 6 */
#define IOCCP7               IOCCPbits.IOCCP7               /* bit 7 */

#define IOCEF3               IOCEFbits.IOCEF3               /* bit 3 */

#define IOCEN3               IOCENbits.IOCEN3               /* bit 3 */

#define IOCEP3               IOCEPbits.IOCEP3               /* bit 3 */

#define LATA0                LATAbits.LATA0                 /* bit 0 */
#define LATA1                LATAbits.LATA1                 /* bit 1 */
#define LATA2                LATAbits.LATA2                 /* bit 2 */
#define LATA3                LATAbits.LATA3                 /* bit 3 */
#define LATA4                LATAbits.LATA4                 /* bit 4 */
#define LATA5                LATAbits.LATA5                 /* bit 5 */
#define LATA6                LATAbits.LATA6                 /* bit 6 */
#define LATA7                LATAbits.LATA7                 /* bit 7 */

#define LATB0                LATBbits.LATB0                 /* bit 0 */
#define LATB1                LATBbits.LATB1                 /* bit 1 */
#define LATB2                LATBbits.LATB2                 /* bit 2 */
#define LATB3                LATBbits.LATB3                 /* bit 3 */
#define LATB4                LATBbits.LATB4                 /* bit 4 */
#define LATB5                LATBbits.LATB5                 /* bit 5 */
#define LATB6                LATBbits.LATB6                 /* bit 6 */
#define LATB7                LATBbits.LATB7                 /* bit 7 */

#define LATC0                LATCbits.LATC0                 /* bit 0 */
#define LATC1                LATCbits.LATC1                 /* bit 1 */
#define LATC2                LATCbits.LATC2                 /* bit 2 */
#define LATC3                LATCbits.LATC3                 /* bit 3 */
#define LATC4                LATCbits.LATC4                 /* bit 4 */
#define LATC5                LATCbits.LATC5                 /* bit 5 */
#define LATC6                LATCbits.LATC6                 /* bit 6 */
#define LATC7                LATCbits.LATC7                 /* bit 7 */

#define ODCONA0              ODCONAbits.ODCONA0             /* bit 0 */
#define ODCONA1              ODCONAbits.ODCONA1             /* bit 1 */
#define ODCONA2              ODCONAbits.ODCONA2             /* bit 2 */
#define ODCONA3              ODCONAbits.ODCONA3             /* bit 3 */
#define ODCONA4              ODCONAbits.ODCONA4             /* bit 4 */
#define ODCONA5              ODCONAbits.ODCONA5             /* bit 5 */
#define ODCONA6              ODCONAbits.ODCONA6             /* bit 6 */
#define ODCONA7              ODCONAbits.ODCONA7             /* bit 7 */

#define ODCONB0              ODCONBbits.ODCONB0             /* bit 0 */
#define ODCONB1              ODCONBbits.ODCONB1             /* bit 1 */
#define ODCONB2              ODCONBbits.ODCONB2             /* bit 2 */
#define ODCONB3              ODCONBbits.ODCONB3             /* bit 3 */
#define ODCONB4              ODCONBbits.ODCONB4             /* bit 4 */
#define ODCONB5              ODCONBbits.ODCONB5             /* bit 5 */
#define ODCONB6              ODCONBbits.ODCONB6             /* bit 6 */
#define ODCONB7              ODCONBbits.ODCONB7             /* bit 7 */

#define ODCONC0              ODCONCbits.ODCONC0             /* bit 0 */
#define ODCONC1              ODCONCbits.ODCONC1             /* bit 1 */
#define ODCONC2              ODCONCbits.ODCONC2             /* bit 2 */
#define ODCONC3              ODCONCbits.ODCONC3             /* bit 3 */
#define ODCONC4              ODCONCbits.ODCONC4             /* bit 4 */
#define ODCONC5              ODCONCbits.ODCONC5             /* bit 5 */
#define ODCONC6              ODCONCbits.ODCONC6             /* bit 6 */
#define ODCONC7              ODCONCbits.ODCONC7             /* bit 7 */

#define OPA1CH0              OPA1CONbits.OPA1CH0            /* bit 0 */
#define OPA1CH1              OPA1CONbits.OPA1CH1            /* bit 1 */
#define OPA1SP               OPA1CONbits.OPA1SP             /* bit 6 */
#define OPA1EN               OPA1CONbits.OPA1EN             /* bit 7 */

#define OPA2CH0              OPA2CONbits.OPA2CH0            /* bit 0 */
#define OPA2CH1              OPA2CONbits.OPA2CH1            /* bit 1 */
#define OPA2SP               OPA2CONbits.OPA2SP             /* bit 6 */
#define OPA2EN               OPA2CONbits.OPA2EN             /* bit 7 */

#define PS0                  OPTION_REGbits.PS0             /* bit 0 */
#define PS1                  OPTION_REGbits.PS1             /* bit 1 */
#define PS2                  OPTION_REGbits.PS2             /* bit 2 */
#define PSA                  OPTION_REGbits.PSA             /* bit 3 */
#define T0SE                 OPTION_REGbits.T0SE            /* bit 4 */
#define TMR0SE               OPTION_REGbits.TMR0SE          /* bit 4 */
#define T0CS                 OPTION_REGbits.T0CS            /* bit 5 */
#define TMR0CS               OPTION_REGbits.TMR0CS          /* bit 5 */
#define INTEDG               OPTION_REGbits.INTEDG          /* bit 6 */
#define NOT_WPUEN            OPTION_REGbits.NOT_WPUEN       /* bit 7 */

#define SCS0                 OSCCONbits.SCS0                /* bit 0 */
#define SCS1                 OSCCONbits.SCS1                /* bit 1 */
#define IRCF0                OSCCONbits.IRCF0               /* bit 3 */
#define IRCF1                OSCCONbits.IRCF1               /* bit 4 */
#define IRCF2                OSCCONbits.IRCF2               /* bit 5 */
#define IRCF3                OSCCONbits.IRCF3               /* bit 6 */
#define SPLLEN               OSCCONbits.SPLLEN              /* bit 7 */

#define HFIOFS               OSCSTATbits.HFIOFS             /* bit 0 */
#define LFIOFR               OSCSTATbits.LFIOFR             /* bit 1 */
#define MFIOFR               OSCSTATbits.MFIOFR             /* bit 2 */
#define HFIOFL               OSCSTATbits.HFIOFL             /* bit 3 */
#define HFIOFR               OSCSTATbits.HFIOFR             /* bit 4 */
#define OSTS                 OSCSTATbits.OSTS               /* bit 5 */
#define PLLR                 OSCSTATbits.PLLR               /* bit 6 */
#define T1OSCR               OSCSTATbits.T1OSCR             /* bit 7 */

#define TUN0                 OSCTUNEbits.TUN0               /* bit 0 */
#define TUN1                 OSCTUNEbits.TUN1               /* bit 1 */
#define TUN2                 OSCTUNEbits.TUN2               /* bit 2 */
#define TUN3                 OSCTUNEbits.TUN3               /* bit 3 */
#define TUN4                 OSCTUNEbits.TUN4               /* bit 4 */
#define TUN5                 OSCTUNEbits.TUN5               /* bit 5 */

#define NOT_BOR              PCONbits.NOT_BOR               /* bit 0 */
#define NOT_POR              PCONbits.NOT_POR               /* bit 1 */
#define NOT_RI               PCONbits.NOT_RI                /* bit 2 */
#define NOT_RMCLR            PCONbits.NOT_RMCLR             /* bit 3 */
#define NOT_RWDT             PCONbits.NOT_RWDT              /* bit 4 */
#define STKUNF               PCONbits.STKUNF                /* bit 6 */
#define STKOVF               PCONbits.STKOVF                /* bit 7 */

#define TMR1IE               PIE1bits.TMR1IE                /* bit 0 */
#define TMR2IE               PIE1bits.TMR2IE                /* bit 1 */
#define CCP1IE               PIE1bits.CCP1IE                /* bit 2 */
#define SSP1IE               PIE1bits.SSP1IE                /* bit 3 */
#define TXIE                 PIE1bits.TXIE                  /* bit 4 */
#define RCIE                 PIE1bits.RCIE                  /* bit 5 */
#define ADIE                 PIE1bits.ADIE                  /* bit 6 */
#define TMR1GIE              PIE1bits.TMR1GIE               /* bit 7 */

#define CCP2IE               PIE2bits.CCP2IE                /* bit 0 */
#define C3IE                 PIE2bits.C3IE                  /* bit 1 */
#define BCL1IE               PIE2bits.BCL1IE                /* bit 3 */
#define EEIE                 PIE2bits.EEIE                  /* bit 4 */
#define C1IE                 PIE2bits.C1IE                  /* bit 5 */
#define C2IE                 PIE2bits.C2IE                  /* bit 6 */
#define OSFIE                PIE2bits.OSFIE                 /* bit 7 */

#define PSMC1SIE             PIE4bits.PSMC1SIE              /* bit 0 */
#define PSMC2SIE             PIE4bits.PSMC2SIE              /* bit 1 */
#define PSMC1TIE             PIE4bits.PSMC1TIE              /* bit 4 */
#define PSMC2TIE             PIE4bits.PSMC2TIE              /* bit 5 */

#define TMR1IF               PIR1bits.TMR1IF                /* bit 0 */
#define TMR2IF               PIR1bits.TMR2IF                /* bit 1 */
#define CCP1IF               PIR1bits.CCP1IF                /* bit 2 */
#define SSP1IF               PIR1bits.SSP1IF                /* bit 3 */
#define TXIF                 PIR1bits.TXIF                  /* bit 4 */
#define RCIF                 PIR1bits.RCIF                  /* bit 5 */
#define ADIF                 PIR1bits.ADIF                  /* bit 6 */
#define TMR1GIF              PIR1bits.TMR1GIF               /* bit 7 */

#define CCP2IF               PIR2bits.CCP2IF                /* bit 0 */
#define C3IF                 PIR2bits.C3IF                  /* bit 1 */
#define BCL1IF               PIR2bits.BCL1IF                /* bit 3 */
#define EEIF                 PIR2bits.EEIF                  /* bit 4 */
#define C1IF                 PIR2bits.C1IF                  /* bit 5 */
#define C2IF                 PIR2bits.C2IF                  /* bit 6 */
#define OSFIF                PIR2bits.OSFIF                 /* bit 7 */

#define PSMC1SIF             PIR4bits.PSMC1SIF              /* bit 0 */
#define PSMC2SIF             PIR4bits.PSMC2SIF              /* bit 1 */
#define PSMC1TIF             PIR4bits.PSMC1TIF              /* bit 4 */
#define PSMC2TIF             PIR4bits.PSMC2TIF              /* bit 5 */

#define RA0                  PORTAbits.RA0                  /* bit 0 */
#define RA1                  PORTAbits.RA1                  /* bit 1 */
#define RA2                  PORTAbits.RA2                  /* bit 2 */
#define RA3                  PORTAbits.RA3                  /* bit 3 */
#define RA4                  PORTAbits.RA4                  /* bit 4 */
#define RA5                  PORTAbits.RA5                  /* bit 5 */
#define RA6                  PORTAbits.RA6                  /* bit 6 */
#define RA7                  PORTAbits.RA7                  /* bit 7 */

#define RB0                  PORTBbits.RB0                  /* bit 0 */
#define RB1                  PORTBbits.RB1                  /* bit 1 */
#define RB2                  PORTBbits.RB2                  /* bit 2 */
#define RB3                  PORTBbits.RB3                  /* bit 3 */
#define RB4                  PORTBbits.RB4                  /* bit 4 */
#define RB5                  PORTBbits.RB5                  /* bit 5 */
#define RB6                  PORTBbits.RB6                  /* bit 6 */
#define RB7                  PORTBbits.RB7                  /* bit 7 */

#define RC0                  PORTCbits.RC0                  /* bit 0 */
#define RC1                  PORTCbits.RC1                  /* bit 1 */
#define RC2                  PORTCbits.RC2                  /* bit 2 */
#define RC3                  PORTCbits.RC3                  /* bit 3 */
#define RC4                  PORTCbits.RC4                  /* bit 4 */
#define RC5                  PORTCbits.RC5                  /* bit 5 */
#define RC6                  PORTCbits.RC6                  /* bit 6 */
#define RC7                  PORTCbits.RC7                  /* bit 7 */

#define RE3                  PORTEbits.RE3                  /* bit 3 */

#define P1ASDOV              PSMC1ASDCbits.P1ASDOV          /* bit 0 */
#define P1ARSEN              PSMC1ASDCbits.P1ARSEN          /* bit 5 */
#define P1ASDEN              PSMC1ASDCbits.P1ASDEN          /* bit 6 */
#define P1ASE                PSMC1ASDCbits.P1ASE            /* bit 7 */

#define P1ASDLA              PSMC1ASDLbits.P1ASDLA          /* bit 0 */
#define P1ASDLB              PSMC1ASDLbits.P1ASDLB          /* bit 1 */
#define P1ASDLC              PSMC1ASDLbits.P1ASDLC          /* bit 2 */
#define P1ASDLD              PSMC1ASDLbits.P1ASDLD          /* bit 3 */
#define P1ASDLE              PSMC1ASDLbits.P1ASDLE          /* bit 4 */
#define P1ASDLF              PSMC1ASDLbits.P1ASDLF          /* bit 5 */

#define P1ASDSC1             PSMC1ASDSbits.P1ASDSC1         /* bit 1 */
#define P1ASDSC2             PSMC1ASDSbits.P1ASDSC2         /* bit 2 */
#define P1ASDSC3             PSMC1ASDSbits.P1ASDSC3         /* bit 3 */
#define P1ASDSIN             PSMC1ASDSbits.P1ASDSIN         /* bit 7 */

#define PSMC1BLKF0           PSMC1BLKFbits.PSMC1BLKF0       /* bit 0 */
#define PSMC1BLKF1           PSMC1BLKFbits.PSMC1BLKF1       /* bit 1 */
#define PSMC1BLKF2           PSMC1BLKFbits.PSMC1BLKF2       /* bit 2 */
#define PSMC1BLKF3           PSMC1BLKFbits.PSMC1BLKF3       /* bit 3 */
#define PSMC1BLKF4           PSMC1BLKFbits.PSMC1BLKF4       /* bit 4 */
#define PSMC1BLKF5           PSMC1BLKFbits.PSMC1BLKF5       /* bit 5 */
#define PSMC1BLKF6           PSMC1BLKFbits.PSMC1BLKF6       /* bit 6 */
#define PSMC1BLKF7           PSMC1BLKFbits.PSMC1BLKF7       /* bit 7 */

#define PSMC1BLKR0           PSMC1BLKRbits.PSMC1BLKR0       /* bit 0 */
#define PSMC1BLKR1           PSMC1BLKRbits.PSMC1BLKR1       /* bit 1 */
#define PSMC1BLKR2           PSMC1BLKRbits.PSMC1BLKR2       /* bit 2 */
#define PSMC1BLKR3           PSMC1BLKRbits.PSMC1BLKR3       /* bit 3 */
#define PSMC1BLKR4           PSMC1BLKRbits.PSMC1BLKR4       /* bit 4 */
#define PSMC1BLKR5           PSMC1BLKRbits.PSMC1BLKR5       /* bit 5 */
#define PSMC1BLKR6           PSMC1BLKRbits.PSMC1BLKR6       /* bit 6 */
#define PSMC1BLKR7           PSMC1BLKRbits.PSMC1BLKR7       /* bit 7 */

#define P1REBM0              PSMC1BLNKbits.P1REBM0          /* bit 0 */
#define P1REBM1              PSMC1BLNKbits.P1REBM1          /* bit 1 */
#define P1FEBM0              PSMC1BLNKbits.P1FEBM0          /* bit 4 */
#define P1FEBM1              PSMC1BLNKbits.P1FEBM1          /* bit 5 */

#define P1CSRC0              PSMC1CLKbits.P1CSRC0           /* bit 0 */
#define P1CSRC1              PSMC1CLKbits.P1CSRC1           /* bit 1 */
#define P1CPRE0              PSMC1CLKbits.P1CPRE0           /* bit 4 */
#define P1CPRE1              PSMC1CLKbits.P1CPRE1           /* bit 5 */

#define P1MODE0              PSMC1CONbits.P1MODE0           /* bit 0 */
#define P1MODE1              PSMC1CONbits.P1MODE1           /* bit 1 */
#define P1MODE2              PSMC1CONbits.P1MODE2           /* bit 2 */
#define P1MODE3              PSMC1CONbits.P1MODE3           /* bit 3 */
#define P1DBRE               PSMC1CONbits.P1DBRE            /* bit 4 */
#define P1DBFE               PSMC1CONbits.P1DBFE            /* bit 5 */
#define PSMC1LD              PSMC1CONbits.PSMC1LD           /* bit 6 */
#define PSMC1EN              PSMC1CONbits.PSMC1EN           /* bit 7 */

#define PSMC1DBF0            PSMC1DBFbits.PSMC1DBF0         /* bit 0 */
#define PSMC1DBF1            PSMC1DBFbits.PSMC1DBF1         /* bit 1 */
#define PSMC1DBF2            PSMC1DBFbits.PSMC1DBF2         /* bit 2 */
#define PSMC1DBF3            PSMC1DBFbits.PSMC1DBF3         /* bit 3 */
#define PSMC1DBF4            PSMC1DBFbits.PSMC1DBF4         /* bit 4 */
#define PSMC1DBF5            PSMC1DBFbits.PSMC1DBF5         /* bit 5 */
#define PSMC1DBF6            PSMC1DBFbits.PSMC1DBF6         /* bit 6 */
#define PSMC1DBF7            PSMC1DBFbits.PSMC1DBF7         /* bit 7 */

#define PSMC1DBR0            PSMC1DBRbits.PSMC1DBR0         /* bit 0 */
#define PSMC1DBR1            PSMC1DBRbits.PSMC1DBR1         /* bit 1 */
#define PSMC1DBR2            PSMC1DBRbits.PSMC1DBR2         /* bit 2 */
#define PSMC1DBR3            PSMC1DBRbits.PSMC1DBR3         /* bit 3 */
#define PSMC1DBR4            PSMC1DBRbits.PSMC1DBR4         /* bit 4 */
#define PSMC1DBR5            PSMC1DBRbits.PSMC1DBR5         /* bit 5 */
#define PSMC1DBR6            PSMC1DBRbits.PSMC1DBR6         /* bit 6 */
#define PSMC1DBR7            PSMC1DBRbits.PSMC1DBR7         /* bit 7 */

#define PSMC1DC8             PSMC1DCHbits.PSMC1DC8          /* bit 0 */
#define PSMC1DC9             PSMC1DCHbits.PSMC1DC9          /* bit 1 */
#define PSMC1DC10            PSMC1DCHbits.PSMC1DC10         /* bit 2 */
#define PSMC1DC11            PSMC1DCHbits.PSMC1DC11         /* bit 3 */
#define PSMC1DC12            PSMC1DCHbits.PSMC1DC12         /* bit 4 */
#define PSMC1DC13            PSMC1DCHbits.PSMC1DC13         /* bit 5 */
#define PSMC1DC14            PSMC1DCHbits.PSMC1DC14         /* bit 6 */
#define PSMC1DC15            PSMC1DCHbits.PSMC1DC15         /* bit 7 */

#define PSMC1DC0             PSMC1DCLbits.PSMC1DC0          /* bit 0 */
#define PSMC1DC1             PSMC1DCLbits.PSMC1DC1          /* bit 1 */
#define PSMC1DC2             PSMC1DCLbits.PSMC1DC2          /* bit 2 */
#define PSMC1DC3             PSMC1DCLbits.PSMC1DC3          /* bit 3 */
#define PSMC1DC4             PSMC1DCLbits.PSMC1DC4          /* bit 4 */
#define PSMC1DC5             PSMC1DCLbits.PSMC1DC5          /* bit 5 */
#define PSMC1DC6             PSMC1DCLbits.PSMC1DC6          /* bit 6 */
#define PSMC1DC7             PSMC1DCLbits.PSMC1DC7          /* bit 7 */

#define P1DCST               PSMC1DCSbits.P1DCST            /* bit 0 */
#define P1DCSC1              PSMC1DCSbits.P1DCSC1           /* bit 1 */
#define P1DCSC2              PSMC1DCSbits.P1DCSC2           /* bit 2 */
#define P1DCSC3              PSMC1DCSbits.P1DCSC3           /* bit 3 */
#define P1DCSIN              PSMC1DCSbits.P1DCSIN           /* bit 7 */

#define P1FEBSC1             PSMC1FEBSbits.P1FEBSC1         /* bit 1 */
#define P1FEBSC2             PSMC1FEBSbits.P1FEBSC2         /* bit 2 */
#define P1FEBSC3             PSMC1FEBSbits.P1FEBSC3         /* bit 3 */
#define P1FEBSIN             PSMC1FEBSbits.P1FEBSIN         /* bit 7 */

#define PSMC1FFA0            PSMC1FFAbits.PSMC1FFA0         /* bit 0 */
#define PSMC1FFA1            PSMC1FFAbits.PSMC1FFA1         /* bit 1 */
#define PSMC1FFA2            PSMC1FFAbits.PSMC1FFA2         /* bit 2 */
#define PSMC1FFA3            PSMC1FFAbits.PSMC1FFA3         /* bit 3 */

#define P1TPRIF              PSMC1INTbits.P1TPRIF           /* bit 0 */
#define P1TDCIF              PSMC1INTbits.P1TDCIF           /* bit 1 */
#define P1TPHIF              PSMC1INTbits.P1TPHIF           /* bit 2 */
#define P1TOVIF              PSMC1INTbits.P1TOVIF           /* bit 3 */
#define P1TPRIE              PSMC1INTbits.P1TPRIE           /* bit 4 */
#define P1TDCIE              PSMC1INTbits.P1TDCIE           /* bit 5 */
#define P1TPHIE              PSMC1INTbits.P1TPHIE           /* bit 6 */
#define P1TOVIE              PSMC1INTbits.P1TOVIE           /* bit 7 */

#define P1MSRC0              PSMC1MDLbits.P1MSRC0           /* bit 0 */
#define P1MSRC1              PSMC1MDLbits.P1MSRC1           /* bit 1 */
#define P1MSRC2              PSMC1MDLbits.P1MSRC2           /* bit 2 */
#define P1MSRC3              PSMC1MDLbits.P1MSRC3           /* bit 3 */
#define P1MDLBIT             PSMC1MDLbits.P1MDLBIT          /* bit 5 */
#define P1MDLPOL             PSMC1MDLbits.P1MDLPOL          /* bit 6 */
#define P1MDLEN              PSMC1MDLbits.P1MDLEN           /* bit 7 */

#define P1OEA                PSMC1OENbits.P1OEA             /* bit 0 */
#define P1OEB                PSMC1OENbits.P1OEB             /* bit 1 */
#define P1OEC                PSMC1OENbits.P1OEC             /* bit 2 */
#define P1OED                PSMC1OENbits.P1OED             /* bit 3 */
#define P1OEE                PSMC1OENbits.P1OEE             /* bit 4 */
#define P1OEF                PSMC1OENbits.P1OEF             /* bit 5 */

#define PSMC1PH8             PSMC1PHHbits.PSMC1PH8          /* bit 0 */
#define PSMC1PH9             PSMC1PHHbits.PSMC1PH9          /* bit 1 */
#define PSMC1PH10            PSMC1PHHbits.PSMC1PH10         /* bit 2 */
#define PSMC1PH11            PSMC1PHHbits.PSMC1PH11         /* bit 3 */
#define PSMC1PH12            PSMC1PHHbits.PSMC1PH12         /* bit 4 */
#define PSMC1PH13            PSMC1PHHbits.PSMC1PH13         /* bit 5 */
#define PSMC1PH14            PSMC1PHHbits.PSMC1PH14         /* bit 6 */
#define PSMC1PH15            PSMC1PHHbits.PSMC1PH15         /* bit 7 */

#define PSMC1PH0             PSMC1PHLbits.PSMC1PH0          /* bit 0 */
#define PSMC1PH1             PSMC1PHLbits.PSMC1PH1          /* bit 1 */
#define PSMC1PH2             PSMC1PHLbits.PSMC1PH2          /* bit 2 */
#define PSMC1PH3             PSMC1PHLbits.PSMC1PH3          /* bit 3 */
#define PSMC1PH4             PSMC1PHLbits.PSMC1PH4          /* bit 4 */
#define PSMC1PH5             PSMC1PHLbits.PSMC1PH5          /* bit 5 */
#define PSMC1PH6             PSMC1PHLbits.PSMC1PH6          /* bit 6 */
#define PSMC1PH7             PSMC1PHLbits.PSMC1PH7          /* bit 7 */

#define P1PHST               PSMC1PHSbits.P1PHST            /* bit 0 */
#define P1PHSC1              PSMC1PHSbits.P1PHSC1           /* bit 1 */
#define P1PHSC2              PSMC1PHSbits.P1PHSC2           /* bit 2 */
#define P1PHSC3              PSMC1PHSbits.P1PHSC3           /* bit 3 */
#define P1PHSIN              PSMC1PHSbits.P1PHSIN           /* bit 7 */

#define P1POLA               PSMC1POLbits.P1POLA            /* bit 0 */
#define P1POLB               PSMC1POLbits.P1POLB            /* bit 1 */
#define P1POLC               PSMC1POLbits.P1POLC            /* bit 2 */
#define P1POLD               PSMC1POLbits.P1POLD            /* bit 3 */
#define P1POLE               PSMC1POLbits.P1POLE            /* bit 4 */
#define P1POLF               PSMC1POLbits.P1POLF            /* bit 5 */
#define P1INPOL              PSMC1POLbits.P1INPOL           /* bit 6 */

#define PSMC1PR8             PSMC1PRHbits.PSMC1PR8          /* bit 0 */
#define PSMC1PR9             PSMC1PRHbits.PSMC1PR9          /* bit 1 */
#define PSMC1PR10            PSMC1PRHbits.PSMC1PR10         /* bit 2 */
#define PSMC1PR11            PSMC1PRHbits.PSMC1PR11         /* bit 3 */
#define PSMC1PR12            PSMC1PRHbits.PSMC1PR12         /* bit 4 */
#define PSMC1PR13            PSMC1PRHbits.PSMC1PR13         /* bit 5 */
#define PSMC1PR14            PSMC1PRHbits.PSMC1PR14         /* bit 6 */
#define PSMC1PR15            PSMC1PRHbits.PSMC1PR15         /* bit 7 */

#define PSMC1PR0             PSMC1PRLbits.PSMC1PR0          /* bit 0 */
#define PSMC1PR1             PSMC1PRLbits.PSMC1PR1          /* bit 1 */
#define PSMC1PR2             PSMC1PRLbits.PSMC1PR2          /* bit 2 */
#define PSMC1PR3             PSMC1PRLbits.PSMC1PR3          /* bit 3 */
#define PSMC1PR4             PSMC1PRLbits.PSMC1PR4          /* bit 4 */
#define PSMC1PR5             PSMC1PRLbits.PSMC1PR5          /* bit 5 */
#define PSMC1PR6             PSMC1PRLbits.PSMC1PR6          /* bit 6 */
#define PSMC1PR7             PSMC1PRLbits.PSMC1PR7          /* bit 7 */

#define P1PRST               PSMC1PRSbits.P1PRST            /* bit 0 */
#define P1PRSC1              PSMC1PRSbits.P1PRSC1           /* bit 1 */
#define P1PRSC2              PSMC1PRSbits.P1PRSC2           /* bit 2 */
#define P1PRSC3              PSMC1PRSbits.P1PRSC3           /* bit 3 */
#define P1PRSIN              PSMC1PRSbits.P1PRSIN           /* bit 7 */

#define P1REBSC1             PSMC1REBSbits.P1REBSC1         /* bit 1 */
#define P1REBSC2             PSMC1REBSbits.P1REBSC2         /* bit 2 */
#define P1REBSC3             PSMC1REBSbits.P1REBSC3         /* bit 3 */
#define P1REBSIN             PSMC1REBSbits.P1REBSIN         /* bit 7 */

#define P1STRA               PSMC1STR0bits.P1STRA           /* bit 0 */
#define P1STRB               PSMC1STR0bits.P1STRB           /* bit 1 */
#define P1STRC               PSMC1STR0bits.P1STRC           /* bit 2 */
#define P1STRD               PSMC1STR0bits.P1STRD           /* bit 3 */
#define P1STRE               PSMC1STR0bits.P1STRE           /* bit 4 */
#define P1STRF               PSMC1STR0bits.P1STRF           /* bit 5 */

#define P1HSMEN              PSMC1STR1bits.P1HSMEN          /* bit 0 */
#define P1LSMEN              PSMC1STR1bits.P1LSMEN          /* bit 1 */
#define P1SSYNC              PSMC1STR1bits.P1SSYNC          /* bit 7 */

#define P1SYNC0              PSMC1SYNCbits.P1SYNC0          /* bit 0 */
#define P1SYNC1              PSMC1SYNCbits.P1SYNC1          /* bit 1 */

#define PSMC1TMR8            PSMC1TMRHbits.PSMC1TMR8        /* bit 0 */
#define PSMC1TMR9            PSMC1TMRHbits.PSMC1TMR9        /* bit 1 */
#define PSMC1TMR10           PSMC1TMRHbits.PSMC1TMR10       /* bit 2 */
#define PSMC1TMR11           PSMC1TMRHbits.PSMC1TMR11       /* bit 3 */
#define PSMC1TMR12           PSMC1TMRHbits.PSMC1TMR12       /* bit 4 */
#define PSMC1TMR13           PSMC1TMRHbits.PSMC1TMR13       /* bit 5 */
#define PSMC1TMR14           PSMC1TMRHbits.PSMC1TMR14       /* bit 6 */
#define PSMC1TMR15           PSMC1TMRHbits.PSMC1TMR15       /* bit 7 */

#define PSMC1TMR0            PSMC1TMRLbits.PSMC1TMR0        /* bit 0 */
#define PSMC1TMR1            PSMC1TMRLbits.PSMC1TMR1        /* bit 1 */
#define PSMC1TMR2            PSMC1TMRLbits.PSMC1TMR2        /* bit 2 */
#define PSMC1TMR3            PSMC1TMRLbits.PSMC1TMR3        /* bit 3 */
#define PSMC1TMR4            PSMC1TMRLbits.PSMC1TMR4        /* bit 4 */
#define PSMC1TMR5            PSMC1TMRLbits.PSMC1TMR5        /* bit 5 */
#define PSMC1TMR6            PSMC1TMRLbits.PSMC1TMR6        /* bit 6 */
#define PSMC1TMR7            PSMC1TMRLbits.PSMC1TMR7        /* bit 7 */

#define P2ASDOV              PSMC2ASDCbits.P2ASDOV          /* bit 0 */
#define P2ARSEN              PSMC2ASDCbits.P2ARSEN          /* bit 5 */
#define P2ASDEN              PSMC2ASDCbits.P2ASDEN          /* bit 6 */
#define P2ASE                PSMC2ASDCbits.P2ASE            /* bit 7 */

#define P2ASDLA              PSMC2ASDLbits.P2ASDLA          /* bit 0 */
#define P2ASDLB              PSMC2ASDLbits.P2ASDLB          /* bit 1 */

#define P2ASDSC1             PSMC2ASDSbits.P2ASDSC1         /* bit 1 */
#define P2ASDSC2             PSMC2ASDSbits.P2ASDSC2         /* bit 2 */
#define P2ASDSC3             PSMC2ASDSbits.P2ASDSC3         /* bit 3 */
#define P2ASDSIN             PSMC2ASDSbits.P2ASDSIN         /* bit 7 */

#define PSMC2BLKF0           PSMC2BLKFbits.PSMC2BLKF0       /* bit 0 */
#define PSMC2BLKF1           PSMC2BLKFbits.PSMC2BLKF1       /* bit 1 */
#define PSMC2BLKF2           PSMC2BLKFbits.PSMC2BLKF2       /* bit 2 */
#define PSMC2BLKF3           PSMC2BLKFbits.PSMC2BLKF3       /* bit 3 */
#define PSMC2BLKF4           PSMC2BLKFbits.PSMC2BLKF4       /* bit 4 */
#define PSMC2BLKF5           PSMC2BLKFbits.PSMC2BLKF5       /* bit 5 */
#define PSMC2BLKF6           PSMC2BLKFbits.PSMC2BLKF6       /* bit 6 */
#define PSMC2BLKF7           PSMC2BLKFbits.PSMC2BLKF7       /* bit 7 */

#define PSMC2BLKR0           PSMC2BLKRbits.PSMC2BLKR0       /* bit 0 */
#define PSMC2BLKR1           PSMC2BLKRbits.PSMC2BLKR1       /* bit 1 */
#define PSMC2BLKR2           PSMC2BLKRbits.PSMC2BLKR2       /* bit 2 */
#define PSMC2BLKR3           PSMC2BLKRbits.PSMC2BLKR3       /* bit 3 */
#define PSMC2BLKR4           PSMC2BLKRbits.PSMC2BLKR4       /* bit 4 */
#define PSMC2BLKR5           PSMC2BLKRbits.PSMC2BLKR5       /* bit 5 */
#define PSMC2BLKR6           PSMC2BLKRbits.PSMC2BLKR6       /* bit 6 */
#define PSMC2BLKR7           PSMC2BLKRbits.PSMC2BLKR7       /* bit 7 */

#define P2REBM0              PSMC2BLNKbits.P2REBM0          /* bit 0 */
#define P2REBM1              PSMC2BLNKbits.P2REBM1          /* bit 1 */
#define P2FEBM0              PSMC2BLNKbits.P2FEBM0          /* bit 4 */
#define P2FEBM1              PSMC2BLNKbits.P2FEBM1          /* bit 5 */

#define P2CSRC0              PSMC2CLKbits.P2CSRC0           /* bit 0 */
#define P2CSRC1              PSMC2CLKbits.P2CSRC1           /* bit 1 */
#define P2CPRE0              PSMC2CLKbits.P2CPRE0           /* bit 4 */
#define P2CPRE1              PSMC2CLKbits.P2CPRE1           /* bit 5 */

#define P2MODE0              PSMC2CONbits.P2MODE0           /* bit 0 */
#define P2MODE1              PSMC2CONbits.P2MODE1           /* bit 1 */
#define P2MODE2              PSMC2CONbits.P2MODE2           /* bit 2 */
#define P2MODE3              PSMC2CONbits.P2MODE3           /* bit 3 */
#define P2DBRE               PSMC2CONbits.P2DBRE            /* bit 4 */
#define P2DBFE               PSMC2CONbits.P2DBFE            /* bit 5 */
#define PSMC2LD              PSMC2CONbits.PSMC2LD           /* bit 6 */
#define PSMC2EN              PSMC2CONbits.PSMC2EN           /* bit 7 */

#define PSMC2DBF0            PSMC2DBFbits.PSMC2DBF0         /* bit 0 */
#define PSMC2DBF1            PSMC2DBFbits.PSMC2DBF1         /* bit 1 */
#define PSMC2DBF2            PSMC2DBFbits.PSMC2DBF2         /* bit 2 */
#define PSMC2DBF3            PSMC2DBFbits.PSMC2DBF3         /* bit 3 */
#define PSMC2DBF4            PSMC2DBFbits.PSMC2DBF4         /* bit 4 */
#define PSMC2DBF5            PSMC2DBFbits.PSMC2DBF5         /* bit 5 */
#define PSMC2DBF6            PSMC2DBFbits.PSMC2DBF6         /* bit 6 */
#define PSMC2DBF7            PSMC2DBFbits.PSMC2DBF7         /* bit 7 */

#define PSMC2DBR0            PSMC2DBRbits.PSMC2DBR0         /* bit 0 */
#define PSMC2DBR1            PSMC2DBRbits.PSMC2DBR1         /* bit 1 */
#define PSMC2DBR2            PSMC2DBRbits.PSMC2DBR2         /* bit 2 */
#define PSMC2DBR3            PSMC2DBRbits.PSMC2DBR3         /* bit 3 */
#define PSMC2DBR4            PSMC2DBRbits.PSMC2DBR4         /* bit 4 */
#define PSMC2DBR5            PSMC2DBRbits.PSMC2DBR5         /* bit 5 */
#define PSMC2DBR6            PSMC2DBRbits.PSMC2DBR6         /* bit 6 */
#define PSMC2DBR7            PSMC2DBRbits.PSMC2DBR7         /* bit 7 */

#define PSMC2DC8             PSMC2DCHbits.PSMC2DC8          /* bit 0 */
#define PSMC2DC9             PSMC2DCHbits.PSMC2DC9          /* bit 1 */
#define PSMC2DC10            PSMC2DCHbits.PSMC2DC10         /* bit 2 */
#define PSMC2DC11            PSMC2DCHbits.PSMC2DC11         /* bit 3 */
#define PSMC2DC12            PSMC2DCHbits.PSMC2DC12         /* bit 4 */
#define PSMC2DC13            PSMC2DCHbits.PSMC2DC13         /* bit 5 */
#define PSMC2DC14            PSMC2DCHbits.PSMC2DC14         /* bit 6 */
#define PSMC2DC15            PSMC2DCHbits.PSMC2DC15         /* bit 7 */

#define PSMC2DC0             PSMC2DCLbits.PSMC2DC0          /* bit 0 */
#define PSMC2DC1             PSMC2DCLbits.PSMC2DC1          /* bit 1 */
#define PSMC2DC2             PSMC2DCLbits.PSMC2DC2          /* bit 2 */
#define PSMC2DC3             PSMC2DCLbits.PSMC2DC3          /* bit 3 */
#define PSMC2DC4             PSMC2DCLbits.PSMC2DC4          /* bit 4 */
#define PSMC2DC5             PSMC2DCLbits.PSMC2DC5          /* bit 5 */
#define PSMC2DC6             PSMC2DCLbits.PSMC2DC6          /* bit 6 */
#define PSMC2DC7             PSMC2DCLbits.PSMC2DC7          /* bit 7 */

#define P2DCST               PSMC2DCSbits.P2DCST            /* bit 0 */
#define P2DCSC1              PSMC2DCSbits.P2DCSC1           /* bit 1 */
#define P2DCSC2              PSMC2DCSbits.P2DCSC2           /* bit 2 */
#define P2DCSC3              PSMC2DCSbits.P2DCSC3           /* bit 3 */
#define P2DCSIN              PSMC2DCSbits.P2DCSIN           /* bit 7 */

#define P2FEBSC1             PSMC2FEBSbits.P2FEBSC1         /* bit 1 */
#define P2FEBSC2             PSMC2FEBSbits.P2FEBSC2         /* bit 2 */
#define P2FEBSC3             PSMC2FEBSbits.P2FEBSC3         /* bit 3 */
#define P2FEBSIN             PSMC2FEBSbits.P2FEBSIN         /* bit 7 */

#define PSMC2FFA0            PSMC2FFAbits.PSMC2FFA0         /* bit 0 */
#define PSMC2FFA1            PSMC2FFAbits.PSMC2FFA1         /* bit 1 */
#define PSMC2FFA2            PSMC2FFAbits.PSMC2FFA2         /* bit 2 */
#define PSMC2FFA3            PSMC2FFAbits.PSMC2FFA3         /* bit 3 */

#define P2TPRIF              PSMC2INTbits.P2TPRIF           /* bit 0 */
#define P2TDCIF              PSMC2INTbits.P2TDCIF           /* bit 1 */
#define P2TPHIF              PSMC2INTbits.P2TPHIF           /* bit 2 */
#define P2TOVIF              PSMC2INTbits.P2TOVIF           /* bit 3 */
#define P2TPRIE              PSMC2INTbits.P2TPRIE           /* bit 4 */
#define P2TDCIE              PSMC2INTbits.P2TDCIE           /* bit 5 */
#define P2TPHIE              PSMC2INTbits.P2TPHIE           /* bit 6 */
#define P2TOVIE              PSMC2INTbits.P2TOVIE           /* bit 7 */

#define P2MSRC0              PSMC2MDLbits.P2MSRC0           /* bit 0 */
#define P2MSRC1              PSMC2MDLbits.P2MSRC1           /* bit 1 */
#define P2MSRC2              PSMC2MDLbits.P2MSRC2           /* bit 2 */
#define P2MSRC3              PSMC2MDLbits.P2MSRC3           /* bit 3 */
#define P2MDLBIT             PSMC2MDLbits.P2MDLBIT          /* bit 5 */
#define P2MDLPOL             PSMC2MDLbits.P2MDLPOL          /* bit 6 */
#define P2MDLEN              PSMC2MDLbits.P2MDLEN           /* bit 7 */

#define P2OEA                PSMC2OENbits.P2OEA             /* bit 0 */
#define P2OEB                PSMC2OENbits.P2OEB             /* bit 1 */

#define PSMC2PH8             PSMC2PHHbits.PSMC2PH8          /* bit 0 */
#define PSMC2PH9             PSMC2PHHbits.PSMC2PH9          /* bit 1 */
#define PSMC2PH10            PSMC2PHHbits.PSMC2PH10         /* bit 2 */
#define PSMC2PH11            PSMC2PHHbits.PSMC2PH11         /* bit 3 */
#define PSMC2PH12            PSMC2PHHbits.PSMC2PH12         /* bit 4 */
#define PSMC2PH13            PSMC2PHHbits.PSMC2PH13         /* bit 5 */
#define PSMC2PH14            PSMC2PHHbits.PSMC2PH14         /* bit 6 */
#define PSMC2PH15            PSMC2PHHbits.PSMC2PH15         /* bit 7 */

#define PSMC2PH0             PSMC2PHLbits.PSMC2PH0          /* bit 0 */
#define PSMC2PH1             PSMC2PHLbits.PSMC2PH1          /* bit 1 */
#define PSMC2PH2             PSMC2PHLbits.PSMC2PH2          /* bit 2 */
#define PSMC2PH3             PSMC2PHLbits.PSMC2PH3          /* bit 3 */
#define PSMC2PH4             PSMC2PHLbits.PSMC2PH4          /* bit 4 */
#define PSMC2PH5             PSMC2PHLbits.PSMC2PH5          /* bit 5 */
#define PSMC2PH6             PSMC2PHLbits.PSMC2PH6          /* bit 6 */
#define PSMC2PH7             PSMC2PHLbits.PSMC2PH7          /* bit 7 */

#define P2PHST               PSMC2PHSbits.P2PHST            /* bit 0 */
#define P2PHSC1              PSMC2PHSbits.P2PHSC1           /* bit 1 */
#define P2PHSC2              PSMC2PHSbits.P2PHSC2           /* bit 2 */
#define P2PHSC3              PSMC2PHSbits.P2PHSC3           /* bit 3 */
#define P2PHSIN              PSMC2PHSbits.P2PHSIN           /* bit 7 */

#define P2POLA               PSMC2POLbits.P2POLA            /* bit 0 */
#define P2POLB               PSMC2POLbits.P2POLB            /* bit 1 */
#define P2INPOL              PSMC2POLbits.P2INPOL           /* bit 6 */

#define PSMC2PR8             PSMC2PRHbits.PSMC2PR8          /* bit 0 */
#define PSMC2PR9             PSMC2PRHbits.PSMC2PR9          /* bit 1 */
#define PSMC2PR10            PSMC2PRHbits.PSMC2PR10         /* bit 2 */
#define PSMC2PR11            PSMC2PRHbits.PSMC2PR11         /* bit 3 */
#define PSMC2PR12            PSMC2PRHbits.PSMC2PR12         /* bit 4 */
#define PSMC2PR13            PSMC2PRHbits.PSMC2PR13         /* bit 5 */
#define PSMC2PR14            PSMC2PRHbits.PSMC2PR14         /* bit 6 */
#define PSMC2PR15            PSMC2PRHbits.PSMC2PR15         /* bit 7 */

#define PSMC2PR0             PSMC2PRLbits.PSMC2PR0          /* bit 0 */
#define PSMC2PR1             PSMC2PRLbits.PSMC2PR1          /* bit 1 */
#define PSMC2PR2             PSMC2PRLbits.PSMC2PR2          /* bit 2 */
#define PSMC2PR3             PSMC2PRLbits.PSMC2PR3          /* bit 3 */
#define PSMC2PR4             PSMC2PRLbits.PSMC2PR4          /* bit 4 */
#define PSMC2PR5             PSMC2PRLbits.PSMC2PR5          /* bit 5 */
#define PSMC2PR6             PSMC2PRLbits.PSMC2PR6          /* bit 6 */
#define PSMC2PR7             PSMC2PRLbits.PSMC2PR7          /* bit 7 */

#define P2PRST               PSMC2PRSbits.P2PRST            /* bit 0 */
#define P2PRSC1              PSMC2PRSbits.P2PRSC1           /* bit 1 */
#define P2PRSC2              PSMC2PRSbits.P2PRSC2           /* bit 2 */
#define P2PRSC3              PSMC2PRSbits.P2PRSC3           /* bit 3 */
#define P2PRSIN              PSMC2PRSbits.P2PRSIN           /* bit 7 */

#define P2REBSC1             PSMC2REBSbits.P2REBSC1         /* bit 1 */
#define P2REBSC2             PSMC2REBSbits.P2REBSC2         /* bit 2 */
#define P2REBSC3             PSMC2REBSbits.P2REBSC3         /* bit 3 */
#define P2REBSIN             PSMC2REBSbits.P2REBSIN         /* bit 7 */

#define P2STRA               PSMC2STR0bits.P2STRA           /* bit 0 */
#define P2STRB               PSMC2STR0bits.P2STRB           /* bit 1 */

#define P2HSMEN              PSMC2STR1bits.P2HSMEN          /* bit 0 */
#define P2LSMEN              PSMC2STR1bits.P2LSMEN          /* bit 1 */
#define P2SSYNC              PSMC2STR1bits.P2SSYNC          /* bit 7 */

#define P2SYNC0              PSMC2SYNCbits.P2SYNC0          /* bit 0 */
#define P2SYNC1              PSMC2SYNCbits.P2SYNC1          /* bit 1 */

#define PSMC2TMR8            PSMC2TMRHbits.PSMC2TMR8        /* bit 0 */
#define PSMC2TMR9            PSMC2TMRHbits.PSMC2TMR9        /* bit 1 */
#define PSMC2TMR10           PSMC2TMRHbits.PSMC2TMR10       /* bit 2 */
#define PSMC2TMR11           PSMC2TMRHbits.PSMC2TMR11       /* bit 3 */
#define PSMC2TMR12           PSMC2TMRHbits.PSMC2TMR12       /* bit 4 */
#define PSMC2TMR13           PSMC2TMRHbits.PSMC2TMR13       /* bit 5 */
#define PSMC2TMR14           PSMC2TMRHbits.PSMC2TMR14       /* bit 6 */
#define PSMC2TMR15           PSMC2TMRHbits.PSMC2TMR15       /* bit 7 */

#define PSMC2TMR0            PSMC2TMRLbits.PSMC2TMR0        /* bit 0 */
#define PSMC2TMR1            PSMC2TMRLbits.PSMC2TMR1        /* bit 1 */
#define PSMC2TMR2            PSMC2TMRLbits.PSMC2TMR2        /* bit 2 */
#define PSMC2TMR3            PSMC2TMRLbits.PSMC2TMR3        /* bit 3 */
#define PSMC2TMR4            PSMC2TMRLbits.PSMC2TMR4        /* bit 4 */
#define PSMC2TMR5            PSMC2TMRLbits.PSMC2TMR5        /* bit 5 */
#define PSMC2TMR6            PSMC2TMRLbits.PSMC2TMR6        /* bit 6 */
#define PSMC2TMR7            PSMC2TMRLbits.PSMC2TMR7        /* bit 7 */

#define RX9D                 RC1STAbits.RX9D                /* bit 0, shadows bit in RCSTAbits, RCSTA1bits */
#define OERR                 RC1STAbits.OERR                /* bit 1, shadows bit in RCSTAbits, RCSTA1bits */
#define FERR                 RC1STAbits.FERR                /* bit 2, shadows bit in RCSTAbits, RCSTA1bits */
#define ADDEN                RC1STAbits.ADDEN               /* bit 3, shadows bit in RCSTAbits, RCSTA1bits */
#define CREN                 RC1STAbits.CREN                /* bit 4, shadows bit in RCSTAbits, RCSTA1bits */
#define SREN                 RC1STAbits.SREN                /* bit 5, shadows bit in RCSTAbits, RCSTA1bits */
#define RX9                  RC1STAbits.RX9                 /* bit 6, shadows bit in RCSTAbits, RCSTA1bits */
#define SPEN                 RC1STAbits.SPEN                /* bit 7, shadows bit in RCSTAbits, RCSTA1bits */

#define SLRCONA0             SLRCONAbits.SLRCONA0           /* bit 0 */
#define SLRCONA1             SLRCONAbits.SLRCONA1           /* bit 1 */
#define SLRCONA2             SLRCONAbits.SLRCONA2           /* bit 2 */
#define SLRCONA3             SLRCONAbits.SLRCONA3           /* bit 3 */
#define SLRCONA4             SLRCONAbits.SLRCONA4           /* bit 4 */
#define SLRCONA5             SLRCONAbits.SLRCONA5           /* bit 5 */
#define SLRCONA6             SLRCONAbits.SLRCONA6           /* bit 6 */
#define SLRCONA7             SLRCONAbits.SLRCONA7           /* bit 7 */

#define SLRCONB0             SLRCONBbits.SLRCONB0           /* bit 0 */
#define SLRCONB1             SLRCONBbits.SLRCONB1           /* bit 1 */
#define SLRCONB2             SLRCONBbits.SLRCONB2           /* bit 2 */
#define SLRCONB3             SLRCONBbits.SLRCONB3           /* bit 3 */
#define SLRCONB4             SLRCONBbits.SLRCONB4           /* bit 4 */
#define SLRCONB5             SLRCONBbits.SLRCONB5           /* bit 5 */
#define SLRCONB6             SLRCONBbits.SLRCONB6           /* bit 6 */
#define SLRCONB7             SLRCONBbits.SLRCONB7           /* bit 7 */

#define SLRCONC0             SLRCONCbits.SLRCONC0           /* bit 0 */
#define SLRCONC1             SLRCONCbits.SLRCONC1           /* bit 1 */
#define SLRCONC2             SLRCONCbits.SLRCONC2           /* bit 2 */
#define SLRCONC3             SLRCONCbits.SLRCONC3           /* bit 3 */
#define SLRCONC4             SLRCONCbits.SLRCONC4           /* bit 4 */
#define SLRCONC5             SLRCONCbits.SLRCONC5           /* bit 5 */
#define SLRCONC6             SLRCONCbits.SLRCONC6           /* bit 6 */
#define SLRCONC7             SLRCONCbits.SLRCONC7           /* bit 7 */

#define SEN                  SSP1CON2bits.SEN               /* bit 0, shadows bit in SSPCON2bits */
#define RSEN                 SSP1CON2bits.RSEN              /* bit 1, shadows bit in SSPCON2bits */
#define PEN                  SSP1CON2bits.PEN               /* bit 2, shadows bit in SSPCON2bits */
#define RCEN                 SSP1CON2bits.RCEN              /* bit 3, shadows bit in SSPCON2bits */
#define ACKEN                SSP1CON2bits.ACKEN             /* bit 4, shadows bit in SSPCON2bits */
#define ACKDT                SSP1CON2bits.ACKDT             /* bit 5, shadows bit in SSPCON2bits */
#define ACKSTAT              SSP1CON2bits.ACKSTAT           /* bit 6, shadows bit in SSPCON2bits */
#define GCEN                 SSP1CON2bits.GCEN              /* bit 7, shadows bit in SSPCON2bits */

#define DHEN                 SSP1CON3bits.DHEN              /* bit 0, shadows bit in SSPCON3bits */
#define AHEN                 SSP1CON3bits.AHEN              /* bit 1, shadows bit in SSPCON3bits */
#define SBCDE                SSP1CON3bits.SBCDE             /* bit 2, shadows bit in SSPCON3bits */
#define SDAHT                SSP1CON3bits.SDAHT             /* bit 3, shadows bit in SSPCON3bits */
#define BOEN                 SSP1CON3bits.BOEN              /* bit 4, shadows bit in SSPCON3bits */
#define SCIE                 SSP1CON3bits.SCIE              /* bit 5, shadows bit in SSPCON3bits */
#define PCIE                 SSP1CON3bits.PCIE              /* bit 6, shadows bit in SSPCON3bits */
#define ACKTIM               SSP1CON3bits.ACKTIM            /* bit 7, shadows bit in SSPCON3bits */

#define SSPM0                SSP1CONbits.SSPM0              /* bit 0, shadows bit in SSPCONbits, SSPCON1bits */
#define SSPM1                SSP1CONbits.SSPM1              /* bit 1, shadows bit in SSPCONbits, SSPCON1bits */
#define SSPM2                SSP1CONbits.SSPM2              /* bit 2, shadows bit in SSPCONbits, SSPCON1bits */
#define SSPM3                SSP1CONbits.SSPM3              /* bit 3, shadows bit in SSPCONbits, SSPCON1bits */
#define CKP                  SSP1CONbits.CKP                /* bit 4, shadows bit in SSPCONbits, SSPCON1bits */
#define SSPEN                SSP1CONbits.SSPEN              /* bit 5, shadows bit in SSPCONbits, SSPCON1bits */
#define SSPOV                SSP1CONbits.SSPOV              /* bit 6, shadows bit in SSPCONbits, SSPCON1bits */
#define WCOL                 SSP1CONbits.WCOL               /* bit 7, shadows bit in SSPCONbits, SSPCON1bits */

#define BF                   SSP1STATbits.BF                /* bit 0, shadows bit in SSPSTATbits */
#define UA                   SSP1STATbits.UA                /* bit 1, shadows bit in SSPSTATbits */
#define R_NOT_W              SSP1STATbits.R_NOT_W           /* bit 2, shadows bit in SSPSTATbits */
#define S                    SSP1STATbits.S                 /* bit 3, shadows bit in SSPSTATbits */
#define P                    SSP1STATbits.P                 /* bit 4, shadows bit in SSPSTATbits */
#define D_NOT_A              SSP1STATbits.D_NOT_A           /* bit 5, shadows bit in SSPSTATbits */
#define CKE                  SSP1STATbits.CKE               /* bit 6, shadows bit in SSPSTATbits */
#define SMP                  SSP1STATbits.SMP               /* bit 7, shadows bit in SSPSTATbits */

#define C_SHAD               STATUS_SHADbits.C_SHAD         /* bit 0 */
#define DC_SHAD              STATUS_SHADbits.DC_SHAD        /* bit 1 */
#define Z_SHAD               STATUS_SHADbits.Z_SHAD         /* bit 2 */

#define C                    STATUSbits.C                   /* bit 0 */
#define DC                   STATUSbits.DC                  /* bit 1 */
#define Z                    STATUSbits.Z                   /* bit 2 */
#define NOT_PD               STATUSbits.NOT_PD              /* bit 3 */
#define NOT_TO               STATUSbits.NOT_TO              /* bit 4 */

#define TMR1ON               T1CONbits.TMR1ON               /* bit 0 */
#define NOT_T1SYNC           T1CONbits.NOT_T1SYNC           /* bit 2 */
#define T1OSCEN              T1CONbits.T1OSCEN              /* bit 3 */
#define T1CKPS0              T1CONbits.T1CKPS0              /* bit 4 */
#define T1CKPS1              T1CONbits.T1CKPS1              /* bit 5 */
#define TMR1CS0              T1CONbits.TMR1CS0              /* bit 6 */
#define TMR1CS1              T1CONbits.TMR1CS1              /* bit 7 */

#define T1GSS0               T1GCONbits.T1GSS0              /* bit 0 */
#define T1GSS1               T1GCONbits.T1GSS1              /* bit 1 */
#define T1GVAL               T1GCONbits.T1GVAL              /* bit 2 */
#define T1GGO                T1GCONbits.T1GGO               /* bit 3 */
#define T1GSPM               T1GCONbits.T1GSPM              /* bit 4 */
#define T1GTM                T1GCONbits.T1GTM               /* bit 5 */
#define T1GPOL               T1GCONbits.T1GPOL              /* bit 6 */
#define TMR1GE               T1GCONbits.TMR1GE              /* bit 7 */

#define T2CKPS0              T2CONbits.T2CKPS0              /* bit 0 */
#define T2CKPS1              T2CONbits.T2CKPS1              /* bit 1 */
#define TMR2ON               T2CONbits.TMR2ON               /* bit 2 */
#define T2OUTPS0             T2CONbits.T2OUTPS0             /* bit 3 */
#define T2OUTPS1             T2CONbits.T2OUTPS1             /* bit 4 */
#define T2OUTPS2             T2CONbits.T2OUTPS2             /* bit 5 */
#define T2OUTPS3             T2CONbits.T2OUTPS3             /* bit 6 */

#define TRISA0               TRISAbits.TRISA0               /* bit 0 */
#define TRISA1               TRISAbits.TRISA1               /* bit 1 */
#define TRISA2               TRISAbits.TRISA2               /* bit 2 */
#define TRISA3               TRISAbits.TRISA3               /* bit 3 */
#define TRISA4               TRISAbits.TRISA4               /* bit 4 */
#define TRISA5               TRISAbits.TRISA5               /* bit 5 */
#define TRISA6               TRISAbits.TRISA6               /* bit 6 */
#define TRISA7               TRISAbits.TRISA7               /* bit 7 */

#define TRISB0               TRISBbits.TRISB0               /* bit 0 */
#define TRISB1               TRISBbits.TRISB1               /* bit 1 */
#define TRISB2               TRISBbits.TRISB2               /* bit 2 */
#define TRISB3               TRISBbits.TRISB3               /* bit 3 */
#define TRISB4               TRISBbits.TRISB4               /* bit 4 */
#define TRISB5               TRISBbits.TRISB5               /* bit 5 */
#define TRISB6               TRISBbits.TRISB6               /* bit 6 */
#define TRISB7               TRISBbits.TRISB7               /* bit 7 */

#define TRISC0               TRISCbits.TRISC0               /* bit 0 */
#define TRISC1               TRISCbits.TRISC1               /* bit 1 */
#define TRISC2               TRISCbits.TRISC2               /* bit 2 */
#define TRISC3               TRISCbits.TRISC3               /* bit 3 */
#define TRISC4               TRISCbits.TRISC4               /* bit 4 */
#define TRISC5               TRISCbits.TRISC5               /* bit 5 */
#define TRISC6               TRISCbits.TRISC6               /* bit 6 */
#define TRISC7               TRISCbits.TRISC7               /* bit 7 */

#define TRISE3               TRISEbits.TRISE3               /* bit 3 */

#define TX9D                 TX1STAbits.TX9D                /* bit 0, shadows bit in TXSTAbits, TXSTA1bits */
#define TRMT                 TX1STAbits.TRMT                /* bit 1, shadows bit in TXSTAbits, TXSTA1bits */
#define BRGH                 TX1STAbits.BRGH                /* bit 2, shadows bit in TXSTAbits, TXSTA1bits */
#define SENDB                TX1STAbits.SENDB               /* bit 3, shadows bit in TXSTAbits, TXSTA1bits */
#define SYNC                 TX1STAbits.SYNC                /* bit 4, shadows bit in TXSTAbits, TXSTA1bits */
#define TXEN                 TX1STAbits.TXEN                /* bit 5, shadows bit in TXSTAbits, TXSTA1bits */
#define TX9                  TX1STAbits.TX9                 /* bit 6, shadows bit in TXSTAbits, TXSTA1bits */
#define CSRC                 TX1STAbits.CSRC                /* bit 7, shadows bit in TXSTAbits, TXSTA1bits */

#define VREGPM0              VREGCONbits.VREGPM0            /* bit 0 */
#define VREGPM1              VREGCONbits.VREGPM1            /* bit 1 */

#define SWDTEN               WDTCONbits.SWDTEN              /* bit 0 */
#define WDTPS0               WDTCONbits.WDTPS0              /* bit 1 */
#define WDTPS1               WDTCONbits.WDTPS1              /* bit 2 */
#define WDTPS2               WDTCONbits.WDTPS2              /* bit 3 */
#define WDTPS3               WDTCONbits.WDTPS3              /* bit 4 */
#define WDTPS4               WDTCONbits.WDTPS4              /* bit 5 */

#define WPUA0                WPUAbits.WPUA0                 /* bit 0 */
#define WPUA1                WPUAbits.WPUA1                 /* bit 1 */
#define WPUA2                WPUAbits.WPUA2                 /* bit 2 */
#define WPUA3                WPUAbits.WPUA3                 /* bit 3 */
#define WPUA4                WPUAbits.WPUA4                 /* bit 4 */
#define WPUA5                WPUAbits.WPUA5                 /* bit 5 */
#define WPUA6                WPUAbits.WPUA6                 /* bit 6 */
#define WPUA7                WPUAbits.WPUA7                 /* bit 7 */

#define WPUB0                WPUBbits.WPUB0                 /* bit 0 */
#define WPUB1                WPUBbits.WPUB1                 /* bit 1 */
#define WPUB2                WPUBbits.WPUB2                 /* bit 2 */
#define WPUB3                WPUBbits.WPUB3                 /* bit 3 */
#define WPUB4                WPUBbits.WPUB4                 /* bit 4 */
#define WPUB5                WPUBbits.WPUB5                 /* bit 5 */
#define WPUB6                WPUBbits.WPUB6                 /* bit 6 */
#define WPUB7                WPUBbits.WPUB7                 /* bit 7 */

#define WPUC0                WPUCbits.WPUC0                 /* bit 0 */
#define WPUC1                WPUCbits.WPUC1                 /* bit 1 */
#define WPUC2                WPUCbits.WPUC2                 /* bit 2 */
#define WPUC3                WPUCbits.WPUC3                 /* bit 3 */
#define WPUC4                WPUCbits.WPUC4                 /* bit 4 */
#define WPUC5                WPUCbits.WPUC5                 /* bit 5 */
#define WPUC6                WPUCbits.WPUC6                 /* bit 6 */
#define WPUC7                WPUCbits.WPUC7                 /* bit 7 */

#define WPUE3                WPUEbits.WPUE3                 /* bit 3 */
#endif /* NO_BIT_DEFINES */

#endif
