text: /* Generated on 2016-07-26
  ===============================================================================
        P I C   T D D   R E A D Y   R E G I S T E R   D E F I N I T I O N
  ===============================================================================
  
  Created by Tibor Simon - tiborsimon.io
  Generator script:  https://github.com/tiborsimon/pic-definition-converter
  
  Based on the register definition header file v1.37 provided by Microchip.
  Original definition date and license: */
  
  // Generated 11/03/2016 GMT
  
  /*
  * Copyright © 2016, Microchip Technology Inc. and its subsidiaries ("Microchip")
  * All rights reserved.
  *
  * This software is developed by Microchip Technology Inc. and its subsidiaries ("Microchip").
  *
  * Redistribution and use in source and binary forms, with or without modification, are
  * permitted provided that the following conditions are met:
  *
  *     1. Redistributions of source code must retain the above copyright notice, this list of
  *        conditions and the following disclaimer.
  *
  *     2. Redistributions in binary form must reproduce the above copyright notice, this list
  *        of conditions and the following disclaimer in the documentation and/or other
  *        materials provided with the distribution.
  *
  *     3. Microchip's name may not be used to endorse or promote products derived from this
  *        software without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY MICROCHIP "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL MICROCHIP BE LIABLE FOR ANY DIRECT, INDIRECT,
  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING BUT NOT LIMITED TO
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWSOEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *  */
  
  #ifndef _PIC16F1933_H_
  #define _PIC16F1933_H_
  
  
  /*------------------------------#
  | INDF0                     0x0 |
  #-------------------------------#
  | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
  #------------------------------*/
  
  #define INDF0                                    0x0
  #define INDF0_address                            0x000
  #define INDF0_position                           0x0
  #define INDF0_size                               0x8
  #define INDF0_value_mask                         0xFF
  #define INDF0_clear_mask                         0x0
  
  
  /*------------------------------#
  | INDF1                     0x1 |
  #-------------------------------#
  | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
  #------------------------------*/
  
  #define INDF1                                    0x0
  #define INDF1_address                            0x001
  #define INDF1_position                           0x0
  #define INDF1_size                               0x8
  #define INDF1_value_mask                         0xFF
  #define INDF1_clear_mask                         0x0
  
  
  /*------------------------------#
  | PCL                       0x2 |
  #-------------------------------#
  | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
  #------------------------------*/
  
  #define PCL                                      0x0
  #define PCL_address                              0x002
  #define PCL_position                             0x0
  #define PCL_size                                 0x8
  #define PCL_value_mask                           0xFF
  #define PCL_clear_mask                           0x0
  
  
  /*--------------------------------------#
  | STATUS                            0x3 |
  #---------------------------------------#
  | - | - | - | nTO | nPD | ZERO | DC | C |
  #---------------------------------------#
  | 7 | 6 | 5 | 4   | 3   | 2    | 1  | 0 |
  #--------------------------------------*/
  
  #define STATUS                                   0x0
  #define STATUS_address                           0x003
  #define STATUS_position                          0x0
  #define STATUS_size                              0x8
  #define STATUS_value_mask                        0xFF
  #define STATUS_clear_mask                        0x0
  
  #define C                                        0x0
  #define C_address                                0x003
  #define C_position                               0x0
  #define C_size                                   0x1
  #define C_value_mask                             0x1
  #define C_clear_mask                             0xFE
  
  #define CARRY                                    0x0
  #define CARRY_address                            0x003
  #define CARRY_position                           0x0
  #define CARRY_size                               0x1
  #define CARRY_value_mask                         0x1
  #define CARRY_clear_mask                         0xFE
  
  #define DC                                       0x1
  #define DC_address                               0x003
  #define DC_position                              0x1
  #define DC_size                                  0x1
  #define DC_value_mask                            0x2
  #define DC_clear_mask                            0xFD
  
  #define ZERO                                     0x2
  #define ZERO_address                             0x003
  #define ZERO_position                            0x2
  #define ZERO_size                                0x1
  #define ZERO_value_mask                          0x4
  #define ZERO_clear_mask                          0xFB
  
  #define Z                                        0x2
  #define Z_address                                0x003
  #define Z_position                               0x2
  #define Z_size                                   0x1
  #define Z_value_mask                             0x4
  #define Z_clear_mask                             0xFB
  
  #define nPD                                      0x3
  #define nPD_address                              0x003
  #define nPD_position                             0x3
  #define nPD_size                                 0x1
  #define nPD_value_mask                           0x8
  #define nPD_clear_mask                           0xF7
  
  #define nTO                                      0x4
  #define nTO_address                              0x003
  #define nTO_position                             0x4
  #define nTO_size                                 0x1
  #define nTO_value_mask                           0x10
  #define nTO_clear_mask                           0xEF
  
  
  /*------------------------------#
  | FSR0L                     0x4 |
  #-------------------------------#
  | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
  #------------------------------*/
  
  #define FSR0L                                    0x0
  #define FSR0L_address                            0x004
  #define FSR0L_position                           0x0
  #define FSR0L_size                               0x8
  #define FSR0L_value_mask                         0xFF
  #define FSR0L_clear_mask                         0x0
  
  
  /*------------------------------#
  | FSR0H                     0x5 |
  #-------------------------------#
  | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
  #------------------------------*/
  
  #define FSR0H                                    0x0
  #define FSR0H_address                            0x005
  #define FSR0H_position                           0x0
  #define FSR0H_size                               0x8
  #define FSR0H_value_mask                         0xFF
  #define FSR0H_clear_mask                         0x0
  
  
  /*------------------------------#
  | FSR1L                     0x6 |
  #-------------------------------#
  | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
  #------------------------------*/
  
  #define FSR1L                                    0x0
  #define FSR1L_address                            0x006
  #define FSR1L_position                           0x0
  #define FSR1L_size                               0x8
  #define FSR1L_value_mask                         0xFF
  #define FSR1L_clear_mask                         0x0
  
  
  /*------------------------------#
  | FSR1H                     0x7 |
  #-------------------------------#
  | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
  #------------------------------*/
  
  #define FSR1H                                    0x0
  #define FSR1H_address                            0x007
  #define FSR1H_position                           0x0
  #define FSR1H_size                               0x8
  #define FSR1H_value_mask                         0xFF
  #define FSR1H_clear_mask                         0x0
  
  
  /*---------------------------------------------#
  | BSR                                      0x8 |
  #----------------------------------------------#
  | - | - | - | BSR4 | BSR3 | BSR2 | BSR1 | BSR0 |
  #----------------------------------------------#
  | 7 | 6 | 5 | 4    | 3    | 2    | 1    | 0    |
  #---------------------------------------------*/
  
  #define BSR                                      0x0
  #define BSR_address                              0x008
  #define BSR_position                             0x0
  #define BSR_size                                 0x5
  #define BSR_value_mask                           0x1F
  #define BSR_clear_mask                           0xE0
  
  #define BSR0                                     0x0
  #define BSR0_address                             0x008
  #define BSR0_position                            0x0
  #define BSR0_size                                0x1
  #define BSR0_value_mask                          0x1
  #define BSR0_clear_mask                          0xFE
  
  #define BSR1                                     0x1
  #define BSR1_address                             0x008
  #define BSR1_position                            0x1
  #define BSR1_size                                0x1
  #define BSR1_value_mask                          0x2
  #define BSR1_clear_mask                          0xFD
  
  #define BSR2                                     0x2
  #define BSR2_address                             0x008
  #define BSR2_position                            0x2
  #define BSR2_size                                0x1
  #define BSR2_value_mask                          0x4
  #define BSR2_clear_mask                          0xFB
  
  #define BSR3                                     0x3
  #define BSR3_address                             0x008
  #define BSR3_position                            0x3
  #define BSR3_size                                0x1
  #define BSR3_value_mask                          0x8
  #define BSR3_clear_mask                          0xF7
  
  #define BSR4                                     0x4
  #define BSR4_address                             0x008
  #define BSR4_position                            0x4
  #define BSR4_size                                0x1
  #define BSR4_value_mask                          0x10
  #define BSR4_clear_mask                          0xEF
  
  
  /*------------------------------#
  | WREG                      0x9 |
  #-------------------------------#
  | WREG0                         |
  #-------------------------------#
  | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
  #------------------------------*/
  
  #define WREG                                     0x0
  #define WREG_address                             0x009
  #define WREG_position                            0x0
  #define WREG_size                                0x8
  #define WREG_value_mask                          0xFF
  #define WREG_clear_mask                          0x0
  
  #define WREG0                                    0x0
  #define WREG0_address                            0x009
  #define WREG0_position                           0x0
  #define WREG0_size                               0x8
  #define WREG0_value_mask                         0xFF
  #define WREG0_clear_mask                         0x0
  
  
  /*------------------------------#
  | PCLATH                    0xA |
  #-------------------------------#
  | - | PCLATH                    |
  #-------------------------------#
  | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
  #------------------------------*/
  
  #define PCLATH                                   0x0
  #define PCLATH_address                           0x00A
  #define PCLATH_position                          0x0
  #define PCLATH_size                              0x7
  #define PCLATH_value_mask                        0x7F
  #define PCLATH_clear_mask                        0x80
  
  
  /*-------------------------------------------------------#
  | INTCON                                             0xB |
  #--------------------------------------------------------#
  | GIE | PEIE | T0IE | INTE | IOCIE | T0IF | INTF | IOCIF |
  #--------------------------------------------------------#
  | 7   | 6    | 5    | 4    | 3     | 2    | 1    | 0     |
  #-------------------------------------------------------*/
  
  #define INTCON                                   0x0
  #define INTCON_address                           0x00B
  #define INTCON_position                          0x0
  #define INTCON_size                              0x8
  #define INTCON_value_mask                        0xFF
  #define INTCON_clear_mask                        0x0
  
  #define IOCIF                                    0x0
  #define IOCIF_address                            0x00B
  #define IOCIF_position                           0x0
  #define IOCIF_size                               0x1
  #define IOCIF_value_mask                         0x1
  #define IOCIF_clear_mask                         0xFE
  
  #define INTF                                     0x1
  #define INTF_address                             0x00B
  #define INTF_position                            0x1
  #define INTF_size                                0x1
  #define INTF_value_mask                          0x2
  #define INTF_clear_mask                          0xFD
  
  #define T0IF                                     0x2
  #define T0IF_address                             0x00B
  #define T0IF_position                            0x2
  #define T0IF_size                                0x1
  #define T0IF_value_mask                          0x4
  #define T0IF_clear_mask                          0xFB
  
  #define TMR0IF                                   0x2
  #define TMR0IF_address                           0x00B
  #define TMR0IF_position                          0x2
  #define TMR0IF_size                              0x1
  #define TMR0IF_value_mask                        0x4
  #define TMR0IF_clear_mask                        0xFB
  
  #define IOCIE                                    0x3
  #define IOCIE_address                            0x00B
  #define IOCIE_position                           0x3
  #define IOCIE_size                               0x1
  #define IOCIE_value_mask                         0x8
  #define IOCIE_clear_mask                         0xF7
  
  #define INTE                                     0x4
  #define INTE_address                             0x00B
  #define INTE_position                            0x4
  #define INTE_size                                0x1
  #define INTE_value_mask                          0x10
  #define INTE_clear_mask                          0xEF
  
  #define T0IE                                     0x5
  #define T0IE_address                             0x00B
  #define T0IE_position                            0x5
  #define T0IE_size                                0x1
  #define T0IE_value_mask                          0x20
  #define T0IE_clear_mask                          0xDF
  
  #define TMR0IE                                   0x5
  #define TMR0IE_address                           0x00B
  #define TMR0IE_position                          0x5
  #define TMR0IE_size                              0x1
  #define TMR0IE_value_mask                        0x20
  #define TMR0IE_clear_mask                        0xDF
  
  #define PEIE                                     0x6
  #define PEIE_address                             0x00B
  #define PEIE_position                            0x6
  #define PEIE_size                                0x1
  #define PEIE_value_mask                          0x40
  #define PEIE_clear_mask                          0xBF
  
  #define GIE                                      0x7
  #define GIE_address                              0x00B
  #define GIE_position                             0x7
  #define GIE_size                                 0x1
  #define GIE_value_mask                           0x80
  #define GIE_clear_mask                           0x7F
  
  
  /*----------------------------------------------#
  | PORTA                                     0xC |
  #-----------------------------------------------#
  | RA7 | RA6 | RA5 | RA4 | RA3 | RA2 | RA1 | RA0 |
  #-----------------------------------------------#
  | 7   | 6   | 5   | 4   | 3   | 2   | 1   | 0   |
  #----------------------------------------------*/
  
  #define PORTA                                    0x0
  #define PORTA_address                            0x00C
  #define PORTA_position                           0x0
  #define PORTA_size                               0x8
  #define PORTA_value_mask                         0xFF
  #define PORTA_clear_mask                         0x0
  
  #define RA0                                      0x0
  #define RA0_address                              0x00C
  #define RA0_position                             0x0
  #define RA0_size                                 0x1
  #define RA0_value_mask                           0x1
  #define RA0_clear_mask                           0xFE
  
  #define RA1                                      0x1
  #define RA1_address                              0x00C
  #define RA1_position                             0x1
  #define RA1_size                                 0x1
  #define RA1_value_mask                           0x2
  #define RA1_clear_mask                           0xFD
  
  #define RA2                                      0x2
  #define RA2_address                              0x00C
  #define RA2_position                             0x2
  #define RA2_size                                 0x1
  #define RA2_value_mask                           0x4
  #define RA2_clear_mask                           0xFB
  
  #define RA3                                      0x3
  #define RA3_address                              0x00C
  #define RA3_position                             0x3
  #define RA3_size                                 0x1
  #define RA3_value_mask                           0x8
  #define RA3_clear_mask                           0xF7
  
  #define RA4                                      0x4
  #define RA4_address                              0x00C
  #define RA4_position                             0x4
  #define RA4_size                                 0x1
  #define RA4_value_mask                           0x10
  #define RA4_clear_mask                           0xEF
  
  #define RA5                                      0x5
  #define RA5_address                              0x00C
  #define RA5_position                             0x5
  #define RA5_size                                 0x1
  #define RA5_value_mask                           0x20
  #define RA5_clear_mask                           0xDF
  
  #define RA6                                      0x6
  #define RA6_address                              0x00C
  #define RA6_position                             0x6
  #define RA6_size                                 0x1
  #define RA6_value_mask                           0x40
  #define RA6_clear_mask                           0xBF
  
  #define RA7                                      0x7
  #define RA7_address                              0x00C
  #define RA7_position                             0x7
  #define RA7_size                                 0x1
  #define RA7_value_mask                           0x80
  #define RA7_clear_mask                           0x7F
  
  
  /*----------------------------------------------#
  | PORTB                                     0xD |
  #-----------------------------------------------#
  | RB7 | RB6 | RB5 | RB4 | RB3 | RB2 | RB1 | RB0 |
  #-----------------------------------------------#
  | 7   | 6   | 5   | 4   | 3   | 2   | 1   | 0   |
  #----------------------------------------------*/
  
  #define PORTB                                    0x0
  #define PORTB_address                            0x00D
  #define PORTB_position                           0x0
  #define PORTB_size                               0x8
  #define PORTB_value_mask                         0xFF
  #define PORTB_clear_mask                         0x0
  
  #define RB0                                      0x0
  #define RB0_address                              0x00D
  #define RB0_position                             0x0
  #define RB0_size                                 0x1
  #define RB0_value_mask                           0x1
  #define RB0_clear_mask                           0xFE
  
  #define RB1                                      0x1
  #define RB1_address                              0x00D
  #define RB1_position                             0x1
  #define RB1_size                                 0x1
  #define RB1_value_mask                           0x2
  #define RB1_clear_mask                           0xFD
  
  #define RB2                                      0x2
  #define RB2_address                              0x00D
  #define RB2_position                             0x2
  #define RB2_size                                 0x1
  #define RB2_value_mask                           0x4
  #define RB2_clear_mask                           0xFB
  
  #define RB3                                      0x3
  #define RB3_address                              0x00D
  #define RB3_position                             0x3
  #define RB3_size                                 0x1
  #define RB3_value_mask                           0x8
  #define RB3_clear_mask                           0xF7
  
  #define RB4                                      0x4
  #define RB4_address                              0x00D
  #define RB4_position                             0x4
  #define RB4_size                                 0x1
  #define RB4_value_mask                           0x10
  #define RB4_clear_mask                           0xEF
  
  #define RB5                                      0x5
  #define RB5_address                              0x00D
  #define RB5_position                             0x5
  #define RB5_size                                 0x1
  #define RB5_value_mask                           0x20
  #define RB5_clear_mask                           0xDF
  
  #define RB6                                      0x6
  #define RB6_address                              0x00D
  #define RB6_position                             0x6
  #define RB6_size                                 0x1
  #define RB6_value_mask                           0x40
  #define RB6_clear_mask                           0xBF
  
  #define RB7                                      0x7
  #define RB7_address                              0x00D
  #define RB7_position                             0x7
  #define RB7_size                                 0x1
  #define RB7_value_mask                           0x80
  #define RB7_clear_mask                           0x7F
  
  
  /*----------------------------------------------#
  | PORTC                                     0xE |
  #-----------------------------------------------#
  | RC7 | RC6 | RC5 | RC4 | RC3 | RC2 | RC1 | RC0 |
  #-----------------------------------------------#
  | 7   | 6   | 5   | 4   | 3   | 2   | 1   | 0   |
  #----------------------------------------------*/
  
  #define PORTC                                    0x0
  #define PORTC_address                            0x00E
  #define PORTC_position                           0x0
  #define PORTC_size                               0x8
  #define PORTC_value_mask                         0xFF
  #define PORTC_clear_mask                         0x0
  
  #define RC0                                      0x0
  #define RC0_address                              0x00E
  #define RC0_position                             0x0
  #define RC0_size                                 0x1
  #define RC0_value_mask                           0x1
  #define RC0_clear_mask                           0xFE
  
  #define RC1                                      0x1
  #define RC1_address                              0x00E
  #define RC1_position                             0x1
  #define RC1_size                                 0x1
  #define RC1_value_mask                           0x2
  #define RC1_clear_mask                           0xFD
  
  #define RC2                                      0x2
  #define RC2_address                              0x00E
  #define RC2_position                             0x2
  #define RC2_size                                 0x1
  #define RC2_value_mask                           0x4
  #define RC2_clear_mask                           0xFB
  
  #define RC3                                      0x3
  #define RC3_address                              0x00E
  #define RC3_position                             0x3
  #define RC3_size                                 0x1
  #define RC3_value_mask                           0x8
  #define RC3_clear_mask                           0xF7
  
  #define RC4                                      0x4
  #define RC4_address                              0x00E
  #define RC4_position                             0x4
  #define RC4_size                                 0x1
  #define RC4_value_mask                           0x10
  #define RC4_clear_mask                           0xEF
  
  #define RC5                                      0x5
  #define RC5_address                              0x00E
  #define RC5_position                             0x5
  #define RC5_size                                 0x1
  #define RC5_value_mask                           0x20
  #define RC5_clear_mask                           0xDF
  
  #define RC6                                      0x6
  #define RC6_address                              0x00E
  #define RC6_position                             0x6
  #define RC6_size                                 0x1
  #define RC6_value_mask                           0x40
  #define RC6_clear_mask                           0xBF
  
  #define RC7                                      0x7
  #define RC7_address                              0x00E
  #define RC7_position                             0x7
  #define RC7_size                                 0x1
  #define RC7_value_mask                           0x80
  #define RC7_clear_mask                           0x7F
  
  
  /*--------------------------------#
  | PORTE                      0x10 |
  #---------------------------------#
  | - | - | - | - | RE3 | - | - | - |
  #---------------------------------#
  | 7 | 6 | 5 | 4 | 3   | 2 | 1 | 0 |
  #--------------------------------*/
  
  #define PORTE                                    0x0
  #define PORTE_address                            0x010
  #define PORTE_position                           0x0
  #define PORTE_size                               0x8
  #define PORTE_value_mask                         0xFF
  #define PORTE_clear_mask                         0x0
  
  #define RE3                                      0x3
  #define RE3_address                              0x010
  #define RE3_position                             0x3
  #define RE3_size                                 0x1
  #define RE3_value_mask                           0x8
  #define RE3_clear_mask                           0xF7
  
  
  /*----------------------------------------------------------------#
  | PIR1                                                       0x11 |
  #-----------------------------------------------------------------#
  | TMR1GIF | ADIF | RCIF | TXIF | SSPIF | CCP1IF | TMR2IF | TMR1IF |
  #-----------------------------------------------------------------#
  | 7       | 6    | 5    | 4    | 3     | 2      | 1      | 0      |
  #----------------------------------------------------------------*/
  
  #define PIR1                                     0x0
  #define PIR1_address                             0x011
  #define PIR1_position                            0x0
  #define PIR1_size                                0x8
  #define PIR1_value_mask                          0xFF
  #define PIR1_clear_mask                          0x0
  
  #define TMR1IF                                   0x0
  #define TMR1IF_address                           0x011
  #define TMR1IF_position                          0x0
  #define TMR1IF_size                              0x1
  #define TMR1IF_value_mask                        0x1
  #define TMR1IF_clear_mask                        0xFE
  
  #define TMR2IF                                   0x1
  #define TMR2IF_address                           0x011
  #define TMR2IF_position                          0x1
  #define TMR2IF_size                              0x1
  #define TMR2IF_value_mask                        0x2
  #define TMR2IF_clear_mask                        0xFD
  
  #define CCP1IF                                   0x2
  #define CCP1IF_address                           0x011
  #define CCP1IF_position                          0x2
  #define CCP1IF_size                              0x1
  #define CCP1IF_value_mask                        0x4
  #define CCP1IF_clear_mask                        0xFB
  
  #define SSPIF                                    0x3
  #define SSPIF_address                            0x011
  #define SSPIF_position                           0x3
  #define SSPIF_size                               0x1
  #define SSPIF_value_mask                         0x8
  #define SSPIF_clear_mask                         0xF7
  
  #define TXIF                                     0x4
  #define TXIF_address                             0x011
  #define TXIF_position                            0x4
  #define TXIF_size                                0x1
  #define TXIF_value_mask                          0x10
  #define TXIF_clear_mask                          0xEF
  
  #define RCIF                                     0x5
  #define RCIF_address                             0x011
  #define RCIF_position                            0x5
  #define RCIF_size                                0x1
  #define RCIF_value_mask                          0x20
  #define RCIF_clear_mask                          0xDF
  
  #define ADIF                                     0x6
  #define ADIF_address                             0x011
  #define ADIF_position                            0x6
  #define ADIF_size                                0x1
  #define ADIF_value_mask                          0x40
  #define ADIF_clear_mask                          0xBF
  
  #define TMR1GIF                                  0x7
  #define TMR1GIF_address                          0x011
  #define TMR1GIF_position                         0x7
  #define TMR1GIF_size                             0x1
  #define TMR1GIF_value_mask                       0x80
  #define TMR1GIF_clear_mask                       0x7F
  
  
  /*--------------------------------------------------------#
  | PIR2                                               0x12 |
  #---------------------------------------------------------#
  | OSFIF | C2IF | C1IF | EEIF | BCLIF | LCDIF | - | CCP2IF |
  #---------------------------------------------------------#
  | 7     | 6    | 5    | 4    | 3     | 2     | 1 | 0      |
  #--------------------------------------------------------*/
  
  #define PIR2                                     0x0
  #define PIR2_address                             0x012
  #define PIR2_position                            0x0
  #define PIR2_size                                0x8
  #define PIR2_value_mask                          0xFF
  #define PIR2_clear_mask                          0x0
  
  #define CCP2IF                                   0x0
  #define CCP2IF_address                           0x012
  #define CCP2IF_position                          0x0
  #define CCP2IF_size                              0x1
  #define CCP2IF_value_mask                        0x1
  #define CCP2IF_clear_mask                        0xFE
  
  #define LCDIF                                    0x2
  #define LCDIF_address                            0x012
  #define LCDIF_position                           0x2
  #define LCDIF_size                               0x1
  #define LCDIF_value_mask                         0x4
  #define LCDIF_clear_mask                         0xFB
  
  #define BCLIF                                    0x3
  #define BCLIF_address                            0x012
  #define BCLIF_position                           0x3
  #define BCLIF_size                               0x1
  #define BCLIF_value_mask                         0x8
  #define BCLIF_clear_mask                         0xF7
  
  #define EEIF                                     0x4
  #define EEIF_address                             0x012
  #define EEIF_position                            0x4
  #define EEIF_size                                0x1
  #define EEIF_value_mask                          0x10
  #define EEIF_clear_mask                          0xEF
  
  #define C1IF                                     0x5
  #define C1IF_address                             0x012
  #define C1IF_position                            0x5
  #define C1IF_size                                0x1
  #define C1IF_value_mask                          0x20
  #define C1IF_clear_mask                          0xDF
  
  #define C2IF                                     0x6
  #define C2IF_address                             0x012
  #define C2IF_position                            0x6
  #define C2IF_size                                0x1
  #define C2IF_value_mask                          0x40
  #define C2IF_clear_mask                          0xBF
  
  #define OSFIF                                    0x7
  #define OSFIF_address                            0x012
  #define OSFIF_position                           0x7
  #define OSFIF_size                               0x1
  #define OSFIF_value_mask                         0x80
  #define OSFIF_clear_mask                         0x7F
  
  
  /*-------------------------------------------------------#
  | PIR3                                              0x13 |
  #--------------------------------------------------------#
  | - | CCP5IF | CCP4IF | CCP3IF | TMR6IF | - | TMR4IF | - |
  #--------------------------------------------------------#
  | 7 | 6      | 5      | 4      | 3      | 2 | 1      | 0 |
  #-------------------------------------------------------*/
  
  #define PIR3                                     0x0
  #define PIR3_address                             0x013
  #define PIR3_position                            0x0
  #define PIR3_size                                0x8
  #define PIR3_value_mask                          0xFF
  #define PIR3_clear_mask                          0x0
  
  #define TMR4IF                                   0x1
  #define TMR4IF_address                           0x013
  #define TMR4IF_position                          0x1
  #define TMR4IF_size                              0x1
  #define TMR4IF_value_mask                        0x2
  #define TMR4IF_clear_mask                        0xFD
  
  #define TMR6IF                                   0x3
  #define TMR6IF_address                           0x013
  #define TMR6IF_position                          0x3
  #define TMR6IF_size                              0x1
  #define TMR6IF_value_mask                        0x8
  #define TMR6IF_clear_mask                        0xF7
  
  #define CCP3IF                                   0x4
  #define CCP3IF_address                           0x013
  #define CCP3IF_position                          0x4
  #define CCP3IF_size                              0x1
  #define CCP3IF_value_mask                        0x10
  #define CCP3IF_clear_mask                        0xEF
  
  #define CCP4IF                                   0x5
  #define CCP4IF_address                           0x013
  #define CCP4IF_position                          0x5
  #define CCP4IF_size                              0x1
  #define CCP4IF_value_mask                        0x20
  #define CCP4IF_clear_mask                        0xDF
  
  #define CCP5IF                                   0x6
  #define CCP5IF_address                           0x013
  #define CCP5IF_position                          0x6
  #define CCP5IF_size                              0x1
  #define CCP5IF_value_mask                        0x40
  #define CCP5IF_clear_mask                        0xBF
  
  
  /*------------------------------#
  | TMR0                     0x15 |
  #-------------------------------#
  | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
  #------------------------------*/
  
  #define TMR0                                     0x0
  #define TMR0_address                             0x015
  #define TMR0_position                            0x0
  #define TMR0_size                                0x8
  #define TMR0_value_mask                          0xFF
  #define TMR0_clear_mask                          0x0
  
  
  /*------------------------------#
  | TMR1L                    0x16 |
  #-------------------------------#
  | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
  #------------------------------*/
  
  #define TMR1L                                    0x0
  #define TMR1L_address                            0x016
  #define TMR1L_position                           0x0
  #define TMR1L_size                               0x8
  #define TMR1L_value_mask                         0xFF
  #define TMR1L_clear_mask                         0x0
  
  
  /*------------------------------#
  | TMR1H                    0x17 |
  #-------------------------------#
  | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
  #------------------------------*/
  
  #define TMR1H                                    0x0
  #define TMR1H_address                            0x017
  #define TMR1H_position                           0x0
  #define TMR1H_size                               0x8
  #define TMR1H_value_mask                         0xFF
  #define TMR1H_clear_mask                         0x0
  
  
  /*-----------------------------------------------------------------------#
  | T1CON                                                             0x18 |
  #------------------------------------------------------------------------#
  | TMR1CS1 | TMR1CS0 | T1CKPS1 | T1CKPS0 | T1OSCEN | nT1SYNC | - | TMR1ON |
  #------------------------------------------------------------------------#
  | 7       | 6       | 5       | 4       | 3       | 2       | 1 | 0      |
  #-----------------------------------------------------------------------*/
  
  #define T1CON                                    0x0
  #define T1CON_address                            0x018
  #define T1CON_position                           0x0
  #define T1CON_size                               0x8
  #define T1CON_value_mask                         0xFF
  #define T1CON_clear_mask                         0x0
  
  #define TMR1ON                                   0x0
  #define TMR1ON_address                           0x018
  #define TMR1ON_position                          0x0
  #define TMR1ON_size                              0x1
  #define TMR1ON_value_mask                        0x1
  #define TMR1ON_clear_mask                        0xFE
  
  #define nT1SYNC                                  0x2
  #define nT1SYNC_address                          0x018
  #define nT1SYNC_position                         0x2
  #define nT1SYNC_size                             0x1
  #define nT1SYNC_value_mask                       0x4
  #define nT1SYNC_clear_mask                       0xFB
  
  #define T1OSCEN                                  0x3
  #define T1OSCEN_address                          0x018
  #define T1OSCEN_position                         0x3
  #define T1OSCEN_size                             0x1
  #define T1OSCEN_value_mask                       0x8
  #define T1OSCEN_clear_mask                       0xF7
  
  #define T1CKPS0                                  0x4
  #define T1CKPS0_address                          0x018
  #define T1CKPS0_position                         0x4
  #define T1CKPS0_size                             0x1
  #define T1CKPS0_value_mask                       0x10
  #define T1CKPS0_clear_mask                       0xEF
  
  #define T1CKPS                                   0x4
  #define T1CKPS_address                           0x018
  #define T1CKPS_position                          0x4
  #define T1CKPS_size                              0x2
  #define T1CKPS_value_mask                        0x30
  #define T1CKPS_clear_mask                        0xCF
  
  #define T1CKPS1                                  0x5
  #define T1CKPS1_address                          0x018
  #define T1CKPS1_position                         0x5
  #define T1CKPS1_size                             0x1
  #define T1CKPS1_value_mask                       0x20
  #define T1CKPS1_clear_mask                       0xDF
  
  #define TMR1CS                                   0x6
  #define TMR1CS_address                           0x018
  #define TMR1CS_position                          0x6
  #define TMR1CS_size                              0x2
  #define TMR1CS_value_mask                        0xC0
  #define TMR1CS_clear_mask                        0x3F
  
  #define TMR1CS0                                  0x6
  #define TMR1CS0_address                          0x018
  #define TMR1CS0_position                         0x6
  #define TMR1CS0_size                             0x1
  #define TMR1CS0_value_mask                       0x40
  #define TMR1CS0_clear_mask                       0xBF
  
  #define TMR1CS1                                  0x7
  #define TMR1CS1_address                          0x018
  #define TMR1CS1_position                         0x7
  #define TMR1CS1_size                             0x1
  #define TMR1CS1_value_mask                       0x80
  #define TMR1CS1_clear_mask                       0x7F
  
  
  /*--------------------------------------------------------------------------#
  | T1GCON                                                               0x19 |
  #---------------------------------------------------------------------------#
  | TMR1GE | T1GPOL | T1GTM | T1GSPM | T1GGO_nDONE | T1GVAL | T1GSS1 | T1GSS0 |
  #---------------------------------------------------------------------------#
  | 7      | 6      | 5     | 4      | 3           | 2      | 1      | 0      |
  #--------------------------------------------------------------------------*/
  
  #define T1GCON                                   0x0
  #define T1GCON_address                           0x019
  #define T1GCON_position                          0x0
  #define T1GCON_size                              0x8
  #define T1GCON_value_mask                        0xFF
  #define T1GCON_clear_mask                        0x0
  
  #define T1GSS0                                   0x0
  #define T1GSS0_address                           0x019
  #define T1GSS0_position                          0x0
  #define T1GSS0_size                              0x1
  #define T1GSS0_value_mask                        0x1
  #define T1GSS0_clear_mask                        0xFE
  
  #define T1GSS                                    0x0
  #define T1GSS_address                            0x019
  #define T1GSS_position                           0x0
  #define T1GSS_size                               0x2
  #define T1GSS_value_mask                         0x3
  #define T1GSS_clear_mask                         0xFC
  
  #define T1GSS1                                   0x1
  #define T1GSS1_address                           0x019
  #define T1GSS1_position                          0x1
  #define T1GSS1_size                              0x1
  #define T1GSS1_value_mask                        0x2
  #define T1GSS1_clear_mask                        0xFD
  
  #define T1GVAL                                   0x2
  #define T1GVAL_address                           0x019
  #define T1GVAL_position                          0x2
  #define T1GVAL_size                              0x1
  #define T1GVAL_value_mask                        0x4
  #define T1GVAL_clear_mask                        0xFB
  
  #define T1GGO_nDONE                              0x3
  #define T1GGO_nDONE_address                      0x019
  #define T1GGO_nDONE_position                     0x3
  #define T1GGO_nDONE_size                         0x1
  #define T1GGO_nDONE_value_mask                   0x8
  #define T1GGO_nDONE_clear_mask                   0xF7
  
  #define T1GGO                                    0x3
  #define T1GGO_address                            0x019
  #define T1GGO_position                           0x3
  #define T1GGO_size                               0x1
  #define T1GGO_value_mask                         0x8
  #define T1GGO_clear_mask                         0xF7
  
  #define T1GSPM                                   0x4
  #define T1GSPM_address                           0x019
  #define T1GSPM_position                          0x4
  #define T1GSPM_size                              0x1
  #define T1GSPM_value_mask                        0x10
  #define T1GSPM_clear_mask                        0xEF
  
  #define T1GTM                                    0x5
  #define T1GTM_address                            0x019
  #define T1GTM_position                           0x5
  #define T1GTM_size                               0x1
  #define T1GTM_value_mask                         0x20
  #define T1GTM_clear_mask                         0xDF
  
  #define T1GPOL                                   0x6
  #define T1GPOL_address                           0x019
  #define T1GPOL_position                          0x6
  #define T1GPOL_size                              0x1
  #define T1GPOL_value_mask                        0x40
  #define T1GPOL_clear_mask                        0xBF
  
  #define TMR1GE                                   0x7
  #define TMR1GE_address                           0x019
  #define TMR1GE_position                          0x7
  #define TMR1GE_size                              0x1
  #define TMR1GE_value_mask                        0x80
  #define TMR1GE_clear_mask                        0x7F
  
  
  /*------------------------------#
  | TMR2                     0x1A |
  #-------------------------------#
  | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
  #------------------------------*/
  
  #define TMR2                                     0x0
  #define TMR2_address                             0x01A
  #define TMR2_position                            0x0
  #define TMR2_size                                0x8
  #define TMR2_value_mask                          0xFF
  #define TMR2_clear_mask                          0x0
  
  
  /*------------------------------#
  | PR2                      0x1B |
  #-------------------------------#
  | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
  #------------------------------*/
  
  #define PR2                                      0x0
  #define PR2_address                              0x01B
  #define PR2_position                             0x0
  #define PR2_size                                 0x8
  #define PR2_value_mask                           0xFF
  #define PR2_clear_mask                           0x0
  
  
  /*---------------------------------------------------------------------------#
  | T2CON                                                                 0x1C |
  #----------------------------------------------------------------------------#
  | - | T2OUTPS3 | T2OUTPS2 | T2OUTPS1 | T2OUTPS0 | TMR2ON | T2CKPS1 | T2CKPS0 |
  #----------------------------------------------------------------------------#
  | 7 | 6        | 5        | 4        | 3        | 2      | 1       | 0       |
  #---------------------------------------------------------------------------*/
  
  #define T2CON                                    0x0
  #define T2CON_address                            0x01C
  #define T2CON_position                           0x0
  #define T2CON_size                               0x8
  #define T2CON_value_mask                         0xFF
  #define T2CON_clear_mask                         0x0
  
  #define T2CKPS0                                  0x0
  #define T2CKPS0_address                          0x01C
  #define T2CKPS0_position                         0x0
  #define T2CKPS0_size                             0x1
  #define T2CKPS0_value_mask                       0x1
  #define T2CKPS0_clear_mask                       0xFE
  
  #define T2CKPS                                   0x0
  #define T2CKPS_address                           0x01C
  #define T2CKPS_position                          0x0
  #define T2CKPS_size                              0x2
  #define T2CKPS_value_mask                        0x3
  #define T2CKPS_clear_mask                        0xFC
  
  #define T2CKPS1                                  0x1
  #define T2CKPS1_address                          0x01C
  #define T2CKPS1_position                         0x1
  #define T2CKPS1_size                             0x1
  #define T2CKPS1_value_mask                       0x2
  #define T2CKPS1_clear_mask                       0xFD
  
  #define TMR2ON                                   0x2
  #define TMR2ON_address                           0x01C
  #define TMR2ON_position                          0x2
  #define TMR2ON_size                              0x1
  #define TMR2ON_value_mask                        0x4
  #define TMR2ON_clear_mask                        0xFB
  
  #define T2OUTPS0                                 0x3
  #define T2OUTPS0_address                         0x01C
  #define T2OUTPS0_position                        0x3
  #define T2OUTPS0_size                            0x1
  #define T2OUTPS0_value_mask                      0x8
  #define T2OUTPS0_clear_mask                      0xF7
  
  #define T2OUTPS                                  0x3
  #define T2OUTPS_address                          0x01C
  #define T2OUTPS_position                         0x3
  #define T2OUTPS_size                             0x4
  #define T2OUTPS_value_mask                       0x78
  #define T2OUTPS_clear_mask                       0x87
  
  #define T2OUTPS1                                 0x4
  #define T2OUTPS1_address                         0x01C
  #define T2OUTPS1_position                        0x4
  #define T2OUTPS1_size                            0x1
  #define T2OUTPS1_value_mask                      0x10
  #define T2OUTPS1_clear_mask                      0xEF
  
  #define T2OUTPS2                                 0x5
  #define T2OUTPS2_address                         0x01C
  #define T2OUTPS2_position                        0x5
  #define T2OUTPS2_size                            0x1
  #define T2OUTPS2_value_mask                      0x20
  #define T2OUTPS2_clear_mask                      0xDF
  
  #define T2OUTPS3                                 0x6
  #define T2OUTPS3_address                         0x01C
  #define T2OUTPS3_position                        0x6
  #define T2OUTPS3_size                            0x1
  #define T2OUTPS3_value_mask                      0x40
  #define T2OUTPS3_clear_mask                      0xBF
  
  
  /*-----------------------------------------------------------#
  | CPSCON0                                               0x1E |
  #------------------------------------------------------------#
  | CPSON | CPSRM | - | - | CPSRNG1 | CPSRNG0 | CPSOUT | T0XCS |
  #------------------------------------------------------------#
  | 7     | 6     | 5 | 4 | 3       | 2       | 1      | 0     |
  #-----------------------------------------------------------*/
  
  #define CPSCON0                                  0x0
  #define CPSCON0_address                          0x01E
  #define CPSCON0_position                         0x0
  #define CPSCON0_size                             0x8
  #define CPSCON0_value_mask                       0xFF
  #define CPSCON0_clear_mask                       0x0
  
  #define T0XCS                                    0x0
  #define T0XCS_address                            0x01E
  #define T0XCS_position                           0x0
  #define T0XCS_size                               0x1
  #define T0XCS_value_mask                         0x1
  #define T0XCS_clear_mask                         0xFE
  
  #define CPSOUT                                   0x1
  #define CPSOUT_address                           0x01E
  #define CPSOUT_position                          0x1
  #define CPSOUT_size                              0x1
  #define CPSOUT_value_mask                        0x2
  #define CPSOUT_clear_mask                        0xFD
  
  #define CPSRNG                                   0x2
  #define CPSRNG_address                           0x01E
  #define CPSRNG_position                          0x2
  #define CPSRNG_size                              0x2
  #define CPSRNG_value_mask                        0xC
  #define CPSRNG_clear_mask                        0xF3
  
  #define CPSRNG0                                  0x2
  #define CPSRNG0_address                          0x01E
  #define CPSRNG0_position                         0x2
  #define CPSRNG0_size                             0x1
  #define CPSRNG0_value_mask                       0x4
  #define CPSRNG0_clear_mask                       0xFB
  
  #define CPSRNG1                                  0x3
  #define CPSRNG1_address                          0x01E
  #define CPSRNG1_position                         0x3
  #define CPSRNG1_size                             0x1
  #define CPSRNG1_value_mask                       0x8
  #define CPSRNG1_clear_mask                       0xF7
  
  #define CPSRM                                    0x6
  #define CPSRM_address                            0x01E
  #define CPSRM_position                           0x6
  #define CPSRM_size                               0x1
  #define CPSRM_value_mask                         0x40
  #define CPSRM_clear_mask                         0xBF
  
  #define CPSON                                    0x7
  #define CPSON_address                            0x01E
  #define CPSON_position                           0x7
  #define CPSON_size                               0x1
  #define CPSON_value_mask                         0x80
  #define CPSON_clear_mask                         0x7F
  
  
  /*---------------------------------------------#
  | CPSCON1                                 0x1F |
  #----------------------------------------------#
  | - | - | - | - | - | CPSCH2 | CPSCH1 | CPSCH0 |
  #----------------------------------------------#
  | 7 | 6 | 5 | 4 | 3 | 2      | 1      | 0      |
  #---------------------------------------------*/
  
  #define CPSCON1                                  0x0
  #define CPSCON1_address                          0x01F
  #define CPSCON1_position                         0x0
  #define CPSCON1_size                             0x8
  #define CPSCON1_value_mask                       0xFF
  #define CPSCON1_clear_mask                       0x0
  
  #define CPSCH                                    0x0
  #define CPSCH_address                            0x01F
  #define CPSCH_position                           0x0
  #define CPSCH_size                               0x3
  #define CPSCH_value_mask                         0x7
  #define CPSCH_clear_mask                         0xF8
  
  #define CPSCH0                                   0x0
  #define CPSCH0_address                           0x01F
  #define CPSCH0_position                          0x0
  #define CPSCH0_size                              0x1
  #define CPSCH0_value_mask                        0x1
  #define CPSCH0_clear_mask                        0xFE
  
  #define CPSCH1                                   0x1
  #define CPSCH1_address                           0x01F
  #define CPSCH1_position                          0x1
  #define CPSCH1_size                              0x1
  #define CPSCH1_value_mask                        0x2
  #define CPSCH1_clear_mask                        0xFD
  
  #define CPSCH2                                   0x2
  #define CPSCH2_address                           0x01F
  #define CPSCH2_position                          0x2
  #define CPSCH2_size                              0x1
  #define CPSCH2_value_mask                        0x4
  #define CPSCH2_clear_mask                        0xFB
  
  
  /*----------------------------------------------------------------------#
  | TRISA                                                            0x8C |
  #-----------------------------------------------------------------------#
  | TRISA7 | TRISA6 | TRISA5 | TRISA4 | TRISA3 | TRISA2 | TRISA1 | TRISA0 |
  #-----------------------------------------------------------------------#
  | 7      | 6      | 5      | 4      | 3      | 2      | 1      | 0      |
  #----------------------------------------------------------------------*/
  
  #define TRISA                                    0x0
  #define TRISA_address                            0x08C
  #define TRISA_position                           0x0
  #define TRISA_size                               0x8
  #define TRISA_value_mask                         0xFF
  #define TRISA_clear_mask                         0x0
  
  #define TRISA0                                   0x0
  #define TRISA0_address                           0x08C
  #define TRISA0_position                          0x0
  #define TRISA0_size                              0x1
  #define TRISA0_value_mask                        0x1
  #define TRISA0_clear_mask                        0xFE
  
  #define TRISA1                                   0x1
  #define TRISA1_address                           0x08C
  #define TRISA1_position                          0x1
  #define TRISA1_size                              0x1
  #define TRISA1_value_mask                        0x2
  #define TRISA1_clear_mask                        0xFD
  
  #define TRISA2                                   0x2
  #define TRISA2_address                           0x08C
  #define TRISA2_position                          0x2
  #define TRISA2_size                              0x1
  #define TRISA2_value_mask                        0x4
  #define TRISA2_clear_mask                        0xFB
  
  #define TRISA3                                   0x3
  #define TRISA3_address                           0x08C
  #define TRISA3_position                          0x3
  #define TRISA3_size                              0x1
  #define TRISA3_value_mask                        0x8
  #define TRISA3_clear_mask                        0xF7
  
  #define TRISA4                                   0x4
  #define TRISA4_address                           0x08C
  #define TRISA4_position                          0x4
  #define TRISA4_size                              0x1
  #define TRISA4_value_mask                        0x10
  #define TRISA4_clear_mask                        0xEF
  
  #define TRISA5                                   0x5
  #define TRISA5_address                           0x08C
  #define TRISA5_position                          0x5
  #define TRISA5_size                              0x1
  #define TRISA5_value_mask                        0x20
  #define TRISA5_clear_mask                        0xDF
  
  #define TRISA6                                   0x6
  #define TRISA6_address                           0x08C
  #define TRISA6_position                          0x6
  #define TRISA6_size                              0x1
  #define TRISA6_value_mask                        0x40
  #define TRISA6_clear_mask                        0xBF
  
  #define TRISA7                                   0x7
  #define TRISA7_address                           0x08C
  #define TRISA7_position                          0x7
  #define TRISA7_size                              0x1
  #define TRISA7_value_mask                        0x80
  #define TRISA7_clear_mask                        0x7F
  
  
  /*----------------------------------------------------------------------#
  | TRISB                                                            0x8D |
  #-----------------------------------------------------------------------#
  | TRISB7 | TRISB6 | TRISB5 | TRISB4 | TRISB3 | TRISB2 | TRISB1 | TRISB0 |
  #-----------------------------------------------------------------------#
  | 7      | 6      | 5      | 4      | 3      | 2      | 1      | 0      |
  #----------------------------------------------------------------------*/
  
  #define TRISB                                    0x0
  #define TRISB_address                            0x08D
  #define TRISB_position                           0x0
  #define TRISB_size                               0x8
  #define TRISB_value_mask                         0xFF
  #define TRISB_clear_mask                         0x0
  
  #define TRISB0                                   0x0
  #define TRISB0_address                           0x08D
  #define TRISB0_position                          0x0
  #define TRISB0_size                              0x1
  #define TRISB0_value_mask                        0x1
  #define TRISB0_clear_mask                        0xFE
  
  #define TRISB1                                   0x1
  #define TRISB1_address                           0x08D
  #define TRISB1_position                          0x1
  #define TRISB1_size                              0x1
  #define TRISB1_value_mask                        0x2
  #define TRISB1_clear_mask                        0xFD
  
  #define TRISB2                                   0x2
  #define TRISB2_address                           0x08D
  #define TRISB2_position                          0x2
  #define TRISB2_size                              0x1
  #define TRISB2_value_mask                        0x4
  #define TRISB2_clear_mask                        0xFB
  
  #define TRISB3                                   0x3
  #define TRISB3_address                           0x08D
  #define TRISB3_position                          0x3
  #define TRISB3_size                              0x1
  #define TRISB3_value_mask                        0x8
  #define TRISB3_clear_mask                        0xF7
  
  #define TRISB4                                   0x4
  #define TRISB4_address                           0x08D
  #define TRISB4_position                          0x4
  #define TRISB4_size                              0x1
  #define TRISB4_value_mask                        0x10
  #define TRISB4_clear_mask                        0xEF
  
  #define TRISB5                                   0x5
  #define TRISB5_address                           0x08D
  #define TRISB5_position                          0x5
  #define TRISB5_size                              0x1
  #define TRISB5_value_mask                        0x20
  #define TRISB5_clear_mask                        0xDF
  
  #define TRISB6                                   0x6
  #define TRISB6_address                           0x08D
  #define TRISB6_position                          0x6
  #define TRISB6_size                              0x1
  #define TRISB6_value_mask                        0x40
  #define TRISB6_clear_mask                        0xBF
  
  #define TRISB7                                   0x7
  #define TRISB7_address                           0x08D
  #define TRISB7_position                          0x7
  #define TRISB7_size                              0x1
  #define TRISB7_value_mask                        0x80
  #define TRISB7_clear_mask                        0x7F
  
  
  /*----------------------------------------------------------------------#
  | TRISC                                                            0x8E |
  #-----------------------------------------------------------------------#
  | TRISC7 | TRISC6 | TRISC5 | TRISC4 | TRISC3 | TRISC2 | TRISC1 | TRISC0 |
  #-----------------------------------------------------------------------#
  | 7      | 6      | 5      | 4      | 3      | 2      | 1      | 0      |
  #----------------------------------------------------------------------*/
  
  #define TRISC                                    0x0
  #define TRISC_address                            0x08E
  #define TRISC_position                           0x0
  #define TRISC_size                               0x8
  #define TRISC_value_mask                         0xFF
  #define TRISC_clear_mask                         0x0
  
  #define TRISC0                                   0x0
  #define TRISC0_address                           0x08E
  #define TRISC0_position                          0x0
  #define TRISC0_size                              0x1
  #define TRISC0_value_mask                        0x1
  #define TRISC0_clear_mask                        0xFE
  
  #define TRISC1                                   0x1
  #define TRISC1_address                           0x08E
  #define TRISC1_position                          0x1
  #define TRISC1_size                              0x1
  #define TRISC1_value_mask                        0x2
  #define TRISC1_clear_mask                        0xFD
  
  #define TRISC2                                   0x2
  #define TRISC2_address                           0x08E
  #define TRISC2_position                          0x2
  #define TRISC2_size                              0x1
  #define TRISC2_value_mask                        0x4
  #define TRISC2_clear_mask                        0xFB
  
  #define TRISC3                                   0x3
  #define TRISC3_address                           0x08E
  #define TRISC3_position                          0x3
  #define TRISC3_size                              0x1
  #define TRISC3_value_mask                        0x8
  #define TRISC3_clear_mask                        0xF7
  
  #define TRISC4                                   0x4
  #define TRISC4_address                           0x08E
  #define TRISC4_position                          0x4
  #define TRISC4_size                              0x1
  #define TRISC4_value_mask                        0x10
  #define TRISC4_clear_mask                        0xEF
  
  #define TRISC5                                   0x5
  #define TRISC5_address                           0x08E
  #define TRISC5_position                          0x5
  #define TRISC5_size                              0x1
  #define TRISC5_value_mask                        0x20
  #define TRISC5_clear_mask                        0xDF
  
  #define TRISC6                                   0x6
  #define TRISC6_address                           0x08E
  #define TRISC6_position                          0x6
  #define TRISC6_size                              0x1
  #define TRISC6_value_mask                        0x40
  #define TRISC6_clear_mask                        0xBF
  
  #define TRISC7                                   0x7
  #define TRISC7_address                           0x08E
  #define TRISC7_position                          0x7
  #define TRISC7_size                              0x1
  #define TRISC7_value_mask                        0x80
  #define TRISC7_clear_mask                        0x7F
  
  
  /*-----------------------------------#
  | TRISE                         0x90 |
  #------------------------------------#
  | - | - | - | - | TRISE3 | - | - | - |
  #------------------------------------#
  | 7 | 6 | 5 | 4 | 3      | 2 | 1 | 0 |
  #-----------------------------------*/
  
  #define TRISE                                    0x0
  #define TRISE_address                            0x090
  #define TRISE_position                           0x0
  #define TRISE_size                               0x8
  #define TRISE_value_mask                         0xFF
  #define TRISE_clear_mask                         0x0
  
  #define TRISE3                                   0x3
  #define TRISE3_address                           0x090
  #define TRISE3_position                          0x3
  #define TRISE3_size                              0x1
  #define TRISE3_value_mask                        0x8
  #define TRISE3_clear_mask                        0xF7
  
  
  /*----------------------------------------------------------------#
  | PIE1                                                       0x91 |
  #-----------------------------------------------------------------#
  | TMR1GIE | ADIE | RCIE | TXIE | SSPIE | CCP1IE | TMR2IE | TMR1IE |
  #-----------------------------------------------------------------#
  | 7       | 6    | 5    | 4    | 3     | 2      | 1      | 0      |
  #----------------------------------------------------------------*/
  
  #define PIE1                                     0x0
  #define PIE1_address                             0x091
  #define PIE1_position                            0x0
  #define PIE1_size                                0x8
  #define PIE1_value_mask                          0xFF
  #define PIE1_clear_mask                          0x0
  
  #define TMR1IE                                   0x0
  #define TMR1IE_address                           0x091
  #define TMR1IE_position                          0x0
  #define TMR1IE_size                              0x1
  #define TMR1IE_value_mask                        0x1
  #define TMR1IE_clear_mask                        0xFE
  
  #define TMR2IE                                   0x1
  #define TMR2IE_address                           0x091
  #define TMR2IE_position                          0x1
  #define TMR2IE_size                              0x1
  #define TMR2IE_value_mask                        0x2
  #define TMR2IE_clear_mask                        0xFD
  
  #define CCP1IE                                   0x2
  #define CCP1IE_address                           0x091
  #define CCP1IE_position                          0x2
  #define CCP1IE_size                              0x1
  #define CCP1IE_value_mask                        0x4
  #define CCP1IE_clear_mask                        0xFB
  
  #define SSPIE                                    0x3
  #define SSPIE_address                            0x091
  #define SSPIE_position                           0x3
  #define SSPIE_size                               0x1
  #define SSPIE_value_mask                         0x8
  #define SSPIE_clear_mask                         0xF7
  
  #define TXIE                                     0x4
  #define TXIE_address                             0x091
  #define TXIE_position                            0x4
  #define TXIE_size                                0x1
  #define TXIE_value_mask                          0x10
  #define TXIE_clear_mask                          0xEF
  
  #define RCIE                                     0x5
  #define RCIE_address                             0x091
  #define RCIE_position                            0x5
  #define RCIE_size                                0x1
  #define RCIE_value_mask                          0x20
  #define RCIE_clear_mask                          0xDF
  
  #define ADIE                                     0x6
  #define ADIE_address                             0x091
  #define ADIE_position                            0x6
  #define ADIE_size                                0x1
  #define ADIE_value_mask                          0x40
  #define ADIE_clear_mask                          0xBF
  
  #define TMR1GIE                                  0x7
  #define TMR1GIE_address                          0x091
  #define TMR1GIE_position                         0x7
  #define TMR1GIE_size                             0x1
  #define TMR1GIE_value_mask                       0x80
  #define TMR1GIE_clear_mask                       0x7F
  
  
  /*--------------------------------------------------------#
  | PIE2                                               0x92 |
  #---------------------------------------------------------#
  | OSFIE | C2IE | C1IE | EEIE | BCLIE | LCDIE | - | CCP2IE |
  #---------------------------------------------------------#
  | 7     | 6    | 5    | 4    | 3     | 2     | 1 | 0      |
  #--------------------------------------------------------*/
  
  #define PIE2                                     0x0
  #define PIE2_address                             0x092
  #define PIE2_position                            0x0
  #define PIE2_size                                0x8
  #define PIE2_value_mask                          0xFF
  #define PIE2_clear_mask                          0x0
  
  #define CCP2IE                                   0x0
  #define CCP2IE_address                           0x092
  #define CCP2IE_position                          0x0
  #define CCP2IE_size                              0x1
  #define CCP2IE_value_mask                        0x1
  #define CCP2IE_clear_mask                        0xFE
  
  #define LCDIE                                    0x2
  #define LCDIE_address                            0x092
  #define LCDIE_position                           0x2
  #define LCDIE_size                               0x1
  #define LCDIE_value_mask                         0x4
  #define LCDIE_clear_mask                         0xFB
  
  #define BCLIE                                    0x3
  #define BCLIE_address                            0x092
  #define BCLIE_position                           0x3
  #define BCLIE_size                               0x1
  #define BCLIE_value_mask                         0x8
  #define BCLIE_clear_mask                         0xF7
  
  #define EEIE                                     0x4
  #define EEIE_address                             0x092
  #define EEIE_position                            0x4
  #define EEIE_size                                0x1
  #define EEIE_value_mask                          0x10
  #define EEIE_clear_mask                          0xEF
  
  #define C1IE                                     0x5
  #define C1IE_address                             0x092
  #define C1IE_position                            0x5
  #define C1IE_size                                0x1
  #define C1IE_value_mask                          0x20
  #define C1IE_clear_mask                          0xDF
  
  #define C2IE                                     0x6
  #define C2IE_address                             0x092
  #define C2IE_position                            0x6
  #define C2IE_size                                0x1
  #define C2IE_value_mask                          0x40
  #define C2IE_clear_mask                          0xBF
  
  #define OSFIE                                    0x7
  #define OSFIE_address                            0x092
  #define OSFIE_position                           0x7
  #define OSFIE_size                               0x1
  #define OSFIE_value_mask                         0x80
  #define OSFIE_clear_mask                         0x7F
  
  
  /*-------------------------------------------------------#
  | PIE3                                              0x93 |
  #--------------------------------------------------------#
  | - | CCP5IE | CCP4IE | CCP3IE | TMR6IE | - | TMR4IE | - |
  #--------------------------------------------------------#
  | 7 | 6      | 5      | 4      | 3      | 2 | 1      | 0 |
  #-------------------------------------------------------*/
  
  #define PIE3                                     0x0
  #define PIE3_address                             0x093
  #define PIE3_position                            0x0
  #define PIE3_size                                0x8
  #define PIE3_value_mask                          0xFF
  #define PIE3_clear_mask                          0x0
  
  #define TMR4IE                                   0x1
  #define TMR4IE_address                           0x093
  #define TMR4IE_position                          0x1
  #define TMR4IE_size                              0x1
  #define TMR4IE_value_mask                        0x2
  #define TMR4IE_clear_mask                        0xFD
  
  #define TMR6IE                                   0x3
  #define TMR6IE_address                           0x093
  #define TMR6IE_position                          0x3
  #define TMR6IE_size                              0x1
  #define TMR6IE_value_mask                        0x8
  #define TMR6IE_clear_mask                        0xF7
  
  #define CCP3IE                                   0x4
  #define CCP3IE_address                           0x093
  #define CCP3IE_position                          0x4
  #define CCP3IE_size                              0x1
  #define CCP3IE_value_mask                        0x10
  #define CCP3IE_clear_mask                        0xEF
  
  #define CCP4IE                                   0x5
  #define CCP4IE_address                           0x093
  #define CCP4IE_position                          0x5
  #define CCP4IE_size                              0x1
  #define CCP4IE_value_mask                        0x20
  #define CCP4IE_clear_mask                        0xDF
  
  #define CCP5IE                                   0x6
  #define CCP5IE_address                           0x093
  #define CCP5IE_position                          0x6
  #define CCP5IE_size                              0x1
  #define CCP5IE_value_mask                        0x40
  #define CCP5IE_clear_mask                        0xBF
  
  
  /*------------------------------------------------------#
  | OPTION_REG                                       0x95 |
  #-------------------------------------------------------#
  | nWPUEN | INTEDG | T0CS | T0SE | PSA | PS2 | PS1 | PS0 |
  #-------------------------------------------------------#
  | 7      | 6      | 5    | 4    | 3   | 2   | 1   | 0   |
  #------------------------------------------------------*/
  
  #define OPTION_REG                               0x0
  #define OPTION_REG_address                       0x095
  #define OPTION_REG_position                      0x0
  #define OPTION_REG_size                          0x8
  #define OPTION_REG_value_mask                    0xFF
  #define OPTION_REG_clear_mask                    0x0
  
  #define PS                                       0x0
  #define PS_address                               0x095
  #define PS_position                              0x0
  #define PS_size                                  0x3
  #define PS_value_mask                            0x7
  #define PS_clear_mask                            0xF8
  
  #define PS0                                      0x0
  #define PS0_address                              0x095
  #define PS0_position                             0x0
  #define PS0_size                                 0x1
  #define PS0_value_mask                           0x1
  #define PS0_clear_mask                           0xFE
  
  #define PS1                                      0x1
  #define PS1_address                              0x095
  #define PS1_position                             0x1
  #define PS1_size                                 0x1
  #define PS1_value_mask                           0x2
  #define PS1_clear_mask                           0xFD
  
  #define PS2                                      0x2
  #define PS2_address                              0x095
  #define PS2_position                             0x2
  #define PS2_size                                 0x1
  #define PS2_value_mask                           0x4
  #define PS2_clear_mask                           0xFB
  
  #define PSA                                      0x3
  #define PSA_address                              0x095
  #define PSA_position                             0x3
  #define PSA_size                                 0x1
  #define PSA_value_mask                           0x8
  #define PSA_clear_mask                           0xF7
  
  #define T0SE                                     0x4
  #define T0SE_address                             0x095
  #define T0SE_position                            0x4
  #define T0SE_size                                0x1
  #define T0SE_value_mask                          0x10
  #define T0SE_clear_mask                          0xEF
  
  #define TMR0SE                                   0x4
  #define TMR0SE_address                           0x095
  #define TMR0SE_position                          0x4
  #define TMR0SE_size                              0x1
  #define TMR0SE_value_mask                        0x10
  #define TMR0SE_clear_mask                        0xEF
  
  #define T0CS                                     0x5
  #define T0CS_address                             0x095
  #define T0CS_position                            0x5
  #define T0CS_size                                0x1
  #define T0CS_value_mask                          0x20
  #define T0CS_clear_mask                          0xDF
  
  #define TMR0CS                                   0x5
  #define TMR0CS_address                           0x095
  #define TMR0CS_position                          0x5
  #define TMR0CS_size                              0x1
  #define TMR0CS_value_mask                        0x20
  #define TMR0CS_clear_mask                        0xDF
  
  #define INTEDG                                   0x6
  #define INTEDG_address                           0x095
  #define INTEDG_position                          0x6
  #define INTEDG_size                              0x1
  #define INTEDG_value_mask                        0x40
  #define INTEDG_clear_mask                        0xBF
  
  #define nWPUEN                                   0x7
  #define nWPUEN_address                           0x095
  #define nWPUEN_position                          0x7
  #define nWPUEN_size                              0x1
  #define nWPUEN_value_mask                        0x80
  #define nWPUEN_clear_mask                        0x7F
  
  
  /*-----------------------------------------------------#
  | PCON                                            0x96 |
  #------------------------------------------------------#
  | STKOVF | STKUNF | - | - | nRMCLR | nRI | nPOR | nBOR |
  #------------------------------------------------------#
  | 7      | 6      | 5 | 4 | 3      | 2   | 1    | 0    |
  #-----------------------------------------------------*/
  
  #define PCON                                     0x0
  #define PCON_address                             0x096
  #define PCON_position                            0x0
  #define PCON_size                                0x8
  #define PCON_value_mask                          0xFF
  #define PCON_clear_mask                          0x0
  
  #define nBOR                                     0x0
  #define nBOR_address                             0x096
  #define nBOR_position                            0x0
  #define nBOR_size                                0x1
  #define nBOR_value_mask                          0x1
  #define nBOR_clear_mask                          0xFE
  
  #define nPOR                                     0x1
  #define nPOR_address                             0x096
  #define nPOR_position                            0x1
  #define nPOR_size                                0x1
  #define nPOR_value_mask                          0x2
  #define nPOR_clear_mask                          0xFD
  
  #define nRI                                      0x2
  #define nRI_address                              0x096
  #define nRI_position                             0x2
  #define nRI_size                                 0x1
  #define nRI_value_mask                           0x4
  #define nRI_clear_mask                           0xFB
  
  #define nRMCLR                                   0x3
  #define nRMCLR_address                           0x096
  #define nRMCLR_position                          0x3
  #define nRMCLR_size                              0x1
  #define nRMCLR_value_mask                        0x8
  #define nRMCLR_clear_mask                        0xF7
  
  #define STKUNF                                   0x6
  #define STKUNF_address                           0x096
  #define STKUNF_position                          0x6
  #define STKUNF_size                              0x1
  #define STKUNF_value_mask                        0x40
  #define STKUNF_clear_mask                        0xBF
  
  #define STKOVF                                   0x7
  #define STKOVF_address                           0x096
  #define STKOVF_position                          0x7
  #define STKOVF_size                              0x1
  #define STKOVF_value_mask                        0x80
  #define STKOVF_clear_mask                        0x7F
  
  
  /*------------------------------------------------------------#
  | WDTCON                                                 0x97 |
  #-------------------------------------------------------------#
  | - | - | WDTPS4 | WDTPS3 | WDTPS2 | WDTPS1 | WDTPS0 | SWDTEN |
  #-------------------------------------------------------------#
  | 7 | 6 | 5      | 4      | 3      | 2      | 1      | 0      |
  #------------------------------------------------------------*/
  
  #define WDTCON                                   0x0
  #define WDTCON_address                           0x097
  #define WDTCON_position                          0x0
  #define WDTCON_size                              0x8
  #define WDTCON_value_mask                        0xFF
  #define WDTCON_clear_mask                        0x0
  
  #define SWDTEN                                   0x0
  #define SWDTEN_address                           0x097
  #define SWDTEN_position                          0x0
  #define SWDTEN_size                              0x1
  #define SWDTEN_value_mask                        0x1
  #define SWDTEN_clear_mask                        0xFE
  
  #define WDTPS                                    0x1
  #define WDTPS_address                            0x097
  #define WDTPS_position                           0x1
  #define WDTPS_size                               0x5
  #define WDTPS_value_mask                         0x3E
  #define WDTPS_clear_mask                         0xC1
  
  #define WDTPS0                                   0x1
  #define WDTPS0_address                           0x097
  #define WDTPS0_position                          0x1
  #define WDTPS0_size                              0x1
  #define WDTPS0_value_mask                        0x2
  #define WDTPS0_clear_mask                        0xFD
  
  #define WDTPS1                                   0x2
  #define WDTPS1_address                           0x097
  #define WDTPS1_position                          0x2
  #define WDTPS1_size                              0x1
  #define WDTPS1_value_mask                        0x4
  #define WDTPS1_clear_mask                        0xFB
  
  #define WDTPS2                                   0x3
  #define WDTPS2_address                           0x097
  #define WDTPS2_position                          0x3
  #define WDTPS2_size                              0x1
  #define WDTPS2_value_mask                        0x8
  #define WDTPS2_clear_mask                        0xF7
  
  #define WDTPS3                                   0x4
  #define WDTPS3_address                           0x097
  #define WDTPS3_position                          0x4
  #define WDTPS3_size                              0x1
  #define WDTPS3_value_mask                        0x10
  #define WDTPS3_clear_mask                        0xEF
  
  #define WDTPS4                                   0x5
  #define WDTPS4_address                           0x097
  #define WDTPS4_position                          0x5
  #define WDTPS4_size                              0x1
  #define WDTPS4_value_mask                        0x20
  #define WDTPS4_clear_mask                        0xDF
  
  
  /*------------------------------------------------#
  | OSCTUNE                                    0x98 |
  #-------------------------------------------------#
  | - | - | TUN5 | TUN4 | TUN3 | TUN2 | TUN1 | TUN0 |
  #-------------------------------------------------#
  | 7 | 6 | 5    | 4    | 3    | 2    | 1    | 0    |
  #------------------------------------------------*/
  
  #define OSCTUNE                                  0x0
  #define OSCTUNE_address                          0x098
  #define OSCTUNE_position                         0x0
  #define OSCTUNE_size                             0x8
  #define OSCTUNE_value_mask                       0xFF
  #define OSCTUNE_clear_mask                       0x0
  
  #define TUN0                                     0x0
  #define TUN0_address                             0x098
  #define TUN0_position                            0x0
  #define TUN0_size                                0x1
  #define TUN0_value_mask                          0x1
  #define TUN0_clear_mask                          0xFE
  
  #define TUN                                      0x0
  #define TUN_address                              0x098
  #define TUN_position                             0x0
  #define TUN_size                                 0x6
  #define TUN_value_mask                           0x3F
  #define TUN_clear_mask                           0xC0
  
  #define TUN1                                     0x1
  #define TUN1_address                             0x098
  #define TUN1_position                            0x1
  #define TUN1_size                                0x1
  #define TUN1_value_mask                          0x2
  #define TUN1_clear_mask                          0xFD
  
  #define TUN2                                     0x2
  #define TUN2_address                             0x098
  #define TUN2_position                            0x2
  #define TUN2_size                                0x1
  #define TUN2_value_mask                          0x4
  #define TUN2_clear_mask                          0xFB
  
  #define TUN3                                     0x3
  #define TUN3_address                             0x098
  #define TUN3_position                            0x3
  #define TUN3_size                                0x1
  #define TUN3_value_mask                          0x8
  #define TUN3_clear_mask                          0xF7
  
  #define TUN4                                     0x4
  #define TUN4_address                             0x098
  #define TUN4_position                            0x4
  #define TUN4_size                                0x1
  #define TUN4_value_mask                          0x10
  #define TUN4_clear_mask                          0xEF
  
  #define TUN5                                     0x5
  #define TUN5_address                             0x098
  #define TUN5_position                            0x5
  #define TUN5_size                                0x1
  #define TUN5_value_mask                          0x20
  #define TUN5_clear_mask                          0xDF
  
  
  /*---------------------------------------------------------#
  | OSCCON                                              0x99 |
  #----------------------------------------------------------#
  | SPLLEN | IRCF3 | IRCF2 | IRCF1 | IRCF0 | - | SCS1 | SCS0 |
  #----------------------------------------------------------#
  | 7      | 6     | 5     | 4     | 3     | 2 | 1    | 0    |
  #---------------------------------------------------------*/
  
  #define OSCCON                                   0x0
  #define OSCCON_address                           0x099
  #define OSCCON_position                          0x0
  #define OSCCON_size                              0x8
  #define OSCCON_value_mask                        0xFF
  #define OSCCON_clear_mask                        0x0
  
  #define SCS0                                     0x0
  #define SCS0_address                             0x099
  #define SCS0_position                            0x0
  #define SCS0_size                                0x1
  #define SCS0_value_mask                          0x1
  #define SCS0_clear_mask                          0xFE
  
  #define SCS                                      0x0
  #define SCS_address                              0x099
  #define SCS_position                             0x0
  #define SCS_size                                 0x2
  #define SCS_value_mask                           0x3
  #define SCS_clear_mask                           0xFC
  
  #define SCS1                                     0x1
  #define SCS1_address                             0x099
  #define SCS1_position                            0x1
  #define SCS1_size                                0x1
  #define SCS1_value_mask                          0x2
  #define SCS1_clear_mask                          0xFD
  
  #define IRCF                                     0x3
  #define IRCF_address                             0x099
  #define IRCF_position                            0x3
  #define IRCF_size                                0x4
  #define IRCF_value_mask                          0x78
  #define IRCF_clear_mask                          0x87
  
  #define IRCF0                                    0x3
  #define IRCF0_address                            0x099
  #define IRCF0_position                           0x3
  #define IRCF0_size                               0x1
  #define IRCF0_value_mask                         0x8
  #define IRCF0_clear_mask                         0xF7
  
  #define IRCF1                                    0x4
  #define IRCF1_address                            0x099
  #define IRCF1_position                           0x4
  #define IRCF1_size                               0x1
  #define IRCF1_value_mask                         0x10
  #define IRCF1_clear_mask                         0xEF
  
  #define IRCF2                                    0x5
  #define IRCF2_address                            0x099
  #define IRCF2_position                           0x5
  #define IRCF2_size                               0x1
  #define IRCF2_value_mask                         0x20
  #define IRCF2_clear_mask                         0xDF
  
  #define IRCF3                                    0x6
  #define IRCF3_address                            0x099
  #define IRCF3_position                           0x6
  #define IRCF3_size                               0x1
  #define IRCF3_value_mask                         0x40
  #define IRCF3_clear_mask                         0xBF
  
  #define SPLLEN                                   0x7
  #define SPLLEN_address                           0x099
  #define SPLLEN_position                          0x7
  #define SPLLEN_size                              0x1
  #define SPLLEN_value_mask                        0x80
  #define SPLLEN_clear_mask                        0x7F
  
  
  /*------------------------------------------------------------------#
  | OSCSTAT                                                      0x9A |
  #-------------------------------------------------------------------#
  | T1OSCR | PLLR | OSTS | HFIOFR | HFIOFL | MFIOFR | LFIOFR | HFIOFS |
  #-------------------------------------------------------------------#
  | 7      | 6    | 5    | 4      | 3      | 2      | 1      | 0      |
  #------------------------------------------------------------------*/
  
  #define OSCSTAT                                  0x0
  #define OSCSTAT_address                          0x09A
  #define OSCSTAT_position                         0x0
  #define OSCSTAT_size                             0x8
  #define OSCSTAT_value_mask                       0xFF
  #define OSCSTAT_clear_mask                       0x0
  
  #define HFIOFS                                   0x0
  #define HFIOFS_address                           0x09A
  #define HFIOFS_position                          0x0
  #define HFIOFS_size                              0x1
  #define HFIOFS_value_mask                        0x1
  #define HFIOFS_clear_mask                        0xFE
  
  #define LFIOFR                                   0x1
  #define LFIOFR_address                           0x09A
  #define LFIOFR_position                          0x1
  #define LFIOFR_size                              0x1
  #define LFIOFR_value_mask                        0x2
  #define LFIOFR_clear_mask                        0xFD
  
  #define MFIOFR                                   0x2
  #define MFIOFR_address                           0x09A
  #define MFIOFR_position                          0x2
  #define MFIOFR_size                              0x1
  #define MFIOFR_value_mask                        0x4
  #define MFIOFR_clear_mask                        0xFB
  
  #define HFIOFL                                   0x3
  #define HFIOFL_address                           0x09A
  #define HFIOFL_position                          0x3
  #define HFIOFL_size                              0x1
  #define HFIOFL_value_mask                        0x8
  #define HFIOFL_clear_mask                        0xF7
  
  #define HFIOFR                                   0x4
  #define HFIOFR_address                           0x09A
  #define HFIOFR_position                          0x4
  #define HFIOFR_size                              0x1
  #define HFIOFR_value_mask                        0x10
  #define HFIOFR_clear_mask                        0xEF
  
  #define OSTS                                     0x5
  #define OSTS_address                             0x09A
  #define OSTS_position                            0x5
  #define OSTS_size                                0x1
  #define OSTS_value_mask                          0x20
  #define OSTS_clear_mask                          0xDF
  
  #define PLLR                                     0x6
  #define PLLR_address                             0x09A
  #define PLLR_position                            0x6
  #define PLLR_size                                0x1
  #define PLLR_value_mask                          0x40
  #define PLLR_clear_mask                          0xBF
  
  #define T1OSCR                                   0x7
  #define T1OSCR_address                           0x09A
  #define T1OSCR_position                          0x7
  #define T1OSCR_size                              0x1
  #define T1OSCR_value_mask                        0x80
  #define T1OSCR_clear_mask                        0x7F
  
  
  /*------------------------------#
  | ADRESL                   0x9B |
  #-------------------------------#
  | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
  #------------------------------*/
  
  #define ADRESL                                   0x0
  #define ADRESL_address                           0x09B
  #define ADRESL_position                          0x0
  #define ADRESL_size                              0x8
  #define ADRESL_value_mask                        0xFF
  #define ADRESL_clear_mask                        0x0
  
  
  /*------------------------------#
  | ADRESH                   0x9C |
  #-------------------------------#
  | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
  #------------------------------*/
  
  #define ADRESH                                   0x0
  #define ADRESH_address                           0x09C
  #define ADRESH_position                          0x0
  #define ADRESH_size                              0x8
  #define ADRESH_value_mask                        0xFF
  #define ADRESH_clear_mask                        0x0
  
  
  /*----------------------------------------------------#
  | ADCON0                                         0x9D |
  #-----------------------------------------------------#
  | - | CHS4 | CHS3 | CHS2 | CHS1 | CHS0 | nDONE | ADON |
  #-----------------------------------------------------#
  | 7 | 6    | 5    | 4    | 3    | 2    | 1     | 0    |
  #----------------------------------------------------*/
  
  #define ADCON0                                   0x0
  #define ADCON0_address                           0x09D
  #define ADCON0_position                          0x0
  #define ADCON0_size                              0x8
  #define ADCON0_value_mask                        0xFF
  #define ADCON0_clear_mask                        0x0
  
  #define ADON                                     0x0
  #define ADON_address                             0x09D
  #define ADON_position                            0x0
  #define ADON_size                                0x1
  #define ADON_value_mask                          0x1
  #define ADON_clear_mask                          0xFE
  
  #define nDONE                                    0x1
  #define nDONE_address                            0x09D
  #define nDONE_position                           0x1
  #define nDONE_size                               0x1
  #define nDONE_value_mask                         0x2
  #define nDONE_clear_mask                         0xFD
  
  #define GO_nDONE                                 0x1
  #define GO_nDONE_address                         0x09D
  #define GO_nDONE_position                        0x1
  #define GO_nDONE_size                            0x1
  #define GO_nDONE_value_mask                      0x2
  #define GO_nDONE_clear_mask                      0xFD
  
  #define GO                                       0x1
  #define GO_address                               0x09D
  #define GO_position                              0x1
  #define GO_size                                  0x1
  #define GO_value_mask                            0x2
  #define GO_clear_mask                            0xFD
  
  #define ADGO                                     0x1
  #define ADGO_address                             0x09D
  #define ADGO_position                            0x1
  #define ADGO_size                                0x1
  #define ADGO_value_mask                          0x2
  #define ADGO_clear_mask                          0xFD
  
  #define CHS0                                     0x2
  #define CHS0_address                             0x09D
  #define CHS0_position                            0x2
  #define CHS0_size                                0x1
  #define CHS0_value_mask                          0x4
  #define CHS0_clear_mask                          0xFB
  
  #define CHS                                      0x2
  #define CHS_address                              0x09D
  #define CHS_position                             0x2
  #define CHS_size                                 0x5
  #define CHS_value_mask                           0x7C
  #define CHS_clear_mask                           0x83
  
  #define CHS1                                     0x3
  #define CHS1_address                             0x09D
  #define CHS1_position                            0x3
  #define CHS1_size                                0x1
  #define CHS1_value_mask                          0x8
  #define CHS1_clear_mask                          0xF7
  
  #define CHS2                                     0x4
  #define CHS2_address                             0x09D
  #define CHS2_position                            0x4
  #define CHS2_size                                0x1
  #define CHS2_value_mask                          0x10
  #define CHS2_clear_mask                          0xEF
  
  #define CHS3                                     0x5
  #define CHS3_address                             0x09D
  #define CHS3_position                            0x5
  #define CHS3_size                                0x1
  #define CHS3_value_mask                          0x20
  #define CHS3_clear_mask                          0xDF
  
  #define CHS4                                     0x6
  #define CHS4_address                             0x09D
  #define CHS4_position                            0x6
  #define CHS4_size                                0x1
  #define CHS4_value_mask                          0x40
  #define CHS4_clear_mask                          0xBF
  
  
  /*--------------------------------------------------------------#
  | ADCON1                                                   0x9E |
  #---------------------------------------------------------------#
  | ADFM | ADCS2 | ADCS1 | ADCS0 | - | ADNREF | ADPREF1 | ADPREF0 |
  #---------------------------------------------------------------#
  | 7    | 6     | 5     | 4     | 3 | 2      | 1       | 0       |
  #--------------------------------------------------------------*/
  
  #define ADCON1                                   0x0
  #define ADCON1_address                           0x09E
  #define ADCON1_position                          0x0
  #define ADCON1_size                              0x8
  #define ADCON1_value_mask                        0xFF
  #define ADCON1_clear_mask                        0x0
  
  #define ADPREF0                                  0x0
  #define ADPREF0_address                          0x09E
  #define ADPREF0_position                         0x0
  #define ADPREF0_size                             0x1
  #define ADPREF0_value_mask                       0x1
  #define ADPREF0_clear_mask                       0xFE
  
  #define ADPREF                                   0x0
  #define ADPREF_address                           0x09E
  #define ADPREF_position                          0x0
  #define ADPREF_size                              0x2
  #define ADPREF_value_mask                        0x3
  #define ADPREF_clear_mask                        0xFC
  
  #define ADPREF1                                  0x1
  #define ADPREF1_address                          0x09E
  #define ADPREF1_position                         0x1
  #define ADPREF1_size                             0x1
  #define ADPREF1_value_mask                       0x2
  #define ADPREF1_clear_mask                       0xFD
  
  #define ADNREF                                   0x2
  #define ADNREF_address                           0x09E
  #define ADNREF_position                          0x2
  #define ADNREF_size                              0x1
  #define ADNREF_value_mask                        0x4
  #define ADNREF_clear_mask                        0xFB
  
  #define ADCS0                                    0x4
  #define ADCS0_address                            0x09E
  #define ADCS0_position                           0x4
  #define ADCS0_size                               0x1
  #define ADCS0_value_mask                         0x10
  #define ADCS0_clear_mask                         0xEF
  
  #define ADCS                                     0x4
  #define ADCS_address                             0x09E
  #define ADCS_position                            0x4
  #define ADCS_size                                0x3
  #define ADCS_value_mask                          0x70
  #define ADCS_clear_mask                          0x8F
  
  #define ADCS1                                    0x5
  #define ADCS1_address                            0x09E
  #define ADCS1_position                           0x5
  #define ADCS1_size                               0x1
  #define ADCS1_value_mask                         0x20
  #define ADCS1_clear_mask                         0xDF
  
  #define ADCS2                                    0x6
  #define ADCS2_address                            0x09E
  #define ADCS2_position                           0x6
  #define ADCS2_size                               0x1
  #define ADCS2_value_mask                         0x40
  #define ADCS2_clear_mask                         0xBF
  
  #define ADFM                                     0x7
  #define ADFM_address                             0x09E
  #define ADFM_position                            0x7
  #define ADFM_size                                0x1
  #define ADFM_value_mask                          0x80
  #define ADFM_clear_mask                          0x7F
  
  
  /*--------------------------------------------------------------#
  | LATA                                                    0x10C |
  #---------------------------------------------------------------#
  | LATA7 | LATA6 | LATA5 | LATA4 | LATA3 | LATA2 | LATA1 | LATA0 |
  #---------------------------------------------------------------#
  | 7     | 6     | 5     | 4     | 3     | 2     | 1     | 0     |
  #--------------------------------------------------------------*/
  
  #define LATA                                     0x0
  #define LATA_address                             0x10C
  #define LATA_position                            0x0
  #define LATA_size                                0x8
  #define LATA_value_mask                          0xFF
  #define LATA_clear_mask                          0x0
  
  #define LATA0                                    0x0
  #define LATA0_address                            0x10C
  #define LATA0_position                           0x0
  #define LATA0_size                               0x1
  #define LATA0_value_mask                         0x1
  #define LATA0_clear_mask                         0xFE
  
  #define LATA1                                    0x1
  #define LATA1_address                            0x10C
  #define LATA1_position                           0x1
  #define LATA1_size                               0x1
  #define LATA1_value_mask                         0x2
  #define LATA1_clear_mask                         0xFD
  
  #define LATA2                                    0x2
  #define LATA2_address                            0x10C
  #define LATA2_position                           0x2
  #define LATA2_size                               0x1
  #define LATA2_value_mask                         0x4
  #define LATA2_clear_mask                         0xFB
  
  #define LATA3                                    0x3
  #define LATA3_address                            0x10C
  #define LATA3_position                           0x3
  #define LATA3_size                               0x1
  #define LATA3_value_mask                         0x8
  #define LATA3_clear_mask                         0xF7
  
  #define LATA4                                    0x4
  #define LATA4_address                            0x10C
  #define LATA4_position                           0x4
  #define LATA4_size                               0x1
  #define LATA4_value_mask                         0x10
  #define LATA4_clear_mask                         0xEF
  
  #define LATA5                                    0x5
  #define LATA5_address                            0x10C
  #define LATA5_position                           0x5
  #define LATA5_size                               0x1
  #define LATA5_value_mask                         0x20
  #define LATA5_clear_mask                         0xDF
  
  #define LATA6                                    0x6
  #define LATA6_address                            0x10C
  #define LATA6_position                           0x6
  #define LATA6_size                               0x1
  #define LATA6_value_mask                         0x40
  #define LATA6_clear_mask                         0xBF
  
  #define LATA7                                    0x7
  #define LATA7_address                            0x10C
  #define LATA7_position                           0x7
  #define LATA7_size                               0x1
  #define LATA7_value_mask                         0x80
  #define LATA7_clear_mask                         0x7F
  
  
  /*--------------------------------------------------------------#
  | LATB                                                    0x10D |
  #---------------------------------------------------------------#
  | LATB7 | LATB6 | LATB5 | LATB4 | LATB3 | LATB2 | LATB1 | LATB0 |
  #---------------------------------------------------------------#
  | 7     | 6     | 5     | 4     | 3     | 2     | 1     | 0     |
  #--------------------------------------------------------------*/
  
  #define LATB                                     0x0
  #define LATB_address                             0x10D
  #define LATB_position                            0x0
  #define LATB_size                                0x8
  #define LATB_value_mask                          0xFF
  #define LATB_clear_mask                          0x0
  
  #define LATB0                                    0x0
  #define LATB0_address                            0x10D
  #define LATB0_position                           0x0
  #define LATB0_size                               0x1
  #define LATB0_value_mask                         0x1
  #define LATB0_clear_mask                         0xFE
  
  #define LATB1                                    0x1
  #define LATB1_address                            0x10D
  #define LATB1_position                           0x1
  #define LATB1_size                               0x1
  #define LATB1_value_mask                         0x2
  #define LATB1_clear_mask                         0xFD
  
  #define LATB2                                    0x2
  #define LATB2_address                            0x10D
  #define LATB2_position                           0x2
  #define LATB2_size                               0x1
  #define LATB2_value_mask                         0x4
  #define LATB2_clear_mask                         0xFB
  
  #define LATB3                                    0x3
  #define LATB3_address                            0x10D
  #define LATB3_position                           0x3
  #define LATB3_size                               0x1
  #define LATB3_value_mask                         0x8
  #define LATB3_clear_mask                         0xF7
  
  #define LATB4                                    0x4
  #define LATB4_address                            0x10D
  #define LATB4_position                           0x4
  #define LATB4_size                               0x1
  #define LATB4_value_mask                         0x10
  #define LATB4_clear_mask                         0xEF
  
  #define LATB5                                    0x5
  #define LATB5_address                            0x10D
  #define LATB5_position                           0x5
  #define LATB5_size                               0x1
  #define LATB5_value_mask                         0x20
  #define LATB5_clear_mask                         0xDF
  
  #define LATB6                                    0x6
  #define LATB6_address                            0x10D
  #define LATB6_position                           0x6
  #define LATB6_size                               0x1
  #define LATB6_value_mask                         0x40
  #define LATB6_clear_mask                         0xBF
  
  #define LATB7                                    0x7
  #define LATB7_address                            0x10D
  #define LATB7_position                           0x7
  #define LATB7_size                               0x1
  #define LATB7_value_mask                         0x80
  #define LATB7_clear_mask                         0x7F
  
  
  /*--------------------------------------------------------------#
  | LATC                                                    0x10E |
  #---------------------------------------------------------------#
  | LATC7 | LATC6 | LATC5 | LATC4 | LATC3 | LATC2 | LATC1 | LATC0 |
  #---------------------------------------------------------------#
  | 7     | 6     | 5     | 4     | 3     | 2     | 1     | 0     |
  #--------------------------------------------------------------*/
  
  #define LATC                                     0x0
  #define LATC_address                             0x10E
  #define LATC_position                            0x0
  #define LATC_size                                0x8
  #define LATC_value_mask                          0xFF
  #define LATC_clear_mask                          0x0
  
  #define LATC0                                    0x0
  #define LATC0_address                            0x10E
  #define LATC0_position                           0x0
  #define LATC0_size                               0x1
  #define LATC0_value_mask                         0x1
  #define LATC0_clear_mask                         0xFE
  
  #define LATC1                                    0x1
  #define LATC1_address                            0x10E
  #define LATC1_position                           0x1
  #define LATC1_size                               0x1
  #define LATC1_value_mask                         0x2
  #define LATC1_clear_mask                         0xFD
  
  #define LATC2                                    0x2
  #define LATC2_address                            0x10E
  #define LATC2_position                           0x2
  #define LATC2_size                               0x1
  #define LATC2_value_mask                         0x4
  #define LATC2_clear_mask                         0xFB
  
  #define LATC3                                    0x3
  #define LATC3_address                            0x10E
  #define LATC3_position                           0x3
  #define LATC3_size                               0x1
  #define LATC3_value_mask                         0x8
  #define LATC3_clear_mask                         0xF7
  
  #define LATC4                                    0x4
  #define LATC4_address                            0x10E
  #define LATC4_position                           0x4
  #define LATC4_size                               0x1
  #define LATC4_value_mask                         0x10
  #define LATC4_clear_mask                         0xEF
  
  #define LATC5                                    0x5
  #define LATC5_address                            0x10E
  #define LATC5_position                           0x5
  #define LATC5_size                               0x1
  #define LATC5_value_mask                         0x20
  #define LATC5_clear_mask                         0xDF
  
  #define LATC6                                    0x6
  #define LATC6_address                            0x10E
  #define LATC6_position                           0x6
  #define LATC6_size                               0x1
  #define LATC6_value_mask                         0x40
  #define LATC6_clear_mask                         0xBF
  
  #define LATC7                                    0x7
  #define LATC7_address                            0x10E
  #define LATC7_position                           0x7
  #define LATC7_size                               0x1
  #define LATC7_value_mask                         0x80
  #define LATC7_clear_mask                         0x7F
  
  
  /*----------------------------------#
  | LATE                        0x110 |
  #-----------------------------------#
  | - | - | - | - | LATE3 | - | - | - |
  #-----------------------------------#
  | 7 | 6 | 5 | 4 | 3     | 2 | 1 | 0 |
  #----------------------------------*/
  
  #define LATE                                     0x0
  #define LATE_address                             0x110
  #define LATE_position                            0x0
  #define LATE_size                                0x8
  #define LATE_value_mask                          0xFF
  #define LATE_clear_mask                          0x0
  
  #define LATE3                                    0x3
  #define LATE3_address                            0x110
  #define LATE3_position                           0x3
  #define LATE3_size                               0x1
  #define LATE3_value_mask                         0x8
  #define LATE3_clear_mask                         0xF7
  
  
  /*--------------------------------------------------------#
  | CM1CON0                                           0x111 |
  #---------------------------------------------------------#
  | C1ON | C1OUT | C1OE | C1POL | - | C1SP | C1HYS | C1SYNC |
  #---------------------------------------------------------#
  | 7    | 6     | 5    | 4     | 3 | 2    | 1     | 0      |
  #--------------------------------------------------------*/
  
  #define CM1CON0                                  0x0
  #define CM1CON0_address                          0x111
  #define CM1CON0_position                         0x0
  #define CM1CON0_size                             0x8
  #define CM1CON0_value_mask                       0xFF
  #define CM1CON0_clear_mask                       0x0
  
  #define C1SYNC                                   0x0
  #define C1SYNC_address                           0x111
  #define C1SYNC_position                          0x0
  #define C1SYNC_size                              0x1
  #define C1SYNC_value_mask                        0x1
  #define C1SYNC_clear_mask                        0xFE
  
  #define C1HYS                                    0x1
  #define C1HYS_address                            0x111
  #define C1HYS_position                           0x1
  #define C1HYS_size                               0x1
  #define C1HYS_value_mask                         0x2
  #define C1HYS_clear_mask                         0xFD
  
  #define C1SP                                     0x2
  #define C1SP_address                             0x111
  #define C1SP_position                            0x2
  #define C1SP_size                                0x1
  #define C1SP_value_mask                          0x4
  #define C1SP_clear_mask                          0xFB
  
  #define C1POL                                    0x4
  #define C1POL_address                            0x111
  #define C1POL_position                           0x4
  #define C1POL_size                               0x1
  #define C1POL_value_mask                         0x10
  #define C1POL_clear_mask                         0xEF
  
  #define C1OE                                     0x5
  #define C1OE_address                             0x111
  #define C1OE_position                            0x5
  #define C1OE_size                                0x1
  #define C1OE_value_mask                          0x20
  #define C1OE_clear_mask                          0xDF
  
  #define C1OUT                                    0x6
  #define C1OUT_address                            0x111
  #define C1OUT_position                           0x6
  #define C1OUT_size                               0x1
  #define C1OUT_value_mask                         0x40
  #define C1OUT_clear_mask                         0xBF
  
  #define C1ON                                     0x7
  #define C1ON_address                             0x111
  #define C1ON_position                            0x7
  #define C1ON_size                                0x1
  #define C1ON_value_mask                          0x80
  #define C1ON_clear_mask                          0x7F
  
  
  /*------------------------------------------------------------#
  | CM1CON1                                               0x112 |
  #-------------------------------------------------------------#
  | C1INTP | C1INTN | C1PCH1 | C1PCH0 | - | - | C1NCH1 | C1NCH0 |
  #-------------------------------------------------------------#
  | 7      | 6      | 5      | 4      | 3 | 2 | 1      | 0      |
  #------------------------------------------------------------*/
  
  #define CM1CON1                                  0x0
  #define CM1CON1_address                          0x112
  #define CM1CON1_position                         0x0
  #define CM1CON1_size                             0x8
  #define CM1CON1_value_mask                       0xFF
  #define CM1CON1_clear_mask                       0x0
  
  #define C1NCH0                                   0x0
  #define C1NCH0_address                           0x112
  #define C1NCH0_position                          0x0
  #define C1NCH0_size                              0x1
  #define C1NCH0_value_mask                        0x1
  #define C1NCH0_clear_mask                        0xFE
  
  #define C1NCH                                    0x0
  #define C1NCH_address                            0x112
  #define C1NCH_position                           0x0
  #define C1NCH_size                               0x2
  #define C1NCH_value_mask                         0x3
  #define C1NCH_clear_mask                         0xFC
  
  #define C1NCH1                                   0x1
  #define C1NCH1_address                           0x112
  #define C1NCH1_position                          0x1
  #define C1NCH1_size                              0x1
  #define C1NCH1_value_mask                        0x2
  #define C1NCH1_clear_mask                        0xFD
  
  #define C1PCH                                    0x4
  #define C1PCH_address                            0x112
  #define C1PCH_position                           0x4
  #define C1PCH_size                               0x2
  #define C1PCH_value_mask                         0x30
  #define C1PCH_clear_mask                         0xCF
  
  #define C1PCH0                                   0x4
  #define C1PCH0_address                           0x112
  #define C1PCH0_position                          0x4
  #define C1PCH0_size                              0x1
  #define C1PCH0_value_mask                        0x10
  #define C1PCH0_clear_mask                        0xEF
  
  #define C1PCH1                                   0x5
  #define C1PCH1_address                           0x112
  #define C1PCH1_position                          0x5
  #define C1PCH1_size                              0x1
  #define C1PCH1_value_mask                        0x20
  #define C1PCH1_clear_mask                        0xDF
  
  #define C1INTN                                   0x6
  #define C1INTN_address                           0x112
  #define C1INTN_position                          0x6
  #define C1INTN_size                              0x1
  #define C1INTN_value_mask                        0x40
  #define C1INTN_clear_mask                        0xBF
  
  #define C1INTP                                   0x7
  #define C1INTP_address                           0x112
  #define C1INTP_position                          0x7
  #define C1INTP_size                              0x1
  #define C1INTP_value_mask                        0x80
  #define C1INTP_clear_mask                        0x7F
  
  
  /*--------------------------------------------------------#
  | CM2CON0                                           0x113 |
  #---------------------------------------------------------#
  | C2ON | C2OUT | C2OE | C2POL | - | C2SP | C2HYS | C2SYNC |
  #---------------------------------------------------------#
  | 7    | 6     | 5    | 4     | 3 | 2    | 1     | 0      |
  #--------------------------------------------------------*/
  
  #define CM2CON0                                  0x0
  #define CM2CON0_address                          0x113
  #define CM2CON0_position                         0x0
  #define CM2CON0_size                             0x8
  #define CM2CON0_value_mask                       0xFF
  #define CM2CON0_clear_mask                       0x0
  
  #define C2SYNC                                   0x0
  #define C2SYNC_address                           0x113
  #define C2SYNC_position                          0x0
  #define C2SYNC_size                              0x1
  #define C2SYNC_value_mask                        0x1
  #define C2SYNC_clear_mask                        0xFE
  
  #define C2HYS                                    0x1
  #define C2HYS_address                            0x113
  #define C2HYS_position                           0x1
  #define C2HYS_size                               0x1
  #define C2HYS_value_mask                         0x2
  #define C2HYS_clear_mask                         0xFD
  
  #define C2SP                                     0x2
  #define C2SP_address                             0x113
  #define C2SP_position                            0x2
  #define C2SP_size                                0x1
  #define C2SP_value_mask                          0x4
  #define C2SP_clear_mask                          0xFB
  
  #define C2POL                                    0x4
  #define C2POL_address                            0x113
  #define C2POL_position                           0x4
  #define C2POL_size                               0x1
  #define C2POL_value_mask                         0x10
  #define C2POL_clear_mask                         0xEF
  
  #define C2OE                                     0x5
  #define C2OE_address                             0x113
  #define C2OE_position                            0x5
  #define C2OE_size                                0x1
  #define C2OE_value_mask                          0x20
  #define C2OE_clear_mask                          0xDF
  
  #define C2OUT                                    0x6
  #define C2OUT_address                            0x113
  #define C2OUT_position                           0x6
  #define C2OUT_size                               0x1
  #define C2OUT_value_mask                         0x40
  #define C2OUT_clear_mask                         0xBF
  
  #define C2ON                                     0x7
  #define C2ON_address                             0x113
  #define C2ON_position                            0x7
  #define C2ON_size                                0x1
  #define C2ON_value_mask                          0x80
  #define C2ON_clear_mask                          0x7F
  
  
  /*------------------------------------------------------------#
  | CM2CON1                                               0x114 |
  #-------------------------------------------------------------#
  | C2INTP | C2INTN | C2PCH1 | C2PCH0 | - | - | C2NCH1 | C2NCH0 |
  #-------------------------------------------------------------#
  | 7      | 6      | 5      | 4      | 3 | 2 | 1      | 0      |
  #------------------------------------------------------------*/
  
  #define CM2CON1                                  0x0
  #define CM2CON1_address                          0x114
  #define CM2CON1_position                         0x0
  #define CM2CON1_size                             0x8
  #define CM2CON1_value_mask                       0xFF
  #define CM2CON1_clear_mask                       0x0
  
  #define C2NCH0                                   0x0
  #define C2NCH0_address                           0x114
  #define C2NCH0_position                          0x0
  #define C2NCH0_size                              0x1
  #define C2NCH0_value_mask                        0x1
  #define C2NCH0_clear_mask                        0xFE
  
  #define C2NCH                                    0x0
  #define C2NCH_address                            0x114
  #define C2NCH_position                           0x0
  #define C2NCH_size                               0x2
  #define C2NCH_value_mask                         0x3
  #define C2NCH_clear_mask                         0xFC
  
  #define C2NCH1                                   0x1
  #define C2NCH1_address                           0x114
  #define C2NCH1_position                          0x1
  #define C2NCH1_size                              0x1
  #define C2NCH1_value_mask                        0x2
  #define C2NCH1_clear_mask                        0xFD
  
  #define C2PCH                                    0x4
  #define C2PCH_address                            0x114
  #define C2PCH_position                           0x4
  #define C2PCH_size                               0x2
  #define C2PCH_value_mask                         0x30
  #define C2PCH_clear_mask                         0xCF
  
  #define C2PCH0                                   0x4
  #define C2PCH0_address                           0x114
  #define C2PCH0_position                          0x4
  #define C2PCH0_size                              0x1
  #define C2PCH0_value_mask                        0x10
  #define C2PCH0_clear_mask                        0xEF
  
  #define C2PCH1                                   0x5
  #define C2PCH1_address                           0x114
  #define C2PCH1_position                          0x5
  #define C2PCH1_size                              0x1
  #define C2PCH1_value_mask                        0x20
  #define C2PCH1_clear_mask                        0xDF
  
  #define C2INTN                                   0x6
  #define C2INTN_address                           0x114
  #define C2INTN_position                          0x6
  #define C2INTN_size                              0x1
  #define C2INTN_value_mask                        0x40
  #define C2INTN_clear_mask                        0xBF
  
  #define C2INTP                                   0x7
  #define C2INTP_address                           0x114
  #define C2INTP_position                          0x7
  #define C2INTP_size                              0x1
  #define C2INTP_value_mask                        0x80
  #define C2INTP_clear_mask                        0x7F
  
  
  /*----------------------------------------#
  | CMOUT                             0x115 |
  #-----------------------------------------#
  | - | - | - | - | - | - | MC2OUT | MC1OUT |
  #-----------------------------------------#
  | 7 | 6 | 5 | 4 | 3 | 2 | 1      | 0      |
  #----------------------------------------*/
  
  #define CMOUT                                    0x0
  #define CMOUT_address                            0x115
  #define CMOUT_position                           0x0
  #define CMOUT_size                               0x8
  #define CMOUT_value_mask                         0xFF
  #define CMOUT_clear_mask                         0x0
  
  #define MC1OUT                                   0x0
  #define MC1OUT_address                           0x115
  #define MC1OUT_position                          0x0
  #define MC1OUT_size                              0x1
  #define MC1OUT_value_mask                        0x1
  #define MC1OUT_clear_mask                        0xFE
  
  #define MC2OUT                                   0x1
  #define MC2OUT_address                           0x115
  #define MC2OUT_position                          0x1
  #define MC2OUT_size                              0x1
  #define MC2OUT_value_mask                        0x2
  #define MC2OUT_clear_mask                        0xFD
  
  
  /*----------------------------------------#
  | BORCON                            0x116 |
  #-----------------------------------------#
  | SBOREN | - | - | - | - | - | - | BORRDY |
  #-----------------------------------------#
  | 7      | 6 | 5 | 4 | 3 | 2 | 1 | 0      |
  #----------------------------------------*/
  
  #define BORCON                                   0x0
  #define BORCON_address                           0x116
  #define BORCON_position                          0x0
  #define BORCON_size                              0x8
  #define BORCON_value_mask                        0xFF
  #define BORCON_clear_mask                        0x0
  
  #define BORRDY                                   0x0
  #define BORRDY_address                           0x116
  #define BORRDY_position                          0x0
  #define BORRDY_size                              0x1
  #define BORRDY_value_mask                        0x1
  #define BORRDY_clear_mask                        0xFE
  
  #define SBOREN                                   0x7
  #define SBOREN_address                           0x116
  #define SBOREN_position                          0x7
  #define SBOREN_size                              0x1
  #define SBOREN_value_mask                        0x80
  #define SBOREN_clear_mask                        0x7F
  
  
  /*--------------------------------------------------------------------#
  | FVRCON                                                        0x117 |
  #---------------------------------------------------------------------#
  | FVREN | FVRRDY | TSEN | TSRNG | CDAFVR1 | CDAFVR0 | ADFVR1 | ADFVR0 |
  #---------------------------------------------------------------------#
  | 7     | 6      | 5    | 4     | 3       | 2       | 1      | 0      |
  #--------------------------------------------------------------------*/
  
  #define FVRCON                                   0x0
  #define FVRCON_address                           0x117
  #define FVRCON_position                          0x0
  #define FVRCON_size                              0x8
  #define FVRCON_value_mask                        0xFF
  #define FVRCON_clear_mask                        0x0
  
  #define ADFVR0                                   0x0
  #define ADFVR0_address                           0x117
  #define ADFVR0_position                          0x0
  #define ADFVR0_size                              0x1
  #define ADFVR0_value_mask                        0x1
  #define ADFVR0_clear_mask                        0xFE
  
  #define ADFVR                                    0x0
  #define ADFVR_address                            0x117
  #define ADFVR_position                           0x0
  #define ADFVR_size                               0x2
  #define ADFVR_value_mask                         0x3
  #define ADFVR_clear_mask                         0xFC
  
  #define ADFVR1                                   0x1
  #define ADFVR1_address                           0x117
  #define ADFVR1_position                          0x1
  #define ADFVR1_size                              0x1
  #define ADFVR1_value_mask                        0x2
  #define ADFVR1_clear_mask                        0xFD
  
  #define CDAFVR0                                  0x2
  #define CDAFVR0_address                          0x117
  #define CDAFVR0_position                         0x2
  #define CDAFVR0_size                             0x1
  #define CDAFVR0_value_mask                       0x4
  #define CDAFVR0_clear_mask                       0xFB
  
  #define CDAFVR                                   0x2
  #define CDAFVR_address                           0x117
  #define CDAFVR_position                          0x2
  #define CDAFVR_size                              0x2
  #define CDAFVR_value_mask                        0xC
  #define CDAFVR_clear_mask                        0xF3
  
  #define CDAFVR1                                  0x3
  #define CDAFVR1_address                          0x117
  #define CDAFVR1_position                         0x3
  #define CDAFVR1_size                             0x1
  #define CDAFVR1_value_mask                       0x8
  #define CDAFVR1_clear_mask                       0xF7
  
  #define TSRNG                                    0x4
  #define TSRNG_address                            0x117
  #define TSRNG_position                           0x4
  #define TSRNG_size                               0x1
  #define TSRNG_value_mask                         0x10
  #define TSRNG_clear_mask                         0xEF
  
  #define TSEN                                     0x5
  #define TSEN_address                             0x117
  #define TSEN_position                            0x5
  #define TSEN_size                                0x1
  #define TSEN_value_mask                          0x20
  #define TSEN_clear_mask                          0xDF
  
  #define FVRRDY                                   0x6
  #define FVRRDY_address                           0x117
  #define FVRRDY_position                          0x6
  #define FVRRDY_size                              0x1
  #define FVRRDY_value_mask                        0x40
  #define FVRRDY_clear_mask                        0xBF
  
  #define FVREN                                    0x7
  #define FVREN_address                            0x117
  #define FVREN_position                           0x7
  #define FVREN_size                               0x1
  #define FVREN_value_mask                         0x80
  #define FVREN_clear_mask                         0x7F
  
  
  /*------------------------------------------------------------#
  | DACCON0                                               0x118 |
  #-------------------------------------------------------------#
  | DACEN | DACLPS | DACOE | - | DACPSS1 | DACPSS0 | - | DACNSS |
  #-------------------------------------------------------------#
  | 7     | 6      | 5     | 4 | 3       | 2       | 1 | 0      |
  #------------------------------------------------------------*/
  
  #define DACCON0                                  0x0
  #define DACCON0_address                          0x118
  #define DACCON0_position                         0x0
  #define DACCON0_size                             0x8
  #define DACCON0_value_mask                       0xFF
  #define DACCON0_clear_mask                       0x0
  
  #define DACNSS                                   0x0
  #define DACNSS_address                           0x118
  #define DACNSS_position                          0x0
  #define DACNSS_size                              0x1
  #define DACNSS_value_mask                        0x1
  #define DACNSS_clear_mask                        0xFE
  
  #define DACPSS                                   0x2
  #define DACPSS_address                           0x118
  #define DACPSS_position                          0x2
  #define DACPSS_size                              0x2
  #define DACPSS_value_mask                        0xC
  #define DACPSS_clear_mask                        0xF3
  
  #define DACPSS0                                  0x2
  #define DACPSS0_address                          0x118
  #define DACPSS0_position                         0x2
  #define DACPSS0_size                             0x1
  #define DACPSS0_value_mask                       0x4
  #define DACPSS0_clear_mask                       0xFB
  
  #define DACPSS1                                  0x3
  #define DACPSS1_address                          0x118
  #define DACPSS1_position                         0x3
  #define DACPSS1_size                             0x1
  #define DACPSS1_value_mask                       0x8
  #define DACPSS1_clear_mask                       0xF7
  
  #define DACOE                                    0x5
  #define DACOE_address                            0x118
  #define DACOE_position                           0x5
  #define DACOE_size                               0x1
  #define DACOE_value_mask                         0x20
  #define DACOE_clear_mask                         0xDF
  
  #define DACLPS                                   0x6
  #define DACLPS_address                           0x118
  #define DACLPS_position                          0x6
  #define DACLPS_size                              0x1
  #define DACLPS_value_mask                        0x40
  #define DACLPS_clear_mask                        0xBF
  
  #define DACEN                                    0x7
  #define DACEN_address                            0x118
  #define DACEN_position                           0x7
  #define DACEN_size                               0x1
  #define DACEN_value_mask                         0x80
  #define DACEN_clear_mask                         0x7F
  
  
  /*--------------------------------------------------#
  | DACCON1                                     0x119 |
  #---------------------------------------------------#
  | - | - | - | DACR4 | DACR3 | DACR2 | DACR1 | DACR0 |
  #---------------------------------------------------#
  | 7 | 6 | 5 | 4     | 3     | 2     | 1     | 0     |
  #--------------------------------------------------*/
  
  #define DACCON1                                  0x0
  #define DACCON1_address                          0x119
  #define DACCON1_position                         0x0
  #define DACCON1_size                             0x8
  #define DACCON1_value_mask                       0xFF
  #define DACCON1_clear_mask                       0x0
  
  #define DACR0                                    0x0
  #define DACR0_address                            0x119
  #define DACR0_position                           0x0
  #define DACR0_size                               0x1
  #define DACR0_value_mask                         0x1
  #define DACR0_clear_mask                         0xFE
  
  #define DACR                                     0x0
  #define DACR_address                             0x119
  #define DACR_position                            0x0
  #define DACR_size                                0x5
  #define DACR_value_mask                          0x1F
  #define DACR_clear_mask                          0xE0
  
  #define DACR1                                    0x1
  #define DACR1_address                            0x119
  #define DACR1_position                           0x1
  #define DACR1_size                               0x1
  #define DACR1_value_mask                         0x2
  #define DACR1_clear_mask                         0xFD
  
  #define DACR2                                    0x2
  #define DACR2_address                            0x119
  #define DACR2_position                           0x2
  #define DACR2_size                               0x1
  #define DACR2_value_mask                         0x4
  #define DACR2_clear_mask                         0xFB
  
  #define DACR3                                    0x3
  #define DACR3_address                            0x119
  #define DACR3_position                           0x3
  #define DACR3_size                               0x1
  #define DACR3_value_mask                         0x8
  #define DACR3_clear_mask                         0xF7
  
  #define DACR4                                    0x4
  #define DACR4_address                            0x119
  #define DACR4_position                           0x4
  #define DACR4_size                               0x1
  #define DACR4_value_mask                         0x10
  #define DACR4_clear_mask                         0xEF
  
  
  /*----------------------------------------------------------------#
  | SRCON0                                                    0x11A |
  #-----------------------------------------------------------------#
  | SRLEN | SRCLK2 | SRCLK1 | SRCLK0 | SRQEN | SRNQEN | SRPS | SRPR |
  #-----------------------------------------------------------------#
  | 7     | 6      | 5      | 4      | 3     | 2      | 1    | 0    |
  #----------------------------------------------------------------*/
  
  #define SRCON0                                   0x0
  #define SRCON0_address                           0x11A
  #define SRCON0_position                          0x0
  #define SRCON0_size                              0x8
  #define SRCON0_value_mask                        0xFF
  #define SRCON0_clear_mask                        0x0
  
  #define SRPR                                     0x0
  #define SRPR_address                             0x11A
  #define SRPR_position                            0x0
  #define SRPR_size                                0x1
  #define SRPR_value_mask                          0x1
  #define SRPR_clear_mask                          0xFE
  
  #define SRPS                                     0x1
  #define SRPS_address                             0x11A
  #define SRPS_position                            0x1
  #define SRPS_size                                0x1
  #define SRPS_value_mask                          0x2
  #define SRPS_clear_mask                          0xFD
  
  #define SRNQEN                                   0x2
  #define SRNQEN_address                           0x11A
  #define SRNQEN_position                          0x2
  #define SRNQEN_size                              0x1
  #define SRNQEN_value_mask                        0x4
  #define SRNQEN_clear_mask                        0xFB
  
  #define SRQEN                                    0x3
  #define SRQEN_address                            0x11A
  #define SRQEN_position                           0x3
  #define SRQEN_size                               0x1
  #define SRQEN_value_mask                         0x8
  #define SRQEN_clear_mask                         0xF7
  
  #define SRCLK0                                   0x4
  #define SRCLK0_address                           0x11A
  #define SRCLK0_position                          0x4
  #define SRCLK0_size                              0x1
  #define SRCLK0_value_mask                        0x10
  #define SRCLK0_clear_mask                        0xEF
  
  #define SRCLK                                    0x4
  #define SRCLK_address                            0x11A
  #define SRCLK_position                           0x4
  #define SRCLK_size                               0x3
  #define SRCLK_value_mask                         0x70
  #define SRCLK_clear_mask                         0x8F
  
  #define SRCLK1                                   0x5
  #define SRCLK1_address                           0x11A
  #define SRCLK1_position                          0x5
  #define SRCLK1_size                              0x1
  #define SRCLK1_value_mask                        0x20
  #define SRCLK1_clear_mask                        0xDF
  
  #define SRCLK2                                   0x6
  #define SRCLK2_address                           0x11A
  #define SRCLK2_position                          0x6
  #define SRCLK2_size                              0x1
  #define SRCLK2_value_mask                        0x40
  #define SRCLK2_clear_mask                        0xBF
  
  #define SRLEN                                    0x7
  #define SRLEN_address                            0x11A
  #define SRLEN_position                           0x7
  #define SRLEN_size                               0x1
  #define SRLEN_value_mask                         0x80
  #define SRLEN_clear_mask                         0x7F
  
  
  /*--------------------------------------------------------------------#
  | SRCON1                                                        0x11B |
  #---------------------------------------------------------------------#
  | SRSPE | SRSCKE | SRSC2E | SRSC1E | SRRPE | SRRCKE | SRRC2E | SRRC1E |
  #---------------------------------------------------------------------#
  | 7     | 6      | 5      | 4      | 3     | 2      | 1      | 0      |
  #--------------------------------------------------------------------*/
  
  #define SRCON1                                   0x0
  #define SRCON1_address                           0x11B
  #define SRCON1_position                          0x0
  #define SRCON1_size                              0x8
  #define SRCON1_value_mask                        0xFF
  #define SRCON1_clear_mask                        0x0
  
  #define SRRC1E                                   0x0
  #define SRRC1E_address                           0x11B
  #define SRRC1E_position                          0x0
  #define SRRC1E_size                              0x1
  #define SRRC1E_value_mask                        0x1
  #define SRRC1E_clear_mask                        0xFE
  
  #define SRRC2E                                   0x1
  #define SRRC2E_address                           0x11B
  #define SRRC2E_position                          0x1
  #define SRRC2E_size                              0x1
  #define SRRC2E_value_mask                        0x2
  #define SRRC2E_clear_mask                        0xFD
  
  #define SRRCKE                                   0x2
  #define SRRCKE_address                           0x11B
  #define SRRCKE_position                          0x2
  #define SRRCKE_size                              0x1
  #define SRRCKE_value_mask                        0x4
  #define SRRCKE_clear_mask                        0xFB
  
  #define SRRPE                                    0x3
  #define SRRPE_address                            0x11B
  #define SRRPE_position                           0x3
  #define SRRPE_size                               0x1
  #define SRRPE_value_mask                         0x8
  #define SRRPE_clear_mask                         0xF7
  
  #define SRSC1E                                   0x4
  #define SRSC1E_address                           0x11B
  #define SRSC1E_position                          0x4
  #define SRSC1E_size                              0x1
  #define SRSC1E_value_mask                        0x10
  #define SRSC1E_clear_mask                        0xEF
  
  #define SRSC2E                                   0x5
  #define SRSC2E_address                           0x11B
  #define SRSC2E_position                          0x5
  #define SRSC2E_size                              0x1
  #define SRSC2E_value_mask                        0x20
  #define SRSC2E_clear_mask                        0xDF
  
  #define SRSCKE                                   0x6
  #define SRSCKE_address                           0x11B
  #define SRSCKE_position                          0x6
  #define SRSCKE_size                              0x1
  #define SRSCKE_value_mask                        0x40
  #define SRSCKE_clear_mask                        0xBF
  
  #define SRSPE                                    0x7
  #define SRSPE_address                            0x11B
  #define SRSPE_position                           0x7
  #define SRSPE_size                               0x1
  #define SRSPE_value_mask                         0x80
  #define SRSPE_clear_mask                         0x7F
  
  
  /*---------------------------------------------------------------------#
  | APFCON                                                         0x11D |
  #----------------------------------------------------------------------#
  | - | CCP3SEL | T1GSEL | P2BSEL | SRNQSEL | C2OUTSEL | SSSEL | CCP2SEL |
  #----------------------------------------------------------------------#
  | 7 | 6       | 5      | 4      | 3       | 2        | 1     | 0       |
  #---------------------------------------------------------------------*/
  
  #define APFCON                                   0x0
  #define APFCON_address                           0x11D
  #define APFCON_position                          0x0
  #define APFCON_size                              0x8
  #define APFCON_value_mask                        0xFF
  #define APFCON_clear_mask                        0x0
  
  #define CCP2SEL                                  0x0
  #define CCP2SEL_address                          0x11D
  #define CCP2SEL_position                         0x0
  #define CCP2SEL_size                             0x1
  #define CCP2SEL_value_mask                       0x1
  #define CCP2SEL_clear_mask                       0xFE
  
  #define SSSEL                                    0x1
  #define SSSEL_address                            0x11D
  #define SSSEL_position                           0x1
  #define SSSEL_size                               0x1
  #define SSSEL_value_mask                         0x2
  #define SSSEL_clear_mask                         0xFD
  
  #define C2OUTSEL                                 0x2
  #define C2OUTSEL_address                         0x11D
  #define C2OUTSEL_position                        0x2
  #define C2OUTSEL_size                            0x1
  #define C2OUTSEL_value_mask                      0x4
  #define C2OUTSEL_clear_mask                      0xFB
  
  #define SRNQSEL                                  0x3
  #define SRNQSEL_address                          0x11D
  #define SRNQSEL_position                         0x3
  #define SRNQSEL_size                             0x1
  #define SRNQSEL_value_mask                       0x8
  #define SRNQSEL_clear_mask                       0xF7
  
  #define P2BSEL                                   0x4
  #define P2BSEL_address                           0x11D
  #define P2BSEL_position                          0x4
  #define P2BSEL_size                              0x1
  #define P2BSEL_value_mask                        0x10
  #define P2BSEL_clear_mask                        0xEF
  
  #define T1GSEL                                   0x5
  #define T1GSEL_address                           0x11D
  #define T1GSEL_position                          0x5
  #define T1GSEL_size                              0x1
  #define T1GSEL_value_mask                        0x20
  #define T1GSEL_clear_mask                        0xDF
  
  #define CCP3SEL                                  0x6
  #define CCP3SEL_address                          0x11D
  #define CCP3SEL_position                         0x6
  #define CCP3SEL_size                             0x1
  #define CCP3SEL_value_mask                       0x40
  #define CCP3SEL_clear_mask                       0xBF
  
  
  /*------------------------------------------------------#
  | ANSELA                                          0x18C |
  #-------------------------------------------------------#
  | - | - | ANSA5 | ANSA4 | ANSA3 | ANSA2 | ANSA1 | ANSA0 |
  #-------------------------------------------------------#
  | 7 | 6 | 5     | 4     | 3     | 2     | 1     | 0     |
  #------------------------------------------------------*/
  
  #define ANSA0                                    0x0
  #define ANSA0_address                            0x18C
  #define ANSA0_position                           0x0
  #define ANSA0_size                               0x1
  #define ANSA0_value_mask                         0x1
  #define ANSA0_clear_mask                         0xFE
  
  #define ANSELA                                   0x0
  #define ANSELA_address                           0x18C
  #define ANSELA_position                          0x0
  #define ANSELA_size                              0x6
  #define ANSELA_value_mask                        0x3F
  #define ANSELA_clear_mask                        0xC0
  
  #define ANSA1                                    0x1
  #define ANSA1_address                            0x18C
  #define ANSA1_position                           0x1
  #define ANSA1_size                               0x1
  #define ANSA1_value_mask                         0x2
  #define ANSA1_clear_mask                         0xFD
  
  #define ANSA2                                    0x2
  #define ANSA2_address                            0x18C
  #define ANSA2_position                           0x2
  #define ANSA2_size                               0x1
  #define ANSA2_value_mask                         0x4
  #define ANSA2_clear_mask                         0xFB
  
  #define ANSA3                                    0x3
  #define ANSA3_address                            0x18C
  #define ANSA3_position                           0x3
  #define ANSA3_size                               0x1
  #define ANSA3_value_mask                         0x8
  #define ANSA3_clear_mask                         0xF7
  
  #define ANSA4                                    0x4
  #define ANSA4_address                            0x18C
  #define ANSA4_position                           0x4
  #define ANSA4_size                               0x1
  #define ANSA4_value_mask                         0x10
  #define ANSA4_clear_mask                         0xEF
  
  #define ANSA5                                    0x5
  #define ANSA5_address                            0x18C
  #define ANSA5_position                           0x5
  #define ANSA5_size                               0x1
  #define ANSA5_value_mask                         0x20
  #define ANSA5_clear_mask                         0xDF
  
  
  /*------------------------------------------------------#
  | ANSELB                                          0x18D |
  #-------------------------------------------------------#
  | - | - | ANSB5 | ANSB4 | ANSB3 | ANSB2 | ANSB1 | ANSB0 |
  #-------------------------------------------------------#
  | 7 | 6 | 5     | 4     | 3     | 2     | 1     | 0     |
  #------------------------------------------------------*/
  
  #define ANSB0                                    0x0
  #define ANSB0_address                            0x18D
  #define ANSB0_position                           0x0
  #define ANSB0_size                               0x1
  #define ANSB0_value_mask                         0x1
  #define ANSB0_clear_mask                         0xFE
  
  #define ANSELB                                   0x0
  #define ANSELB_address                           0x18D
  #define ANSELB_position                          0x0
  #define ANSELB_size                              0x6
  #define ANSELB_value_mask                        0x3F
  #define ANSELB_clear_mask                        0xC0
  
  #define ANSB1                                    0x1
  #define ANSB1_address                            0x18D
  #define ANSB1_position                           0x1
  #define ANSB1_size                               0x1
  #define ANSB1_value_mask                         0x2
  #define ANSB1_clear_mask                         0xFD
  
  #define ANSB2                                    0x2
  #define ANSB2_address                            0x18D
  #define ANSB2_position                           0x2
  #define ANSB2_size                               0x1
  #define ANSB2_value_mask                         0x4
  #define ANSB2_clear_mask                         0xFB
  
  #define ANSB3                                    0x3
  #define ANSB3_address                            0x18D
  #define ANSB3_position                           0x3
  #define ANSB3_size                               0x1
  #define ANSB3_value_mask                         0x8
  #define ANSB3_clear_mask                         0xF7
  
  #define ANSB4                                    0x4
  #define ANSB4_address                            0x18D
  #define ANSB4_position                           0x4
  #define ANSB4_size                               0x1
  #define ANSB4_value_mask                         0x10
  #define ANSB4_clear_mask                         0xEF
  
  #define ANSB5                                    0x5
  #define ANSB5_address                            0x18D
  #define ANSB5_position                           0x5
  #define ANSB5_size                               0x1
  #define ANSB5_value_mask                         0x20
  #define ANSB5_clear_mask                         0xDF
  
  
  /*------------------------------#
  | EEADRL                  0x191 |
  #-------------------------------#
  | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
  #------------------------------*/
  
  #define EEADRL                                   0x0
  #define EEADRL_address                           0x191
  #define EEADRL_position                          0x0
  #define EEADRL_size                              0x8
  #define EEADRL_value_mask                        0xFF
  #define EEADRL_clear_mask                        0x0
  
  
  /*------------------------------#
  | EEADRH                  0x192 |
  #-------------------------------#
  | - | EEADRH                    |
  #-------------------------------#
  | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
  #------------------------------*/
  
  #define EEADRH                                   0x0
  #define EEADRH_address                           0x192
  #define EEADRH_position                          0x0
  #define EEADRH_size                              0x7
  #define EEADRH_value_mask                        0x7F
  #define EEADRH_clear_mask                        0x80
  
  
  /*------------------------------#
  | EEDATL                  0x193 |
  #-------------------------------#
  | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
  #------------------------------*/
  
  #define EEDATL                                   0x0
  #define EEDATL_address                           0x193
  #define EEDATL_position                          0x0
  #define EEDATL_size                              0x8
  #define EEDATL_value_mask                        0xFF
  #define EEDATL_clear_mask                        0x0
  
  
  /*------------------------------#
  | EEDATH                  0x194 |
  #-------------------------------#
  | - | - | EEDATH                |
  #-------------------------------#
  | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
  #------------------------------*/
  
  #define EEDATH                                   0x0
  #define EEDATH_address                           0x194
  #define EEDATH_position                          0x0
  #define EEDATH_size                              0x6
  #define EEDATH_value_mask                        0x3F
  #define EEDATH_clear_mask                        0xC0
  
  
  /*----------------------------------------------------#
  | EECON1                                        0x195 |
  #-----------------------------------------------------#
  | EEPGD | CFGS | LWLO | FREE | WRERR | WREN | WR | RD |
  #-----------------------------------------------------#
  | 7     | 6    | 5    | 4    | 3     | 2    | 1  | 0  |
  #----------------------------------------------------*/
  
  #define EECON1                                   0x0
  #define EECON1_address                           0x195
  #define EECON1_position                          0x0
  #define EECON1_size                              0x8
  #define EECON1_value_mask                        0xFF
  #define EECON1_clear_mask                        0x0
  
  #define RD                                       0x0
  #define RD_address                               0x195
  #define RD_position                              0x0
  #define RD_size                                  0x1
  #define RD_value_mask                            0x1
  #define RD_clear_mask                            0xFE
  
  #define WR                                       0x1
  #define WR_address                               0x195
  #define WR_position                              0x1
  #define WR_size                                  0x1
  #define WR_value_mask                            0x2
  #define WR_clear_mask                            0xFD
  
  #define WREN                                     0x2
  #define WREN_address                             0x195
  #define WREN_position                            0x2
  #define WREN_size                                0x1
  #define WREN_value_mask                          0x4
  #define WREN_clear_mask                          0xFB
  
  #define WRERR                                    0x3
  #define WRERR_address                            0x195
  #define WRERR_position                           0x3
  #define WRERR_size                               0x1
  #define WRERR_value_mask                         0x8
  #define WRERR_clear_mask                         0xF7
  
  #define FREE                                     0x4
  #define FREE_address                             0x195
  #define FREE_position                            0x4
  #define FREE_size                                0x1
  #define FREE_value_mask                          0x10
  #define FREE_clear_mask                          0xEF
  
  #define LWLO                                     0x5
  #define LWLO_address                             0x195
  #define LWLO_position                            0x5
  #define LWLO_size                                0x1
  #define LWLO_value_mask                          0x20
  #define LWLO_clear_mask                          0xDF
  
  #define CFGS                                     0x6
  #define CFGS_address                             0x195
  #define CFGS_position                            0x6
  #define CFGS_size                                0x1
  #define CFGS_value_mask                          0x40
  #define CFGS_clear_mask                          0xBF
  
  #define EEPGD                                    0x7
  #define EEPGD_address                            0x195
  #define EEPGD_position                           0x7
  #define EEPGD_size                               0x1
  #define EEPGD_value_mask                         0x80
  #define EEPGD_clear_mask                         0x7F
  
  
  /*------------------------------#
  | EECON2                  0x196 |
  #-------------------------------#
  | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
  #------------------------------*/
  
  #define EECON2                                   0x0
  #define EECON2_address                           0x196
  #define EECON2_position                          0x0
  #define EECON2_size                              0x8
  #define EECON2_value_mask                        0xFF
  #define EECON2_clear_mask                        0x0
  
  
  /*------------------------------#
  | RCREG                   0x199 |
  #-------------------------------#
  | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
  #------------------------------*/
  
  #define RCREG                                    0x0
  #define RCREG_address                            0x199
  #define RCREG_position                           0x0
  #define RCREG_size                               0x8
  #define RCREG_value_mask                         0xFF
  #define RCREG_clear_mask                         0x0
  
  
  /*------------------------------#
  | TXREG                   0x19A |
  #-------------------------------#
  | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
  #------------------------------*/
  
  #define TXREG                                    0x0
  #define TXREG_address                            0x19A
  #define TXREG_position                           0x0
  #define TXREG_size                               0x8
  #define TXREG_value_mask                         0xFF
  #define TXREG_clear_mask                         0x0
  
  
  /*------------------------------#
  | SP1BRGL                 0x19B |
  #-------------------------------#
  | SPBRGL                        |
  #-------------------------------#
  | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
  #------------------------------*/
  
  #define SP1BRGL                                  0x0
  #define SP1BRGL_address                          0x19B
  #define SP1BRGL_position                         0x0
  #define SP1BRGL_size                             0x8
  #define SP1BRGL_value_mask                       0xFF
  #define SP1BRGL_clear_mask                       0x0
  
  #define SPBRGL                                   0x0
  #define SPBRGL_address                           0x19B
  #define SPBRGL_position                          0x0
  #define SPBRGL_size                              0x8
  #define SPBRGL_value_mask                        0xFF
  #define SPBRGL_clear_mask                        0x0
  
  
  /*------------------------------#
  | SP1BRGH                 0x19C |
  #-------------------------------#
  | SPBRGH                        |
  #-------------------------------#
  | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
  #------------------------------*/
  
  #define SP1BRGH                                  0x0
  #define SP1BRGH_address                          0x19C
  #define SP1BRGH_position                         0x0
  #define SP1BRGH_size                             0x8
  #define SP1BRGH_value_mask                       0xFF
  #define SP1BRGH_clear_mask                       0x0
  
  #define SPBRGH                                   0x0
  #define SPBRGH_address                           0x19C
  #define SPBRGH_position                          0x0
  #define SPBRGH_size                              0x8
  #define SPBRGH_value_mask                        0xFF
  #define SPBRGH_clear_mask                        0x0
  
  
  /*------------------------------------------------------#
  | RCSTA                                           0x19D |
  #-------------------------------------------------------#
  | SPEN | RX9 | SREN | CREN | ADDEN | FERR | OERR | RX9D |
  #-------------------------------------------------------#
  | 7    | 6   | 5    | 4    | 3     | 2    | 1    | 0    |
  #------------------------------------------------------*/
  
  #define RCSTA                                    0x0
  #define RCSTA_address                            0x19D
  #define RCSTA_position                           0x0
  #define RCSTA_size                               0x8
  #define RCSTA_value_mask                         0xFF
  #define RCSTA_clear_mask                         0x0
  
  #define RX9D                                     0x0
  #define RX9D_address                             0x19D
  #define RX9D_position                            0x0
  #define RX9D_size                                0x1
  #define RX9D_value_mask                          0x1
  #define RX9D_clear_mask                          0xFE
  
  #define OERR                                     0x1
  #define OERR_address                             0x19D
  #define OERR_position                            0x1
  #define OERR_size                                0x1
  #define OERR_value_mask                          0x2
  #define OERR_clear_mask                          0xFD
  
  #define FERR                                     0x2
  #define FERR_address                             0x19D
  #define FERR_position                            0x2
  #define FERR_size                                0x1
  #define FERR_value_mask                          0x4
  #define FERR_clear_mask                          0xFB
  
  #define ADDEN                                    0x3
  #define ADDEN_address                            0x19D
  #define ADDEN_position                           0x3
  #define ADDEN_size                               0x1
  #define ADDEN_value_mask                         0x8
  #define ADDEN_clear_mask                         0xF7
  
  #define CREN                                     0x4
  #define CREN_address                             0x19D
  #define CREN_position                            0x4
  #define CREN_size                                0x1
  #define CREN_value_mask                          0x10
  #define CREN_clear_mask                          0xEF
  
  #define SREN                                     0x5
  #define SREN_address                             0x19D
  #define SREN_position                            0x5
  #define SREN_size                                0x1
  #define SREN_value_mask                          0x20
  #define SREN_clear_mask                          0xDF
  
  #define RX9                                      0x6
  #define RX9_address                              0x19D
  #define RX9_position                             0x6
  #define RX9_size                                 0x1
  #define RX9_value_mask                           0x40
  #define RX9_clear_mask                           0xBF
  
  #define SPEN                                     0x7
  #define SPEN_address                             0x19D
  #define SPEN_position                            0x7
  #define SPEN_size                                0x1
  #define SPEN_value_mask                          0x80
  #define SPEN_clear_mask                          0x7F
  
  
  /*------------------------------------------------------#
  | TXSTA                                           0x19E |
  #-------------------------------------------------------#
  | CSRC | TX9 | TXEN | SYNC | SENDB | BRGH | TRMT | TX9D |
  #-------------------------------------------------------#
  | 7    | 6   | 5    | 4    | 3     | 2    | 1    | 0    |
  #------------------------------------------------------*/
  
  #define TXSTA                                    0x0
  #define TXSTA_address                            0x19E
  #define TXSTA_position                           0x0
  #define TXSTA_size                               0x8
  #define TXSTA_value_mask                         0xFF
  #define TXSTA_clear_mask                         0x0
  
  #define TX9D                                     0x0
  #define TX9D_address                             0x19E
  #define TX9D_position                            0x0
  #define TX9D_size                                0x1
  #define TX9D_value_mask                          0x1
  #define TX9D_clear_mask                          0xFE
  
  #define TRMT                                     0x1
  #define TRMT_address                             0x19E
  #define TRMT_position                            0x1
  #define TRMT_size                                0x1
  #define TRMT_value_mask                          0x2
  #define TRMT_clear_mask                          0xFD
  
  #define BRGH                                     0x2
  #define BRGH_address                             0x19E
  #define BRGH_position                            0x2
  #define BRGH_size                                0x1
  #define BRGH_value_mask                          0x4
  #define BRGH_clear_mask                          0xFB
  
  #define SENDB                                    0x3
  #define SENDB_address                            0x19E
  #define SENDB_position                           0x3
  #define SENDB_size                               0x1
  #define SENDB_value_mask                         0x8
  #define SENDB_clear_mask                         0xF7
  
  #define SYNC                                     0x4
  #define SYNC_address                             0x19E
  #define SYNC_position                            0x4
  #define SYNC_size                                0x1
  #define SYNC_value_mask                          0x10
  #define SYNC_clear_mask                          0xEF
  
  #define TXEN                                     0x5
  #define TXEN_address                             0x19E
  #define TXEN_position                            0x5
  #define TXEN_size                                0x1
  #define TXEN_value_mask                          0x20
  #define TXEN_clear_mask                          0xDF
  
  #define TX9                                      0x6
  #define TX9_address                              0x19E
  #define TX9_position                             0x6
  #define TX9_size                                 0x1
  #define TX9_value_mask                           0x40
  #define TX9_clear_mask                           0xBF
  
  #define CSRC                                     0x7
  #define CSRC_address                             0x19E
  #define CSRC_position                            0x7
  #define CSRC_size                                0x1
  #define CSRC_value_mask                          0x80
  #define CSRC_clear_mask                          0x7F
  
  
  /*----------------------------------------------------#
  | BAUDCON                                       0x19F |
  #-----------------------------------------------------#
  | ABDOVF | RCIDL | - | SCKP | BRG16 | - | WUE | ABDEN |
  #-----------------------------------------------------#
  | 7      | 6     | 5 | 4    | 3     | 2 | 1   | 0     |
  #----------------------------------------------------*/
  
  #define BAUDCON                                  0x0
  #define BAUDCON_address                          0x19F
  #define BAUDCON_position                         0x0
  #define BAUDCON_size                             0x8
  #define BAUDCON_value_mask                       0xFF
  #define BAUDCON_clear_mask                       0x0
  
  #define ABDEN                                    0x0
  #define ABDEN_address                            0x19F
  #define ABDEN_position                           0x0
  #define ABDEN_size                               0x1
  #define ABDEN_value_mask                         0x1
  #define ABDEN_clear_mask                         0xFE
  
  #define WUE                                      0x1
  #define WUE_address                              0x19F
  #define WUE_position                             0x1
  #define WUE_size                                 0x1
  #define WUE_value_mask                           0x2
  #define WUE_clear_mask                           0xFD
  
  #define BRG16                                    0x3
  #define BRG16_address                            0x19F
  #define BRG16_position                           0x3
  #define BRG16_size                               0x1
  #define BRG16_value_mask                         0x8
  #define BRG16_clear_mask                         0xF7
  
  #define SCKP                                     0x4
  #define SCKP_address                             0x19F
  #define SCKP_position                            0x4
  #define SCKP_size                                0x1
  #define SCKP_value_mask                          0x10
  #define SCKP_clear_mask                          0xEF
  
  #define RCIDL                                    0x6
  #define RCIDL_address                            0x19F
  #define RCIDL_position                           0x6
  #define RCIDL_size                               0x1
  #define RCIDL_value_mask                         0x40
  #define RCIDL_clear_mask                         0xBF
  
  #define ABDOVF                                   0x7
  #define ABDOVF_address                           0x19F
  #define ABDOVF_position                          0x7
  #define ABDOVF_size                              0x1
  #define ABDOVF_value_mask                        0x80
  #define ABDOVF_clear_mask                        0x7F
  
  
  /*--------------------------------------------------------------#
  | WPUB                                                    0x20D |
  #---------------------------------------------------------------#
  | WPUB7 | WPUB6 | WPUB5 | WPUB4 | WPUB3 | WPUB2 | WPUB1 | WPUB0 |
  #---------------------------------------------------------------#
  | 7     | 6     | 5     | 4     | 3     | 2     | 1     | 0     |
  #--------------------------------------------------------------*/
  
  #define WPUB0                                    0x0
  #define WPUB0_address                            0x20D
  #define WPUB0_position                           0x0
  #define WPUB0_size                               0x1
  #define WPUB0_value_mask                         0x1
  #define WPUB0_clear_mask                         0xFE
  
  #define WPUB                                     0x0
  #define WPUB_address                             0x20D
  #define WPUB_position                            0x0
  #define WPUB_size                                0x8
  #define WPUB_value_mask                          0xFF
  #define WPUB_clear_mask                          0x0
  
  #define WPUB1                                    0x1
  #define WPUB1_address                            0x20D
  #define WPUB1_position                           0x1
  #define WPUB1_size                               0x1
  #define WPUB1_value_mask                         0x2
  #define WPUB1_clear_mask                         0xFD
  
  #define WPUB2                                    0x2
  #define WPUB2_address                            0x20D
  #define WPUB2_position                           0x2
  #define WPUB2_size                               0x1
  #define WPUB2_value_mask                         0x4
  #define WPUB2_clear_mask                         0xFB
  
  #define WPUB3                                    0x3
  #define WPUB3_address                            0x20D
  #define WPUB3_position                           0x3
  #define WPUB3_size                               0x1
  #define WPUB3_value_mask                         0x8
  #define WPUB3_clear_mask                         0xF7
  
  #define WPUB4                                    0x4
  #define WPUB4_address                            0x20D
  #define WPUB4_position                           0x4
  #define WPUB4_size                               0x1
  #define WPUB4_value_mask                         0x10
  #define WPUB4_clear_mask                         0xEF
  
  #define WPUB5                                    0x5
  #define WPUB5_address                            0x20D
  #define WPUB5_position                           0x5
  #define WPUB5_size                               0x1
  #define WPUB5_value_mask                         0x20
  #define WPUB5_clear_mask                         0xDF
  
  #define WPUB6                                    0x6
  #define WPUB6_address                            0x20D
  #define WPUB6_position                           0x6
  #define WPUB6_size                               0x1
  #define WPUB6_value_mask                         0x40
  #define WPUB6_clear_mask                         0xBF
  
  #define WPUB7                                    0x7
  #define WPUB7_address                            0x20D
  #define WPUB7_position                           0x7
  #define WPUB7_size                               0x1
  #define WPUB7_value_mask                         0x80
  #define WPUB7_clear_mask                         0x7F
  
  
  /*----------------------------------#
  | WPUE                        0x210 |
  #-----------------------------------#
  | - | - | - | - | WPUE3 | - | - | - |
  #-----------------------------------#
  | 7 | 6 | 5 | 4 | 3     | 2 | 1 | 0 |
  #----------------------------------*/
  
  #define WPUE                                     0x0
  #define WPUE_address                             0x210
  #define WPUE_position                            0x0
  #define WPUE_size                                0x8
  #define WPUE_value_mask                          0xFF
  #define WPUE_clear_mask                          0x0
  
  #define WPUE3                                    0x3
  #define WPUE3_address                            0x210
  #define WPUE3_position                           0x3
  #define WPUE3_size                               0x1
  #define WPUE3_value_mask                         0x8
  #define WPUE3_clear_mask                         0xF7
  
  
  /*------------------------------#
  | SSPBUF                  0x211 |
  #-------------------------------#
  | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
  #------------------------------*/
  
  #define SSPBUF                                   0x0
  #define SSPBUF_address                           0x211
  #define SSPBUF_position                          0x0
  #define SSPBUF_size                              0x8
  #define SSPBUF_value_mask                        0xFF
  #define SSPBUF_clear_mask                        0x0
  
  
  /*------------------------------#
  | SSPADD                  0x212 |
  #-------------------------------#
  | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
  #------------------------------*/
  
  #define SSPADD                                   0x0
  #define SSPADD_address                           0x212
  #define SSPADD_position                          0x0
  #define SSPADD_size                              0x8
  #define SSPADD_value_mask                        0xFF
  #define SSPADD_clear_mask                        0x0
  
  
  /*------------------------------#
  | SSPMSK                  0x213 |
  #-------------------------------#
  | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
  #------------------------------*/
  
  #define SSPMSK                                   0x0
  #define SSPMSK_address                           0x213
  #define SSPMSK_position                          0x0
  #define SSPMSK_size                              0x8
  #define SSPMSK_value_mask                        0xFF
  #define SSPMSK_clear_mask                        0x0
  
  
  /*------------------------------------------#
  | SSPSTAT                             0x214 |
  #-------------------------------------------#
  | SMP | CKE | D_nA | P | S | R_nW | UA | BF |
  #-------------------------------------------#
  | 7   | 6   | 5    | 4 | 3 | 2    | 1  | 0  |
  #------------------------------------------*/
  
  #define SSPSTAT                                  0x0
  #define SSPSTAT_address                          0x214
  #define SSPSTAT_position                         0x0
  #define SSPSTAT_size                             0x8
  #define SSPSTAT_value_mask                       0xFF
  #define SSPSTAT_clear_mask                       0x0
  
  #define BF                                       0x0
  #define BF_address                               0x214
  #define BF_position                              0x0
  #define BF_size                                  0x1
  #define BF_value_mask                            0x1
  #define BF_clear_mask                            0xFE
  
  #define UA                                       0x1
  #define UA_address                               0x214
  #define UA_position                              0x1
  #define UA_size                                  0x1
  #define UA_value_mask                            0x2
  #define UA_clear_mask                            0xFD
  
  #define R_nW                                     0x2
  #define R_nW_address                             0x214
  #define R_nW_position                            0x2
  #define R_nW_size                                0x1
  #define R_nW_value_mask                          0x4
  #define R_nW_clear_mask                          0xFB
  
  #define S                                        0x3
  #define S_address                                0x214
  #define S_position                               0x3
  #define S_size                                   0x1
  #define S_value_mask                             0x8
  #define S_clear_mask                             0xF7
  
  #define P                                        0x4
  #define P_address                                0x214
  #define P_position                               0x4
  #define P_size                                   0x1
  #define P_value_mask                             0x10
  #define P_clear_mask                             0xEF
  
  #define D_nA                                     0x5
  #define D_nA_address                             0x214
  #define D_nA_position                            0x5
  #define D_nA_size                                0x1
  #define D_nA_value_mask                          0x20
  #define D_nA_clear_mask                          0xDF
  
  #define CKE                                      0x6
  #define CKE_address                              0x214
  #define CKE_position                             0x6
  #define CKE_size                                 0x1
  #define CKE_value_mask                           0x40
  #define CKE_clear_mask                           0xBF
  
  #define SMP                                      0x7
  #define SMP_address                              0x214
  #define SMP_position                             0x7
  #define SMP_size                                 0x1
  #define SMP_value_mask                           0x80
  #define SMP_clear_mask                           0x7F
  
  
  /*-----------------------------------------------------------#
  | SSPCON1                                              0x215 |
  #------------------------------------------------------------#
  | WCOL | SSPOV | SSPEN | CKP | SSPM3 | SSPM2 | SSPM1 | SSPM0 |
  #------------------------------------------------------------#
  | 7    | 6     | 5     | 4   | 3     | 2     | 1     | 0     |
  #-----------------------------------------------------------*/
  
  #define SSPCON1                                  0x0
  #define SSPCON1_address                          0x215
  #define SSPCON1_position                         0x0
  #define SSPCON1_size                             0x8
  #define SSPCON1_value_mask                       0xFF
  #define SSPCON1_clear_mask                       0x0
  
  #define SSPM0                                    0x0
  #define SSPM0_address                            0x215
  #define SSPM0_position                           0x0
  #define SSPM0_size                               0x1
  #define SSPM0_value_mask                         0x1
  #define SSPM0_clear_mask                         0xFE
  
  #define SSPM1                                    0x1
  #define SSPM1_address                            0x215
  #define SSPM1_position                           0x1
  #define SSPM1_size                               0x1
  #define SSPM1_value_mask                         0x2
  #define SSPM1_clear_mask                         0xFD
  
  #define SSPM2                                    0x2
  #define SSPM2_address                            0x215
  #define SSPM2_position                           0x2
  #define SSPM2_size                               0x1
  #define SSPM2_value_mask                         0x4
  #define SSPM2_clear_mask                         0xFB
  
  #define SSPM3                                    0x3
  #define SSPM3_address                            0x215
  #define SSPM3_position                           0x3
  #define SSPM3_size                               0x1
  #define SSPM3_value_mask                         0x8
  #define SSPM3_clear_mask                         0xF7
  
  #define CKP                                      0x4
  #define CKP_address                              0x215
  #define CKP_position                             0x4
  #define CKP_size                                 0x1
  #define CKP_value_mask                           0x10
  #define CKP_clear_mask                           0xEF
  
  #define SSPEN                                    0x5
  #define SSPEN_address                            0x215
  #define SSPEN_position                           0x5
  #define SSPEN_size                               0x1
  #define SSPEN_value_mask                         0x20
  #define SSPEN_clear_mask                         0xDF
  
  #define SSPOV                                    0x6
  #define SSPOV_address                            0x215
  #define SSPOV_position                           0x6
  #define SSPOV_size                               0x1
  #define SSPOV_value_mask                         0x40
  #define SSPOV_clear_mask                         0xBF
  
  #define WCOL                                     0x7
  #define WCOL_address                             0x215
  #define WCOL_position                            0x7
  #define WCOL_size                                0x1
  #define WCOL_value_mask                          0x80
  #define WCOL_clear_mask                          0x7F
  
  
  /*---------------------------------------------------------#
  | SSPCON2                                            0x216 |
  #----------------------------------------------------------#
  | GCEN | ACKSTAT | ACKDT | ACKEN | RCEN | PEN | RSEN | SEN |
  #----------------------------------------------------------#
  | 7    | 6       | 5     | 4     | 3    | 2   | 1    | 0   |
  #---------------------------------------------------------*/
  
  #define SSPCON2                                  0x0
  #define SSPCON2_address                          0x216
  #define SSPCON2_position                         0x0
  #define SSPCON2_size                             0x8
  #define SSPCON2_value_mask                       0xFF
  #define SSPCON2_clear_mask                       0x0
  
  #define SEN                                      0x0
  #define SEN_address                              0x216
  #define SEN_position                             0x0
  #define SEN_size                                 0x1
  #define SEN_value_mask                           0x1
  #define SEN_clear_mask                           0xFE
  
  #define RSEN                                     0x1
  #define RSEN_address                             0x216
  #define RSEN_position                            0x1
  #define RSEN_size                                0x1
  #define RSEN_value_mask                          0x2
  #define RSEN_clear_mask                          0xFD
  
  #define PEN                                      0x2
  #define PEN_address                              0x216
  #define PEN_position                             0x2
  #define PEN_size                                 0x1
  #define PEN_value_mask                           0x4
  #define PEN_clear_mask                           0xFB
  
  #define RCEN                                     0x3
  #define RCEN_address                             0x216
  #define RCEN_position                            0x3
  #define RCEN_size                                0x1
  #define RCEN_value_mask                          0x8
  #define RCEN_clear_mask                          0xF7
  
  #define ACKEN                                    0x4
  #define ACKEN_address                            0x216
  #define ACKEN_position                           0x4
  #define ACKEN_size                               0x1
  #define ACKEN_value_mask                         0x10
  #define ACKEN_clear_mask                         0xEF
  
  #define ACKDT                                    0x5
  #define ACKDT_address                            0x216
  #define ACKDT_position                           0x5
  #define ACKDT_size                               0x1
  #define ACKDT_value_mask                         0x20
  #define ACKDT_clear_mask                         0xDF
  
  #define ACKSTAT                                  0x6
  #define ACKSTAT_address                          0x216
  #define ACKSTAT_position                         0x6
  #define ACKSTAT_size                             0x1
  #define ACKSTAT_value_mask                       0x40
  #define ACKSTAT_clear_mask                       0xBF
  
  #define GCEN                                     0x7
  #define GCEN_address                             0x216
  #define GCEN_position                            0x7
  #define GCEN_size                                0x1
  #define GCEN_value_mask                          0x80
  #define GCEN_clear_mask                          0x7F
  
  
  /*----------------------------------------------------------#
  | SSPCON3                                             0x217 |
  #-----------------------------------------------------------#
  | ACKTIM | PCIE | SCIE | BOEN | SDAHT | SBCDE | AHEN | DHEN |
  #-----------------------------------------------------------#
  | 7      | 6    | 5    | 4    | 3     | 2     | 1    | 0    |
  #----------------------------------------------------------*/
  
  #define SSPCON3                                  0x0
  #define SSPCON3_address                          0x217
  #define SSPCON3_position                         0x0
  #define SSPCON3_size                             0x8
  #define SSPCON3_value_mask                       0xFF
  #define SSPCON3_clear_mask                       0x0
  
  #define DHEN                                     0x0
  #define DHEN_address                             0x217
  #define DHEN_position                            0x0
  #define DHEN_size                                0x1
  #define DHEN_value_mask                          0x1
  #define DHEN_clear_mask                          0xFE
  
  #define AHEN                                     0x1
  #define AHEN_address                             0x217
  #define AHEN_position                            0x1
  #define AHEN_size                                0x1
  #define AHEN_value_mask                          0x2
  #define AHEN_clear_mask                          0xFD
  
  #define SBCDE                                    0x2
  #define SBCDE_address                            0x217
  #define SBCDE_position                           0x2
  #define SBCDE_size                               0x1
  #define SBCDE_value_mask                         0x4
  #define SBCDE_clear_mask                         0xFB
  
  #define SDAHT                                    0x3
  #define SDAHT_address                            0x217
  #define SDAHT_position                           0x3
  #define SDAHT_size                               0x1
  #define SDAHT_value_mask                         0x8
  #define SDAHT_clear_mask                         0xF7
  
  #define BOEN                                     0x4
  #define BOEN_address                             0x217
  #define BOEN_position                            0x4
  #define BOEN_size                                0x1
  #define BOEN_value_mask                          0x10
  #define BOEN_clear_mask                          0xEF
  
  #define SCIE                                     0x5
  #define SCIE_address                             0x217
  #define SCIE_position                            0x5
  #define SCIE_size                                0x1
  #define SCIE_value_mask                          0x20
  #define SCIE_clear_mask                          0xDF
  
  #define PCIE                                     0x6
  #define PCIE_address                             0x217
  #define PCIE_position                            0x6
  #define PCIE_size                                0x1
  #define PCIE_value_mask                          0x40
  #define PCIE_clear_mask                          0xBF
  
  #define ACKTIM                                   0x7
  #define ACKTIM_address                           0x217
  #define ACKTIM_position                          0x7
  #define ACKTIM_size                              0x1
  #define ACKTIM_value_mask                        0x80
  #define ACKTIM_clear_mask                        0x7F
  
  
  /*------------------------------#
  | CCPR1L                  0x291 |
  #-------------------------------#
  | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
  #------------------------------*/
  
  #define CCPR1L                                   0x0
  #define CCPR1L_address                           0x291
  #define CCPR1L_position                          0x0
  #define CCPR1L_size                              0x8
  #define CCPR1L_value_mask                        0xFF
  #define CCPR1L_clear_mask                        0x0
  
  
  /*------------------------------#
  | CCPR1H                  0x292 |
  #-------------------------------#
  | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
  #------------------------------*/
  
  #define CCPR1H                                   0x0
  #define CCPR1H_address                           0x292
  #define CCPR1H_position                          0x0
  #define CCPR1H_size                              0x8
  #define CCPR1H_value_mask                        0xFF
  #define CCPR1H_clear_mask                        0x0
  
  
  /*----------------------------------------------------------------#
  | CCP1CON                                                   0x293 |
  #-----------------------------------------------------------------#
  | P1M1 | P1M0 | DC1B1 | DC1B0 | CCP1M3 | CCP1M2 | CCP1M1 | CCP1M0 |
  #-----------------------------------------------------------------#
  | 7    | 6    | 5     | 4     | 3      | 2      | 1      | 0      |
  #----------------------------------------------------------------*/
  
  #define CCP1CON                                  0x0
  #define CCP1CON_address                          0x293
  #define CCP1CON_position                         0x0
  #define CCP1CON_size                             0x8
  #define CCP1CON_value_mask                       0xFF
  #define CCP1CON_clear_mask                       0x0
  
  #define CCP1M0                                   0x0
  #define CCP1M0_address                           0x293
  #define CCP1M0_position                          0x0
  #define CCP1M0_size                              0x1
  #define CCP1M0_value_mask                        0x1
  #define CCP1M0_clear_mask                        0xFE
  
  #define CCP1M                                    0x0
  #define CCP1M_address                            0x293
  #define CCP1M_position                           0x0
  #define CCP1M_size                               0x4
  #define CCP1M_value_mask                         0xF
  #define CCP1M_clear_mask                         0xF0
  
  #define CCP1M1                                   0x1
  #define CCP1M1_address                           0x293
  #define CCP1M1_position                          0x1
  #define CCP1M1_size                              0x1
  #define CCP1M1_value_mask                        0x2
  #define CCP1M1_clear_mask                        0xFD
  
  #define CCP1M2                                   0x2
  #define CCP1M2_address                           0x293
  #define CCP1M2_position                          0x2
  #define CCP1M2_size                              0x1
  #define CCP1M2_value_mask                        0x4
  #define CCP1M2_clear_mask                        0xFB
  
  #define CCP1M3                                   0x3
  #define CCP1M3_address                           0x293
  #define CCP1M3_position                          0x3
  #define CCP1M3_size                              0x1
  #define CCP1M3_value_mask                        0x8
  #define CCP1M3_clear_mask                        0xF7
  
  #define DC1B                                     0x4
  #define DC1B_address                             0x293
  #define DC1B_position                            0x4
  #define DC1B_size                                0x2
  #define DC1B_value_mask                          0x30
  #define DC1B_clear_mask                          0xCF
  
  #define DC1B0                                    0x4
  #define DC1B0_address                            0x293
  #define DC1B0_position                           0x4
  #define DC1B0_size                               0x1
  #define DC1B0_value_mask                         0x10
  #define DC1B0_clear_mask                         0xEF
  
  #define DC1B1                                    0x5
  #define DC1B1_address                            0x293
  #define DC1B1_position                           0x5
  #define DC1B1_size                               0x1
  #define DC1B1_value_mask                         0x20
  #define DC1B1_clear_mask                         0xDF
  
  #define P1M                                      0x6
  #define P1M_address                              0x293
  #define P1M_position                             0x6
  #define P1M_size                                 0x2
  #define P1M_value_mask                           0xC0
  #define P1M_clear_mask                           0x3F
  
  #define P1M0                                     0x6
  #define P1M0_address                             0x293
  #define P1M0_position                            0x6
  #define P1M0_size                                0x1
  #define P1M0_value_mask                          0x40
  #define P1M0_clear_mask                          0xBF
  
  #define P1M1                                     0x7
  #define P1M1_address                             0x293
  #define P1M1_position                            0x7
  #define P1M1_size                                0x1
  #define P1M1_value_mask                          0x80
  #define P1M1_clear_mask                          0x7F
  
  
  /*---------------------------------------------------------------#
  | PWM1CON                                                  0x294 |
  #----------------------------------------------------------------#
  | P1RSEN | P1DC6 | P1DC5 | P1DC4 | P1DC3 | P1DC2 | P1DC1 | P1DC0 |
  #----------------------------------------------------------------#
  | 7      | 6     | 5     | 4     | 3     | 2     | 1     | 0     |
  #---------------------------------------------------------------*/
  
  #define PWM1CON                                  0x0
  #define PWM1CON_address                          0x294
  #define PWM1CON_position                         0x0
  #define PWM1CON_size                             0x8
  #define PWM1CON_value_mask                       0xFF
  #define PWM1CON_clear_mask                       0x0
  
  #define P1DC0                                    0x0
  #define P1DC0_address                            0x294
  #define P1DC0_position                           0x0
  #define P1DC0_size                               0x1
  #define P1DC0_value_mask                         0x1
  #define P1DC0_clear_mask                         0xFE
  
  #define P1DC1                                    0x1
  #define P1DC1_address                            0x294
  #define P1DC1_position                           0x1
  #define P1DC1_size                               0x1
  #define P1DC1_value_mask                         0x2
  #define P1DC1_clear_mask                         0xFD
  
  #define P1DC2                                    0x2
  #define P1DC2_address                            0x294
  #define P1DC2_position                           0x2
  #define P1DC2_size                               0x1
  #define P1DC2_value_mask                         0x4
  #define P1DC2_clear_mask                         0xFB
  
  #define P1DC3                                    0x3
  #define P1DC3_address                            0x294
  #define P1DC3_position                           0x3
  #define P1DC3_size                               0x1
  #define P1DC3_value_mask                         0x8
  #define P1DC3_clear_mask                         0xF7
  
  #define P1DC4                                    0x4
  #define P1DC4_address                            0x294
  #define P1DC4_position                           0x4
  #define P1DC4_size                               0x1
  #define P1DC4_value_mask                         0x10
  #define P1DC4_clear_mask                         0xEF
  
  #define P1DC5                                    0x5
  #define P1DC5_address                            0x294
  #define P1DC5_position                           0x5
  #define P1DC5_size                               0x1
  #define P1DC5_value_mask                         0x20
  #define P1DC5_clear_mask                         0xDF
  
  #define P1DC6                                    0x6
  #define P1DC6_address                            0x294
  #define P1DC6_position                           0x6
  #define P1DC6_size                               0x1
  #define P1DC6_value_mask                         0x40
  #define P1DC6_clear_mask                         0xBF
  
  #define P1RSEN                                   0x7
  #define P1RSEN_address                           0x294
  #define P1RSEN_position                          0x7
  #define P1RSEN_size                              0x1
  #define P1RSEN_value_mask                        0x80
  #define P1RSEN_clear_mask                        0x7F
  
  
  /*------------------------------------------------------------------------------#
  | CCP1AS                                                                  0x295 |
  #-------------------------------------------------------------------------------#
  | CCP1ASE | CCP1AS2 | CCP1AS1 | CCP1AS0 | PSS1AC1 | PSS1AC0 | PSS1BD1 | PSS1BD0 |
  #-------------------------------------------------------------------------------#
  | 7       | 6       | 5       | 4       | 3       | 2       | 1       | 0       |
  #------------------------------------------------------------------------------*/
  
  #define CCP1AS                                   0x0
  #define CCP1AS_address                           0x295
  #define CCP1AS_position                          0x0
  #define CCP1AS_size                              0x8
  #define CCP1AS_value_mask                        0xFF
  #define CCP1AS_clear_mask                        0x0
  
  #define PSS1BD0                                  0x0
  #define PSS1BD0_address                          0x295
  #define PSS1BD0_position                         0x0
  #define PSS1BD0_size                             0x1
  #define PSS1BD0_value_mask                       0x1
  #define PSS1BD0_clear_mask                       0xFE
  
  #define PSS1BD1                                  0x1
  #define PSS1BD1_address                          0x295
  #define PSS1BD1_position                         0x1
  #define PSS1BD1_size                             0x1
  #define PSS1BD1_value_mask                       0x2
  #define PSS1BD1_clear_mask                       0xFD
  
  #define PSS1AC0                                  0x2
  #define PSS1AC0_address                          0x295
  #define PSS1AC0_position                         0x2
  #define PSS1AC0_size                             0x1
  #define PSS1AC0_value_mask                       0x4
  #define PSS1AC0_clear_mask                       0xFB
  
  #define PSS1AC1                                  0x3
  #define PSS1AC1_address                          0x295
  #define PSS1AC1_position                         0x3
  #define PSS1AC1_size                             0x1
  #define PSS1AC1_value_mask                       0x8
  #define PSS1AC1_clear_mask                       0xF7
  
  #define CCP1AS0                                  0x4
  #define CCP1AS0_address                          0x295
  #define CCP1AS0_position                         0x4
  #define CCP1AS0_size                             0x1
  #define CCP1AS0_value_mask                       0x10
  #define CCP1AS0_clear_mask                       0xEF
  
  #define CCP1AS1                                  0x5
  #define CCP1AS1_address                          0x295
  #define CCP1AS1_position                         0x5
  #define CCP1AS1_size                             0x1
  #define CCP1AS1_value_mask                       0x20
  #define CCP1AS1_clear_mask                       0xDF
  
  #define CCP1AS2                                  0x6
  #define CCP1AS2_address                          0x295
  #define CCP1AS2_position                         0x6
  #define CCP1AS2_size                             0x1
  #define CCP1AS2_value_mask                       0x40
  #define CCP1AS2_clear_mask                       0xBF
  
  #define CCP1ASE                                  0x7
  #define CCP1ASE_address                          0x295
  #define CCP1ASE_position                         0x7
  #define CCP1ASE_size                             0x1
  #define CCP1ASE_value_mask                       0x80
  #define CCP1ASE_clear_mask                       0x7F
  
  
  /*-----------------------------------------------------#
  | PSTR1CON                                       0x296 |
  #------------------------------------------------------#
  | - | - | - | STR1SYNC | STR1D | STR1C | STR1B | STR1A |
  #------------------------------------------------------#
  | 7 | 6 | 5 | 4        | 3     | 2     | 1     | 0     |
  #-----------------------------------------------------*/
  
  #define PSTR1CON                                 0x0
  #define PSTR1CON_address                         0x296
  #define PSTR1CON_position                        0x0
  #define PSTR1CON_size                            0x8
  #define PSTR1CON_value_mask                      0xFF
  #define PSTR1CON_clear_mask                      0x0
  
  #define STR1A                                    0x0
  #define STR1A_address                            0x296
  #define STR1A_position                           0x0
  #define STR1A_size                               0x1
  #define STR1A_value_mask                         0x1
  #define STR1A_clear_mask                         0xFE
  
  #define STR1B                                    0x1
  #define STR1B_address                            0x296
  #define STR1B_position                           0x1
  #define STR1B_size                               0x1
  #define STR1B_value_mask                         0x2
  #define STR1B_clear_mask                         0xFD
  
  #define STR1C                                    0x2
  #define STR1C_address                            0x296
  #define STR1C_position                           0x2
  #define STR1C_size                               0x1
  #define STR1C_value_mask                         0x4
  #define STR1C_clear_mask                         0xFB
  
  #define STR1D                                    0x3
  #define STR1D_address                            0x296
  #define STR1D_position                           0x3
  #define STR1D_size                               0x1
  #define STR1D_value_mask                         0x8
  #define STR1D_clear_mask                         0xF7
  
  #define STR1SYNC                                 0x4
  #define STR1SYNC_address                         0x296
  #define STR1SYNC_position                        0x4
  #define STR1SYNC_size                            0x1
  #define STR1SYNC_value_mask                      0x10
  #define STR1SYNC_clear_mask                      0xEF
  
  
  /*------------------------------#
  | CCPR2L                  0x298 |
  #-------------------------------#
  | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
  #------------------------------*/
  
  #define CCPR2L                                   0x0
  #define CCPR2L_address                           0x298
  #define CCPR2L_position                          0x0
  #define CCPR2L_size                              0x8
  #define CCPR2L_value_mask                        0xFF
  #define CCPR2L_clear_mask                        0x0
  
  
  /*------------------------------#
  | CCPR2H                  0x299 |
  #-------------------------------#
  | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
  #------------------------------*/
  
  #define CCPR2H                                   0x0
  #define CCPR2H_address                           0x299
  #define CCPR2H_position                          0x0
  #define CCPR2H_size                              0x8
  #define CCPR2H_value_mask                        0xFF
  #define CCPR2H_clear_mask                        0x0
  
  
  /*----------------------------------------------------------------#
  | CCP2CON                                                   0x29A |
  #-----------------------------------------------------------------#
  | P2M1 | P2M0 | DC2B1 | DC2B0 | CCP2M3 | CCP2M2 | CCP2M1 | CCP2M0 |
  #-----------------------------------------------------------------#
  | 7    | 6    | 5     | 4     | 3      | 2      | 1      | 0      |
  #----------------------------------------------------------------*/
  
  #define CCP2CON                                  0x0
  #define CCP2CON_address                          0x29A
  #define CCP2CON_position                         0x0
  #define CCP2CON_size                             0x8
  #define CCP2CON_value_mask                       0xFF
  #define CCP2CON_clear_mask                       0x0
  
  #define CCP2M                                    0x0
  #define CCP2M_address                            0x29A
  #define CCP2M_position                           0x0
  #define CCP2M_size                               0x4
  #define CCP2M_value_mask                         0xF
  #define CCP2M_clear_mask                         0xF0
  
  #define CCP2M0                                   0x0
  #define CCP2M0_address                           0x29A
  #define CCP2M0_position                          0x0
  #define CCP2M0_size                              0x1
  #define CCP2M0_value_mask                        0x1
  #define CCP2M0_clear_mask                        0xFE
  
  #define CCP2M1                                   0x1
  #define CCP2M1_address                           0x29A
  #define CCP2M1_position                          0x1
  #define CCP2M1_size                              0x1
  #define CCP2M1_value_mask                        0x2
  #define CCP2M1_clear_mask                        0xFD
  
  #define CCP2M2                                   0x2
  #define CCP2M2_address                           0x29A
  #define CCP2M2_position                          0x2
  #define CCP2M2_size                              0x1
  #define CCP2M2_value_mask                        0x4
  #define CCP2M2_clear_mask                        0xFB
  
  #define CCP2M3                                   0x3
  #define CCP2M3_address                           0x29A
  #define CCP2M3_position                          0x3
  #define CCP2M3_size                              0x1
  #define CCP2M3_value_mask                        0x8
  #define CCP2M3_clear_mask                        0xF7
  
  #define DC2B                                     0x4
  #define DC2B_address                             0x29A
  #define DC2B_position                            0x4
  #define DC2B_size                                0x2
  #define DC2B_value_mask                          0x30
  #define DC2B_clear_mask                          0xCF
  
  #define DC2B0                                    0x4
  #define DC2B0_address                            0x29A
  #define DC2B0_position                           0x4
  #define DC2B0_size                               0x1
  #define DC2B0_value_mask                         0x10
  #define DC2B0_clear_mask                         0xEF
  
  #define DC2B1                                    0x5
  #define DC2B1_address                            0x29A
  #define DC2B1_position                           0x5
  #define DC2B1_size                               0x1
  #define DC2B1_value_mask                         0x20
  #define DC2B1_clear_mask                         0xDF
  
  #define P2M                                      0x6
  #define P2M_address                              0x29A
  #define P2M_position                             0x6
  #define P2M_size                                 0x2
  #define P2M_value_mask                           0xC0
  #define P2M_clear_mask                           0x3F
  
  #define P2M0                                     0x6
  #define P2M0_address                             0x29A
  #define P2M0_position                            0x6
  #define P2M0_size                                0x1
  #define P2M0_value_mask                          0x40
  #define P2M0_clear_mask                          0xBF
  
  #define P2M1                                     0x7
  #define P2M1_address                             0x29A
  #define P2M1_position                            0x7
  #define P2M1_size                                0x1
  #define P2M1_value_mask                          0x80
  #define P2M1_clear_mask                          0x7F
  
  
  /*---------------------------------------------------------------#
  | PWM2CON                                                  0x29B |
  #----------------------------------------------------------------#
  | P2RSEN | P2DC6 | P2DC5 | P2DC4 | P2DC3 | P2DC2 | P2DC1 | P2DC0 |
  #----------------------------------------------------------------#
  | 7      | 6     | 5     | 4     | 3     | 2     | 1     | 0     |
  #---------------------------------------------------------------*/
  
  #define PWM2CON                                  0x0
  #define PWM2CON_address                          0x29B
  #define PWM2CON_position                         0x0
  #define PWM2CON_size                             0x8
  #define PWM2CON_value_mask                       0xFF
  #define PWM2CON_clear_mask                       0x0
  
  #define P2DC0                                    0x0
  #define P2DC0_address                            0x29B
  #define P2DC0_position                           0x0
  #define P2DC0_size                               0x1
  #define P2DC0_value_mask                         0x1
  #define P2DC0_clear_mask                         0xFE
  
  #define P2DC1                                    0x1
  #define P2DC1_address                            0x29B
  #define P2DC1_position                           0x1
  #define P2DC1_size                               0x1
  #define P2DC1_value_mask                         0x2
  #define P2DC1_clear_mask                         0xFD
  
  #define P2DC2                                    0x2
  #define P2DC2_address                            0x29B
  #define P2DC2_position                           0x2
  #define P2DC2_size                               0x1
  #define P2DC2_value_mask                         0x4
  #define P2DC2_clear_mask                         0xFB
  
  #define P2DC3                                    0x3
  #define P2DC3_address                            0x29B
  #define P2DC3_position                           0x3
  #define P2DC3_size                               0x1
  #define P2DC3_value_mask                         0x8
  #define P2DC3_clear_mask                         0xF7
  
  #define P2DC4                                    0x4
  #define P2DC4_address                            0x29B
  #define P2DC4_position                           0x4
  #define P2DC4_size                               0x1
  #define P2DC4_value_mask                         0x10
  #define P2DC4_clear_mask                         0xEF
  
  #define P2DC5                                    0x5
  #define P2DC5_address                            0x29B
  #define P2DC5_position                           0x5
  #define P2DC5_size                               0x1
  #define P2DC5_value_mask                         0x20
  #define P2DC5_clear_mask                         0xDF
  
  #define P2DC6                                    0x6
  #define P2DC6_address                            0x29B
  #define P2DC6_position                           0x6
  #define P2DC6_size                               0x1
  #define P2DC6_value_mask                         0x40
  #define P2DC6_clear_mask                         0xBF
  
  #define P2RSEN                                   0x7
  #define P2RSEN_address                           0x29B
  #define P2RSEN_position                          0x7
  #define P2RSEN_size                              0x1
  #define P2RSEN_value_mask                        0x80
  #define P2RSEN_clear_mask                        0x7F
  
  
  /*------------------------------------------------------------------------------#
  | CCP2AS                                                                  0x29C |
  #-------------------------------------------------------------------------------#
  | CCP2ASE | CCP2AS2 | CCP2AS1 | CCP2AS0 | PSS2AC1 | PSS2AC0 | PSS2BD1 | PSS2BD0 |
  #-------------------------------------------------------------------------------#
  | 7       | 6       | 5       | 4       | 3       | 2       | 1       | 0       |
  #------------------------------------------------------------------------------*/
  
  #define CCP2AS                                   0x0
  #define CCP2AS_address                           0x29C
  #define CCP2AS_position                          0x0
  #define CCP2AS_size                              0x8
  #define CCP2AS_value_mask                        0xFF
  #define CCP2AS_clear_mask                        0x0
  
  #define PSS2BD0                                  0x0
  #define PSS2BD0_address                          0x29C
  #define PSS2BD0_position                         0x0
  #define PSS2BD0_size                             0x1
  #define PSS2BD0_value_mask                       0x1
  #define PSS2BD0_clear_mask                       0xFE
  
  #define PSS2BD1                                  0x1
  #define PSS2BD1_address                          0x29C
  #define PSS2BD1_position                         0x1
  #define PSS2BD1_size                             0x1
  #define PSS2BD1_value_mask                       0x2
  #define PSS2BD1_clear_mask                       0xFD
  
  #define PSS2AC0                                  0x2
  #define PSS2AC0_address                          0x29C
  #define PSS2AC0_position                         0x2
  #define PSS2AC0_size                             0x1
  #define PSS2AC0_value_mask                       0x4
  #define PSS2AC0_clear_mask                       0xFB
  
  #define PSS2AC1                                  0x3
  #define PSS2AC1_address                          0x29C
  #define PSS2AC1_position                         0x3
  #define PSS2AC1_size                             0x1
  #define PSS2AC1_value_mask                       0x8
  #define PSS2AC1_clear_mask                       0xF7
  
  #define CCP2AS0                                  0x4
  #define CCP2AS0_address                          0x29C
  #define CCP2AS0_position                         0x4
  #define CCP2AS0_size                             0x1
  #define CCP2AS0_value_mask                       0x10
  #define CCP2AS0_clear_mask                       0xEF
  
  #define CCP2AS1                                  0x5
  #define CCP2AS1_address                          0x29C
  #define CCP2AS1_position                         0x5
  #define CCP2AS1_size                             0x1
  #define CCP2AS1_value_mask                       0x20
  #define CCP2AS1_clear_mask                       0xDF
  
  #define CCP2AS2                                  0x6
  #define CCP2AS2_address                          0x29C
  #define CCP2AS2_position                         0x6
  #define CCP2AS2_size                             0x1
  #define CCP2AS2_value_mask                       0x40
  #define CCP2AS2_clear_mask                       0xBF
  
  #define CCP2ASE                                  0x7
  #define CCP2ASE_address                          0x29C
  #define CCP2ASE_position                         0x7
  #define CCP2ASE_size                             0x1
  #define CCP2ASE_value_mask                       0x80
  #define CCP2ASE_clear_mask                       0x7F
  
  
  /*-----------------------------------------------------#
  | PSTR2CON                                       0x29D |
  #------------------------------------------------------#
  | - | - | - | STR2SYNC | STR2D | STR2C | STR2B | STR2A |
  #------------------------------------------------------#
  | 7 | 6 | 5 | 4        | 3     | 2     | 1     | 0     |
  #-----------------------------------------------------*/
  
  #define PSTR2CON                                 0x0
  #define PSTR2CON_address                         0x29D
  #define PSTR2CON_position                        0x0
  #define PSTR2CON_size                            0x8
  #define PSTR2CON_value_mask                      0xFF
  #define PSTR2CON_clear_mask                      0x0
  
  #define STR2A                                    0x0
  #define STR2A_address                            0x29D
  #define STR2A_position                           0x0
  #define STR2A_size                               0x1
  #define STR2A_value_mask                         0x1
  #define STR2A_clear_mask                         0xFE
  
  #define STR2B                                    0x1
  #define STR2B_address                            0x29D
  #define STR2B_position                           0x1
  #define STR2B_size                               0x1
  #define STR2B_value_mask                         0x2
  #define STR2B_clear_mask                         0xFD
  
  #define STR2C                                    0x2
  #define STR2C_address                            0x29D
  #define STR2C_position                           0x2
  #define STR2C_size                               0x1
  #define STR2C_value_mask                         0x4
  #define STR2C_clear_mask                         0xFB
  
  #define STR2D                                    0x3
  #define STR2D_address                            0x29D
  #define STR2D_position                           0x3
  #define STR2D_size                               0x1
  #define STR2D_value_mask                         0x8
  #define STR2D_clear_mask                         0xF7
  
  #define STR2SYNC                                 0x4
  #define STR2SYNC_address                         0x29D
  #define STR2SYNC_position                        0x4
  #define STR2SYNC_size                            0x1
  #define STR2SYNC_value_mask                      0x10
  #define STR2SYNC_clear_mask                      0xEF
  
  
  /*------------------------------------------------------------------------------#
  | CCPTMRS0                                                                0x29E |
  #-------------------------------------------------------------------------------#
  | C4TSEL1 | C4TSEL0 | C3TSEL1 | C3TSEL0 | C2TSEL1 | C2TSEL0 | C1TSEL1 | C1TSEL0 |
  #-------------------------------------------------------------------------------#
  | 7       | 6       | 5       | 4       | 3       | 2       | 1       | 0       |
  #------------------------------------------------------------------------------*/
  
  #define CCPTMRS0                                 0x0
  #define CCPTMRS0_address                         0x29E
  #define CCPTMRS0_position                        0x0
  #define CCPTMRS0_size                            0x8
  #define CCPTMRS0_value_mask                      0xFF
  #define CCPTMRS0_clear_mask                      0x0
  
  #define C1TSEL0                                  0x0
  #define C1TSEL0_address                          0x29E
  #define C1TSEL0_position                         0x0
  #define C1TSEL0_size                             0x1
  #define C1TSEL0_value_mask                       0x1
  #define C1TSEL0_clear_mask                       0xFE
  
  #define C1TSEL                                   0x0
  #define C1TSEL_address                           0x29E
  #define C1TSEL_position                          0x0
  #define C1TSEL_size                              0x2
  #define C1TSEL_value_mask                        0x3
  #define C1TSEL_clear_mask                        0xFC
  
  #define C1TSEL1                                  0x1
  #define C1TSEL1_address                          0x29E
  #define C1TSEL1_position                         0x1
  #define C1TSEL1_size                             0x1
  #define C1TSEL1_value_mask                       0x2
  #define C1TSEL1_clear_mask                       0xFD
  
  #define C2TSEL0                                  0x2
  #define C2TSEL0_address                          0x29E
  #define C2TSEL0_position                         0x2
  #define C2TSEL0_size                             0x1
  #define C2TSEL0_value_mask                       0x4
  #define C2TSEL0_clear_mask                       0xFB
  
  #define C2TSEL                                   0x2
  #define C2TSEL_address                           0x29E
  #define C2TSEL_position                          0x2
  #define C2TSEL_size                              0x2
  #define C2TSEL_value_mask                        0xC
  #define C2TSEL_clear_mask                        0xF3
  
  #define C2TSEL1                                  0x3
  #define C2TSEL1_address                          0x29E
  #define C2TSEL1_position                         0x3
  #define C2TSEL1_size                             0x1
  #define C2TSEL1_value_mask                       0x8
  #define C2TSEL1_clear_mask                       0xF7
  
  #define C3TSEL0                                  0x4
  #define C3TSEL0_address                          0x29E
  #define C3TSEL0_position                         0x4
  #define C3TSEL0_size                             0x1
  #define C3TSEL0_value_mask                       0x10
  #define C3TSEL0_clear_mask                       0xEF
  
  #define C3TSEL                                   0x4
  #define C3TSEL_address                           0x29E
  #define C3TSEL_position                          0x4
  #define C3TSEL_size                              0x2
  #define C3TSEL_value_mask                        0x30
  #define C3TSEL_clear_mask                        0xCF
  
  #define C3TSEL1                                  0x5
  #define C3TSEL1_address                          0x29E
  #define C3TSEL1_position                         0x5
  #define C3TSEL1_size                             0x1
  #define C3TSEL1_value_mask                       0x20
  #define C3TSEL1_clear_mask                       0xDF
  
  #define C4TSEL                                   0x6
  #define C4TSEL_address                           0x29E
  #define C4TSEL_position                          0x6
  #define C4TSEL_size                              0x2
  #define C4TSEL_value_mask                        0xC0
  #define C4TSEL_clear_mask                        0x3F
  
  #define C4TSEL0                                  0x6
  #define C4TSEL0_address                          0x29E
  #define C4TSEL0_position                         0x6
  #define C4TSEL0_size                             0x1
  #define C4TSEL0_value_mask                       0x40
  #define C4TSEL0_clear_mask                       0xBF
  
  #define C4TSEL1                                  0x7
  #define C4TSEL1_address                          0x29E
  #define C4TSEL1_position                         0x7
  #define C4TSEL1_size                             0x1
  #define C4TSEL1_value_mask                       0x80
  #define C4TSEL1_clear_mask                       0x7F
  
  
  /*------------------------------------------#
  | CCPTMRS1                            0x29F |
  #-------------------------------------------#
  | - | - | - | - | - | - | C5TSEL1 | C5TSEL0 |
  #-------------------------------------------#
  | 7 | 6 | 5 | 4 | 3 | 2 | 1       | 0       |
  #------------------------------------------*/
  
  #define CCPTMRS1                                 0x0
  #define CCPTMRS1_address                         0x29F
  #define CCPTMRS1_position                        0x0
  #define CCPTMRS1_size                            0x8
  #define CCPTMRS1_value_mask                      0xFF
  #define CCPTMRS1_clear_mask                      0x0
  
  #define C5TSEL                                   0x0
  #define C5TSEL_address                           0x29F
  #define C5TSEL_position                          0x0
  #define C5TSEL_size                              0x2
  #define C5TSEL_value_mask                        0x3
  #define C5TSEL_clear_mask                        0xFC
  
  #define C5TSEL0                                  0x0
  #define C5TSEL0_address                          0x29F
  #define C5TSEL0_position                         0x0
  #define C5TSEL0_size                             0x1
  #define C5TSEL0_value_mask                       0x1
  #define C5TSEL0_clear_mask                       0xFE
  
  #define C5TSEL1                                  0x1
  #define C5TSEL1_address                          0x29F
  #define C5TSEL1_position                         0x1
  #define C5TSEL1_size                             0x1
  #define C5TSEL1_value_mask                       0x2
  #define C5TSEL1_clear_mask                       0xFD
  
  
  /*------------------------------#
  | CCPR3L                  0x311 |
  #-------------------------------#
  | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
  #------------------------------*/
  
  #define CCPR3L                                   0x0
  #define CCPR3L_address                           0x311
  #define CCPR3L_position                          0x0
  #define CCPR3L_size                              0x8
  #define CCPR3L_value_mask                        0xFF
  #define CCPR3L_clear_mask                        0x0
  
  
  /*------------------------------#
  | CCPR3H                  0x312 |
  #-------------------------------#
  | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
  #------------------------------*/
  
  #define CCPR3H                                   0x0
  #define CCPR3H_address                           0x312
  #define CCPR3H_position                          0x0
  #define CCPR3H_size                              0x8
  #define CCPR3H_value_mask                        0xFF
  #define CCPR3H_clear_mask                        0x0
  
  
  /*----------------------------------------------------------------#
  | CCP3CON                                                   0x313 |
  #-----------------------------------------------------------------#
  | P3M1 | P3M0 | DC3B1 | DC3B0 | CCP3M3 | CCP3M2 | CCP3M1 | CCP3M0 |
  #-----------------------------------------------------------------#
  | 7    | 6    | 5     | 4     | 3      | 2      | 1      | 0      |
  #----------------------------------------------------------------*/
  
  #define CCP3CON                                  0x0
  #define CCP3CON_address                          0x313
  #define CCP3CON_position                         0x0
  #define CCP3CON_size                             0x8
  #define CCP3CON_value_mask                       0xFF
  #define CCP3CON_clear_mask                       0x0
  
  #define CCP3M0                                   0x0
  #define CCP3M0_address                           0x313
  #define CCP3M0_position                          0x0
  #define CCP3M0_size                              0x1
  #define CCP3M0_value_mask                        0x1
  #define CCP3M0_clear_mask                        0xFE
  
  #define CCP3M1                                   0x1
  #define CCP3M1_address                           0x313
  #define CCP3M1_position                          0x1
  #define CCP3M1_size                              0x1
  #define CCP3M1_value_mask                        0x2
  #define CCP3M1_clear_mask                        0xFD
  
  #define CCP3M2                                   0x2
  #define CCP3M2_address                           0x313
  #define CCP3M2_position                          0x2
  #define CCP3M2_size                              0x1
  #define CCP3M2_value_mask                        0x4
  #define CCP3M2_clear_mask                        0xFB
  
  #define CCP3M3                                   0x3
  #define CCP3M3_address                           0x313
  #define CCP3M3_position                          0x3
  #define CCP3M3_size                              0x1
  #define CCP3M3_value_mask                        0x8
  #define CCP3M3_clear_mask                        0xF7
  
  #define DC3B0                                    0x4
  #define DC3B0_address                            0x313
  #define DC3B0_position                           0x4
  #define DC3B0_size                               0x1
  #define DC3B0_value_mask                         0x10
  #define DC3B0_clear_mask                         0xEF
  
  #define DC3B1                                    0x5
  #define DC3B1_address                            0x313
  #define DC3B1_position                           0x5
  #define DC3B1_size                               0x1
  #define DC3B1_value_mask                         0x20
  #define DC3B1_clear_mask                         0xDF
  
  #define P3M0                                     0x6
  #define P3M0_address                             0x313
  #define P3M0_position                            0x6
  #define P3M0_size                                0x1
  #define P3M0_value_mask                          0x40
  #define P3M0_clear_mask                          0xBF
  
  #define P3M1                                     0x7
  #define P3M1_address                             0x313
  #define P3M1_position                            0x7
  #define P3M1_size                                0x1
  #define P3M1_value_mask                          0x80
  #define P3M1_clear_mask                          0x7F
  
  
  /*---------------------------------------------------------------#
  | PWM3CON                                                  0x314 |
  #----------------------------------------------------------------#
  | P3RSEN | P3DC6 | P3DC5 | P3DC4 | P3DC3 | P3DC2 | P3DC1 | P3DC0 |
  #----------------------------------------------------------------#
  | 7      | 6     | 5     | 4     | 3     | 2     | 1     | 0     |
  #---------------------------------------------------------------*/
  
  #define PWM3CON                                  0x0
  #define PWM3CON_address                          0x314
  #define PWM3CON_position                         0x0
  #define PWM3CON_size                             0x8
  #define PWM3CON_value_mask                       0xFF
  #define PWM3CON_clear_mask                       0x0
  
  #define P3DC0                                    0x0
  #define P3DC0_address                            0x314
  #define P3DC0_position                           0x0
  #define P3DC0_size                               0x1
  #define P3DC0_value_mask                         0x1
  #define P3DC0_clear_mask                         0xFE
  
  #define P3DC1                                    0x1
  #define P3DC1_address                            0x314
  #define P3DC1_position                           0x1
  #define P3DC1_size                               0x1
  #define P3DC1_value_mask                         0x2
  #define P3DC1_clear_mask                         0xFD
  
  #define P3DC2                                    0x2
  #define P3DC2_address                            0x314
  #define P3DC2_position                           0x2
  #define P3DC2_size                               0x1
  #define P3DC2_value_mask                         0x4
  #define P3DC2_clear_mask                         0xFB
  
  #define P3DC3                                    0x3
  #define P3DC3_address                            0x314
  #define P3DC3_position                           0x3
  #define P3DC3_size                               0x1
  #define P3DC3_value_mask                         0x8
  #define P3DC3_clear_mask                         0xF7
  
  #define P3DC4                                    0x4
  #define P3DC4_address                            0x314
  #define P3DC4_position                           0x4
  #define P3DC4_size                               0x1
  #define P3DC4_value_mask                         0x10
  #define P3DC4_clear_mask                         0xEF
  
  #define P3DC5                                    0x5
  #define P3DC5_address                            0x314
  #define P3DC5_position                           0x5
  #define P3DC5_size                               0x1
  #define P3DC5_value_mask                         0x20
  #define P3DC5_clear_mask                         0xDF
  
  #define P3DC6                                    0x6
  #define P3DC6_address                            0x314
  #define P3DC6_position                           0x6
  #define P3DC6_size                               0x1
  #define P3DC6_value_mask                         0x40
  #define P3DC6_clear_mask                         0xBF
  
  #define P3RSEN                                   0x7
  #define P3RSEN_address                           0x314
  #define P3RSEN_position                          0x7
  #define P3RSEN_size                              0x1
  #define P3RSEN_value_mask                        0x80
  #define P3RSEN_clear_mask                        0x7F
  
  
  /*------------------------------------------------------------------------------#
  | CCP3AS                                                                  0x315 |
  #-------------------------------------------------------------------------------#
  | CCP3ASE | CCP3AS2 | CCP3AS1 | CCP3AS0 | PSS3AC1 | PSS3AC0 | PSS3BD1 | PSS3BD0 |
  #-------------------------------------------------------------------------------#
  | 7       | 6       | 5       | 4       | 3       | 2       | 1       | 0       |
  #------------------------------------------------------------------------------*/
  
  #define CCP3AS                                   0x0
  #define CCP3AS_address                           0x315
  #define CCP3AS_position                          0x0
  #define CCP3AS_size                              0x8
  #define CCP3AS_value_mask                        0xFF
  #define CCP3AS_clear_mask                        0x0
  
  #define PSS3BD0                                  0x0
  #define PSS3BD0_address                          0x315
  #define PSS3BD0_position                         0x0
  #define PSS3BD0_size                             0x1
  #define PSS3BD0_value_mask                       0x1
  #define PSS3BD0_clear_mask                       0xFE
  
  #define PSS3BD1                                  0x1
  #define PSS3BD1_address                          0x315
  #define PSS3BD1_position                         0x1
  #define PSS3BD1_size                             0x1
  #define PSS3BD1_value_mask                       0x2
  #define PSS3BD1_clear_mask                       0xFD
  
  #define PSS3AC0                                  0x2
  #define PSS3AC0_address                          0x315
  #define PSS3AC0_position                         0x2
  #define PSS3AC0_size                             0x1
  #define PSS3AC0_value_mask                       0x4
  #define PSS3AC0_clear_mask                       0xFB
  
  #define PSS3AC1                                  0x3
  #define PSS3AC1_address                          0x315
  #define PSS3AC1_position                         0x3
  #define PSS3AC1_size                             0x1
  #define PSS3AC1_value_mask                       0x8
  #define PSS3AC1_clear_mask                       0xF7
  
  #define CCP3AS0                                  0x4
  #define CCP3AS0_address                          0x315
  #define CCP3AS0_position                         0x4
  #define CCP3AS0_size                             0x1
  #define CCP3AS0_value_mask                       0x10
  #define CCP3AS0_clear_mask                       0xEF
  
  #define CCP3AS1                                  0x5
  #define CCP3AS1_address                          0x315
  #define CCP3AS1_position                         0x5
  #define CCP3AS1_size                             0x1
  #define CCP3AS1_value_mask                       0x20
  #define CCP3AS1_clear_mask                       0xDF
  
  #define CCP3AS2                                  0x6
  #define CCP3AS2_address                          0x315
  #define CCP3AS2_position                         0x6
  #define CCP3AS2_size                             0x1
  #define CCP3AS2_value_mask                       0x40
  #define CCP3AS2_clear_mask                       0xBF
  
  #define CCP3ASE                                  0x7
  #define CCP3ASE_address                          0x315
  #define CCP3ASE_position                         0x7
  #define CCP3ASE_size                             0x1
  #define CCP3ASE_value_mask                       0x80
  #define CCP3ASE_clear_mask                       0x7F
  
  
  /*-----------------------------------------------------#
  | PSTR3CON                                       0x316 |
  #------------------------------------------------------#
  | - | - | - | STR3SYNC | STR3D | STR3C | STR3B | STR3A |
  #------------------------------------------------------#
  | 7 | 6 | 5 | 4        | 3     | 2     | 1     | 0     |
  #-----------------------------------------------------*/
  
  #define PSTR3CON                                 0x0
  #define PSTR3CON_address                         0x316
  #define PSTR3CON_position                        0x0
  #define PSTR3CON_size                            0x8
  #define PSTR3CON_value_mask                      0xFF
  #define PSTR3CON_clear_mask                      0x0
  
  #define STR3A                                    0x0
  #define STR3A_address                            0x316
  #define STR3A_position                           0x0
  #define STR3A_size                               0x1
  #define STR3A_value_mask                         0x1
  #define STR3A_clear_mask                         0xFE
  
  #define STR3B                                    0x1
  #define STR3B_address                            0x316
  #define STR3B_position                           0x1
  #define STR3B_size                               0x1
  #define STR3B_value_mask                         0x2
  #define STR3B_clear_mask                         0xFD
  
  #define STR3C                                    0x2
  #define STR3C_address                            0x316
  #define STR3C_position                           0x2
  #define STR3C_size                               0x1
  #define STR3C_value_mask                         0x4
  #define STR3C_clear_mask                         0xFB
  
  #define STR3D                                    0x3
  #define STR3D_address                            0x316
  #define STR3D_position                           0x3
  #define STR3D_size                               0x1
  #define STR3D_value_mask                         0x8
  #define STR3D_clear_mask                         0xF7
  
  #define STR3SYNC                                 0x4
  #define STR3SYNC_address                         0x316
  #define STR3SYNC_position                        0x4
  #define STR3SYNC_size                            0x1
  #define STR3SYNC_value_mask                      0x10
  #define STR3SYNC_clear_mask                      0xEF
  
  
  /*------------------------------#
  | CCPR4L                  0x318 |
  #-------------------------------#
  | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
  #------------------------------*/
  
  #define CCPR4L                                   0x0
  #define CCPR4L_address                           0x318
  #define CCPR4L_position                          0x0
  #define CCPR4L_size                              0x8
  #define CCPR4L_value_mask                        0xFF
  #define CCPR4L_clear_mask                        0x0
  
  
  /*------------------------------#
  | CCPR4H                  0x319 |
  #-------------------------------#
  | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
  #------------------------------*/
  
  #define CCPR4H                                   0x0
  #define CCPR4H_address                           0x319
  #define CCPR4H_position                          0x0
  #define CCPR4H_size                              0x8
  #define CCPR4H_value_mask                        0xFF
  #define CCPR4H_clear_mask                        0x0
  
  
  /*----------------------------------------------------------#
  | CCP4CON                                             0x31A |
  #-----------------------------------------------------------#
  | - | - | DC4B1 | DC4B0 | CCP4M3 | CCP4M2 | CCP4M1 | CCP4M0 |
  #-----------------------------------------------------------#
  | 7 | 6 | 5     | 4     | 3      | 2      | 1      | 0      |
  #----------------------------------------------------------*/
  
  #define CCP4CON                                  0x0
  #define CCP4CON_address                          0x31A
  #define CCP4CON_position                         0x0
  #define CCP4CON_size                             0x8
  #define CCP4CON_value_mask                       0xFF
  #define CCP4CON_clear_mask                       0x0
  
  #define CCP4M0                                   0x0
  #define CCP4M0_address                           0x31A
  #define CCP4M0_position                          0x0
  #define CCP4M0_size                              0x1
  #define CCP4M0_value_mask                        0x1
  #define CCP4M0_clear_mask                        0xFE
  
  #define CCP4M1                                   0x1
  #define CCP4M1_address                           0x31A
  #define CCP4M1_position                          0x1
  #define CCP4M1_size                              0x1
  #define CCP4M1_value_mask                        0x2
  #define CCP4M1_clear_mask                        0xFD
  
  #define CCP4M2                                   0x2
  #define CCP4M2_address                           0x31A
  #define CCP4M2_position                          0x2
  #define CCP4M2_size                              0x1
  #define CCP4M2_value_mask                        0x4
  #define CCP4M2_clear_mask                        0xFB
  
  #define CCP4M3                                   0x3
  #define CCP4M3_address                           0x31A
  #define CCP4M3_position                          0x3
  #define CCP4M3_size                              0x1
  #define CCP4M3_value_mask                        0x8
  #define CCP4M3_clear_mask                        0xF7
  
  #define DC4B0                                    0x4
  #define DC4B0_address                            0x31A
  #define DC4B0_position                           0x4
  #define DC4B0_size                               0x1
  #define DC4B0_value_mask                         0x10
  #define DC4B0_clear_mask                         0xEF
  
  #define DC4B1                                    0x5
  #define DC4B1_address                            0x31A
  #define DC4B1_position                           0x5
  #define DC4B1_size                               0x1
  #define DC4B1_value_mask                         0x20
  #define DC4B1_clear_mask                         0xDF
  
  
  /*------------------------------#
  | CCPR5L                  0x31C |
  #-------------------------------#
  | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
  #------------------------------*/
  
  #define CCPR5L                                   0x0
  #define CCPR5L_address                           0x31C
  #define CCPR5L_position                          0x0
  #define CCPR5L_size                              0x8
  #define CCPR5L_value_mask                        0xFF
  #define CCPR5L_clear_mask                        0x0
  
  
  /*------------------------------#
  | CCPR5H                  0x31D |
  #-------------------------------#
  | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
  #------------------------------*/
  
  #define CCPR5H                                   0x0
  #define CCPR5H_address                           0x31D
  #define CCPR5H_position                          0x0
  #define CCPR5H_size                              0x8
  #define CCPR5H_value_mask                        0xFF
  #define CCPR5H_clear_mask                        0x0
  
  
  /*----------------------------------------------------------#
  | CCP5CON                                             0x31E |
  #-----------------------------------------------------------#
  | - | - | DC5B1 | DC5B0 | CCP5M3 | CCP5M2 | CCP5M1 | CCP5M0 |
  #-----------------------------------------------------------#
  | 7 | 6 | 5     | 4     | 3      | 2      | 1      | 0      |
  #----------------------------------------------------------*/
  
  #define CCP5CON                                  0x0
  #define CCP5CON_address                          0x31E
  #define CCP5CON_position                         0x0
  #define CCP5CON_size                             0x8
  #define CCP5CON_value_mask                       0xFF
  #define CCP5CON_clear_mask                       0x0
  
  #define CCP5M0                                   0x0
  #define CCP5M0_address                           0x31E
  #define CCP5M0_position                          0x0
  #define CCP5M0_size                              0x1
  #define CCP5M0_value_mask                        0x1
  #define CCP5M0_clear_mask                        0xFE
  
  #define CCP5M1                                   0x1
  #define CCP5M1_address                           0x31E
  #define CCP5M1_position                          0x1
  #define CCP5M1_size                              0x1
  #define CCP5M1_value_mask                        0x2
  #define CCP5M1_clear_mask                        0xFD
  
  #define CCP5M2                                   0x2
  #define CCP5M2_address                           0x31E
  #define CCP5M2_position                          0x2
  #define CCP5M2_size                              0x1
  #define CCP5M2_value_mask                        0x4
  #define CCP5M2_clear_mask                        0xFB
  
  #define CCP5M3                                   0x3
  #define CCP5M3_address                           0x31E
  #define CCP5M3_position                          0x3
  #define CCP5M3_size                              0x1
  #define CCP5M3_value_mask                        0x8
  #define CCP5M3_clear_mask                        0xF7
  
  #define DC5B0                                    0x4
  #define DC5B0_address                            0x31E
  #define DC5B0_position                           0x4
  #define DC5B0_size                               0x1
  #define DC5B0_value_mask                         0x10
  #define DC5B0_clear_mask                         0xEF
  
  #define DC5B1                                    0x5
  #define DC5B1_address                            0x31E
  #define DC5B1_position                           0x5
  #define DC5B1_size                               0x1
  #define DC5B1_value_mask                         0x20
  #define DC5B1_clear_mask                         0xDF
  
  
  /*----------------------------------------------------------------------#
  | IOCBP                                                           0x394 |
  #-----------------------------------------------------------------------#
  | IOCBP7 | IOCBP6 | IOCBP5 | IOCBP4 | IOCBP3 | IOCBP2 | IOCBP1 | IOCBP0 |
  #-----------------------------------------------------------------------#
  | 7      | 6      | 5      | 4      | 3      | 2      | 1      | 0      |
  #----------------------------------------------------------------------*/
  
  #define IOCBP                                    0x0
  #define IOCBP_address                            0x394
  #define IOCBP_position                           0x0
  #define IOCBP_size                               0x8
  #define IOCBP_value_mask                         0xFF
  #define IOCBP_clear_mask                         0x0
  
  #define IOCBP0                                   0x0
  #define IOCBP0_address                           0x394
  #define IOCBP0_position                          0x0
  #define IOCBP0_size                              0x1
  #define IOCBP0_value_mask                        0x1
  #define IOCBP0_clear_mask                        0xFE
  
  #define IOCBP1                                   0x1
  #define IOCBP1_address                           0x394
  #define IOCBP1_position                          0x1
  #define IOCBP1_size                              0x1
  #define IOCBP1_value_mask                        0x2
  #define IOCBP1_clear_mask                        0xFD
  
  #define IOCBP2                                   0x2
  #define IOCBP2_address                           0x394
  #define IOCBP2_position                          0x2
  #define IOCBP2_size                              0x1
  #define IOCBP2_value_mask                        0x4
  #define IOCBP2_clear_mask                        0xFB
  
  #define IOCBP3                                   0x3
  #define IOCBP3_address                           0x394
  #define IOCBP3_position                          0x3
  #define IOCBP3_size                              0x1
  #define IOCBP3_value_mask                        0x8
  #define IOCBP3_clear_mask                        0xF7
  
  #define IOCBP4                                   0x4
  #define IOCBP4_address                           0x394
  #define IOCBP4_position                          0x4
  #define IOCBP4_size                              0x1
  #define IOCBP4_value_mask                        0x10
  #define IOCBP4_clear_mask                        0xEF
  
  #define IOCBP5                                   0x5
  #define IOCBP5_address                           0x394
  #define IOCBP5_position                          0x5
  #define IOCBP5_size                              0x1
  #define IOCBP5_value_mask                        0x20
  #define IOCBP5_clear_mask                        0xDF
  
  #define IOCBP6                                   0x6
  #define IOCBP6_address                           0x394
  #define IOCBP6_position                          0x6
  #define IOCBP6_size                              0x1
  #define IOCBP6_value_mask                        0x40
  #define IOCBP6_clear_mask                        0xBF
  
  #define IOCBP7                                   0x7
  #define IOCBP7_address                           0x394
  #define IOCBP7_position                          0x7
  #define IOCBP7_size                              0x1
  #define IOCBP7_value_mask                        0x80
  #define IOCBP7_clear_mask                        0x7F
  
  
  /*----------------------------------------------------------------------#
  | IOCBN                                                           0x395 |
  #-----------------------------------------------------------------------#
  | IOCBN7 | IOCBN6 | IOCBN5 | IOCBN4 | IOCBN3 | IOCBN2 | IOCBN1 | IOCBN0 |
  #-----------------------------------------------------------------------#
  | 7      | 6      | 5      | 4      | 3      | 2      | 1      | 0      |
  #----------------------------------------------------------------------*/
  
  #define IOCBN0                                   0x0
  #define IOCBN0_address                           0x395
  #define IOCBN0_position                          0x0
  #define IOCBN0_size                              0x1
  #define IOCBN0_value_mask                        0x1
  #define IOCBN0_clear_mask                        0xFE
  
  #define IOCBN                                    0x0
  #define IOCBN_address                            0x395
  #define IOCBN_position                           0x0
  #define IOCBN_size                               0x8
  #define IOCBN_value_mask                         0xFF
  #define IOCBN_clear_mask                         0x0
  
  #define IOCBN1                                   0x1
  #define IOCBN1_address                           0x395
  #define IOCBN1_position                          0x1
  #define IOCBN1_size                              0x1
  #define IOCBN1_value_mask                        0x2
  #define IOCBN1_clear_mask                        0xFD
  
  #define IOCBN2                                   0x2
  #define IOCBN2_address                           0x395
  #define IOCBN2_position                          0x2
  #define IOCBN2_size                              0x1
  #define IOCBN2_value_mask                        0x4
  #define IOCBN2_clear_mask                        0xFB
  
  #define IOCBN3                                   0x3
  #define IOCBN3_address                           0x395
  #define IOCBN3_position                          0x3
  #define IOCBN3_size                              0x1
  #define IOCBN3_value_mask                        0x8
  #define IOCBN3_clear_mask                        0xF7
  
  #define IOCBN4                                   0x4
  #define IOCBN4_address                           0x395
  #define IOCBN4_position                          0x4
  #define IOCBN4_size                              0x1
  #define IOCBN4_value_mask                        0x10
  #define IOCBN4_clear_mask                        0xEF
  
  #define IOCBN5                                   0x5
  #define IOCBN5_address                           0x395
  #define IOCBN5_position                          0x5
  #define IOCBN5_size                              0x1
  #define IOCBN5_value_mask                        0x20
  #define IOCBN5_clear_mask                        0xDF
  
  #define IOCBN6                                   0x6
  #define IOCBN6_address                           0x395
  #define IOCBN6_position                          0x6
  #define IOCBN6_size                              0x1
  #define IOCBN6_value_mask                        0x40
  #define IOCBN6_clear_mask                        0xBF
  
  #define IOCBN7                                   0x7
  #define IOCBN7_address                           0x395
  #define IOCBN7_position                          0x7
  #define IOCBN7_size                              0x1
  #define IOCBN7_value_mask                        0x80
  #define IOCBN7_clear_mask                        0x7F
  
  
  /*----------------------------------------------------------------------#
  | IOCBF                                                           0x396 |
  #-----------------------------------------------------------------------#
  | IOCBF7 | IOCBF6 | IOCBF5 | IOCBF4 | IOCBF3 | IOCBF2 | IOCBF1 | IOCBF0 |
  #-----------------------------------------------------------------------#
  | 7      | 6      | 5      | 4      | 3      | 2      | 1      | 0      |
  #----------------------------------------------------------------------*/
  
  #define IOCBF0                                   0x0
  #define IOCBF0_address                           0x396
  #define IOCBF0_position                          0x0
  #define IOCBF0_size                              0x1
  #define IOCBF0_value_mask                        0x1
  #define IOCBF0_clear_mask                        0xFE
  
  #define IOCBF                                    0x0
  #define IOCBF_address                            0x396
  #define IOCBF_position                           0x0
  #define IOCBF_size                               0x8
  #define IOCBF_value_mask                         0xFF
  #define IOCBF_clear_mask                         0x0
  
  #define IOCBF1                                   0x1
  #define IOCBF1_address                           0x396
  #define IOCBF1_position                          0x1
  #define IOCBF1_size                              0x1
  #define IOCBF1_value_mask                        0x2
  #define IOCBF1_clear_mask                        0xFD
  
  #define IOCBF2                                   0x2
  #define IOCBF2_address                           0x396
  #define IOCBF2_position                          0x2
  #define IOCBF2_size                              0x1
  #define IOCBF2_value_mask                        0x4
  #define IOCBF2_clear_mask                        0xFB
  
  #define IOCBF3                                   0x3
  #define IOCBF3_address                           0x396
  #define IOCBF3_position                          0x3
  #define IOCBF3_size                              0x1
  #define IOCBF3_value_mask                        0x8
  #define IOCBF3_clear_mask                        0xF7
  
  #define IOCBF4                                   0x4
  #define IOCBF4_address                           0x396
  #define IOCBF4_position                          0x4
  #define IOCBF4_size                              0x1
  #define IOCBF4_value_mask                        0x10
  #define IOCBF4_clear_mask                        0xEF
  
  #define IOCBF5                                   0x5
  #define IOCBF5_address                           0x396
  #define IOCBF5_position                          0x5
  #define IOCBF5_size                              0x1
  #define IOCBF5_value_mask                        0x20
  #define IOCBF5_clear_mask                        0xDF
  
  #define IOCBF6                                   0x6
  #define IOCBF6_address                           0x396
  #define IOCBF6_position                          0x6
  #define IOCBF6_size                              0x1
  #define IOCBF6_value_mask                        0x40
  #define IOCBF6_clear_mask                        0xBF
  
  #define IOCBF7                                   0x7
  #define IOCBF7_address                           0x396
  #define IOCBF7_position                          0x7
  #define IOCBF7_size                              0x1
  #define IOCBF7_value_mask                        0x80
  #define IOCBF7_clear_mask                        0x7F
  
  
  /*------------------------------#
  | TMR4                    0x415 |
  #-------------------------------#
  | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
  #------------------------------*/
  
  #define TMR4                                     0x0
  #define TMR4_address                             0x415
  #define TMR4_position                            0x0
  #define TMR4_size                                0x8
  #define TMR4_value_mask                          0xFF
  #define TMR4_clear_mask                          0x0
  
  
  /*------------------------------#
  | PR4                     0x416 |
  #-------------------------------#
  | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
  #------------------------------*/
  
  #define PR4                                      0x0
  #define PR4_address                              0x416
  #define PR4_position                             0x0
  #define PR4_size                                 0x8
  #define PR4_value_mask                           0xFF
  #define PR4_clear_mask                           0x0
  
  
  /*---------------------------------------------------------------------------#
  | T4CON                                                                0x417 |
  #----------------------------------------------------------------------------#
  | - | T4OUTPS3 | T4OUTPS2 | T4OUTPS1 | T4OUTPS0 | TMR4ON | T4CKPS1 | T4CKPS0 |
  #----------------------------------------------------------------------------#
  | 7 | 6        | 5        | 4        | 3        | 2      | 1       | 0       |
  #---------------------------------------------------------------------------*/
  
  #define T4CON                                    0x0
  #define T4CON_address                            0x417
  #define T4CON_position                           0x0
  #define T4CON_size                               0x8
  #define T4CON_value_mask                         0xFF
  #define T4CON_clear_mask                         0x0
  
  #define T4CKPS0                                  0x0
  #define T4CKPS0_address                          0x417
  #define T4CKPS0_position                         0x0
  #define T4CKPS0_size                             0x1
  #define T4CKPS0_value_mask                       0x1
  #define T4CKPS0_clear_mask                       0xFE
  
  #define T4CKPS                                   0x0
  #define T4CKPS_address                           0x417
  #define T4CKPS_position                          0x0
  #define T4CKPS_size                              0x2
  #define T4CKPS_value_mask                        0x3
  #define T4CKPS_clear_mask                        0xFC
  
  #define T4CKPS1                                  0x1
  #define T4CKPS1_address                          0x417
  #define T4CKPS1_position                         0x1
  #define T4CKPS1_size                             0x1
  #define T4CKPS1_value_mask                       0x2
  #define T4CKPS1_clear_mask                       0xFD
  
  #define TMR4ON                                   0x2
  #define TMR4ON_address                           0x417
  #define TMR4ON_position                          0x2
  #define TMR4ON_size                              0x1
  #define TMR4ON_value_mask                        0x4
  #define TMR4ON_clear_mask                        0xFB
  
  #define T4OUTPS                                  0x3
  #define T4OUTPS_address                          0x417
  #define T4OUTPS_position                         0x3
  #define T4OUTPS_size                             0x4
  #define T4OUTPS_value_mask                       0x78
  #define T4OUTPS_clear_mask                       0x87
  
  #define T4OUTPS0                                 0x3
  #define T4OUTPS0_address                         0x417
  #define T4OUTPS0_position                        0x3
  #define T4OUTPS0_size                            0x1
  #define T4OUTPS0_value_mask                      0x8
  #define T4OUTPS0_clear_mask                      0xF7
  
  #define T4OUTPS1                                 0x4
  #define T4OUTPS1_address                         0x417
  #define T4OUTPS1_position                        0x4
  #define T4OUTPS1_size                            0x1
  #define T4OUTPS1_value_mask                      0x10
  #define T4OUTPS1_clear_mask                      0xEF
  
  #define T4OUTPS2                                 0x5
  #define T4OUTPS2_address                         0x417
  #define T4OUTPS2_position                        0x5
  #define T4OUTPS2_size                            0x1
  #define T4OUTPS2_value_mask                      0x20
  #define T4OUTPS2_clear_mask                      0xDF
  
  #define T4OUTPS3                                 0x6
  #define T4OUTPS3_address                         0x417
  #define T4OUTPS3_position                        0x6
  #define T4OUTPS3_size                            0x1
  #define T4OUTPS3_value_mask                      0x40
  #define T4OUTPS3_clear_mask                      0xBF
  
  
  /*------------------------------#
  | TMR6                    0x41C |
  #-------------------------------#
  | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
  #------------------------------*/
  
  #define TMR6                                     0x0
  #define TMR6_address                             0x41C
  #define TMR6_position                            0x0
  #define TMR6_size                                0x8
  #define TMR6_value_mask                          0xFF
  #define TMR6_clear_mask                          0x0
  
  
  /*------------------------------#
  | PR6                     0x41D |
  #-------------------------------#
  | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
  #------------------------------*/
  
  #define PR6                                      0x0
  #define PR6_address                              0x41D
  #define PR6_position                             0x0
  #define PR6_size                                 0x8
  #define PR6_value_mask                           0xFF
  #define PR6_clear_mask                           0x0
  
  
  /*---------------------------------------------------------------------------#
  | T6CON                                                                0x41E |
  #----------------------------------------------------------------------------#
  | - | T6OUTPS3 | T6OUTPS2 | T6OUTPS1 | T6OUTPS0 | TMR6ON | T6CKPS1 | T6CKPS0 |
  #----------------------------------------------------------------------------#
  | 7 | 6        | 5        | 4        | 3        | 2      | 1       | 0       |
  #---------------------------------------------------------------------------*/
  
  #define T6CON                                    0x0
  #define T6CON_address                            0x41E
  #define T6CON_position                           0x0
  #define T6CON_size                               0x8
  #define T6CON_value_mask                         0xFF
  #define T6CON_clear_mask                         0x0
  
  #define T6CKPS0                                  0x0
  #define T6CKPS0_address                          0x41E
  #define T6CKPS0_position                         0x0
  #define T6CKPS0_size                             0x1
  #define T6CKPS0_value_mask                       0x1
  #define T6CKPS0_clear_mask                       0xFE
  
  #define T6CKPS                                   0x0
  #define T6CKPS_address                           0x41E
  #define T6CKPS_position                          0x0
  #define T6CKPS_size                              0x2
  #define T6CKPS_value_mask                        0x3
  #define T6CKPS_clear_mask                        0xFC
  
  #define T6CKPS1                                  0x1
  #define T6CKPS1_address                          0x41E
  #define T6CKPS1_position                         0x1
  #define T6CKPS1_size                             0x1
  #define T6CKPS1_value_mask                       0x2
  #define T6CKPS1_clear_mask                       0xFD
  
  #define TMR6ON                                   0x2
  #define TMR6ON_address                           0x41E
  #define TMR6ON_position                          0x2
  #define TMR6ON_size                              0x1
  #define TMR6ON_value_mask                        0x4
  #define TMR6ON_clear_mask                        0xFB
  
  #define T6OUTPS0                                 0x3
  #define T6OUTPS0_address                         0x41E
  #define T6OUTPS0_position                        0x3
  #define T6OUTPS0_size                            0x1
  #define T6OUTPS0_value_mask                      0x8
  #define T6OUTPS0_clear_mask                      0xF7
  
  #define T6OUTPS                                  0x3
  #define T6OUTPS_address                          0x41E
  #define T6OUTPS_position                         0x3
  #define T6OUTPS_size                             0x4
  #define T6OUTPS_value_mask                       0x78
  #define T6OUTPS_clear_mask                       0x87
  
  #define T6OUTPS1                                 0x4
  #define T6OUTPS1_address                         0x41E
  #define T6OUTPS1_position                        0x4
  #define T6OUTPS1_size                            0x1
  #define T6OUTPS1_value_mask                      0x10
  #define T6OUTPS1_clear_mask                      0xEF
  
  #define T6OUTPS2                                 0x5
  #define T6OUTPS2_address                         0x41E
  #define T6OUTPS2_position                        0x5
  #define T6OUTPS2_size                            0x1
  #define T6OUTPS2_value_mask                      0x20
  #define T6OUTPS2_clear_mask                      0xDF
  
  #define T6OUTPS3                                 0x6
  #define T6OUTPS3_address                         0x41E
  #define T6OUTPS3_position                        0x6
  #define T6OUTPS3_size                            0x1
  #define T6OUTPS3_value_mask                      0x40
  #define T6OUTPS3_clear_mask                      0xBF
  
  
  /*-----------------------------------------------------#
  | LCDCON                                         0x791 |
  #------------------------------------------------------#
  | LCDEN | SLPEN | WERR | - | CS1 | CS0 | LMUX1 | LMUX0 |
  #------------------------------------------------------#
  | 7     | 6     | 5    | 4 | 3   | 2   | 1     | 0     |
  #-----------------------------------------------------*/
  
  #define LCDCON                                   0x0
  #define LCDCON_address                           0x791
  #define LCDCON_position                          0x0
  #define LCDCON_size                              0x8
  #define LCDCON_value_mask                        0xFF
  #define LCDCON_clear_mask                        0x0
  
  #define LMUX0                                    0x0
  #define LMUX0_address                            0x791
  #define LMUX0_position                           0x0
  #define LMUX0_size                               0x1
  #define LMUX0_value_mask                         0x1
  #define LMUX0_clear_mask                         0xFE
  
  #define LMUX                                     0x0
  #define LMUX_address                             0x791
  #define LMUX_position                            0x0
  #define LMUX_size                                0x2
  #define LMUX_value_mask                          0x3
  #define LMUX_clear_mask                          0xFC
  
  #define LMUX1                                    0x1
  #define LMUX1_address                            0x791
  #define LMUX1_position                           0x1
  #define LMUX1_size                               0x1
  #define LMUX1_value_mask                         0x2
  #define LMUX1_clear_mask                         0xFD
  
  #define CS                                       0x2
  #define CS_address                               0x791
  #define CS_position                              0x2
  #define CS_size                                  0x2
  #define CS_value_mask                            0xC
  #define CS_clear_mask                            0xF3
  
  #define CS0                                      0x2
  #define CS0_address                              0x791
  #define CS0_position                             0x2
  #define CS0_size                                 0x1
  #define CS0_value_mask                           0x4
  #define CS0_clear_mask                           0xFB
  
  #define CS1                                      0x3
  #define CS1_address                              0x791
  #define CS1_position                             0x3
  #define CS1_size                                 0x1
  #define CS1_value_mask                           0x8
  #define CS1_clear_mask                           0xF7
  
  #define WERR                                     0x5
  #define WERR_address                             0x791
  #define WERR_position                            0x5
  #define WERR_size                                0x1
  #define WERR_value_mask                          0x20
  #define WERR_clear_mask                          0xDF
  
  #define SLPEN                                    0x6
  #define SLPEN_address                            0x791
  #define SLPEN_position                           0x6
  #define SLPEN_size                               0x1
  #define SLPEN_value_mask                         0x40
  #define SLPEN_clear_mask                         0xBF
  
  #define LCDEN                                    0x7
  #define LCDEN_address                            0x791
  #define LCDEN_position                           0x7
  #define LCDEN_size                               0x1
  #define LCDEN_value_mask                         0x80
  #define LCDEN_clear_mask                         0x7F
  
  
  /*-------------------------------------------------#
  | LCDPS                                      0x792 |
  #--------------------------------------------------#
  | WFT | BIASMD | LCDA | WA | LP3 | LP2 | LP1 | LP0 |
  #--------------------------------------------------#
  | 7   | 6      | 5    | 4  | 3   | 2   | 1   | 0   |
  #-------------------------------------------------*/
  
  #define LCDPS                                    0x0
  #define LCDPS_address                            0x792
  #define LCDPS_position                           0x0
  #define LCDPS_size                               0x8
  #define LCDPS_value_mask                         0xFF
  #define LCDPS_clear_mask                         0x0
  
  #define LP                                       0x0
  #define LP_address                               0x792
  #define LP_position                              0x0
  #define LP_size                                  0x4
  #define LP_value_mask                            0xF
  #define LP_clear_mask                            0xF0
  
  #define LP0                                      0x0
  #define LP0_address                              0x792
  #define LP0_position                             0x0
  #define LP0_size                                 0x1
  #define LP0_value_mask                           0x1
  #define LP0_clear_mask                           0xFE
  
  #define LP1                                      0x1
  #define LP1_address                              0x792
  #define LP1_position                             0x1
  #define LP1_size                                 0x1
  #define LP1_value_mask                           0x2
  #define LP1_clear_mask                           0xFD
  
  #define LP2                                      0x2
  #define LP2_address                              0x792
  #define LP2_position                             0x2
  #define LP2_size                                 0x1
  #define LP2_value_mask                           0x4
  #define LP2_clear_mask                           0xFB
  
  #define LP3                                      0x3
  #define LP3_address                              0x792
  #define LP3_position                             0x3
  #define LP3_size                                 0x1
  #define LP3_value_mask                           0x8
  #define LP3_clear_mask                           0xF7
  
  #define WA                                       0x4
  #define WA_address                               0x792
  #define WA_position                              0x4
  #define WA_size                                  0x1
  #define WA_value_mask                            0x10
  #define WA_clear_mask                            0xEF
  
  #define LCDA                                     0x5
  #define LCDA_address                             0x792
  #define LCDA_position                            0x5
  #define LCDA_size                                0x1
  #define LCDA_value_mask                          0x20
  #define LCDA_clear_mask                          0xDF
  
  #define BIASMD                                   0x6
  #define BIASMD_address                           0x792
  #define BIASMD_position                          0x6
  #define BIASMD_size                              0x1
  #define BIASMD_value_mask                        0x40
  #define BIASMD_clear_mask                        0xBF
  
  #define WFT                                      0x7
  #define WFT_address                              0x792
  #define WFT_position                             0x7
  #define WFT_size                                 0x1
  #define WFT_value_mask                           0x80
  #define WFT_clear_mask                           0x7F
  
  
  /*---------------------------------------------------------------#
  | LCDREF                                                   0x793 |
  #----------------------------------------------------------------#
  | LCDIRE | LCDIRS | LCDIRI | - | VLCD3PE | VLCD2PE | VLCD1PE | - |
  #----------------------------------------------------------------#
  | 7      | 6      | 5      | 4 | 3       | 2       | 1       | 0 |
  #---------------------------------------------------------------*/
  
  #define LCDREF                                   0x0
  #define LCDREF_address                           0x793
  #define LCDREF_position                          0x0
  #define LCDREF_size                              0x8
  #define LCDREF_value_mask                        0xFF
  #define LCDREF_clear_mask                        0x0
  
  #define VLCD1PE                                  0x1
  #define VLCD1PE_address                          0x793
  #define VLCD1PE_position                         0x1
  #define VLCD1PE_size                             0x1
  #define VLCD1PE_value_mask                       0x2
  #define VLCD1PE_clear_mask                       0xFD
  
  #define VLCD2PE                                  0x2
  #define VLCD2PE_address                          0x793
  #define VLCD2PE_position                         0x2
  #define VLCD2PE_size                             0x1
  #define VLCD2PE_value_mask                       0x4
  #define VLCD2PE_clear_mask                       0xFB
  
  #define VLCD3PE                                  0x3
  #define VLCD3PE_address                          0x793
  #define VLCD3PE_position                         0x3
  #define VLCD3PE_size                             0x1
  #define VLCD3PE_value_mask                       0x8
  #define VLCD3PE_clear_mask                       0xF7
  
  #define LCDIRI                                   0x5
  #define LCDIRI_address                           0x793
  #define LCDIRI_position                          0x5
  #define LCDIRI_size                              0x1
  #define LCDIRI_value_mask                        0x20
  #define LCDIRI_clear_mask                        0xDF
  
  #define LCDIRS                                   0x6
  #define LCDIRS_address                           0x793
  #define LCDIRS_position                          0x6
  #define LCDIRS_size                              0x1
  #define LCDIRS_value_mask                        0x40
  #define LCDIRS_clear_mask                        0xBF
  
  #define LCDIRE                                   0x7
  #define LCDIRE_address                           0x793
  #define LCDIRE_position                          0x7
  #define LCDIRE_size                              0x1
  #define LCDIRE_value_mask                        0x80
  #define LCDIRE_clear_mask                        0x7F
  
  
  /*------------------------------------------------#
  | LCDCST                                    0x794 |
  #-------------------------------------------------#
  | - | - | - | - | - | LCDCST2 | LCDCST1 | LCDCST0 |
  #-------------------------------------------------#
  | 7 | 6 | 5 | 4 | 3 | 2       | 1       | 0       |
  #------------------------------------------------*/
  
  #define LCDCST0                                  0x0
  #define LCDCST0_address                          0x794
  #define LCDCST0_position                         0x0
  #define LCDCST0_size                             0x1
  #define LCDCST0_value_mask                       0x1
  #define LCDCST0_clear_mask                       0xFE
  
  #define LCDCST                                   0x0
  #define LCDCST_address                           0x794
  #define LCDCST_position                          0x0
  #define LCDCST_size                              0x3
  #define LCDCST_value_mask                        0x7
  #define LCDCST_clear_mask                        0xF8
  
  #define LCDCST1                                  0x1
  #define LCDCST1_address                          0x794
  #define LCDCST1_position                         0x1
  #define LCDCST1_size                             0x1
  #define LCDCST1_value_mask                       0x2
  #define LCDCST1_clear_mask                       0xFD
  
  #define LCDCST2                                  0x2
  #define LCDCST2_address                          0x794
  #define LCDCST2_position                         0x2
  #define LCDCST2_size                             0x1
  #define LCDCST2_value_mask                       0x4
  #define LCDCST2_clear_mask                       0xFB
  
  
  /*-----------------------------------------------------------------#
  | LCDRL                                                      0x795 |
  #------------------------------------------------------------------#
  | LRLAP1 | LRLAP0 | LRLBP1 | LRLBP0 | - | LRLAT2 | LRLAT1 | LRLAT0 |
  #------------------------------------------------------------------#
  | 7      | 6      | 5      | 4      | 3 | 2      | 1      | 0      |
  #-----------------------------------------------------------------*/
  
  #define LCDRL                                    0x0
  #define LCDRL_address                            0x795
  #define LCDRL_position                           0x0
  #define LCDRL_size                               0x8
  #define LCDRL_value_mask                         0xFF
  #define LCDRL_clear_mask                         0x0
  
  #define LRLAT0                                   0x0
  #define LRLAT0_address                           0x795
  #define LRLAT0_position                          0x0
  #define LRLAT0_size                              0x1
  #define LRLAT0_value_mask                        0x1
  #define LRLAT0_clear_mask                        0xFE
  
  #define LRLAT                                    0x0
  #define LRLAT_address                            0x795
  #define LRLAT_position                           0x0
  #define LRLAT_size                               0x3
  #define LRLAT_value_mask                         0x7
  #define LRLAT_clear_mask                         0xF8
  
  #define LRLAT1                                   0x1
  #define LRLAT1_address                           0x795
  #define LRLAT1_position                          0x1
  #define LRLAT1_size                              0x1
  #define LRLAT1_value_mask                        0x2
  #define LRLAT1_clear_mask                        0xFD
  
  #define LRLAT2                                   0x2
  #define LRLAT2_address                           0x795
  #define LRLAT2_position                          0x2
  #define LRLAT2_size                              0x1
  #define LRLAT2_value_mask                        0x4
  #define LRLAT2_clear_mask                        0xFB
  
  #define LRLBP                                    0x4
  #define LRLBP_address                            0x795
  #define LRLBP_position                           0x4
  #define LRLBP_size                               0x2
  #define LRLBP_value_mask                         0x30
  #define LRLBP_clear_mask                         0xCF
  
  #define LRLBP0                                   0x4
  #define LRLBP0_address                           0x795
  #define LRLBP0_position                          0x4
  #define LRLBP0_size                              0x1
  #define LRLBP0_value_mask                        0x10
  #define LRLBP0_clear_mask                        0xEF
  
  #define LRLBP1                                   0x5
  #define LRLBP1_address                           0x795
  #define LRLBP1_position                          0x5
  #define LRLBP1_size                              0x1
  #define LRLBP1_value_mask                        0x20
  #define LRLBP1_clear_mask                        0xDF
  
  #define LRLAP0                                   0x6
  #define LRLAP0_address                           0x795
  #define LRLAP0_position                          0x6
  #define LRLAP0_size                              0x1
  #define LRLAP0_value_mask                        0x40
  #define LRLAP0_clear_mask                        0xBF
  
  #define LRLAP                                    0x6
  #define LRLAP_address                            0x795
  #define LRLAP_position                           0x6
  #define LRLAP_size                               0x2
  #define LRLAP_value_mask                         0xC0
  #define LRLAP_clear_mask                         0x3F
  
  #define LRLAP1                                   0x7
  #define LRLAP1_address                           0x795
  #define LRLAP1_position                          0x7
  #define LRLAP1_size                              0x1
  #define LRLAP1_value_mask                        0x80
  #define LRLAP1_clear_mask                        0x7F
  
  
  /*----------------------------------------------#
  | LCDSE0                                  0x798 |
  #-----------------------------------------------#
  | SE7 | SE6 | SE5 | SE4 | SE3 | SE2 | SE1 | SE0 |
  #-----------------------------------------------#
  | 7   | 6   | 5   | 4   | 3   | 2   | 1   | 0   |
  #----------------------------------------------*/
  
  #define LCDSE0                                   0x0
  #define LCDSE0_address                           0x798
  #define LCDSE0_position                          0x0
  #define LCDSE0_size                              0x8
  #define LCDSE0_value_mask                        0xFF
  #define LCDSE0_clear_mask                        0x0
  
  #define SE0                                      0x0
  #define SE0_address                              0x798
  #define SE0_position                             0x0
  #define SE0_size                                 0x1
  #define SE0_value_mask                           0x1
  #define SE0_clear_mask                           0xFE
  
  #define SE1                                      0x1
  #define SE1_address                              0x798
  #define SE1_position                             0x1
  #define SE1_size                                 0x1
  #define SE1_value_mask                           0x2
  #define SE1_clear_mask                           0xFD
  
  #define SE2                                      0x2
  #define SE2_address                              0x798
  #define SE2_position                             0x2
  #define SE2_size                                 0x1
  #define SE2_value_mask                           0x4
  #define SE2_clear_mask                           0xFB
  
  #define SE3                                      0x3
  #define SE3_address                              0x798
  #define SE3_position                             0x3
  #define SE3_size                                 0x1
  #define SE3_value_mask                           0x8
  #define SE3_clear_mask                           0xF7
  
  #define SE4                                      0x4
  #define SE4_address                              0x798
  #define SE4_position                             0x4
  #define SE4_size                                 0x1
  #define SE4_value_mask                           0x10
  #define SE4_clear_mask                           0xEF
  
  #define SE5                                      0x5
  #define SE5_address                              0x798
  #define SE5_position                             0x5
  #define SE5_size                                 0x1
  #define SE5_value_mask                           0x20
  #define SE5_clear_mask                           0xDF
  
  #define SE6                                      0x6
  #define SE6_address                              0x798
  #define SE6_position                             0x6
  #define SE6_size                                 0x1
  #define SE6_value_mask                           0x40
  #define SE6_clear_mask                           0xBF
  
  #define SE7                                      0x7
  #define SE7_address                              0x798
  #define SE7_position                             0x7
  #define SE7_size                                 0x1
  #define SE7_value_mask                           0x80
  #define SE7_clear_mask                           0x7F
  
  
  /*----------------------------------------------------#
  | LCDSE1                                        0x799 |
  #-----------------------------------------------------#
  | SE15 | SE14 | SE13 | SE12 | SE11 | SE10 | SE9 | SE8 |
  #-----------------------------------------------------#
  | 7    | 6    | 5    | 4    | 3    | 2    | 1   | 0   |
  #----------------------------------------------------*/
  
  #define LCDSE1                                   0x0
  #define LCDSE1_address                           0x799
  #define LCDSE1_position                          0x0
  #define LCDSE1_size                              0x8
  #define LCDSE1_value_mask                        0xFF
  #define LCDSE1_clear_mask                        0x0
  
  #define SE8                                      0x0
  #define SE8_address                              0x799
  #define SE8_position                             0x0
  #define SE8_size                                 0x1
  #define SE8_value_mask                           0x1
  #define SE8_clear_mask                           0xFE
  
  #define SE9                                      0x1
  #define SE9_address                              0x799
  #define SE9_position                             0x1
  #define SE9_size                                 0x1
  #define SE9_value_mask                           0x2
  #define SE9_clear_mask                           0xFD
  
  #define SE10                                     0x2
  #define SE10_address                             0x799
  #define SE10_position                            0x2
  #define SE10_size                                0x1
  #define SE10_value_mask                          0x4
  #define SE10_clear_mask                          0xFB
  
  #define SE11                                     0x3
  #define SE11_address                             0x799
  #define SE11_position                            0x3
  #define SE11_size                                0x1
  #define SE11_value_mask                          0x8
  #define SE11_clear_mask                          0xF7
  
  #define SE12                                     0x4
  #define SE12_address                             0x799
  #define SE12_position                            0x4
  #define SE12_size                                0x1
  #define SE12_value_mask                          0x10
  #define SE12_clear_mask                          0xEF
  
  #define SE13                                     0x5
  #define SE13_address                             0x799
  #define SE13_position                            0x5
  #define SE13_size                                0x1
  #define SE13_value_mask                          0x20
  #define SE13_clear_mask                          0xDF
  
  #define SE14                                     0x6
  #define SE14_address                             0x799
  #define SE14_position                            0x6
  #define SE14_size                                0x1
  #define SE14_value_mask                          0x40
  #define SE14_clear_mask                          0xBF
  
  #define SE15                                     0x7
  #define SE15_address                             0x799
  #define SE15_position                            0x7
  #define SE15_size                                0x1
  #define SE15_value_mask                          0x80
  #define SE15_clear_mask                          0x7F
  
  
  /*--------------------------------------------------------------------------------------#
  | LCDDATA0                                                                        0x7A0 |
  #---------------------------------------------------------------------------------------#
  | SEG7COM0 | SEG6COM0 | SEG5COM0 | SEG4COM0 | SEG3COM0 | SEG2COM0 | SEG1COM0 | SEG0COM0 |
  #---------------------------------------------------------------------------------------#
  | 7        | 6        | 5        | 4        | 3        | 2        | 1        | 0        |
  #--------------------------------------------------------------------------------------*/
  
  #define LCDDATA0                                 0x0
  #define LCDDATA0_address                         0x7A0
  #define LCDDATA0_position                        0x0
  #define LCDDATA0_size                            0x8
  #define LCDDATA0_value_mask                      0xFF
  #define LCDDATA0_clear_mask                      0x0
  
  #define SEG0COM0                                 0x0
  #define SEG0COM0_address                         0x7A0
  #define SEG0COM0_position                        0x0
  #define SEG0COM0_size                            0x1
  #define SEG0COM0_value_mask                      0x1
  #define SEG0COM0_clear_mask                      0xFE
  
  #define SEG1COM0                                 0x1
  #define SEG1COM0_address                         0x7A0
  #define SEG1COM0_position                        0x1
  #define SEG1COM0_size                            0x1
  #define SEG1COM0_value_mask                      0x2
  #define SEG1COM0_clear_mask                      0xFD
  
  #define SEG2COM0                                 0x2
  #define SEG2COM0_address                         0x7A0
  #define SEG2COM0_position                        0x2
  #define SEG2COM0_size                            0x1
  #define SEG2COM0_value_mask                      0x4
  #define SEG2COM0_clear_mask                      0xFB
  
  #define SEG3COM0                                 0x3
  #define SEG3COM0_address                         0x7A0
  #define SEG3COM0_position                        0x3
  #define SEG3COM0_size                            0x1
  #define SEG3COM0_value_mask                      0x8
  #define SEG3COM0_clear_mask                      0xF7
  
  #define SEG4COM0                                 0x4
  #define SEG4COM0_address                         0x7A0
  #define SEG4COM0_position                        0x4
  #define SEG4COM0_size                            0x1
  #define SEG4COM0_value_mask                      0x10
  #define SEG4COM0_clear_mask                      0xEF
  
  #define SEG5COM0                                 0x5
  #define SEG5COM0_address                         0x7A0
  #define SEG5COM0_position                        0x5
  #define SEG5COM0_size                            0x1
  #define SEG5COM0_value_mask                      0x20
  #define SEG5COM0_clear_mask                      0xDF
  
  #define SEG6COM0                                 0x6
  #define SEG6COM0_address                         0x7A0
  #define SEG6COM0_position                        0x6
  #define SEG6COM0_size                            0x1
  #define SEG6COM0_value_mask                      0x40
  #define SEG6COM0_clear_mask                      0xBF
  
  #define SEG7COM0                                 0x7
  #define SEG7COM0_address                         0x7A0
  #define SEG7COM0_position                        0x7
  #define SEG7COM0_size                            0x1
  #define SEG7COM0_value_mask                      0x80
  #define SEG7COM0_clear_mask                      0x7F
  
  
  /*--------------------------------------------------------------------------------------------#
  | LCDDATA1                                                                              0x7A1 |
  #---------------------------------------------------------------------------------------------#
  | SEG15COM0 | SEG14COM0 | SEG13COM0 | SEG12COM0 | SEG11COM0 | SEG10COM0 | SEG9COM0 | SEG8COM0 |
  #---------------------------------------------------------------------------------------------#
  | 7         | 6         | 5         | 4         | 3         | 2         | 1        | 0        |
  #--------------------------------------------------------------------------------------------*/
  
  #define LCDDATA1                                 0x0
  #define LCDDATA1_address                         0x7A1
  #define LCDDATA1_position                        0x0
  #define LCDDATA1_size                            0x8
  #define LCDDATA1_value_mask                      0xFF
  #define LCDDATA1_clear_mask                      0x0
  
  #define SEG8COM0                                 0x0
  #define SEG8COM0_address                         0x7A1
  #define SEG8COM0_position                        0x0
  #define SEG8COM0_size                            0x1
  #define SEG8COM0_value_mask                      0x1
  #define SEG8COM0_clear_mask                      0xFE
  
  #define SEG9COM0                                 0x1
  #define SEG9COM0_address                         0x7A1
  #define SEG9COM0_position                        0x1
  #define SEG9COM0_size                            0x1
  #define SEG9COM0_value_mask                      0x2
  #define SEG9COM0_clear_mask                      0xFD
  
  #define SEG10COM0                                0x2
  #define SEG10COM0_address                        0x7A1
  #define SEG10COM0_position                       0x2
  #define SEG10COM0_size                           0x1
  #define SEG10COM0_value_mask                     0x4
  #define SEG10COM0_clear_mask                     0xFB
  
  #define SEG11COM0                                0x3
  #define SEG11COM0_address                        0x7A1
  #define SEG11COM0_position                       0x3
  #define SEG11COM0_size                           0x1
  #define SEG11COM0_value_mask                     0x8
  #define SEG11COM0_clear_mask                     0xF7
  
  #define SEG12COM0                                0x4
  #define SEG12COM0_address                        0x7A1
  #define SEG12COM0_position                       0x4
  #define SEG12COM0_size                           0x1
  #define SEG12COM0_value_mask                     0x10
  #define SEG12COM0_clear_mask                     0xEF
  
  #define SEG13COM0                                0x5
  #define SEG13COM0_address                        0x7A1
  #define SEG13COM0_position                       0x5
  #define SEG13COM0_size                           0x1
  #define SEG13COM0_value_mask                     0x20
  #define SEG13COM0_clear_mask                     0xDF
  
  #define SEG14COM0                                0x6
  #define SEG14COM0_address                        0x7A1
  #define SEG14COM0_position                       0x6
  #define SEG14COM0_size                           0x1
  #define SEG14COM0_value_mask                     0x40
  #define SEG14COM0_clear_mask                     0xBF
  
  #define SEG15COM0                                0x7
  #define SEG15COM0_address                        0x7A1
  #define SEG15COM0_position                       0x7
  #define SEG15COM0_size                           0x1
  #define SEG15COM0_value_mask                     0x80
  #define SEG15COM0_clear_mask                     0x7F
  
  
  /*--------------------------------------------------------------------------------------#
  | LCDDATA3                                                                        0x7A3 |
  #---------------------------------------------------------------------------------------#
  | SEG7COM1 | SEG6COM1 | SEG5COM1 | SEG4COM1 | SEG3COM1 | SEG2COM1 | SEG1COM1 | SEG0COM1 |
  #---------------------------------------------------------------------------------------#
  | 7        | 6        | 5        | 4        | 3        | 2        | 1        | 0        |
  #--------------------------------------------------------------------------------------*/
  
  #define LCDDATA3                                 0x0
  #define LCDDATA3_address                         0x7A3
  #define LCDDATA3_position                        0x0
  #define LCDDATA3_size                            0x8
  #define LCDDATA3_value_mask                      0xFF
  #define LCDDATA3_clear_mask                      0x0
  
  #define SEG0COM1                                 0x0
  #define SEG0COM1_address                         0x7A3
  #define SEG0COM1_position                        0x0
  #define SEG0COM1_size                            0x1
  #define SEG0COM1_value_mask                      0x1
  #define SEG0COM1_clear_mask                      0xFE
  
  #define SEG1COM1                                 0x1
  #define SEG1COM1_address                         0x7A3
  #define SEG1COM1_position                        0x1
  #define SEG1COM1_size                            0x1
  #define SEG1COM1_value_mask                      0x2
  #define SEG1COM1_clear_mask                      0xFD
  
  #define SEG2COM1                                 0x2
  #define SEG2COM1_address                         0x7A3
  #define SEG2COM1_position                        0x2
  #define SEG2COM1_size                            0x1
  #define SEG2COM1_value_mask                      0x4
  #define SEG2COM1_clear_mask                      0xFB
  
  #define SEG3COM1                                 0x3
  #define SEG3COM1_address                         0x7A3
  #define SEG3COM1_position                        0x3
  #define SEG3COM1_size                            0x1
  #define SEG3COM1_value_mask                      0x8
  #define SEG3COM1_clear_mask                      0xF7
  
  #define SEG4COM1                                 0x4
  #define SEG4COM1_address                         0x7A3
  #define SEG4COM1_position                        0x4
  #define SEG4COM1_size                            0x1
  #define SEG4COM1_value_mask                      0x10
  #define SEG4COM1_clear_mask                      0xEF
  
  #define SEG5COM1                                 0x5
  #define SEG5COM1_address                         0x7A3
  #define SEG5COM1_position                        0x5
  #define SEG5COM1_size                            0x1
  #define SEG5COM1_value_mask                      0x20
  #define SEG5COM1_clear_mask                      0xDF
  
  #define SEG6COM1                                 0x6
  #define SEG6COM1_address                         0x7A3
  #define SEG6COM1_position                        0x6
  #define SEG6COM1_size                            0x1
  #define SEG6COM1_value_mask                      0x40
  #define SEG6COM1_clear_mask                      0xBF
  
  #define SEG7COM1                                 0x7
  #define SEG7COM1_address                         0x7A3
  #define SEG7COM1_position                        0x7
  #define SEG7COM1_size                            0x1
  #define SEG7COM1_value_mask                      0x80
  #define SEG7COM1_clear_mask                      0x7F
  
  
  /*--------------------------------------------------------------------------------------------#
  | LCDDATA4                                                                              0x7A4 |
  #---------------------------------------------------------------------------------------------#
  | SEG15COM1 | SEG14COM1 | SEG13COM1 | SEG12COM1 | SEG11COM1 | SEG10COM1 | SEG9COM1 | SEG8COM1 |
  #---------------------------------------------------------------------------------------------#
  | 7         | 6         | 5         | 4         | 3         | 2         | 1        | 0        |
  #--------------------------------------------------------------------------------------------*/
  
  #define LCDDATA4                                 0x0
  #define LCDDATA4_address                         0x7A4
  #define LCDDATA4_position                        0x0
  #define LCDDATA4_size                            0x8
  #define LCDDATA4_value_mask                      0xFF
  #define LCDDATA4_clear_mask                      0x0
  
  #define SEG8COM1                                 0x0
  #define SEG8COM1_address                         0x7A4
  #define SEG8COM1_position                        0x0
  #define SEG8COM1_size                            0x1
  #define SEG8COM1_value_mask                      0x1
  #define SEG8COM1_clear_mask                      0xFE
  
  #define SEG9COM1                                 0x1
  #define SEG9COM1_address                         0x7A4
  #define SEG9COM1_position                        0x1
  #define SEG9COM1_size                            0x1
  #define SEG9COM1_value_mask                      0x2
  #define SEG9COM1_clear_mask                      0xFD
  
  #define SEG10COM1                                0x2
  #define SEG10COM1_address                        0x7A4
  #define SEG10COM1_position                       0x2
  #define SEG10COM1_size                           0x1
  #define SEG10COM1_value_mask                     0x4
  #define SEG10COM1_clear_mask                     0xFB
  
  #define SEG11COM1                                0x3
  #define SEG11COM1_address                        0x7A4
  #define SEG11COM1_position                       0x3
  #define SEG11COM1_size                           0x1
  #define SEG11COM1_value_mask                     0x8
  #define SEG11COM1_clear_mask                     0xF7
  
  #define SEG12COM1                                0x4
  #define SEG12COM1_address                        0x7A4
  #define SEG12COM1_position                       0x4
  #define SEG12COM1_size                           0x1
  #define SEG12COM1_value_mask                     0x10
  #define SEG12COM1_clear_mask                     0xEF
  
  #define SEG13COM1                                0x5
  #define SEG13COM1_address                        0x7A4
  #define SEG13COM1_position                       0x5
  #define SEG13COM1_size                           0x1
  #define SEG13COM1_value_mask                     0x20
  #define SEG13COM1_clear_mask                     0xDF
  
  #define SEG14COM1                                0x6
  #define SEG14COM1_address                        0x7A4
  #define SEG14COM1_position                       0x6
  #define SEG14COM1_size                           0x1
  #define SEG14COM1_value_mask                     0x40
  #define SEG14COM1_clear_mask                     0xBF
  
  #define SEG15COM1                                0x7
  #define SEG15COM1_address                        0x7A4
  #define SEG15COM1_position                       0x7
  #define SEG15COM1_size                           0x1
  #define SEG15COM1_value_mask                     0x80
  #define SEG15COM1_clear_mask                     0x7F
  
  
  /*--------------------------------------------------------------------------------------#
  | LCDDATA6                                                                        0x7A6 |
  #---------------------------------------------------------------------------------------#
  | SEG7COM2 | SEG6COM2 | SEG5COM2 | SEG4COM2 | SEG3COM2 | SEG2COM2 | SEG1COM2 | SEG0COM2 |
  #---------------------------------------------------------------------------------------#
  | 7        | 6        | 5        | 4        | 3        | 2        | 1        | 0        |
  #--------------------------------------------------------------------------------------*/
  
  #define LCDDATA6                                 0x0
  #define LCDDATA6_address                         0x7A6
  #define LCDDATA6_position                        0x0
  #define LCDDATA6_size                            0x8
  #define LCDDATA6_value_mask                      0xFF
  #define LCDDATA6_clear_mask                      0x0
  
  #define SEG0COM2                                 0x0
  #define SEG0COM2_address                         0x7A6
  #define SEG0COM2_position                        0x0
  #define SEG0COM2_size                            0x1
  #define SEG0COM2_value_mask                      0x1
  #define SEG0COM2_clear_mask                      0xFE
  
  #define SEG1COM2                                 0x1
  #define SEG1COM2_address                         0x7A6
  #define SEG1COM2_position                        0x1
  #define SEG1COM2_size                            0x1
  #define SEG1COM2_value_mask                      0x2
  #define SEG1COM2_clear_mask                      0xFD
  
  #define SEG2COM2                                 0x2
  #define SEG2COM2_address                         0x7A6
  #define SEG2COM2_position                        0x2
  #define SEG2COM2_size                            0x1
  #define SEG2COM2_value_mask                      0x4
  #define SEG2COM2_clear_mask                      0xFB
  
  #define SEG3COM2                                 0x3
  #define SEG3COM2_address                         0x7A6
  #define SEG3COM2_position                        0x3
  #define SEG3COM2_size                            0x1
  #define SEG3COM2_value_mask                      0x8
  #define SEG3COM2_clear_mask                      0xF7
  
  #define SEG4COM2                                 0x4
  #define SEG4COM2_address                         0x7A6
  #define SEG4COM2_position                        0x4
  #define SEG4COM2_size                            0x1
  #define SEG4COM2_value_mask                      0x10
  #define SEG4COM2_clear_mask                      0xEF
  
  #define SEG5COM2                                 0x5
  #define SEG5COM2_address                         0x7A6
  #define SEG5COM2_position                        0x5
  #define SEG5COM2_size                            0x1
  #define SEG5COM2_value_mask                      0x20
  #define SEG5COM2_clear_mask                      0xDF
  
  #define SEG6COM2                                 0x6
  #define SEG6COM2_address                         0x7A6
  #define SEG6COM2_position                        0x6
  #define SEG6COM2_size                            0x1
  #define SEG6COM2_value_mask                      0x40
  #define SEG6COM2_clear_mask                      0xBF
  
  #define SEG7COM2                                 0x7
  #define SEG7COM2_address                         0x7A6
  #define SEG7COM2_position                        0x7
  #define SEG7COM2_size                            0x1
  #define SEG7COM2_value_mask                      0x80
  #define SEG7COM2_clear_mask                      0x7F
  
  
  /*--------------------------------------------------------------------------------------------#
  | LCDDATA7                                                                              0x7A7 |
  #---------------------------------------------------------------------------------------------#
  | SEG15COM2 | SEG14COM2 | SEG13COM2 | SEG12COM2 | SEG11COM2 | SEG10COM2 | SEG9COM2 | SEG8COM2 |
  #---------------------------------------------------------------------------------------------#
  | 7         | 6         | 5         | 4         | 3         | 2         | 1        | 0        |
  #--------------------------------------------------------------------------------------------*/
  
  #define LCDDATA7                                 0x0
  #define LCDDATA7_address                         0x7A7
  #define LCDDATA7_position                        0x0
  #define LCDDATA7_size                            0x8
  #define LCDDATA7_value_mask                      0xFF
  #define LCDDATA7_clear_mask                      0x0
  
  #define SEG8COM2                                 0x0
  #define SEG8COM2_address                         0x7A7
  #define SEG8COM2_position                        0x0
  #define SEG8COM2_size                            0x1
  #define SEG8COM2_value_mask                      0x1
  #define SEG8COM2_clear_mask                      0xFE
  
  #define SEG9COM2                                 0x1
  #define SEG9COM2_address                         0x7A7
  #define SEG9COM2_position                        0x1
  #define SEG9COM2_size                            0x1
  #define SEG9COM2_value_mask                      0x2
  #define SEG9COM2_clear_mask                      0xFD
  
  #define SEG10COM2                                0x2
  #define SEG10COM2_address                        0x7A7
  #define SEG10COM2_position                       0x2
  #define SEG10COM2_size                           0x1
  #define SEG10COM2_value_mask                     0x4
  #define SEG10COM2_clear_mask                     0xFB
  
  #define SEG11COM2                                0x3
  #define SEG11COM2_address                        0x7A7
  #define SEG11COM2_position                       0x3
  #define SEG11COM2_size                           0x1
  #define SEG11COM2_value_mask                     0x8
  #define SEG11COM2_clear_mask                     0xF7
  
  #define SEG12COM2                                0x4
  #define SEG12COM2_address                        0x7A7
  #define SEG12COM2_position                       0x4
  #define SEG12COM2_size                           0x1
  #define SEG12COM2_value_mask                     0x10
  #define SEG12COM2_clear_mask                     0xEF
  
  #define SEG13COM2                                0x5
  #define SEG13COM2_address                        0x7A7
  #define SEG13COM2_position                       0x5
  #define SEG13COM2_size                           0x1
  #define SEG13COM2_value_mask                     0x20
  #define SEG13COM2_clear_mask                     0xDF
  
  #define SEG14COM2                                0x6
  #define SEG14COM2_address                        0x7A7
  #define SEG14COM2_position                       0x6
  #define SEG14COM2_size                           0x1
  #define SEG14COM2_value_mask                     0x40
  #define SEG14COM2_clear_mask                     0xBF
  
  #define SEG15COM2                                0x7
  #define SEG15COM2_address                        0x7A7
  #define SEG15COM2_position                       0x7
  #define SEG15COM2_size                           0x1
  #define SEG15COM2_value_mask                     0x80
  #define SEG15COM2_clear_mask                     0x7F
  
  
  /*--------------------------------------------------------------------------------------#
  | LCDDATA9                                                                        0x7A9 |
  #---------------------------------------------------------------------------------------#
  | SEG7COM3 | SEG6COM3 | SEG5COM3 | SEG4COM3 | SEG3COM3 | SEG2COM3 | SEG1COM3 | SEG0COM3 |
  #---------------------------------------------------------------------------------------#
  | 7        | 6        | 5        | 4        | 3        | 2        | 1        | 0        |
  #--------------------------------------------------------------------------------------*/
  
  #define LCDDATA9                                 0x0
  #define LCDDATA9_address                         0x7A9
  #define LCDDATA9_position                        0x0
  #define LCDDATA9_size                            0x8
  #define LCDDATA9_value_mask                      0xFF
  #define LCDDATA9_clear_mask                      0x0
  
  #define SEG0COM3                                 0x0
  #define SEG0COM3_address                         0x7A9
  #define SEG0COM3_position                        0x0
  #define SEG0COM3_size                            0x1
  #define SEG0COM3_value_mask                      0x1
  #define SEG0COM3_clear_mask                      0xFE
  
  #define SEG1COM3                                 0x1
  #define SEG1COM3_address                         0x7A9
  #define SEG1COM3_position                        0x1
  #define SEG1COM3_size                            0x1
  #define SEG1COM3_value_mask                      0x2
  #define SEG1COM3_clear_mask                      0xFD
  
  #define SEG2COM3                                 0x2
  #define SEG2COM3_address                         0x7A9
  #define SEG2COM3_position                        0x2
  #define SEG2COM3_size                            0x1
  #define SEG2COM3_value_mask                      0x4
  #define SEG2COM3_clear_mask                      0xFB
  
  #define SEG3COM3                                 0x3
  #define SEG3COM3_address                         0x7A9
  #define SEG3COM3_position                        0x3
  #define SEG3COM3_size                            0x1
  #define SEG3COM3_value_mask                      0x8
  #define SEG3COM3_clear_mask                      0xF7
  
  #define SEG4COM3                                 0x4
  #define SEG4COM3_address                         0x7A9
  #define SEG4COM3_position                        0x4
  #define SEG4COM3_size                            0x1
  #define SEG4COM3_value_mask                      0x10
  #define SEG4COM3_clear_mask                      0xEF
  
  #define SEG5COM3                                 0x5
  #define SEG5COM3_address                         0x7A9
  #define SEG5COM3_position                        0x5
  #define SEG5COM3_size                            0x1
  #define SEG5COM3_value_mask                      0x20
  #define SEG5COM3_clear_mask                      0xDF
  
  #define SEG6COM3                                 0x6
  #define SEG6COM3_address                         0x7A9
  #define SEG6COM3_position                        0x6
  #define SEG6COM3_size                            0x1
  #define SEG6COM3_value_mask                      0x40
  #define SEG6COM3_clear_mask                      0xBF
  
  #define SEG7COM3                                 0x7
  #define SEG7COM3_address                         0x7A9
  #define SEG7COM3_position                        0x7
  #define SEG7COM3_size                            0x1
  #define SEG7COM3_value_mask                      0x80
  #define SEG7COM3_clear_mask                      0x7F
  
  
  /*--------------------------------------------------------------------------------------------#
  | LCDDATA10                                                                             0x7AA |
  #---------------------------------------------------------------------------------------------#
  | SEG15COM3 | SEG14COM3 | SEG13COM3 | SEG12COM3 | SEG11COM3 | SEG10COM3 | SEG9COM3 | SEG8COM3 |
  #---------------------------------------------------------------------------------------------#
  | 7         | 6         | 5         | 4         | 3         | 2         | 1        | 0        |
  #--------------------------------------------------------------------------------------------*/
  
  #define LCDDATA10                                0x0
  #define LCDDATA10_address                        0x7AA
  #define LCDDATA10_position                       0x0
  #define LCDDATA10_size                           0x8
  #define LCDDATA10_value_mask                     0xFF
  #define LCDDATA10_clear_mask                     0x0
  
  #define SEG8COM3                                 0x0
  #define SEG8COM3_address                         0x7AA
  #define SEG8COM3_position                        0x0
  #define SEG8COM3_size                            0x1
  #define SEG8COM3_value_mask                      0x1
  #define SEG8COM3_clear_mask                      0xFE
  
  #define SEG9COM3                                 0x1
  #define SEG9COM3_address                         0x7AA
  #define SEG9COM3_position                        0x1
  #define SEG9COM3_size                            0x1
  #define SEG9COM3_value_mask                      0x2
  #define SEG9COM3_clear_mask                      0xFD
  
  #define SEG10COM3                                0x2
  #define SEG10COM3_address                        0x7AA
  #define SEG10COM3_position                       0x2
  #define SEG10COM3_size                           0x1
  #define SEG10COM3_value_mask                     0x4
  #define SEG10COM3_clear_mask                     0xFB
  
  #define SEG11COM3                                0x3
  #define SEG11COM3_address                        0x7AA
  #define SEG11COM3_position                       0x3
  #define SEG11COM3_size                           0x1
  #define SEG11COM3_value_mask                     0x8
  #define SEG11COM3_clear_mask                     0xF7
  
  #define SEG12COM3                                0x4
  #define SEG12COM3_address                        0x7AA
  #define SEG12COM3_position                       0x4
  #define SEG12COM3_size                           0x1
  #define SEG12COM3_value_mask                     0x10
  #define SEG12COM3_clear_mask                     0xEF
  
  #define SEG13COM3                                0x5
  #define SEG13COM3_address                        0x7AA
  #define SEG13COM3_position                       0x5
  #define SEG13COM3_size                           0x1
  #define SEG13COM3_value_mask                     0x20
  #define SEG13COM3_clear_mask                     0xDF
  
  #define SEG14COM3                                0x6
  #define SEG14COM3_address                        0x7AA
  #define SEG14COM3_position                       0x6
  #define SEG14COM3_size                           0x1
  #define SEG14COM3_value_mask                     0x40
  #define SEG14COM3_clear_mask                     0xBF
  
  #define SEG15COM3                                0x7
  #define SEG15COM3_address                        0x7AA
  #define SEG15COM3_position                       0x7
  #define SEG15COM3_size                           0x1
  #define SEG15COM3_value_mask                     0x80
  #define SEG15COM3_clear_mask                     0x7F
  
  
  /*----------------------------------------------#
  | STATUS_SHAD                             0xFE4 |
  #-----------------------------------------------#
  | - | - | - | - | - | Z_SHAD | DC_SHAD | C_SHAD |
  #-----------------------------------------------#
  | 7 | 6 | 5 | 4 | 3 | 2      | 1       | 0      |
  #----------------------------------------------*/
  
  #define STATUS_SHAD                              0x0
  #define STATUS_SHAD_address                      0xFE4
  #define STATUS_SHAD_position                     0x0
  #define STATUS_SHAD_size                         0x8
  #define STATUS_SHAD_value_mask                   0xFF
  #define STATUS_SHAD_clear_mask                   0x0
  
  #define C_SHAD                                   0x0
  #define C_SHAD_address                           0xFE4
  #define C_SHAD_position                          0x0
  #define C_SHAD_size                              0x1
  #define C_SHAD_value_mask                        0x1
  #define C_SHAD_clear_mask                        0xFE
  
  #define DC_SHAD                                  0x1
  #define DC_SHAD_address                          0xFE4
  #define DC_SHAD_position                         0x1
  #define DC_SHAD_size                             0x1
  #define DC_SHAD_value_mask                       0x2
  #define DC_SHAD_clear_mask                       0xFD
  
  #define Z_SHAD                                   0x2
  #define Z_SHAD_address                           0xFE4
  #define Z_SHAD_position                          0x2
  #define Z_SHAD_size                              0x1
  #define Z_SHAD_value_mask                        0x4
  #define Z_SHAD_clear_mask                        0xFB
  
  
  /*------------------------------#
  | WREG_SHAD               0xFE5 |
  #-------------------------------#
  | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
  #------------------------------*/
  
  #define WREG_SHAD                                0x0
  #define WREG_SHAD_address                        0xFE5
  #define WREG_SHAD_position                       0x0
  #define WREG_SHAD_size                           0x8
  #define WREG_SHAD_value_mask                     0xFF
  #define WREG_SHAD_clear_mask                     0x0
  
  
  /*------------------------------#
  | BSR_SHAD                0xFE6 |
  #-------------------------------#
  | - | - | - | BSR_SHAD          |
  #-------------------------------#
  | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
  #------------------------------*/
  
  #define BSR_SHAD                                 0x0
  #define BSR_SHAD_address                         0xFE6
  #define BSR_SHAD_position                        0x0
  #define BSR_SHAD_size                            0x5
  #define BSR_SHAD_value_mask                      0x1F
  #define BSR_SHAD_clear_mask                      0xE0
  
  
  /*------------------------------#
  | PCLATH_SHAD             0xFE7 |
  #-------------------------------#
  | - | PCLATH_SHAD               |
  #-------------------------------#
  | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
  #------------------------------*/
  
  #define PCLATH_SHAD                              0x0
  #define PCLATH_SHAD_address                      0xFE7
  #define PCLATH_SHAD_position                     0x0
  #define PCLATH_SHAD_size                         0x7
  #define PCLATH_SHAD_value_mask                   0x7F
  #define PCLATH_SHAD_clear_mask                   0x80
  
  
  /*------------------------------#
  | FSR0L_SHAD              0xFE8 |
  #-------------------------------#
  | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
  #------------------------------*/
  
  #define FSR0L_SHAD                               0x0
  #define FSR0L_SHAD_address                       0xFE8
  #define FSR0L_SHAD_position                      0x0
  #define FSR0L_SHAD_size                          0x8
  #define FSR0L_SHAD_value_mask                    0xFF
  #define FSR0L_SHAD_clear_mask                    0x0
  
  
  /*------------------------------#
  | FSR0H_SHAD              0xFE9 |
  #-------------------------------#
  | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
  #------------------------------*/
  
  #define FSR0H_SHAD                               0x0
  #define FSR0H_SHAD_address                       0xFE9
  #define FSR0H_SHAD_position                      0x0
  #define FSR0H_SHAD_size                          0x8
  #define FSR0H_SHAD_value_mask                    0xFF
  #define FSR0H_SHAD_clear_mask                    0x0
  
  
  /*------------------------------#
  | FSR1L_SHAD              0xFEA |
  #-------------------------------#
  | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
  #------------------------------*/
  
  #define FSR1L_SHAD                               0x0
  #define FSR1L_SHAD_address                       0xFEA
  #define FSR1L_SHAD_position                      0x0
  #define FSR1L_SHAD_size                          0x8
  #define FSR1L_SHAD_value_mask                    0xFF
  #define FSR1L_SHAD_clear_mask                    0x0
  
  
  /*------------------------------#
  | FSR1H_SHAD              0xFEB |
  #-------------------------------#
  | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
  #------------------------------*/
  
  #define FSR1H_SHAD                               0x0
  #define FSR1H_SHAD_address                       0xFEB
  #define FSR1H_SHAD_position                      0x0
  #define FSR1H_SHAD_size                          0x8
  #define FSR1H_SHAD_value_mask                    0xFF
  #define FSR1H_SHAD_clear_mask                    0x0
  
  
  /*------------------------------#
  | STKPTR                  0xFED |
  #-------------------------------#
  | - | - | - | STKPTR            |
  #-------------------------------#
  | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
  #------------------------------*/
  
  #define STKPTR                                   0x0
  #define STKPTR_address                           0xFED
  #define STKPTR_position                          0x0
  #define STKPTR_size                              0x5
  #define STKPTR_value_mask                        0x1F
  #define STKPTR_clear_mask                        0xE0
  
  
  /*------------------------------#
  | TOSL                    0xFEE |
  #-------------------------------#
  | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
  #------------------------------*/
  
  #define TOSL                                     0x0
  #define TOSL_address                             0xFEE
  #define TOSL_position                            0x0
  #define TOSL_size                                0x8
  #define TOSL_value_mask                          0xFF
  #define TOSL_clear_mask                          0x0
  
  
  /*------------------------------#
  | TOSH                    0xFEF |
  #-------------------------------#
  | - | TOSH                      |
  #-------------------------------#
  | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
  #------------------------------*/
  
  #define TOSH                                     0x0
  #define TOSH_address                             0xFEF
  #define TOSH_position                            0x0
  #define TOSH_size                                0x7
  #define TOSH_value_mask                          0x7F
  #define TOSH_clear_mask                          0x80
  
  #endif // _PIC16F1933_H_
  