Force "blank" issue template to end of list (#8387 )

* force ascii sort of issue templates to add blank to end of list
Fix darkmode (#8393 )
2020-03-12 01:27:33 -07:00 · 2020-03-12 18:17:47 +11:00 · 2020-03-12 02:50:19 +00:00 · 2020-03-12 12:59:55 +11:00 · 2020-03-11 16:06:47 -07:00 · 2020-03-11 21:23:31 +00:00
73 changed files with 2974 additions and 640 deletions
@@ -23,4 +23,4 @@ endif
 # Generate the keymap.c
 $(KEYBOARD_OUTPUT)/src/keymap.c: $(KEYMAP_JSON)
-	bin/qmk json-keymap --quiet --output $(KEYMAP_C) $(KEYMAP_JSON)
+	bin/qmk json2c --quiet --output $(KEYMAP_C) $(KEYMAP_JSON)
@@ -141,6 +141,10 @@ else
        SRC += $(PLATFORM_COMMON_DIR)/flash_stm32.c
        OPT_DEFS += -DEEPROM_EMU_STM32F072xB
        OPT_DEFS += -DSTM32_EEPROM_ENABLE
      else ifneq ($(filter $(MCU_SERIES),STM32L0xx STM32L1xx),)
        OPT_DEFS += -DEEPROM_DRIVER
        COMMON_VPATH += $(DRIVER_PATH)/eeprom
        SRC += eeprom_driver.c eeprom_stm32_L0_L1.c
      else
        # This will effectively work the same as "transient" if not supported by the chip
        SRC += $(PLATFORM_COMMON_DIR)/eeprom_teensy.c
@@ -2,7 +2,7 @@
 QMK can leverage the Analog-to-Digital Converter (ADC) on supported MCUs to measure voltages on certain pins. This can be useful for implementing things such as battery level indicators for Bluetooth keyboards, or volume controls using a potentiometer, as opposed to a [rotary encoder](feature_encoders.md).
-This driver is currently AVR-only. The values returned are 10-bit integers (0-1023) mapped between 0V and VCC (usually 5V or 3.3V).
+This driver currently supports both AVR and a limited selection of ARM devices. On AVR devices, the values returned are 10-bit integers (0-1023) mapped between 0V and VCC (usually 5V or 3.3V). On supported ARM devices, there is more flexibility in control of operation through `#define`s, but by default the values returned are 12-bit integers (0-4095) mapped between 0V and VCC (usually 3.3V).
 ## Usage
@@ -20,6 +20,8 @@ Then place this include at the top of your code:
 ## Channels
 ### AVR
 |Channel|AT90USB64/128|ATmega16/32U4|ATmega32A|ATmega328P|
 |-------|-------------|-------------|---------|----------|
 |0      |`F0`         |`F0`         |`A0`     |`C0`      |
@@ -39,8 +41,84 @@ Then place this include at the top of your code:
 <sup>\* The ATmega328P possesses two extra ADC channels; however, they are not present on the DIP pinout, and are not shared with GPIO pins. You can use `adc_read()` directly to gain access to these.</sup>
 ### ARM
 Note that some of these pins are doubled-up on ADCs with the same channel. This is because the pins can be used for either ADC.
 Also note that the F0 and F3 use different numbering schemes. The F0 has a single ADC and the channels are 0-based, whereas the F3 has 4 ADCs and the channels are 1 based. This is because the F0 uses the `ADCv1` implementation of the ADC, whereas the F3 uses the `ADCv3` implementation.
 |ADC|Channel|STM32F0XX|STM32F3XX|
 |---|-------|---------|---------|
 |1  |0      |`A0`     |         |
 |1  |1      |`A1`     |`A0`     |
 |1  |2      |`A2`     |`A1`     |
 |1  |3      |`A3`     |`A2`     |
 |1  |4      |`A4`     |`A3`     |
 |1  |5      |`A5`     |`F4`     |
 |1  |6      |`A6`     |`C0`     |
 |1  |7      |`A7`     |`C1`     |
 |1  |8      |`B0`     |`C2`     |
 |1  |9      |`B1`     |`C3`     |
 |1  |10     |`C0`     |`F2`     |
 |1  |11     |`C1`     |         |
 |1  |12     |`C2`     |         |
 |1  |13     |`C3`     |         |
 |1  |14     |`C4`     |         |
 |1  |15     |`C5`     |         |
 |1  |16     |         |         |
 |2  |1      |         |`A4`     |
 |2  |2      |         |`A5`     |
 |2  |3      |         |`A6`     |
 |2  |4      |         |`A7`     |
 |2  |5      |         |`C4`     |
 |2  |6      |         |`C0`     |
 |2  |7      |         |`C1`     |
 |2  |8      |         |`C2`     |
 |2  |9      |         |`C3`     |
 |2  |10     |         |`F2`     |
 |2  |11     |         |`C5`     |
 |2  |12     |         |`B2`     |
 |2  |13     |         |         |
 |2  |14     |         |         |
 |2  |15     |         |         |
 |2  |16     |         |         |
 |3  |1      |         |`B1`     |
 |3  |2      |         |`E9`     |
 |3  |3      |         |`E13`    |
 |3  |4      |         |         |
 |3  |5      |         |         |
 |3  |6      |         |`E8`     |
 |3  |7      |         |`D10`    |
 |3  |8      |         |`D11`    |
 |3  |9      |         |`D12`    |
 |3  |10     |         |`D13`    |
 |3  |11     |         |`D14`    |
 |3  |12     |         |`B0`     |
 |3  |13     |         |`E7`     |
 |3  |14     |         |`E10`    |
 |3  |15     |         |`E11`    |
 |3  |16     |         |`E12`    |
 |4  |1      |         |`E14`    |
 |4  |2      |         |`B12`    |
 |4  |3      |         |`B13`    |
 |4  |4      |         |`B14`    |
 |4  |5      |         |`B15`    |
 |4  |6      |         |`E8`     |
 |4  |7      |         |`D10`    |
 |4  |8      |         |`D11`    |
 |4  |9      |         |`D12`    |
 |4  |10     |         |`D13`    |
 |4  |11     |         |`D14`    |
 |4  |12     |         |`D8`     |
 |4  |13     |         |`D9`     |
 |4  |14     |         |         |
 |4  |15     |         |         |
 |4  |16     |         |         |
 ## Functions
 ### AVR
 |Function                    |Description                                                                                                        |
 |----------------------------|-------------------------------------------------------------------------------------------------------------------|
 |`analogReference(mode)`     |Sets the analog voltage reference source. Must be one of `ADC_REF_EXTERNAL`, `ADC_REF_POWER` or `ADC_REF_INTERNAL`.|
@@ -48,3 +126,28 @@ Then place this include at the top of your code:
 |`analogReadPin(pin)`        |Reads the value from the specified QMK pin, eg. `F6` for ADC6 on the ATmega32U4.                                   |
 |`pinToMux(pin)`             |Translates a given QMK pin to a mux value. If an unsupported pin is given, returns the mux value for "0V (GND)".   |
 |`adc_read(mux)`             |Reads the value from the ADC according to the specified mux. See your MCU's datasheet for more information.        |
 ### ARM
 Note that care was taken to match all of the functions used for AVR devices, however complications in the ARM platform prevent that from always being possible. For example, the `STM32` chips do not have assigned Arduino pins. We could use the default pin numbers, but those numbers change based on the package type of the device. For this reason, please specify your target pins with their identifiers (`A0`, `F3`, etc.). Also note that there are some variants of functions that accept the target ADC for the pin. Some pins can be used for multiple ADCs, and this specified can help you pick which ADC will be used to interact with that pin.
 |Function                    |Description                                                                                                         |
 |----------------------------|--------------------------------------------------------------------------------------------------------------------|
 |`analogReadPin(pin)`        |Reads the value from the specified QMK pin, eg. `A0` for channel 0 on the STM32F0 and ADC1 channel 1 on the STM32F3. Note that if a pin can be used for multiple ADCs, it will pick the lower numbered ADC for this function. eg. `C0` will be channel 6 of ADC 1 when it could be used for ADC 2 as well.|
 |`analogReadPinAdc(pin, adc)`|Reads the value from the specified QMK pin and ADC, eg. `C0, 1` will read from channel 6, ADC 2 instead of ADC 1. Note that the ADCs are 0-indexed for this function.|
 |`pinToMux(pin)`             |Translates a given QMK pin to a channel and ADC combination. If an unsupported pin is given, returns the mux value for "0V (GND)".|
 |`adc_read(mux)`             |Reads the value from the ADC according to the specified pin and adc combination. See your MCU's datasheet for more information.|
 ## Configuration
 ## ARM
 The ARM implementation of the ADC has a few additional options that you can override in your own keyboards and keymaps to change how it operates.
 |`#define`          |Type  |Default              |Description|
 |-------------------|------|---------------------|-----------|
 |ADC_CIRCULAR_BUFFER|`bool`|`false`              |If `TRUE`, then the implementation will use a circular buffer.|
 |ADC_NUM_CHANNELS   |`int` |`1`                  |Sets the number of channels that will be scanned as part of an ADC operation. The current implementation only supports `1`.|
 |ADC_BUFFER_DEPTH   |`int` |`2`                  |Sets the depth of each result. Since we are only getting a 12-bit result by default, we set this to `2` bytes so we can contain our one value. This could be set to 1 if you opt for a 8-bit or lower result.|
 |ADC_SAMPLING_RATE  |`int` |`ADC_SMPR_SMP_1P5`   |Sets the sampling rate of the ADC. By default, it is set to the fastest setting. Please consult the corresponding `hal_adc_lld.h` in ChibiOS for your specific microcontroller for further documentation on your available options.|
 |ADC_RESOLUTION     |`int` |`ADC_CFGR1_RES_12BIT`|The resolution of your result. We choose 12 bit by default, but you can opt for 12, 10, 8, or 6 bit. Please consult the corresponding `hal_adc_lld.h` in ChibiOS for your specific microcontroller for further documentation on your available options.|
@@ -231,14 +231,14 @@ Check your environment and report problems only:
    qmk doctor -n
-## `qmk json-keymap`
+## `qmk json2c`
 Creates a keymap.c from a QMK Configurator export.
 **Usage**:
 ```
-qmk json-keymap [-o OUTPUT] filename
+qmk json2c [-o OUTPUT] filename
 ```
 ## `qmk kle2json`
@@ -190,6 +190,8 @@ If you define these options you will enable the associated feature, which may in
  * pin the DI on the WS2812 is hooked-up to
 * `#define RGBLIGHT_ANIMATIONS`
  * run RGB animations
 * `#define RGBLIGHT_LAYERS`
  * Lets you define [lighting layers](feature_rgblight.md) that can be toggled on or off. Great for showing the current keyboard layer or caps lock state.
 * `#define RGBLED_NUM 12`
  * number of LEDs
 * `#define RGBLIGHT_SPLIT`
@@ -2,14 +2,16 @@
 The EEPROM driver can be swapped out depending on the needs of the keyboard, or whether extra hardware is present.
-Driver                      | Description
+Driver                             | Description
--------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+-----------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
-`EEPROM_DRIVER = vendor`    | Uses the on-chip driver provided by the chip manufacturer. For AVR, this is provided by avr-libc. This is supported on ARM for a subset of chips -- STM32F3xx, STM32F1xx, and STM32F072xB will be emulated by writing to flash. Other chips will generally act as "transient" below.
+`EEPROM_DRIVER = vendor` (default) | Uses the on-chip driver provided by the chip manufacturer. For AVR, this is provided by avr-libc. This is supported on ARM for a subset of chips -- STM32F3xx, STM32F1xx, and STM32F072xB will be emulated by writing to flash. STM32L0xx and STM32L1xx will use the onboard dedicated true EEPROM. Other chips will generally act as "transient" below.
-`EEPROM_DRIVER = i2c`       | Supports writing to I2C-based 24xx EEPROM chips. See the driver section below.
+`EEPROM_DRIVER = i2c`              | Supports writing to I2C-based 24xx EEPROM chips. See the driver section below.
-`EEPROM_DRIVER = transient` | Fake EEPROM driver -- supports reading/writing to RAM, and will be discarded when power is lost.
+`EEPROM_DRIVER = transient`        | Fake EEPROM driver -- supports reading/writing to RAM, and will be discarded when power is lost.
 ## Vendor Driver Configuration
 !> Resetting EEPROM using an STM32L0/L1 device takes up to 1 second for every 1kB of internal EEPROM used.
 No configurable options are available.
 ## I2C Driver Configuration
@@ -172,6 +172,62 @@ const uint8_t RGBLED_KNIGHT_INTERVALS[] PROGMEM = {127, 63, 31};
 const uint8_t RGBLED_GRADIENT_RANGES[] PROGMEM = {255, 170, 127, 85, 64};
 ```
 ## Lighting Layers
 By including `#define RGBLIGHT_LAYERS` in your `config.h` file you can enable lighting layers. These make
 it easy to use your underglow LEDs as status indicators to show which keyboard layer is currently active, or the state of caps lock, all without disrupting any animations. [Here's a video](https://youtu.be/uLGE1epbmdY) showing an example of what you can do. 
 To define a layer, we modify `keymap.c` to list out LED ranges and the colors we want to overlay on them using an array of `rgblight_segment_t` using the `RGBLIGHT_LAYER_SEGMENTS` macro. We can define multiple layers and enable/disable them independently:
 ```c
 // Light LEDs 6 to 9 and 12 to 15 red when caps lock is active. Hard to ignore!
 const rgblight_segment_t PROGMEM my_capslock_layer[] = RGBLIGHT_LAYER_SEGMENTS(
 	{6, 4, HSV_RED},       // Light 4 LEDs, starting with LED 6
 	{12, 4, HSV_RED}       // Light 4 LEDs, starting with LED 12
 );
 // Light LEDs 9 & 10 in cyan when keyboard layer 1 is active
 const rgblight_segment_t PROGMEM my_layer1_layer[] = RGBLIGHT_LAYER_SEGMENTS(
 	{9, 2, HSV_CYAN}
 );
 // Light LEDs 11 & 12 in purple when keyboard layer 2 is active
 const rgblight_segment_t PROGMEM my_layer2_layer[] = RGBLIGHT_LAYER_SEGMENTS(
 	{11, 2, HSV_PURPLE}, 
 );
 // etc..
 ```
 We combine these layers into an array using the `RGBLIGHT_LAYERS_LIST` macro, and assign it to the `rgblight_layers` variable during keyboard setup. Note that you can only define up to 8 lighting layers. Any extra layers will be ignored. Since the different lighting layers overlap, the order matters in the array, with later layers taking precedence:
 ```c
 // Now define the array of layers. Later layers take precedence
 const rgblight_segment_t* const PROGMEM my_rgb_layers[] = RGBLIGHT_LAYERS_LIST(
 	my_capslock_layer,
 	my_layer1_layer,    // Overrides caps lock layer
 	my_layer2_layer     // Overrides other layers
 );
 void keyboard_post_init_user(void) {
 	// Enable the LED layers
 	rgblight_layers = my_rgb_layers;
 }
 ```
 Finally, we enable and disable the lighting layers whenever the state of the keyboard changes:
 ```c
 layer_state_t layer_state_set_user(layer_state_t state) {
 	// Both layers will light up if both kb layers are active
 	rgblight_set_layer_state(1, layer_state_cmp(state, 1));
 	rgblight_set_layer_state(2, layer_state_cmp(state, 2));
 	return state;
 }
 bool led_update_user(led_t led_state) {
 	rgblight_set_layer_state(0, led_state.caps_lock);
 	return true;
 }
 ```
 ## Functions
 If you need to change your RGB lighting in code, for example in a macro to change the color whenever you switch layers, QMK provides a set of functions to assist you. See [`rgblight.h`](https://github.com/qmk/qmk_firmware/blob/master/quantum/rgblight.h) for the full list, but the most commonly used functions include:
@@ -263,6 +319,12 @@ rgblight_sethsv(HSV_GREEN, 2); // led 2
 |`rgblight_sethsv(h, s, v)`                  |Set effect range LEDs to the given HSV value where `h`/`s`/`v` are between 0 and 255 |
 |`rgblight_sethsv_noeeprom(h, s, v)`         |Set effect range LEDs to the given HSV value where `h`/`s`/`v` are between 0 and 255 (not written to EEPROM) |
 #### layer functions
 |Function                                    |Description  |
 |--------------------------------------------|-------------|
 |`rgblight_get_layer_state(i)`               |Returns `true` if lighting layer `i` is enabled |
 |`rgblight_set_layer_state(i, is_on)`        |Enable or disable lighting layer `i` based on value of `bool is_on` |
 #### query
 |Function               |Description      |
 |-----------------------|-----------------|
@@ -16,7 +16,8 @@
  <link rel="stylesheet" href="//unpkg.com/docsify/lib/themes/buble.css" title="light">
  <link rel="stylesheet" href="//unpkg.com/docsify/lib/themes/dark.css" media="(prefers-color-scheme: dark)">
  <link rel="stylesheet" href="//unpkg.com/[email protected]/dist/toc.css">
-  <link rel="stylesheet" href="sidebar.css" />
+  <link rel="stylesheet" href="qmk_custom_light.css">
  <link rel="stylesheet" href="qmk_custom_dark.css" media="(prefers-color-scheme: dark)">
 </head>
 <body>
  <div id="app"></div>
@@ -215,14 +215,14 @@ qmk doctor [-y] [-n]
    qmk doctor -n
-## `qmk json-keymap`
+## `qmk json2c`
 QMK Configurator からエクスポートしたものから keymap.c を生成します。
 **使用法**:
 ```
-qmk json-keymap [-o OUTPUT] filename
+qmk json2c [-o OUTPUT] filename
 ```
 ## `qmk kle2json`
@@ -0,0 +1,29 @@
 .sidebar li.active {
    background-color: #555;
 }
 .markdown-section p.tip,
 .markdown-section tr:nth-child(2n) {
 background-color:#444;
 }
 .markdown-section tr {
    border-top: 1px solid #555;
 }
 .markdown-section td, .markdown-section th {
    border: 1px solid #555;
 }
 .markdown-section p.tip code {
    background-color: #555;
    color: #fff;
 }
 .page_toc code {
    background-color: #555;
 }
 .markdown-section hr, .search {
    border-bottom: 1px solid #777 !important;
 }
@@ -0,0 +1,207 @@
 /* Copyright 2019 Drew Mills
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 #include "analog.h"
 #include "quantum.h"
 /* User configurable ADC options */
 #ifndef ADC_CIRCULAR_BUFFER
 #    define ADC_CIRCULAR_BUFFER FALSE
 #endif
 #ifndef ADC_NUM_CHANNELS
 #    define ADC_NUM_CHANNELS 1
 #elif ADC_NUM_CHANNELS != 1
 #    error "The ARM ADC implementation currently only supports reading one channel at a time."
 #endif
 #ifndef ADC_BUFFER_DEPTH
 #    define ADC_BUFFER_DEPTH 2
 #endif
 // For more sampling rate options, look at hal_adc_lld.h in ChibiOS
 #ifndef ADC_SAMPLING_RATE
 #    define ADC_SAMPLING_RATE ADC_SMPR_SMP_1P5
 #endif
 // Options are 12, 10, 8, and 6 bit.
 #ifndef ADC_RESOLUTION
 #    define ADC_RESOLUTION ADC_CFGR1_RES_12BIT
 #endif
 static ADCConfig   adcCfg = {};
 static adcsample_t sampleBuffer[ADC_NUM_CHANNELS * ADC_BUFFER_DEPTH];
 // Initialize to max number of ADCs, set to empty object to initialize all to false.
 #if defined(STM32F0XX)
 static bool adcInitialized[1] = {};
 #elif defined(STM32F3XX)
 static bool adcInitialized[4] = {};
 #else
 #    error "adcInitialized has not been implemented for this ARM microcontroller."
 #endif
 static ADCConversionGroup adcConversionGroup = {
    ADC_CIRCULAR_BUFFER,
    (uint16_t)(ADC_NUM_CHANNELS),
    NULL,  // No end callback
    NULL,  // No error callback
 #if defined(STM32F0XX)
    ADC_CFGR1_CONT | ADC_RESOLUTION,
    ADC_TR(0, 0).ADC_SAMPLING_RATE,
    NULL,  // Doesn't specify a default channel
 #elif defined(STM32F3XX)
    ADC_CFGR_CONT | ADC_RESOLUTION,
    ADC_TR(0, 4095),
    {
        ADC_SAMPLING_RATE,
        ADC_SAMPLING_RATE,
    },
    {
        0,  // Doesn't specify a default channel
        0,
        0,
        0,
    },
 #endif
 };
 static inline ADCDriver* intToADCDriver(uint8_t adcInt) {
    ADCDriver* target;
    switch (adcInt) {
        // clang-format off
 #if STM32_ADC_USE_ADC1
        case 0: target = &ADCD1; break;
 #endif
 #if STM32_ADC_USE_ADC2
        case 1: target = &ADCD2; break;
 #endif
 #if STM32_ADC_USE_ADC3
        case 2: target = &ADCD3; break;
 #endif
 #if STM32_ADC_USE_ADC4
        case 3: target = &ADCD4; break;
 #endif
        default: target = NULL; break;
            // clang-format on
    }
    return target;
 }
 static inline void manageAdcInitializationDriver(uint8_t adc, ADCDriver* adcDriver) {
    if (!adcInitialized[adc]) {
        adcStart(adcDriver, &adcCfg);
        adcInitialized[adc] = true;
    }
 }
 static inline void manageAdcInitialization(uint8_t adc) { manageAdcInitializationDriver(adc, intToADCDriver(adc)); }
 pin_and_adc pinToMux(pin_t pin) {
    switch (pin) {
        // clang-format off
 #if defined(STM32F0XX)
        case A0:  return (pin_and_adc){ ADC_CHANNEL_IN0,  0 };
        case A1:  return (pin_and_adc){ ADC_CHANNEL_IN1,  0 };
        case A2:  return (pin_and_adc){ ADC_CHANNEL_IN2,  0 };
        case A3:  return (pin_and_adc){ ADC_CHANNEL_IN3,  0 };
        case A4:  return (pin_and_adc){ ADC_CHANNEL_IN4,  0 };
        case A5:  return (pin_and_adc){ ADC_CHANNEL_IN5,  0 };
        case A6:  return (pin_and_adc){ ADC_CHANNEL_IN6,  0 };
        case A7:  return (pin_and_adc){ ADC_CHANNEL_IN7,  0 };
        case B0:  return (pin_and_adc){ ADC_CHANNEL_IN8,  0 };
        case B1:  return (pin_and_adc){ ADC_CHANNEL_IN9,  0 };
        case C0:  return (pin_and_adc){ ADC_CHANNEL_IN10, 0 };
        case C1:  return (pin_and_adc){ ADC_CHANNEL_IN11, 0 };
        case C2:  return (pin_and_adc){ ADC_CHANNEL_IN12, 0 };
        case C3:  return (pin_and_adc){ ADC_CHANNEL_IN13, 0 };
        case C4:  return (pin_and_adc){ ADC_CHANNEL_IN14, 0 };
        case C5:  return (pin_and_adc){ ADC_CHANNEL_IN15, 0 };
 #elif defined(STM32F3XX)
        case A0:  return (pin_and_adc){ ADC_CHANNEL_IN1,  0 };
        case A1:  return (pin_and_adc){ ADC_CHANNEL_IN2,  0 };
        case A2:  return (pin_and_adc){ ADC_CHANNEL_IN3,  0 };
        case A3:  return (pin_and_adc){ ADC_CHANNEL_IN4,  0 };
        case A4:  return (pin_and_adc){ ADC_CHANNEL_IN1,  1 };
        case A5:  return (pin_and_adc){ ADC_CHANNEL_IN2,  1 };
        case A6:  return (pin_and_adc){ ADC_CHANNEL_IN3,  1 };
        case A7:  return (pin_and_adc){ ADC_CHANNEL_IN4,  1 };
        case B0:  return (pin_and_adc){ ADC_CHANNEL_IN12, 2 };
        case B1:  return (pin_and_adc){ ADC_CHANNEL_IN1,  2 };
        case B2:  return (pin_and_adc){ ADC_CHANNEL_IN12, 1 };
        case B12: return (pin_and_adc){ ADC_CHANNEL_IN2,  3 };
        case B13: return (pin_and_adc){ ADC_CHANNEL_IN3,  3 };
        case B14: return (pin_and_adc){ ADC_CHANNEL_IN4,  3 };
        case B15: return (pin_and_adc){ ADC_CHANNEL_IN5,  3 };
        case C0:  return (pin_and_adc){ ADC_CHANNEL_IN6,  0 }; // Can also be ADC2
        case C1:  return (pin_and_adc){ ADC_CHANNEL_IN7,  0 }; // Can also be ADC2
        case C2:  return (pin_and_adc){ ADC_CHANNEL_IN8,  0 }; // Can also be ADC2
        case C3:  return (pin_and_adc){ ADC_CHANNEL_IN9,  0 }; // Can also be ADC2
        case C4:  return (pin_and_adc){ ADC_CHANNEL_IN5,  1 };
        case C5:  return (pin_and_adc){ ADC_CHANNEL_IN11, 1 };
        case D8:  return (pin_and_adc){ ADC_CHANNEL_IN12, 3 };
        case D9:  return (pin_and_adc){ ADC_CHANNEL_IN13, 3 };
        case D10: return (pin_and_adc){ ADC_CHANNEL_IN7,  2 }; // Can also be ADC4
        case D11: return (pin_and_adc){ ADC_CHANNEL_IN8,  2 }; // Can also be ADC4
        case D12: return (pin_and_adc){ ADC_CHANNEL_IN9,  2 }; // Can also be ADC4
        case D13: return (pin_and_adc){ ADC_CHANNEL_IN10, 2 }; // Can also be ADC4
        case D14: return (pin_and_adc){ ADC_CHANNEL_IN11, 2 }; // Can also be ADC4
        case E7:  return (pin_and_adc){ ADC_CHANNEL_IN13, 2 };
        case E8:  return (pin_and_adc){ ADC_CHANNEL_IN6,  2 }; // Can also be ADC4
        case E9:  return (pin_and_adc){ ADC_CHANNEL_IN2,  2 };
        case E10: return (pin_and_adc){ ADC_CHANNEL_IN14, 2 };
        case E11: return (pin_and_adc){ ADC_CHANNEL_IN15, 2 };
        case E12: return (pin_and_adc){ ADC_CHANNEL_IN16, 2 };
        case E13: return (pin_and_adc){ ADC_CHANNEL_IN3,  2 };
        case E14: return (pin_and_adc){ ADC_CHANNEL_IN1,  3 };
        case E15: return (pin_and_adc){ ADC_CHANNEL_IN2,  3 };
        case F2:  return (pin_and_adc){ ADC_CHANNEL_IN10, 0 }; // Can also be ADC2
        case F4:  return (pin_and_adc){ ADC_CHANNEL_IN5,  0 };
 #else
 #error "An ADC pin-to-mux configuration has not been specified for this microcontroller."
 #endif
        default:  return (pin_and_adc){ 0, 0 };
            // clang-format on
    }
 }
 adcsample_t analogReadPin(pin_t pin) { return adc_read(pinToMux(pin)); }
 adcsample_t analogReadPinAdc(pin_t pin, uint8_t adc) {
    pin_and_adc target = pinToMux(pin);
    target.adc         = adc;
    return adc_read(target);
 }
 adcsample_t adc_read(pin_and_adc mux) {
 #if defined(STM32F0XX)
    adcConversionGroup.sqr = ADC_CHSELR_CHSEL1;
 #elif defined(STM32F3XX)
    adcConversionGroup.sqr[0] = ADC_SQR1_SQ1_N(mux.pin);
 #else
 #    error "adc_read has not been updated to support this ARM microcontroller."
 #endif
    ADCDriver* targetDriver = intToADCDriver(mux.adc);
    manageAdcInitializationDriver(mux.adc, targetDriver);
    adcConvert(targetDriver, &adcConversionGroup, &sampleBuffer[0], ADC_BUFFER_DEPTH);
    adcsample_t* result = sampleBuffer;
    return *result;
 }
@@ -0,0 +1,57 @@
 /* Copyright 2019 Drew Mills
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 #pragma once
 #include "quantum.h"
 #include "ch.h"
 #include <hal.h>
 #if !defined(STM32F0XX) && !defined(STM32F3XX)
 #    error "Only STM23F0 and STM32F3 devices have ADC support in QMK at this time."
 #endif
 #if !HAL_USE_ADC
 #    error "You need to set HAL_USE_ADC to TRUE in your halconf.h to use the ADC."
 #endif
 #if !STM32_ADC_USE_ADC1 && !STM32_ADC_USE_ADC2 && !STM32_ADC_USE_ADC3 && !STM32_ADC_USE_ADC4
 #    error "You need to set one of the 'STM32_ADC_USE_ADCx' settings to TRUE in your mcuconf.h to use the ADC."
 #endif
 #if STM32_ADC_DUAL_MODE
 #    error "STM32 ADC Dual Mode is not supported at this time."
 #endif
 #if STM32_ADCV3_OVERSAMPLING
 #    error "STM32 ADCV3 Oversampling is not supported at this time."
 #endif
 typedef struct {
    pin_t   pin;
    uint8_t adc;
 } pin_and_adc;
 #define PIN_AND_ADC(p, a) \
    (pin_and_adc) { p, a }
 // analogReference has been left un-defined for ARM devices.
 // void analogReference(uint8_t mode);
 adcsample_t analogReadPin(pin_t pin);
 adcsample_t analogReadPinAdc(pin_t pin, uint8_t adc);
 pin_and_adc pinToMux(pin_t pin);
 adcsample_t adc_read(pin_and_adc mux);
@@ -0,0 +1,96 @@
 /* Copyright 2020 Nick Brassel (tzarc)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 #include <stdint.h>
 #include <string.h>
 #include "hal.h"
 #include "eeprom_driver.h"
 #include "eeprom_stm32_L0_L1.h"
 #define EEPROM_BASE_ADDR 0x08080000
 #define EEPROM_ADDR(offset) (EEPROM_BASE_ADDR + (offset))
 #define EEPROM_PTR(offset) ((__IO uint8_t *)EEPROM_ADDR(offset))
 #define EEPROM_BYTE(location, offset) (*(EEPROM_PTR(((uint32_t)location) + ((uint32_t)offset))))
 #define BUFFER_BYTE(buffer, offset) (*(((uint8_t *)buffer) + offset))
 #define FLASH_PEKEY1 0x89ABCDEF
 #define FLASH_PEKEY2 0x02030405
 static inline void STM32_L0_L1_EEPROM_WaitNotBusy(void) {
    while (FLASH->SR & FLASH_SR_BSY) {
        __WFI();
    }
 }
 static inline void STM32_L0_L1_EEPROM_Unlock(void) {
    STM32_L0_L1_EEPROM_WaitNotBusy();
    if (FLASH->PECR & FLASH_PECR_PELOCK) {
        FLASH->PEKEYR = FLASH_PEKEY1;
        FLASH->PEKEYR = FLASH_PEKEY2;
    }
 }
 static inline void STM32_L0_L1_EEPROM_Lock(void) {
    STM32_L0_L1_EEPROM_WaitNotBusy();
    FLASH->PECR |= FLASH_PECR_PELOCK;
 }
 void eeprom_driver_init(void) {}
 void eeprom_driver_erase(void) {
    STM32_L0_L1_EEPROM_Unlock();
    for (size_t offset = 0; offset < STM32_ONBOARD_EEPROM_SIZE; offset += sizeof(uint32_t)) {
        FLASH->PECR |= FLASH_PECR_ERASE | FLASH_PECR_DATA;
        *(__IO uint32_t *)EEPROM_ADDR(offset) = (uint32_t)0;
        STM32_L0_L1_EEPROM_WaitNotBusy();
        FLASH->PECR &= ~(FLASH_PECR_ERASE | FLASH_PECR_DATA);
    }
    STM32_L0_L1_EEPROM_Lock();
 }
 void eeprom_read_block(void *buf, const void *addr, size_t len) {
    for (size_t offset = 0; offset < len; ++offset) {
        // Drop out if we've hit the limit of the EEPROM
        if ((((uint32_t)addr) + offset) >= STM32_ONBOARD_EEPROM_SIZE) {
            break;
        }
        STM32_L0_L1_EEPROM_WaitNotBusy();
        BUFFER_BYTE(buf, offset) = EEPROM_BYTE(addr, offset);
    }
 }
 void eeprom_write_block(const void *buf, void *addr, size_t len) {
    STM32_L0_L1_EEPROM_Unlock();
    for (size_t offset = 0; offset < len; ++offset) {
        // Drop out if we've hit the limit of the EEPROM
        if ((((uint32_t)addr) + offset) >= STM32_ONBOARD_EEPROM_SIZE) {
            break;
        }
        STM32_L0_L1_EEPROM_WaitNotBusy();
        EEPROM_BYTE(addr, offset) = BUFFER_BYTE(buf, offset);
    }
    STM32_L0_L1_EEPROM_Lock();
 }
@@ -0,0 +1,33 @@
 /* Copyright 2020 Nick Brassel (tzarc)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 #pragma once
 /*
    The size used by the STM32 L0/L1 EEPROM driver.
 */
 #ifndef STM32_ONBOARD_EEPROM_SIZE
 #    ifdef VIA_ENABLE
 #        define STM32_ONBOARD_EEPROM_SIZE 1024
 #    else
 #        include "eeconfig.h"
 #        define STM32_ONBOARD_EEPROM_SIZE (((EECONFIG_SIZE + 3) / 4) * 4)  // based off eeconfig's current usage, aligned to 4-byte sizes, to deal with LTO and EEPROM page sizing
 #    endif
 #endif
 #if STM32_ONBOARD_EEPROM_SIZE > 128
 #    pragma message("Please note: resetting EEPROM using an STM32L0/L1 device takes up to 1 second for every 1kB of internal EEPROM used.")
 #endif
@@ -1,49 +0,0 @@
 /* Copyright 2019 Ryota Goto
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 #include QMK_KEYBOARD_H
 /*
    K000, K001, K002, K003, K004, K005, K006, K007, K008, K009, K010, K011, \
    K100, K101, K102, K103, K104, K105, K106, K107, K108, K109, K110, K111, \
    K200, K201, K202, K203, K204, K205, K206, K207, K208, K209, K210, K211, \
    K300, K301, K302,     K304,       K306,       K308,   K309, K310, K311  \
 */
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
  [0] = LAYOUT_all( /* Base */
    MO(2),   KC_Q,    KC_W,    KC_E,    KC_R,    KC_T,    KC_Y,    KC_U,    KC_I,    KC_O,    KC_P,    KC_BSPC, 
    MO(1),   KC_A,    KC_S,    KC_D,    KC_F,    KC_G,    KC_H,    KC_J,    KC_K,    KC_L,    KC_SCLN, KC_ENT, 
    KC_LSFT, KC_LSFT, KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,    KC_N,    KC_M,    KC_COMM, KC_DOT,  KC_RSFT, 
    KC_LCTL, KC_LGUI, KC_LALT,          KC_SPC,           KC_SPC,       KC_SPC,      KC_GRV,  KC_RGUI, KC_DEL
  ),
  [1] = LAYOUT_all( /* Extra Keys */
    _______, _______, KC_PGUP, _______, _______, KC_LBRC, KC_RBRC, _______, KC_UP,   _______, _______, _______, 
    _______, KC_HOME, KC_PGDN, KC_END,  _______, KC_BSLS, KC_SLSH, KC_LEFT, KC_DOWN, KC_RGHT, _______, _______, 
    _______, _______, _______, _______, _______, KC_PSCR, KC_ESC,  KC_QUOT, _______, KC_DOT,  _______, _______, 
    _______, _______, _______,          _______,          _______,     _______,      _______, _______, _______
  ),
  [2] = LAYOUT_all( /* Num and FN */
    _______, KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    KC_6,    KC_7,    KC_8,    KC_9,    KC_0,    _______, 
    _______, KC_F1,   KC_F2,   KC_F3,   KC_F4,   KC_F5,   KC_F6,   _______, _______, _______, _______, _______, 
    _______, _______, KC_F7,   KC_F8,   KC_F9,   KC_F10,  KC_F11,  KC_F12,  _______, _______, _______, _______, 
    _______, _______, _______,          _______,          _______,     _______,      _______, _______, _______
  ),
  [3] = LAYOUT_all( /* Other */
    _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, 
    _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, 
    _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, 
    _______, _______, _______,          _______,          _______,     _______,      _______, _______, _______
  )
 };
@@ -1,4 +0,0 @@
 # The proto via keymap for equinox
 Has the necessary tweaks to run on early prototype PCBs.  
 Not to be used for production run PCBs.  
@@ -1,5 +0,0 @@
 VIA_ENABLE = yes
 # Fix for prototype missing COL0, COL1, using backlight and RGB underglow I/O pins
 BACKLIGHT_ENABLE = no       # Enable keyboard backlight functionality
 RGBLIGHT_ENABLE = no        # Enable keyboard RGB underglow
@@ -21,3 +21,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #undef MATRIX_COL_PINS
 #define MATRIX_COL_PINS { C4, B7, C6, C7, B6, B5, B4, B3, B2, B1, B0, D6 }
 // This directs backlight code to use a disconnected pin, so the firwmare still has
 // backlight code and VIA support even though it doesn't do anything.
 #undef BACKLIGHT_PIN
 #define BACKLIGHT_PIN D1
@@ -0,0 +1 @@
 # Dummy rules.mk, rev0 uses parent rules.mk as is
@@ -0,0 +1,18 @@
 /*
 Copyright 2019 Ryota Goto
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation, either version 2 of the License, or
 (at your option) any later version.
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 #pragma once
@@ -0,0 +1 @@
 # Dummy rules.mk, rev1 uses parent rules.mk as is
@@ -16,10 +16,6 @@
 #undef MOUSEKEY_WHEEL_TIME_TO_MAX
 #define MOUSEKEY_WHEEL_TIME_TO_MAX 60
 // Timeout settings for leader key
 #undef  LEADER_TIMEOUT
 #define LEADER_TIMEOUT 350
 #define LEADER_PER_KEY_TIMING
 #undef DEBOUNCE
 #define DEBOUNCE 45
@@ -36,9 +36,9 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
    OSM(MOD_LSFT)       ,LT(2,KC_BSPACE)     ,OSM(MOD_LGUI)              ,
-    TO(1)               ,KC_6                ,KC_7                ,KC_8                ,TD_F9               ,LT(3,KC_0)          ,KC_DQUO             ,
+    TO(1)               ,KC_6                ,KC_7                ,KC_8                ,KC_9                ,LT(3,KC_0)          ,KC_DQUO             ,
    KC_UNDS             ,KC_Y                ,KC_U                ,KC_I                ,KC_O                ,KC_P                ,RSFT_T(KC_MINUS)            ,
-    HYPR_T(KC_H)        ,ALT_T(KC_J)         ,RCTL_T(KC_K)        ,LT(6,KC_L)          ,TD_CLN              ,GUI_T(KC_QUOTE)     ,
+    HYPR_H              ,ALT_J               ,CTL_K               ,LT(6,KC_L)          ,TD_CLN              ,CMD_QUOT            ,
    ALT_TAB             ,KC_N                ,MEH_T(KC_M)         ,KC_COMMA            ,KC_DOT              ,KC_SLASH            ,LT(4,KC_KP_ASTERISK),
    LT(4,KC_ENTER)      ,KC_DOWN             ,KC_LBRACKET         ,KC_RBRACKET         ,OSL(2)              ,
    KC_AUDIO_MUTE       ,KC_ESCAPE           ,
@@ -88,14 +88,14 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
    KC_TRANSPARENT     ,KC_TRANSPARENT     ,KC_TRANSPARENT     ,KC_LABK            ,KC_RABK            ,KC_TRANSPARENT     ,KC_TRANSPARENT     ,
    KC_TRANSPARENT     ,KC_AT              ,KC_TRANSPARENT     ,KC_EQL             ,F_ARROW            ,KC_GRAVE           ,
    KC_TRANSPARENT     ,KC_TRANSPARENT     ,KC_TRANSPARENT     ,KC_LBRACKET        ,KC_RBRACKET        ,KC_TRANSPARENT     ,KC_TRANSPARENT     ,
-    KC_TRANSPARENT     ,KC_TRANSPARENT     ,KC_TRANSPARENT     ,KC_TRANSPARENT     ,KC_TRANSPARENT     ,
+    KC_TRANSPARENT     ,KC_TRANSPARENT     ,KC_TRANSPARENT     ,IARROW             ,ARROW               ,
    KC_TRANSPARENT     ,KC_TRANSPARENT     ,
    KC_TRANSPARENT     ,
    // Right hand
    KC_TRANSPARENT     ,KC_TRANSPARENT     ,KC_TRANSPARENT     ,
    KC_TRANSPARENT     ,KC_TRANSPARENT     ,KC_TRANSPARENT     ,KC_TRANSPARENT     ,KC_TRANSPARENT     ,KC_TRANSPARENT     ,KC_TRANSPARENT     ,
    LALT(LSFT(KC_UP))  ,KC_HASH            ,KC_LCBR            ,KC_RCBR            ,KC_KP_ASTERISK     ,KC_PERC            ,KC_DLR             ,
-                        KC_AMPR            ,KC_LPRN            ,KC_RPRN            ,KC_CIRC            ,KC_KP_PLUS         ,KC_PIPE            ,
+                        KC_AMPR            ,KC_LPRN            ,KC_RPRN            ,CLN_EQ             ,KC_KP_PLUS         ,KC_PIPE            ,
    LALT(LSFT(KC_DOWN)),KC_EXLM            ,KC_TILD            ,KC_CIRC            ,ARROW              ,KC_BSLASH          ,KC_BSLASH          ,
    KC_TRANSPARENT     ,KC_TRANSPARENT     ,KC_TRANSPARENT     ,KC_TRANSPARENT     ,KC_TRANSPARENT     ,
    RESET              ,KC_TRANSPARENT     ,
@@ -316,3 +316,11 @@ void oneshot_mods_changed_user(uint8_t mods) {
 void oneshot_locked_mods_changed_user(uint8_t mods) {
    oneshot_mods_changed_user(mods);
 }
 //=============== alt_tab callbacks
 void alt_tab_activated(void){
    layer_on(7); // activate motion layer
 }
 void alt_tab_deactivated(void){
    layer_off(7); // activate motion layer
 }
@@ -0,0 +1,102 @@
 #include QMK_KEYBOARD_H
 #include "keymap_nordic.h"
 enum layers {
  _DEFAULT,
  _LOWER,
  _RAISE,
  _FN
 };
 enum custom_keycodes {
    PRKL = SAFE_RANGE,
 };
 #define LOWER MO(_LOWER)
 #define RAISE MO(_RAISE)
 #define FN MO(_FN)
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 /* Default
 * ,-----------------------------------------------------------------------------------.------.
 * | Esc  |   Q  |   W  |   E  |   R  |   T  |   Y  |   U  |   I  |   O  |   P  |  ¨^  | Bksp |
 * |------+------+------+------+------+-------------+------+------+------+------+------|------|
 * |  Tab |   A  |   S  |   D  |   F  |   G  |   H  |   J  |   K  |   L  |   Ö  |  Ä   | Entr |
 * |------+------+------+------+------+------|------+------+------+------+------+------|------'
 * | Shift|   Z  |   X  |   C  |   V  |    Space    |   B  |   N  |   M  |   ,  |   .  |
 * |------+------+------+------+------+------+------+------+------+------+------+------'
 */
 [_DEFAULT] = LAYOUT_2u_space(
    KC_ESC,  KC_Q,    KC_W,    KC_E,    KC_R,    KC_T,               KC_Y,    KC_U,    KC_I,    KC_O,    KC_P,    NO_QUOT, KC_BSPC,
    KC_LCTL, KC_A,    KC_S,    KC_D,    KC_F,    KC_G,               KC_H,    KC_J,    KC_K,    KC_L,    NO_AE,   NO_OSLH, LT(_FN, KC_ENT),
    KC_LSFT, LGUI_T(KC_Z),    KC_X,    KC_C,    KC_V,  LT(_LOWER, KC_SPC),    KC_B,    KC_N,    KC_M,    KC_COMM, LT(_RAISE, KC_DOT)
 ),
 /* Lower - Numbers and some symbols
 * ,------------------------------------------------------------------------------------------.
 * |   ~  |   1  |   2  |   3  |   4  |   5  |   6  |   7  |   8  |   9  |   0   |  +  | DEL  |
 * |------+------+------+------+------+------+------+------+------+------+------+------|------|
 * |      | TAB  |      |      |      |      |      |      |      |      |      |   '  |      |
 * |------+------+------+------+------+------+------+------+------+------+------+------|------'
 * |      |      |      |      |      |             |      |      |      |  -   |      |
 * `------+------+------+------+------+------+------+------+------+------+------+------'
 */
 [_LOWER] = LAYOUT_2u_space(
    KC_TILD, KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    KC_6,    KC_7,    KC_8,    KC_9,    KC_0,    NO_PLUS, KC_DEL,
    _______, KC_TAB, _______, _______, _______, _______, _______, _______, _______, _______, _______, NO_APOS, _______,
    _______, _______, _______, _______, _______, _______,      _______,    _______, _______, NO_MINS, _______
 ),
 /* Raise - AltGred Characters and more symbols
 * ,------------------------------------------------------------------------------------------.
 * |   ~  |   >  |   @  |   £  |   $  |   %  |   &  |   |  |   [  |   ]  |   ≈  | ?    | {    |
 * |------+------+------+------+------+------+------+------+------+------+------+------|------|
 * |      |      |      |  UP  |      |      |      |      |      |      |      |      | }    |
 * |------+------+------+------+------+------+------+------+------+------+------+------|------'
 * |      |   <  | LEFT | DOWN | RIGHT|             |      |      |      |      |      |
 * `------+------+------+------+------+------+------+------+------+------+------+------'
 */
 [_RAISE] = LAYOUT_2u_space(
    NO_TILD, NO_SECT, NO_AT,   NO_PND,  NO_DLR,  KC_PERC, NO_AMPR, NO_LCBR, NO_LBRC, NO_RBRC, NO_RCBR, NO_QUES, LSFT(NO_LBRC),
    _______, _______, _______, KC_UP,   _______, _______, _______, _______, _______, _______, _______, _______, LSFT(NO_RBRC),
    _______, NO_HALF, KC_LEFT, KC_DOWN, KC_RGHT, _______, _______, _______, _______, _______, _______
 ),
 /* FN
 * ,------------------------------------------------------------------------------------------.
 * |RESET |   F1 |   F2 |   F3 |   F4 |   F5 |   F6 |   F7 |   F8 |   F9 |  F10 |  F11 | F12  |
 * |------+------+------+------+------+------+------+------+------+------+------+------|------|
 * |      |RGB_P |RGB_HD|RGB_HI| VOL- | PREV | NEXT | VOL+ |      |      |      | PRKL |      |
 * |------+------+------+------+------+------+------+------+------+------+------+------|------'
 * | RGB_M|RGB_VD|RGB_VI|RGB_TG|      | PLAY/PAUSE  |      |      |      |LCA(DEL)|    |
 * `------+------+------+------+------+------+------+------+------+------+------+------'
 */
 [_FN] = LAYOUT_2u_space(
    RESET,   KC_F1,   KC_F2,   KC_F3,   KC_F4,   KC_F5,   KC_F6,   KC_F7,   KC_F8,   KC_F9,   KC_F10,  KC_F11,  KC_F12,
    _______, RGB_M_P, RGB_HUD, RGB_HUI, KC_VOLD, KC_MPRV, KC_MNXT, KC_VOLU, _______, _______, _______, PRKL,    _______,
    RGB_MOD, RGB_VAD, RGB_VAI, RGB_TOG, _______, KC_MPLY, _______, _______, _______, LCA(KC_DEL), _______
 ),
 };
 void encoder_update_user(uint8_t index, bool clockwise) {
    if (clockwise) {
      tap_code16(LCTL(KC_RIGHT));
    } else {
      tap_code16(LCTL(KC_LEFT));
    }
 }
 bool process_record_user(uint16_t keycode, keyrecord_t *record) {
  switch (keycode) {
    case PRKL:
      if (record->event.pressed) {
        //When PRKL is pressed, print out the holy power word of our people
        SEND_STRING("PERKELE");
      }
      break;
  }
  return true;
 };
@@ -0,0 +1,16 @@
 # The default keymap for PRKL30
 Layout geared towards productivity with OSX
 -----
 Default layer  
 ![prkl30 default layout image](https://i.imgur.com/tekFaHW.png "default")
 Lower  
 ![prkl30 lower layout image](https://i.imgur.com/5F4CL4g.png "lower")
 Raise  
 ![prkl30 raise layout image](https://i.imgur.com/BpC8T6p.png "raise")
 FN  
 ![prkl30 fn layout image](https://i.imgur.com/gwgIKqj.png "fn")
@@ -32,7 +32,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
      if (record->event.pressed) {
        SEND_STRING("Hello from Illuminati Works");
      } else {
-		SEND_STRING("iS0 working properly");
+        SEND_STRING("iS0 working properly");
      }
      break;
  }
@@ -0,0 +1,36 @@
 /* Copyright 2020 Lorenz Wellmer
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 #include QMK_KEYBOARD_H
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
    [0] = LAYOUT_tkl_ansi(
        KC_ESC,           KC_F1,   KC_F2,   KC_F3,   KC_F4,   KC_F5,   KC_F6,   KC_F7,   KC_F8,   KC_F9,   KC_F10,  KC_F11,  KC_F12,                KC_PSCR, KC_SLCK, KC_PAUS,
        KC_GRV,  KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    KC_6,    KC_7,    KC_8,    KC_9,    KC_0,    KC_MINS, KC_EQL,  KC_BSPC,               KC_INS,  KC_HOME, KC_PGUP,
        KC_TAB,  KC_Q,    KC_W,    KC_E,    KC_R,    KC_T,    KC_Y,    KC_U,    KC_I,    KC_O,    KC_P,    KC_LBRC, KC_RBRC, KC_BSLS,               KC_DEL,  KC_END,  KC_PGDN,
        KC_CAPS, KC_A,    KC_S,    KC_D,    KC_F,    KC_G,    KC_H,    KC_J,    KC_K,    KC_L,    KC_SCLN, KC_QUOT,          KC_ENT,  
        KC_LSFT,          KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,    KC_N,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH,          KC_RSFT,                        KC_UP,
        KC_LCTL, KC_LGUI, KC_LALT,                            KC_SPC,                             KC_RALT, MO(1),   KC_RGUI, KC_RCTL,               KC_LEFT, KC_DOWN, KC_RGHT),
    [1] = LAYOUT_tkl_ansi(
        KC_TRNS,          KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,               BL_TOGG, BL_DEC,  BL_INC,
        KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,               KC_TRNS, KC_TRNS, KC_VOLU,
        KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, RESET,   KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,               KC_MPLY, KC_MNXT, KC_VOLD,
        KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,          KC_TRNS,
        KC_TRNS,          KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,          KC_TRNS,                        KC_TRNS,
        KC_TRNS, KC_TRNS, KC_TRNS,                            KC_TRNS,                            KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,               KC_TRNS, KC_TRNS, KC_TRNS),
 };
@@ -0,0 +1 @@
 # The default ANSI keymap for Kira 80
@@ -0,0 +1,36 @@
 /* Copyright 2020 Lorenz Wellmer
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 #include QMK_KEYBOARD_H
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
    [0] = LAYOUT_tkl_ansi_wkl(
        KC_ESC,           KC_F1,   KC_F2,   KC_F3,   KC_F4,   KC_F5,   KC_F6,   KC_F7,   KC_F8,   KC_F9,   KC_F10,  KC_F11,  KC_F12,                KC_PSCR, KC_SLCK, KC_PAUS,
        KC_GRV,  KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    KC_6,    KC_7,    KC_8,    KC_9,    KC_0,    KC_MINS, KC_EQL,  KC_BSPC,               KC_INS,  KC_HOME, KC_PGUP,
        KC_TAB,  KC_Q,    KC_W,    KC_E,    KC_R,    KC_T,    KC_Y,    KC_U,    KC_I,    KC_O,    KC_P,    KC_LBRC, KC_RBRC, KC_BSLS,               KC_DEL,  KC_END,  KC_PGDN,
        KC_CAPS, KC_A,    KC_S,    KC_D,    KC_F,    KC_G,    KC_H,    KC_J,    KC_K,    KC_L,    KC_SCLN, KC_QUOT,          KC_ENT,  
        KC_LSFT,          KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,    KC_N,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH,          KC_RSFT,                        KC_UP,
        KC_LCTL,          KC_LALT,                            KC_SPC,                                      KC_RALT,          MO(1),                 KC_LEFT, KC_DOWN, KC_RGHT),
    [1] = LAYOUT_tkl_ansi_wkl(
        KC_TRNS,          KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,               BL_TOGG, BL_DEC,  BL_INC,
        KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,               KC_TRNS, KC_TRNS, KC_VOLU,
        KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, RESET,   KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,               KC_MPLY, KC_MNXT, KC_VOLD,
        KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,          KC_TRNS,
        KC_TRNS,          KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,          KC_TRNS,                        KC_TRNS,
        KC_TRNS,          KC_TRNS,                            KC_TRNS,                                     KC_TRNS,          KC_TRNS,               KC_TRNS, KC_TRNS, KC_TRNS),
 };
@@ -0,0 +1 @@
 # The default ANSI WKL keymap for Kira 80
@@ -26,7 +26,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
        KC_LCTL, KC_LGUI, KC_LALT,                            KC_SPC,                             KC_RALT, MO(1),   KC_RGUI, KC_RCTL,               KC_LEFT, KC_DOWN, KC_RGHT),
    [1] = LAYOUT_all(
-        KC_TRNS,          KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, RGB_TOG, RGB_MOD, RGB_HUD, RGB_HUI, RGB_SAD, RGB_SAI, RGB_VAD, RGB_VAI,               BL_TOGG, BL_DEC,  BL_INC,
+        KC_TRNS,          KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,               BL_TOGG, BL_DEC,  BL_INC,
        KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,      KC_TRNS, KC_TRNS, KC_VOLU,
        KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, RESET,   KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,               KC_MPLY, KC_MNXT, KC_VOLD,
        KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,          KC_TRNS,
@@ -1 +1 @@
-# The default keymap for kira80
+# The default keymap for Kira 80
@@ -0,0 +1,36 @@
 /* Copyright 2020 Lorenz Wellmer
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 #include QMK_KEYBOARD_H
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
    [0] = LAYOUT_tkl_iso(
        KC_ESC,           KC_F1,   KC_F2,   KC_F3,   KC_F4,   KC_F5,   KC_F6,   KC_F7,   KC_F8,   KC_F9,   KC_F10,  KC_F11,  KC_F12,                KC_PSCR, KC_SLCK, KC_PAUS,
        KC_GRV,  KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    KC_6,    KC_7,    KC_8,    KC_9,    KC_0,    KC_MINS, KC_EQL,  KC_BSPC,               KC_INS,  KC_HOME, KC_PGUP,
        KC_TAB,  KC_Q,    KC_W,    KC_E,    KC_R,    KC_T,    KC_Y,    KC_U,    KC_I,    KC_O,    KC_P,    KC_LBRC, KC_RBRC,                        KC_DEL,  KC_END,  KC_PGDN,
        KC_CAPS, KC_A,    KC_S,    KC_D,    KC_F,    KC_G,    KC_H,    KC_J,    KC_K,    KC_L,    KC_SCLN, KC_QUOT, KC_NUHS, KC_ENT,  
        KC_LSFT, KC_NUBS, KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,    KC_N,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH,          KC_RSFT,                        KC_UP,
        KC_LCTL, KC_LGUI, KC_LALT,                            KC_SPC,                             KC_RALT, MO(1),   KC_RGUI, KC_RCTL,               KC_LEFT, KC_DOWN, KC_RGHT),
    [1] = LAYOUT_tkl_iso(
        KC_TRNS,          KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,               BL_TOGG, BL_DEC,  BL_INC,
        KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,               KC_TRNS, KC_TRNS, KC_VOLU,
        KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, RESET,   KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,                        KC_MPLY, KC_MNXT, KC_VOLD,
        KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,
        KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,          KC_TRNS,                        KC_TRNS,
        KC_TRNS, KC_TRNS, KC_TRNS,                            KC_TRNS,                            KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,               KC_TRNS, KC_TRNS, KC_TRNS),
 };
@@ -0,0 +1 @@
 # The default ISO keymap for Kira 80
@@ -52,10 +52,10 @@
    K075, K076, K077,                   K079,                   K083, K084, K085, K086,          K087, K088, K082   \
 ) { \
    { K000,  K001,  K002,  K003,  K004,  K005,  KC_NO, K007,  K008,  K009,  K010,  K011,  K012,  K013,  KC_NO }, \
-    { K015,  K016,  K017,  K018,  K019,  K020,  K021,  K022,  K023,  K024,  K025,  K026,  K027,  K028,  K029  }, \
+    { K015,  K016,  K017,  K018,  K019,  K020,  K021,  K022,  K023,  K024,  K025,  K026,  K027,  K028,  KC_NO }, \
    { K030,  K031,  K032,  K033,  K034,  K035,  K036,  K037,  K038,  K039,  K040,  K041,  K042,  K043,  KC_NO }, \
-    { K045,  K046,  K047,  K048,  K049,  K050,  K051,  K052,  K053,  K054,  K055,  K056,  K057,  K058,  KC_NO }, \
+    { K045,  K046,  K047,  K048,  K049,  K050,  K051,  K052,  K053,  K054,  K055,  K056,  K057,  KC_NO, KC_NO }, \
-    { K060,  K061,  K062,  K063,  K064,  K065,  K066,  K067,  K068,  K069,  K070,  K071,  K072,  K073,  KC_NO }, \
+    { K060,  K061,  K062,  K063,  K064,  K065,  K066,  K067,  K068,  K069,  K070,  K071,  KC_NO, K073,  KC_NO }, \
    { K075,  K076,  K077,  KC_NO, K079,  KC_NO, KC_NO, K082,  K083,  K084,  K085,  K086,  K087,  K088,  KC_NO }, \
    { KC_NO, K091,  K092,  KC_NO, K094,  K095,  K096,  K097,  K098,  KC_NO, KC_NO, KC_NO, K102,  K103,  KC_NO }  \
 }
@@ -69,11 +69,11 @@
    K075,       K077,                   K079,                         K084,       K086,          K087, K088, K082   \
 ) { \
    { K000,  K001,  K002,  K003,  K004,  K005,  KC_NO, K007,  K008,  K009,  K010,  K011,  K012,  K013,  KC_NO }, \
-    { K015,  K016,  K017,  K018,  K019,  K020,  K021,  K022,  K023,  K024,  K025,  K026,  K027,  K028,  K029  }, \
+    { K015,  K016,  K017,  K018,  K019,  K020,  K021,  K022,  K023,  K024,  K025,  K026,  K027,  K028,  KC_NO }, \
    { K030,  K031,  K032,  K033,  K034,  K035,  K036,  K037,  K038,  K039,  K040,  K041,  K042,  K043,  KC_NO }, \
-    { K045,  K046,  K047,  K048,  K049,  K050,  K051,  K052,  K053,  K054,  K055,  K056,  K057,  K058,  KC_NO }, \
+    { K045,  K046,  K047,  K048,  K049,  K050,  K051,  K052,  K053,  K054,  K055,  K056,  K057,  KC_NO, KC_NO }, \
-    { K060,  K061,  K062,  K063,  K064,  K065,  K066,  K067,  K068,  K069,  K070,  K071,  K072,  K073,  KC_NO }, \
+    { K060,  K061,  K062,  K063,  K064,  K065,  K066,  K067,  K068,  K069,  K070,  K071,  KC_NO, K073,  KC_NO }, \
-    { K075,  K076,  K077,  KC_NO, K079,  KC_NO, KC_NO, K082,  K083,  K084,  K085,  K086,  K087,  K088,  KC_NO }, \
+    { K075,  KC_NO, K077,  KC_NO, K079,  KC_NO, KC_NO, K082,  KC_NO, K084,  KC_NO, K086,  K087,  K088,  KC_NO }, \
    { KC_NO, K091,  K092,  KC_NO, K094,  K095,  K096,  K097,  K098,  KC_NO, KC_NO, KC_NO, K102,  K103,  KC_NO }  \
 }
@@ -86,10 +86,10 @@
    K075, K076, K077,                   K079,                   K083, K084, K085, K086,          K087, K088, K082   \
 ) { \
    { K000,  K001,  K002,  K003,  K004,  K005,  KC_NO, K007,  K008,  K009,  K010,  K011,  K012,  K013,  KC_NO }, \
-    { K015,  K016,  K017,  K018,  K019,  K020,  K021,  K022,  K023,  K024,  K025,  K026,  K027,  K028,  K029  }, \
+    { K015,  K016,  K017,  K018,  K019,  K020,  K021,  K022,  K023,  K024,  K025,  K026,  K027,  K028,  KC_NO }, \
    { K030,  K031,  K032,  K033,  K034,  K035,  K036,  K037,  K038,  K039,  K040,  K041,  K042,  K043,  KC_NO }, \
    { K045,  K046,  K047,  K048,  K049,  K050,  K051,  K052,  K053,  K054,  K055,  K056,  K057,  K058,  KC_NO }, \
-    { K060,  K061,  K062,  K063,  K064,  K065,  K066,  K067,  K068,  K069,  K070,  K071,  K072,  K073,  KC_NO }, \
+    { K060,  K061,  K062,  K063,  K064,  K065,  K066,  K067,  K068,  K069,  K070,  K071,  KC_NO, K073,  KC_NO }, \
    { K075,  K076,  K077,  KC_NO, K079,  KC_NO, KC_NO, K082,  K083,  K084,  K085,  K086,  K087,  K088,  KC_NO }, \
    { KC_NO, K091,  K092,  KC_NO, K094,  K095,  K096,  K097,  K098,  KC_NO, KC_NO, KC_NO, K102,  K103,  KC_NO }  \
 }
@@ -16,8 +16,6 @@
 #ifndef RGBLIGHT_H
 #define RGBLIGHT_H
 #include "rgblight_reconfig.h"
 /***** rgblight_mode(mode)/rgblight_mode_noeeprom(mode) ****
 old mode number (before 0.6.117) to new mode name table
@@ -64,6 +62,39 @@
 |-----------------|-----------------------------------|
 *****/
 #ifdef RGBLIGHT_ANIMATIONS
 // for backward compatibility
 #    define RGBLIGHT_EFFECT_BREATHING
 #    define RGBLIGHT_EFFECT_RAINBOW_MOOD
 #    define RGBLIGHT_EFFECT_RAINBOW_SWIRL
 #    define RGBLIGHT_EFFECT_SNAKE
 #    define RGBLIGHT_EFFECT_KNIGHT
 #    define RGBLIGHT_EFFECT_CHRISTMAS
 #    define RGBLIGHT_EFFECT_STATIC_GRADIENT
 #    define RGBLIGHT_EFFECT_RGB_TEST
 #    define RGBLIGHT_EFFECT_ALTERNATING
 #endif
 #ifdef RGBLIGHT_STATIC_PATTERNS
 #    define RGBLIGHT_EFFECT_STATIC_GRADIENT
 #endif
 // clang-format off
 // check dynamic animation effects chose ?
 #if  defined(RGBLIGHT_EFFECT_BREATHING)     \
  || defined(RGBLIGHT_EFFECT_RAINBOW_MOOD)  \
  || defined(RGBLIGHT_EFFECT_RAINBOW_SWIRL) \
  || defined(RGBLIGHT_EFFECT_SNAKE)         \
  || defined(RGBLIGHT_EFFECT_KNIGHT)        \
  || defined(RGBLIGHT_EFFECT_CHRISTMAS)     \
  || defined(RGBLIGHT_EFFECT_RGB_TEST)      \
  || defined(RGBLIGHT_EFFECT_ALTERNATING)
 #    define RGBLIGHT_USE_TIMER
 #endif
 // clang-format on
 #define _RGBM_SINGLE_STATIC(sym) RGBLIGHT_MODE_##sym,
 #define _RGBM_SINGLE_DYNAMIC(sym) RGBLIGHT_MODE_##sym,
 #define _RGBM_MULTI_STATIC(sym) RGBLIGHT_MODE_##sym,
@@ -263,12 +294,19 @@ void rgblight_mode_eeprom_helper(uint8_t mode, bool write_to_eeprom);
 #    define EZ_RGB(val) rgblight_show_solid_color((val >> 16) & 0xFF, (val >> 8) & 0xFF, val & 0xFF)
 void rgblight_show_solid_color(uint8_t r, uint8_t g, uint8_t b);
 #    ifdef RGBLIGHT_USE_TIMER
 void rgblight_task(void);
 void rgblight_timer_init(void);
 void rgblight_timer_enable(void);
 void rgblight_timer_disable(void);
 void rgblight_timer_toggle(void);
 #    else
 #        define rgblight_task()
 #        define rgblight_timer_init()
 #        define rgblight_timer_enable()
 #        define rgblight_timer_disable()
 #        define rgblight_timer_toggle()
 #    endif
 #    ifdef RGBLIGHT_SPLIT
 #        define RGBLIGHT_STATUS_CHANGE_MODE (1 << 0)
@@ -0,0 +1,270 @@
 #include <avr/io.h>
 #include <avr/interrupt.h>
 #include "quantum.h"
 #include "pointing_device.h"
 #include "adns9800_srom_A4.h"
 #include "../../lib/lufa/LUFA/Drivers/Peripheral/SPI.h"
 // registers
 #define REG_Product_ID                           0x00
 #define REG_Revision_ID                          0x01
 #define REG_Motion                               0x02
 #define REG_Delta_X_L                            0x03
 #define REG_Delta_X_H                            0x04
 #define REG_Delta_Y_L                            0x05
 #define REG_Delta_Y_H                            0x06
 #define REG_SQUAL                                0x07
 #define REG_Pixel_Sum                            0x08
 #define REG_Maximum_Pixel                        0x09
 #define REG_Minimum_Pixel                        0x0a
 #define REG_Shutter_Lower                        0x0b
 #define REG_Shutter_Upper                        0x0c
 #define REG_Frame_Period_Lower                   0x0d
 #define REG_Frame_Period_Upper                   0x0e
 #define REG_Configuration_I                      0x0f
 #define REG_Configuration_II                     0x10
 #define REG_Frame_Capture                        0x12
 #define REG_SROM_Enable                          0x13
 #define REG_Run_Downshift                        0x14
 #define REG_Rest1_Rate                           0x15
 #define REG_Rest1_Downshift                      0x16
 #define REG_Rest2_Rate                           0x17
 #define REG_Rest2_Downshift                      0x18
 #define REG_Rest3_Rate                           0x19
 #define REG_Frame_Period_Max_Bound_Lower         0x1a
 #define REG_Frame_Period_Max_Bound_Upper         0x1b
 #define REG_Frame_Period_Min_Bound_Lower         0x1c
 #define REG_Frame_Period_Min_Bound_Upper         0x1d
 #define REG_Shutter_Max_Bound_Lower              0x1e
 #define REG_Shutter_Max_Bound_Upper              0x1f
 #define REG_LASER_CTRL0                          0x20
 #define REG_Observation                          0x24
 #define REG_Data_Out_Lower                       0x25
 #define REG_Data_Out_Upper                       0x26
 #define REG_SROM_ID                              0x2a
 #define REG_Lift_Detection_Thr                   0x2e
 #define REG_Configuration_V                      0x2f
 #define REG_Configuration_IV                     0x39
 #define REG_Power_Up_Reset                       0x3a
 #define REG_Shutdown                             0x3b
 #define REG_Inverse_Product_ID                   0x3f
 #define REG_Motion_Burst                         0x50
 #define REG_SROM_Load_Burst                      0x62
 #define REG_Pixel_Burst                          0x64
 // pins
 #define NCS 0
 extern const uint16_t firmware_length;
 extern const uint8_t firmware_data[];
 enum motion_burst_property{
    motion = 0,
    observation,
    delta_x_l,
    delta_x_h,
    delta_y_l,
    delta_y_h,
    squal,
    pixel_sum,
    maximum_pixel,
    minimum_pixel,
    shutter_upper,
    shutter_lower,
    frame_period_upper,
    frame_period_lower,
    end_data
 };
 // used to track the motion delta between updates
 volatile int32_t delta_x;
 volatile int32_t delta_y;
 void adns_begin(void){
    PORTB &= ~ (1 << NCS);
 }
 void adns_end(void){
    PORTB |= (1 << NCS);
 }
 void adns_write(uint8_t reg_addr, uint8_t data){
    adns_begin();
    //send address of the register, with MSBit = 1 to indicate it's a write
    SPI_TransferByte(reg_addr | 0x80 );
    SPI_TransferByte(data);
    // tSCLK-NCS for write operation
    wait_us(20);
    adns_end();
    // tSWW/tSWR (=120us) minus tSCLK-NCS. Could be shortened, but is looks like a safe lower bound
    wait_us(100);
 }
 uint8_t adns_read(uint8_t reg_addr){
    adns_begin();
    // send adress of the register, with MSBit = 0 to indicate it's a read
    SPI_TransferByte(reg_addr & 0x7f );
    uint8_t data = SPI_TransferByte(0);
    // tSCLK-NCS for read operation is 120ns
    wait_us(1);
    adns_end();
    //  tSRW/tSRR (=20us) minus tSCLK-NCS
    wait_us(19);
    return data;
 }
 void pointing_device_init(void) {
    if(!is_keyboard_master())
        return;
    // interrupt 2
    EICRA &= ~(1 << 4);
    EICRA |= (1 << 5);
    EIMSK |= (1<<INT2);
    // mode 3
    SPI_Init(
        SPI_SPEED_FCPU_DIV_8 |
        SPI_ORDER_MSB_FIRST |
        SPI_SCK_LEAD_FALLING |
        SPI_SAMPLE_TRAILING |
        SPI_MODE_MASTER);
    // set B0 output
    DDRB |= (1 << 0);
    // reset serial port
    adns_end();
    adns_begin();
    adns_end();
    // reboot
    adns_write(REG_Power_Up_Reset, 0x5a);
    wait_ms(50);
    // read registers and discard
    adns_read(REG_Motion);
    adns_read(REG_Delta_X_L);
    adns_read(REG_Delta_X_H);
    adns_read(REG_Delta_Y_L);
    adns_read(REG_Delta_Y_H);
    // upload firmware
    // set the configuration_IV register in 3k firmware mode
    // bit 1 = 1 for 3k mode, other bits are reserved
    adns_write(REG_Configuration_IV, 0x02);
    // write 0x1d in SROM_enable reg for initializing
    adns_write(REG_SROM_Enable, 0x1d);
    // wait for more than one frame period
    // assume that the frame rate is as low as 100fps... even if it should never be that low
    wait_ms(10);
    // write 0x18 to SROM_enable to start SROM download
    adns_write(REG_SROM_Enable, 0x18);
    // write the SROM file (=firmware data)
    adns_begin();
    // write burst destination adress
    SPI_TransferByte(REG_SROM_Load_Burst | 0x80);
    wait_us(15);
    // send all bytes of the firmware
    unsigned char c;
    for(int i = 0; i < firmware_length; i++){
        c = (unsigned char)pgm_read_byte(firmware_data + i);
        SPI_TransferByte(c);
        wait_us(15);
    }
    adns_end();
    wait_ms(10);
    // enable laser(bit 0 = 0b), in normal mode (bits 3,2,1 = 000b)
    // reading the actual value of the register is important because the real
    // default value is different from what is said in the datasheet, and if you
    // change the reserved bytes (like by writing 0x00...) it would not work.
    uint8_t laser_ctrl0 = adns_read(REG_LASER_CTRL0);
    adns_write(REG_LASER_CTRL0, laser_ctrl0 & 0xf0);
    wait_ms(1);
    // set the configuration_I register to set the CPI
    // 0x01 = 50, minimum
    // 0x44 = 3400, default
    // 0x8e = 7100
    // 0xA4 = 8200, maximum
    adns_write(REG_Configuration_I, 0x04);
    wait_ms(100);
 }
 void pointing_device_task(void) {
    if(!is_keyboard_master())
        return;
    report_mouse_t report = pointing_device_get_report();
    // clamp deltas from -127 to 127
    report.x = delta_x < -127 ? 127 : delta_x > 127 ? 127 : delta_x;
    report.x = -report.x;
    report.y = delta_y < -127 ? 127 : delta_y > 127 ? 127 : delta_y;
    // reset deltas
    delta_x = 0;
    delta_y = 0;
    pointing_device_set_report(report);
    pointing_device_send();
 }
 int16_t convertDeltaToInt(uint8_t high, uint8_t low){
    // join bytes into twos compliment
    uint16_t twos_comp = (high << 8) | low;
    // convert twos comp to int
    if (twos_comp & 0x8000)
        return -1 * ((twos_comp ^ 0xffff) + 1);
    return twos_comp;
 }
 ISR(INT2_vect) {
    // called on interrupt 2 when sensed motion
    // copy burst data from the respective registers
    adns_begin();
    // send adress of the register, with MSBit = 1 to indicate it's a write
    SPI_TransferByte(REG_Motion_Burst & 0x7f);
    uint8_t burst_data[pixel_sum];
    for (int i = 0; i < pixel_sum; ++i) {
        burst_data[i] = SPI_TransferByte(0);
    }
    delta_x += convertDeltaToInt(burst_data[delta_x_h], burst_data[delta_x_l]);
    delta_y += convertDeltaToInt(burst_data[delta_y_h], burst_data[delta_y_l]);
    adns_end();
 }
@@ -0,0 +1,212 @@
 #pragma once
 #include <avr/pgmspace.h>
 const uint16_t firmware_length = 3070;
 const uint8_t firmware_data[] PROGMEM = {
 0x03, 0xa4, 0x6e, 0x16, 0x6d, 0x89, 0x3e, 0xfe, 0x5f, 0x1c, 0xb8, 0xf2, 0x47, 0x0c, 0x7b,
 0x74, 0x6a, 0x56, 0x0f, 0x7d, 0x76, 0x71, 0x4b, 0x0c, 0x97, 0xb6, 0xcf, 0xfd, 0x78, 0x72,
 0x66, 0x2f, 0xbd, 0xf8, 0x53, 0x24, 0xab, 0xd4, 0x2c, 0xb0, 0xe4, 0x32, 0xf1, 0x6a, 0x56,
 0x2e, 0xbf, 0xfc, 0x7a, 0x57, 0x0d, 0x79, 0x70, 0x66, 0x46, 0x0e, 0x7f, 0x5d, 0x19, 0x91,
 0xaa, 0xc2, 0x0d, 0x8e, 0x7f, 0x5d, 0x19, 0xb0, 0xe2, 0x46, 0xef, 0x5c, 0x3a, 0xd7, 0x2c,
 0xbb, 0xf4, 0x6a, 0x37, 0xcd, 0x18, 0xb2, 0xc7, 0x0c, 0x9a, 0x97, 0x8f, 0x52, 0xfd, 0x0d,
 0xb8, 0x41, 0x00, 0x9e, 0x8e, 0x9a, 0x1e, 0x6d, 0x0c, 0xe2, 0xaa, 0x13, 0x93, 0xb8, 0xc1,
 0x2a, 0x29, 0xbb, 0x0b, 0xe3, 0x71, 0x08, 0x6d, 0xfd, 0xb6, 0xd9, 0xcf, 0x65, 0x21, 0x27,
 0x45, 0x1b, 0xbe, 0xe2, 0x61, 0x86, 0x3c, 0xbf, 0x68, 0x9c, 0xd6, 0x75, 0x01, 0x5e, 0xe0,
 0xc6, 0x92, 0x79, 0xf4, 0x6a, 0xa9, 0xbb, 0x2a, 0x79, 0xd0, 0xe1, 0x5c, 0x32, 0xb1, 0x5a,
 0x1b, 0xba, 0xaf, 0x11, 0xea, 0x24, 0x6a, 0x83, 0x4f, 0x8d, 0xed, 0x19, 0x62, 0x70, 0x54,
 0xfb, 0x0e, 0x1f, 0x83, 0xcc, 0xf0, 0xb7, 0xae, 0x05, 0xd3, 0x42, 0x5d, 0x48, 0xa0, 0x7a,
 0x0b, 0x73, 0xb3, 0xc8, 0xa6, 0xb7, 0x1b, 0x08, 0x13, 0x9b, 0x89, 0x44, 0x42, 0xae, 0xd8,
 0x6a, 0xba, 0x9b, 0x84, 0x25, 0x8b, 0xa4, 0x5e, 0x0b, 0x85, 0xb0, 0x8f, 0x8d, 0x80, 0x9c,
 0xd1, 0x52, 0xc7, 0xcb, 0xff, 0x8d, 0x8b, 0xdd, 0x87, 0xf2, 0x63, 0xca, 0xe7, 0x4f, 0x4a,
 0x57, 0x3c, 0xdf, 0xaf, 0xcb, 0x5c, 0xbb, 0x39, 0x0b, 0x01, 0x9c, 0x79, 0x22, 0x15, 0xb8,
 0xa0, 0xd3, 0x72, 0x02, 0x35, 0x20, 0x40, 0xe0, 0x17, 0xde, 0x89, 0x88, 0xce, 0xe9, 0x2b,
 0x75, 0xba, 0xa0, 0x96, 0x24, 0x1e, 0x71, 0xb5, 0x15, 0x00, 0x61, 0xe0, 0x5c, 0x93, 0x4e,
 0xea, 0x53, 0xd0, 0xfc, 0xef, 0xae, 0x2b, 0xeb, 0x8f, 0xc7, 0x69, 0x68, 0xc7, 0xfc, 0x1a,
 0x1f, 0x41, 0x0d, 0xd0, 0xc1, 0x03, 0xaf, 0xc9, 0xfd, 0xe4, 0x21, 0x43, 0xc4, 0xef, 0xc2,
 0xdd, 0x7b, 0x73, 0xbc, 0xca, 0xf4, 0xa5, 0x2e, 0x83, 0x90, 0x1f, 0x78, 0x41, 0xc3, 0x13,
 0x8e, 0x95, 0x0a, 0x57, 0xdf, 0x0a, 0x87, 0x40, 0x2b, 0xd9, 0xba, 0x56, 0x59, 0x9d, 0x2c,
 0xb2, 0xb8, 0xb3, 0xfb, 0x77, 0x78, 0x3a, 0xef, 0xbf, 0x2d, 0xc8, 0xb9, 0x94, 0x62, 0x47,
 0x92, 0x98, 0x42, 0x23, 0x07, 0xd9, 0x39, 0x46, 0x5e, 0x6f, 0xe0, 0x46, 0x14, 0x0e, 0x3d,
 0x74, 0x40, 0x21, 0xb4, 0x67, 0x05, 0xa8, 0xe2, 0x12, 0x93, 0x41, 0xc2, 0x80, 0xb9, 0x56,
 0x4b, 0xf9, 0x5a, 0x15, 0x9c, 0x37, 0xc4, 0x4b, 0x05, 0xad, 0x5a, 0xaf, 0xa1, 0x3e, 0xe4,
 0x6e, 0xc5, 0x91, 0xb6, 0x75, 0x7d, 0x1b, 0xe4, 0xc5, 0x4d, 0x28, 0x6b, 0xe9, 0xad, 0x20,
 0x8b, 0x64, 0x91, 0x57, 0x4f, 0xdf, 0x9a, 0x97, 0x7e, 0xbe, 0x8e, 0xd6, 0xd6, 0x3b, 0x17,
 0xf9, 0x19, 0x28, 0xb2, 0x2e, 0x8f, 0x26, 0xb4, 0x9b, 0xe5, 0xde, 0x0f, 0x8d, 0x0a, 0x9a,
 0x9d, 0x1b, 0xde, 0x6f, 0xcb, 0x84, 0xba, 0x26, 0xd0, 0x12, 0xef, 0x30, 0x38, 0x43, 0xac,
 0xb7, 0xa7, 0xef, 0x09, 0x7c, 0x52, 0x27, 0xfc, 0x2e, 0xab, 0x50, 0xa0, 0x21, 0x40, 0xe7,
 0xc1, 0x5f, 0x02, 0x41, 0x84, 0xa8, 0x54, 0xa8, 0x2e, 0x37, 0x6f, 0xd8, 0xb1, 0xa4, 0xd0,
 0x75, 0xef, 0x31, 0xca, 0x54, 0x1e, 0x33, 0xad, 0x19, 0xa1, 0x94, 0xbc, 0x1b, 0x34, 0x6c,
 0xfb, 0x5f, 0xcc, 0x45, 0x76, 0xc8, 0x96, 0xce, 0x1c, 0x3a, 0x0e, 0x77, 0xed, 0xd8, 0xd2,
 0x96, 0xac, 0x77, 0x30, 0xe1, 0xef, 0xb0, 0x33, 0xf0, 0x6e, 0x3d, 0xce, 0x5e, 0x6d, 0xde,
 0x8a, 0xdc, 0x9b, 0x91, 0x63, 0x2a, 0x95, 0x20, 0x0d, 0xfd, 0x78, 0xba, 0xcb, 0x15, 0x43,
 0xc9, 0x20, 0x96, 0x83, 0x06, 0xd9, 0x11, 0xf3, 0xe2, 0x13, 0xcf, 0x9c, 0x91, 0x7f, 0x33,
 0x46, 0xa7, 0xe2, 0xd3, 0x75, 0xff, 0x4f, 0x0c, 0x0c, 0xaf, 0xcd, 0xa6, 0x9c, 0xa6, 0x73,
 0xe2, 0x6d, 0x17, 0x16, 0xb5, 0x99, 0x80, 0x35, 0xd9, 0x61, 0xf3, 0x48, 0x23, 0xff, 0xae,
 0x53, 0x89, 0xfa, 0x55, 0x1c, 0x37, 0xa5, 0xe8, 0x62, 0x12, 0xb2, 0x22, 0x04, 0xed, 0x42,
 0xb6, 0x65, 0xc4, 0x41, 0x42, 0x72, 0xca, 0x7e, 0x5e, 0x2f, 0x69, 0x46, 0xef, 0xbd, 0x7e,
 0xdf, 0x35, 0x1e, 0x5b, 0x77, 0xaf, 0x8d, 0x39, 0xf8, 0xa7, 0xd8, 0x31, 0x00, 0xd3, 0x85,
 0x66, 0xd5, 0xcd, 0x59, 0xd6, 0x5e, 0x9f, 0xb2, 0x3f, 0x09, 0xd1, 0xc4, 0x5b, 0x74, 0x62,
 0xd3, 0x30, 0x35, 0xf3, 0xe3, 0x7d, 0x7f, 0xab, 0x38, 0xc2, 0x33, 0x42, 0xd0, 0x67, 0xd0,
 0xf4, 0xcf, 0x97, 0xec, 0x35, 0x31, 0xfe, 0x94, 0x9c, 0xa1, 0x66, 0x91, 0xc8, 0x05, 0x45,
 0x19, 0x85, 0x0f, 0x4a, 0xb0, 0x3a, 0x20, 0x44, 0xa4, 0x6b, 0x33, 0x0c, 0xa6, 0xb4, 0x4c,
 0x46, 0x30, 0x15, 0x2d, 0xbb, 0x04, 0x3c, 0x9d, 0x48, 0xf6, 0x84, 0x9a, 0x62, 0x07, 0xe9,
 0x6c, 0x8f, 0xde, 0x29, 0x28, 0x5a, 0x17, 0xec, 0x56, 0xf3, 0xc4, 0xe0, 0x86, 0x2f, 0xb5,
 0x1c, 0x8f, 0xaa, 0xc6, 0xc0, 0xcf, 0x0d, 0xcf, 0x1d, 0x4f, 0xb2, 0xbf, 0x26, 0x5c, 0x7c,
 0x8d, 0xd3, 0xe4, 0x56, 0xd1, 0xe8, 0x90, 0x94, 0x6a, 0xba, 0x27, 0xba, 0xf7, 0xba, 0x39,
 0xc8, 0x08, 0x03, 0x25, 0x7f, 0x16, 0x8f, 0x61, 0xbf, 0xdf, 0x45, 0x88, 0x7d, 0x90, 0x80,
 0x55, 0x58, 0x72, 0x4f, 0xf8, 0xd0, 0x94, 0xbb, 0x55, 0x2a, 0x47, 0x4f, 0xaa, 0x87, 0x2d,
 0xd4, 0xe7, 0xaf, 0x08, 0x33, 0xc9, 0xec, 0x0b, 0x5b, 0xb8, 0x53, 0x27, 0x2e, 0xfb, 0xad,
 0x69, 0xb6, 0x53, 0x64, 0x48, 0x13, 0x41, 0xf8, 0x02, 0x06, 0x6f, 0xb8, 0xcc, 0x64, 0xec,
 0x65, 0x65, 0x7e, 0xdf, 0x3f, 0x1e, 0xe1, 0xee, 0xde, 0x3c, 0x1a, 0xe8, 0x0f, 0xf0, 0x2c,
 0xea, 0x6e, 0x52, 0x77, 0x34, 0x41, 0xa1, 0xcc, 0x72, 0x8f, 0x6e, 0x9c, 0x3b, 0x8d, 0x39,
 0xdf, 0xd4, 0x08, 0x24, 0xba, 0x36, 0xc7, 0x09, 0xf2, 0xf1, 0xa2, 0xd1, 0xe0, 0xa3, 0x6a,
 0x5c, 0xc7, 0xb2, 0x0d, 0x1c, 0xfb, 0x5f, 0xc8, 0x86, 0xd8, 0x3e, 0x1c, 0xb7, 0x1f, 0x2d,
 0xd8, 0xf2, 0xcd, 0x52, 0xeb, 0xde, 0x50, 0x14, 0xb7, 0xc7, 0xa2, 0x8b, 0x78, 0x70, 0x11,
 0x87, 0x1a, 0xc5, 0xb8, 0xe5, 0x5e, 0xa5, 0xc9, 0x94, 0x22, 0x66, 0x7b, 0x8b, 0x74, 0xab,
 0x85, 0x28, 0x95, 0x90, 0x6e, 0x07, 0xdd, 0x79, 0x57, 0xb3, 0x75, 0xc8, 0x18, 0x67, 0x39,
 0x06, 0x21, 0x55, 0xba, 0xba, 0xda, 0xf9, 0x3b, 0xe9, 0x5d, 0xc9, 0x1f, 0x6f, 0x61, 0x3b,
 0xc2, 0x7e, 0x3d, 0x07, 0xa6, 0x84, 0x91, 0xb7, 0x63, 0x7e, 0x5f, 0xfc, 0xd1, 0x7d, 0x08,
 0xdd, 0x79, 0x07, 0xe1, 0x9e, 0x11, 0x25, 0xe8, 0x10, 0x05, 0x66, 0xfa, 0xca, 0xc3, 0x41,
 0x01, 0x27, 0x54, 0xd2, 0x46, 0xae, 0xe3, 0xff, 0x43, 0xae, 0x8d, 0x0e, 0x31, 0x13, 0x1f,
 0x95, 0x79, 0x82, 0x86, 0x7e, 0xfb, 0xd4, 0x17, 0x57, 0xb8, 0x25, 0xe7, 0x1d, 0x18, 0x8f,
 0x06, 0x1a, 0xe5, 0xef, 0x55, 0x28, 0x72, 0x42, 0xae, 0xdf, 0x9e, 0xbb, 0x14, 0xab, 0xd8,
 0x36, 0x4f, 0x46, 0x4b, 0x35, 0x92, 0x64, 0x6d, 0xbb, 0x60, 0xc2, 0x0b, 0x6f, 0x57, 0x5e,
 0x3a, 0x8f, 0x3d, 0xcb, 0xe5, 0xda, 0x6c, 0x5c, 0x85, 0x8f, 0x9d, 0xa6, 0x7e, 0x1e, 0x49,
 0x1a, 0xcc, 0xc9, 0xec, 0x04, 0xab, 0x35, 0xf2, 0x9b, 0xe7, 0xb3, 0x52, 0xb1, 0x1c, 0xc1,
 0xfe, 0x5c, 0x0b, 0xf5, 0x72, 0x0b, 0xec, 0x8e, 0xcd, 0x67, 0x98, 0xbf, 0xa5, 0x28, 0xca,
 0x48, 0x9b, 0x60, 0x1c, 0xee, 0x00, 0xde, 0x01, 0xbc, 0xa4, 0x02, 0xd2, 0x19, 0xb6, 0x05,
 0xd6, 0x52, 0x78, 0xdb, 0x20, 0xbd, 0x3f, 0x95, 0x97, 0xb1, 0x59, 0x3d, 0x9d, 0x83, 0xc2,
 0xfd, 0x23, 0xa5, 0xfd, 0xd8, 0x20, 0x92, 0x27, 0xee, 0x3c, 0xe9, 0x5a, 0x61, 0x11, 0xe1,
 0x31, 0xb4, 0x4c, 0xb4, 0xa9, 0xe2, 0x6d, 0x2e, 0xae, 0x5f, 0x37, 0x8e, 0x07, 0xfd, 0xed,
 0x85, 0x07, 0x79, 0x43, 0x7e, 0xfa, 0xd6, 0x03, 0xe8, 0x5b, 0x65, 0x2a, 0xe4, 0xf9, 0x36,
 0x9e, 0xff, 0x53, 0x6d, 0x51, 0x50, 0x61, 0x72, 0x18, 0xcd, 0x3d, 0xe4, 0xb6, 0x27, 0x10,
 0x4a, 0xdd, 0xfd, 0xa3, 0x36, 0x67, 0xac, 0xc7, 0x85, 0x1c, 0xd3, 0xe7, 0x17, 0x74, 0xe2,
 0x8e, 0xee, 0xa6, 0xf4, 0xb6, 0x86, 0x24, 0xcf, 0x40, 0xdf, 0x35, 0x08, 0x0f, 0x55, 0xdd,
 0x51, 0xe9, 0x7c, 0x39, 0x78, 0x5c, 0xdf, 0x20, 0x2a, 0xeb, 0xed, 0x35, 0x10, 0x26, 0x98,
 0x77, 0x69, 0x4e, 0x51, 0x7a, 0xb2, 0x9f, 0x1d, 0xbc, 0x06, 0xcd, 0xcf, 0x4d, 0xb9, 0xfa,
 0xb7, 0xaf, 0x6a, 0x07, 0x0c, 0x96, 0x42, 0x57, 0x6c, 0x3d, 0xa5, 0xfe, 0x91, 0xe3, 0x76,
 0x9f, 0xdd, 0x3c, 0x83, 0x25, 0xab, 0x24, 0x89, 0x47, 0x7c, 0xba, 0xd7, 0x7d, 0x72, 0x90,
 0x80, 0xb0, 0x03, 0xa4, 0xef, 0x04, 0x0a, 0x9e, 0x5a, 0x14, 0x1c, 0xab, 0x75, 0x47, 0x05,
 0xcb, 0xa2, 0x97, 0x0d, 0x6a, 0xa5, 0x7c, 0xa4, 0x40, 0x90, 0xe2, 0x6c, 0xfa, 0xd4, 0xbd,
 0x69, 0xd0, 0x06, 0x53, 0x67, 0xfa, 0xe7, 0xcc, 0x06, 0x42, 0x45, 0xbe, 0xbd, 0x6f, 0x3e,
 0x48, 0x70, 0xf5, 0x2b, 0x83, 0xc7, 0xba, 0x54, 0x9c, 0xab, 0x54, 0x1f, 0x81, 0xe2, 0x11,
 0x82, 0x51, 0x02, 0x51, 0x63, 0x13, 0x86, 0x38, 0xb1, 0x56, 0x0c, 0x4d, 0x68, 0xf3, 0x53,
 0x1d, 0xfb, 0xe3, 0x15, 0xe8, 0x42, 0xf3, 0x27, 0x9b, 0xa5, 0x4a, 0x86, 0x90, 0xe1, 0x17,
 0xdc, 0x99, 0xe2, 0x5c, 0x79, 0xc6, 0x5f, 0x7e, 0x33, 0xc0, 0x41, 0xb6, 0x9e, 0xfc, 0x10,
 0x8a, 0xf4, 0xfd, 0xe9, 0xd2, 0x52, 0x53, 0x54, 0x89, 0x04, 0xbd, 0x69, 0xd2, 0x54, 0x32,
 0x96, 0xec, 0x44, 0x08, 0xc3, 0x86, 0x10, 0xd1, 0x3e, 0x32, 0xb5, 0x4f, 0x52, 0x49, 0x58,
 0x49, 0xf2, 0x8d, 0x83, 0x89, 0xf3, 0x24, 0x83, 0x65, 0x72, 0x53, 0xaf, 0x2d, 0x90, 0x61,
 0x99, 0x92, 0x31, 0x75, 0x93, 0x46, 0xe5, 0xd3, 0x48, 0x11, 0x01, 0xc9, 0x10, 0x98, 0x66,
 0x86, 0x79, 0x19, 0x73, 0x7d, 0xda, 0xa1, 0xb0, 0x41, 0x9e, 0xcd, 0xdc, 0xc2, 0x66, 0x86,
 0xdd, 0xb8, 0xc9, 0xe3, 0xe7, 0x80, 0x96, 0xf5, 0x38, 0x72, 0xa5, 0xda, 0xe5, 0x38, 0x13,
 0x57, 0x2b, 0xbd, 0x32, 0xc7, 0x44, 0xe0, 0xe3, 0x2d, 0xed, 0x54, 0x40, 0x74, 0x9d, 0x02,
 0x55, 0x38, 0x45, 0x89, 0x6f, 0x14, 0x40, 0xf6, 0x7b, 0x41, 0x1e, 0x04, 0xdb, 0xa4, 0xd9,
 0xf3, 0x90, 0xae, 0x10, 0xc9, 0xc3, 0x72, 0x5d, 0x0d, 0x01, 0x51, 0xf1, 0xd1, 0x96, 0x43,
 0xc6, 0x1a, 0x98, 0x3d, 0xbd, 0xcd, 0xdf, 0x44, 0x82, 0xd0, 0x17, 0xa2, 0x9e, 0x6c, 0x0c,
 0x2f, 0x46, 0xeb, 0xd8, 0x4a, 0xce, 0xfe, 0xbe, 0xcd, 0xf9, 0xd4, 0xe3, 0x36, 0xf3, 0xd8,
 0x1c, 0x00, 0x24, 0xf2, 0xac, 0x03, 0x11, 0xb6, 0x18, 0x8f, 0x9c, 0xba, 0xf6, 0x4f, 0xfd,
 0x78, 0x72, 0x83, 0xbf, 0x3e, 0x5c, 0x24, 0xf9, 0x4d, 0xea, 0x85, 0x74, 0x25, 0xe3, 0x46,
 0x7b, 0x5e, 0xfe, 0xbd, 0xbf, 0x5e, 0x68, 0x51, 0xe5, 0x53, 0x85, 0x9a, 0x03, 0x4c, 0x09,
 0xf0, 0x6b, 0xc2, 0x97, 0xfc, 0xcc, 0x96, 0x2c, 0xaf, 0xf7, 0x8c, 0x26, 0xd8, 0xc7, 0xfc,
 0xda, 0x1f, 0x0e, 0x0f, 0x39, 0x1a, 0xb2, 0x0a, 0x98, 0x1a, 0x15, 0xdc, 0x3e, 0x4b, 0x9e,
 0x9d, 0x40, 0x3e, 0x71, 0x5b, 0x66, 0xc3, 0x88, 0xf8, 0x57, 0x14, 0x06, 0xc7, 0x2c, 0xcd,
 0x31, 0x8e, 0x1e, 0x88, 0x79, 0x9f, 0x33, 0x94, 0xea, 0x21, 0x08, 0x0d, 0x35, 0x7d, 0xa2,
 0x57, 0x46, 0xe3, 0x0f, 0xb9, 0xa9, 0xbc, 0xd2, 0x06, 0xb8, 0xfa, 0xf9, 0xb0, 0xf3, 0xc3,
 0x8a, 0x38, 0x82, 0x06, 0x7f, 0xd9, 0xce, 0x92, 0xa2, 0x9e, 0xfc, 0x2a, 0xc8, 0x51, 0xb7,
 0x7d, 0xdb, 0x47, 0x37, 0xaf, 0x8b, 0xb8, 0x6d, 0x70, 0x21, 0x02, 0x63, 0x5e, 0xbd, 0x38,
 0xf1, 0xe1, 0x9f, 0xe3, 0xe2, 0x79, 0x3b, 0x42, 0x05, 0xe2, 0xc6, 0x13, 0x7a, 0xe2, 0x91,
 0x73, 0xe2, 0x79, 0x8b, 0x2f, 0x7f, 0x88, 0x02, 0x06, 0x4e, 0xb8, 0x66, 0xb8, 0xc0, 0xc4,
 0x3b, 0x1c, 0x3e, 0x96, 0x0f, 0xbb, 0x7f, 0xe8, 0x85, 0x5b, 0xb2, 0xf6, 0xa7, 0x48, 0x5b,
 0x95, 0x83, 0x57, 0xe0, 0xe8, 0x22, 0x67, 0x07, 0x3c, 0x27, 0x65, 0x66, 0xe8, 0x84, 0xab,
 0xea, 0xf5, 0xb5, 0x00, 0xec, 0xa4, 0xa3, 0xe8, 0x25, 0x77, 0xd1, 0x81, 0x9c, 0x87, 0xd3,
 0x1a, 0x31, 0x58, 0xa4, 0x0a, 0xa8, 0x71, 0x9c, 0x52, 0x88, 0x4d, 0x50, 0xff, 0xdb, 0x41,
 0x81, 0x04, 0xc3, 0x84, 0xaa, 0x72, 0x79, 0x2f, 0x9b, 0x2d, 0x2f, 0x1c, 0xa5, 0x6b, 0x68,
 0x9b, 0x3b, 0x6b, 0x1c, 0x67, 0xeb, 0x42, 0xe0, 0xe3, 0x2c, 0x7b, 0x52, 0x8e, 0xc1, 0x7e,
 0xd8, 0xab, 0x02, 0x46, 0xd1, 0x83, 0x38, 0x1a, 0x18, 0xad, 0x90, 0x7f, 0xdb, 0x22, 0xc1,
 0x80, 0xea, 0xf7, 0x67, 0x1d, 0xa7, 0xb2, 0x40, 0xdb, 0xc3, 0xc4, 0xd5, 0x8b, 0x49, 0xf8,
 0xdc, 0x25, 0x80, 0x7e, 0xfa, 0x64, 0xac, 0x36, 0x4d, 0x74, 0x6f, 0x3e, 0x57, 0x23, 0xb4,
 0x49, 0x7c, 0x6f, 0x3e, 0x7c, 0xa7, 0x34, 0xb7, 0x6b, 0x66, 0xf8, 0xd1, 0x69, 0x6d, 0x83,
 0xc5, 0x8a, 0xe2, 0x42, 0x3f, 0x8b, 0x5e, 0x5a, 0xd5, 0xcd, 0x47, 0x64, 0xeb, 0x4e, 0xef,
 0x62, 0x19, 0x37, 0xd3, 0x8e, 0x68, 0x51, 0x4a, 0x96, 0xbb, 0x5b, 0xa0, 0x34, 0xd8, 0xb4,
 0xf4, 0xb0, 0x99, 0x53, 0xb1, 0x70, 0xc3, 0x1d, 0x6e, 0x2b, 0x03, 0x76, 0xc9, 0x00, 0x0b,
 0x10, 0xca, 0xb7, 0xf3, 0xbe, 0x4b, 0xe2, 0xb4, 0x6c, 0x4a, 0x9f, 0x59, 0x39, 0x30, 0xc7,
 0xc3, 0x88, 0x38, 0x63, 0xc4, 0xcf, 0xd1, 0xfd, 0xf0, 0x6d, 0xfe, 0x68, 0x92, 0x98, 0x11,
 0x7d, 0x90, 0x0c, 0x64, 0x23, 0xe8, 0x25, 0x77, 0xd1, 0x81, 0x75, 0xa4, 0xf4, 0x35, 0x6f,
 0xe4, 0x9c, 0x7a, 0x48, 0xd0, 0xde, 0x37, 0x42, 0xf8, 0x5b, 0xe9, 0x16, 0xba, 0x16, 0x4b,
 0x7c, 0xdb, 0x2c, 0x0e, 0xa0, 0xbc, 0x5c, 0x82, 0x71, 0xa0, 0x9d, 0x3a, 0x0a, 0x7e, 0xd0,
 0xdc, 0x93, 0x79, 0xf6, 0x78, 0xb5, 0x89, 0xd9, 0x70, 0x5d, 0xe0, 0x9d, 0xe7, 0xea, 0xee,
 0x88, 0x52, 0x18, 0x11, 0x7d, 0xf1, 0xce, 0xc1, 0x69, 0x8d, 0x3f, 0xea, 0x51, 0xc1, 0x49,
 0xb1, 0xc4, 0xa6, 0xf0, 0xdc, 0xbd, 0x61, 0xb7, 0x2c, 0x85, 0x4a, 0xcb, 0xdd, 0x96, 0x50,
 0x8b, 0x68, 0xf7, 0x7e, 0xb9, 0x1c, 0x19, 0xfb, 0x5c, 0x79, 0xf8, 0x7d, 0xe9, 0xf3, 0x0e,
 0xc7, 0x6e, 0x1c, 0x67, 0xb4, 0xb7, 0x4a, 0xc5, 0xbe, 0x3c, 0x8c, 0x94, 0x36, 0x02, 0x8f,
 0x81, 0x57, 0xe7, 0x4b, 0xd6, 0x2b, 0x10, 0xbe, 0x3c, 0x97, 0xbb, 0x41, 0x88, 0x6f, 0x13,
 0xe6, 0x27, 0x13, 0x4b, 0xd5, 0x44, 0xa9, 0xd9, 0x2d, 0xcd, 0x51, 0x91, 0x03, 0x14, 0xd5,
 0x6b, 0x3d, 0xb5, 0x98, 0xf0, 0x09, 0xaa, 0x42, 0x8e, 0x82, 0xe8, 0xf1, 0x36, 0xec, 0xb5,
 0x48, 0x5f, 0x9f, 0xca, 0x16, 0x5a, 0x3f, 0x4d, 0xbb, 0xa6, 0xd4, 0x08, 0x1a, 0xfb, 0xe5,
 0xeb, 0x40, 0x04, 0xe8, 0x40, 0x84, 0xc4, 0x8e, 0x74, 0xae, 0x47, 0x4d, 0xfc, 0xb5, 0x91,
 0xe2, 0x33, 0xf2, 0xf7, 0xae, 0xcd, 0x10, 0x47, 0xb1, 0x4b, 0xe2, 0xa2, 0x8d, 0x7c, 0x2c,
 0x32, 0x6f, 0xdd, 0xc4, 0xc2, 0xf1, 0x09, 0x56, 0x2d, 0x1e, 0x9d, 0x7d, 0x67, 0x32, 0x61,
 0x7f, 0x12, 0xe4, 0x3f, 0xfa, 0xe2, 0x7d, 0x7b, 0xd4, 0x67, 0x4e, 0x7f, 0x14, 0x6a, 0x6c,
 0x8e, 0x74, 0x9b, 0xbc, 0x3d, 0xc4, 0x70, 0xc4, 0x37, 0xd5, 0x60, 0xe0, 0x87, 0xbd, 0xb8,
 0x1a, 0x75, 0x9d, 0x7a, 0x80, 0xc1, 0xa9, 0x1f, 0xad, 0x7b, 0x27, 0xe5, 0x4c, 0xb0, 0x06,
 0xd0, 0xfb, 0x1c, 0x5a, 0xeb, 0xbd, 0x2e, 0x96, 0x49, 0x13, 0x43, 0x06, 0x8b, 0xcb, 0x6a,
 0xf0, 0x5d, 0x56, 0x6c, 0x4e, 0x18, 0x26, 0xd4, 0xc8, 0x53, 0x48, 0x70, 0xe2, 0x0f, 0x9c,
 0xa1, 0x35, 0x01, 0x96, 0xc7, 0x0b, 0xc9, 0x4b, 0xd3, 0x19, 0xe8, 0x5a, 0x75, 0xad, 0xc8,
 0x52, 0xce, 0x3c, 0x2e, 0xfd, 0x5f, 0x04, 0xcf, 0x9e, 0xd6, 0x33, 0xdb, 0x08, 0x34, 0xba,
 0x34, 0x9b, 0xf4, 0x25, 0xaa, 0x7f, 0x52, 0x37, 0x4f, 0x8b, 0x94, 0x95, 0x94, 0x2d, 0x88,
 0x10, 0xd1, 0x05, 0x07, 0xcf, 0xd4, 0x04, 0xdb, 0x95, 0xbe, 0x36, 0xd0, 0x1c, 0x1c, 0xa4,
 0x85, 0x0a, 0x02, 0x80, 0xde, 0xb1, 0x1b, 0x56, 0xaf, 0x51, 0x22, 0xa7, 0xa4, 0x4a, 0x2c,
 0x2f, 0x17, 0x7c, 0x13, 0x4c, 0x36, 0xad, 0x90, 0x8c, 0xea, 0xd4, 0x58, 0x3a, 0xca, 0xea,
 0x1d, 0x5c, 0x6c, 0x93, 0xad, 0x59, 0xed, 0xb1, 0x17, 0xa4, 0x22, 0x95, 0x67, 0xbe, 0xbb,
 0x25, 0xaf, 0x65, 0xc8, 0xe5, 0x90, 0xe1, 0x17, 0xdc, 0x7a, 0x47, 0xe9, 0x8f, 0xc3, 0xc3,
 0x5a, 0xdc, 0x20, 0x20, 0x4a, 0x09, 0xfc, 0x39, 0x51, 0x29, 0x31, 0xfb, 0xa0, 0x0a, 0x61,
 0x08, 0x9b, 0xb9, 0xb3, 0x6c, 0x95, 0xc5, 0x94, 0x00, 0x66, 0xf1, 0xb9, 0x79, 0x90, 0x7f,
 0x95, 0x5f, 0x55, 0xe1, 0x13, 0x6b, 0x87, 0xa8, 0x62, 0x21, 0x98, 0xf2, 0x57, 0x19, 0x92,
 0x10, 0xb3, 0x24, 0x81, 0x12, 0x21, 0xff, 0xd6, 0xf9, 0x73, 0x71, 0xc2, 0x62, 0x09, 0x31,
 0xeb, 0xe0, 0x7a, 0x35, 0x60, 0x8d, 0xc9, 0xb1, 0xe5, 0xa7, 0x8b, 0xca, 0xbc, 0x2d, 0xfa,
 0x63, 0xc7, 0x68, 0x1d, 0x19, 0xb5, 0x61, 0x78, 0xd0, 0x8b, 0xdb, 0xc0, 0x39, 0x22, 0x55,
 0x6a, 0x28, 0xc2, 0x52, 0x1e, 0x6b, 0xf7, 0x1d, 0xb6, 0xfa, 0x4f, 0xcf, 0x27, 0x7c, 0xaf,
 0x7f, 0x0c, 0x96, 0xba, 0xce, 0x2a, 0x54, 0x59, 0x5b, 0x20, 0xfb, 0x42, 0x87, 0x44, 0xd9,
 0x2e, 0x10, 0x43, 0xab, 0x58, 0x92, 0xb6, 0x8d, 0x78, 0xf3, 0xa3, 0xde, 0x0e, 0x07, 0x75,
 0x68, 0x52, 0x26, 0x3f, 0x3d, 0xec, 0xd0, 0x36, 0xdf, 0x1a, 0x16, 0x88, 0x5f, 0xbd, 0x1c,
 0x4d, 0x9e, 0x27, 0x4c, 0x12, 0x07, 0x0d, 0x2b, 0xb1, 0xdc, 0x00, 0x45, 0x54, 0x3d, 0xfc,
 0xcf, 0xfa, 0xc9, 0x06, 0x4b, 0x08, 0x64, 0xac, 0x8d, 0x17, 0x4d, 0xdf, 0x83, 0x24, 0xfb,
 0xf6, 0x9e, 0x5f, 0xf9, 0x0f, 0x8d, 0x07, 0x18, 0xb1, 0xb2, 0x37, 0xd2, 0x66, 0x9c, 0x82,
 0x09, 0x75, 0x52, 0x5b, 0x19, 0x74, 0x59, 0xa3, 0x64, 0x6d, 0x17, 0x93, 0x3a, 0x13, 0xd2,
 0xda, 0x97, 0xa4, 0x2b, 0x55, 0x7a, 0x32, 0xf9, 0x2f, 0x9b, 0xaa, 0x87, 0x6d, 0xce, 0x1d,
 0x07, 0x9a, 0x52, 0xfa, 0x40, 0xc5, 0x20, 0x43, 0xcc, 0xa8, 0xc3, 0x84, 0x2c, 0x44, 0x8b,
 0x44, 0x88, 0x62, 0xe7, 0x68, 0x4c, 0x2a, 0x69, 0xa7, 0xcf, 0x6f, 0x4d, 0x06, 0xed, 0x8a,
 0x8f, 0x9a, 0x62, 0xca, 0xed, 0xa5, 0x57, 0x18, 0x86, 0x9d, 0xe8, 0x7c, 0x14, 0xeb, 0x71,
 0xeb, 0xc0, 0xf4, 0x3a, 0x98, 0x11, 0x01, 0xc0, 0xa3, 0x53, 0xaf, 0x20, 0x7e, 0xde, 0x22,
 0x5c, 0x1f, 0x60, 0x8b, 0xb7, 0x5f, 0x74, 0x76, 0xd0, 0x87, 0xfa, 0x11, 0xd3, 0xa5, 0xba,
 0x5c, 0x82, 0xe1, 0x52, 0x54, 0x6b, 0x69, 0xeb, 0x31, 0x43, 0x01, 0x1a, 0x55, 0x7f, 0xdc,
 0x2f, 0xd8, 0x01, 0x26, 0x6f, 0x1c, 0x2d, 0x72, 0x7b, 0xc8, 0x93, 0x99, 0x2a, 0x08, 0xa8,
 0x6f, 0xb4, 0x28, 0x40, 0x8a, 0x8a, 0x4e, 0xd5, 0x3b, 0x39, 0x45, 0xa8, 0xe4, 0xe7, 0x73,
 0x8f, 0x00, 0x64, 0xd3, 0xc7, 0x87, 0xde, 0x43, 0x82, 0x2c, 0xe8, 0x57, 0x17, 0x29, 0xce,
 0xb8, 0x47, 0xd6, 0x08, 0x79, 0xd7, 0xc4, 0xe9, 0x23, 0x43, 0x9d, 0xb8, 0xcb, 0x78, 0x08,
 0x32, 0xf1, 0xec, 0x84, 0x80, 0x1e, 0xb9, 0x29, 0x12, 0x0c, 0x29, 0xcc, 0x9c, 0xd0, 0x10,
 0xa7, 0xd6, 0x8a, 0xe9, 0xf6, 0xfa, 0x8d, 0x7e, 0x95, 0x2e, 0x57, 0xcf, 0x8e, 0x38, 0x6b,
 0x35, 0xf0, 0xbc, 0xa6, 0x4e, 0x13, 0x7b, 0x41, 0x19, 0x15, 0x5d, 0x99, 0xbd, 0x22, 0x40,
 0x6a, 0x07, 0x2d, 0xd5, 0xd6, 0xff, 0x1d, 0x7b, 0xa6, 0xc4, 0xaa, 0x77, 0x44, 0x78, 0x2f,
 0x55, 0x9f, 0x7d, 0x53, 0xf0, 0x2b, 0x2b, 0xba, 0x36, 0xc2, 0xf8, 0x6d, 0xf0, 0x2b, 0xbb,
 0x6b, 0x97, 0x05, 0xb4, 0x4a, 0xc2, 0x86, 0x62, 0xb8, 0x76, 0xe7, 0xbb, 0xdf, 0x9c, 0x5a,
 0x70, 0x19, 0x95, 0x59, 0x15, 0xcf, 0xa6, 0xa9, 0x7a, 0x24, 0x4c, 0xc6, 0x65, 0xb9, 0xda,
 0x17, 0x6f, 0x2b, 0x55, 0x07, 0x32, 0x72, 0xd1, 0xee, 0x9c, 0x3a, 0x51, 0x98, 0x36, 0x37,
 0xf8, 0x61, 0xfc, 0x91, 0xbc, 0xcb, 0x34, 0xd8, 0x43, 0xa0, 0x7a, 0xea, 0xc4, 0x8a, 0x64,
 0x4d, 0xe0, 0x03, 0x93, 0xfb, 0xb4, 0xd8, 0x11, 0x21, 0x11, 0x66, 0x97, 0xb9, 0xba, 0x81,
 0x29, 0xc2, 0x8f, 0x8c, 0x14, 0x18, 0x22, 0x94, 0xc4, 0xb0, 0xf1, 0x10, 0xc4, 0x8b, 0x5d,
 0x8d, 0x7f, 0x14, 0xaf, 0x46, 0x19, 0x36, 0xa4, 0x36, 0x22, 0x18, 0x18, 0xe3, 0xab, 0x2c,
 0x91, 0x03, 0xf7, 0xc5, 0xf5, 0xf5, 0x59, 0xc2, 0xd2, 0xf7, 0xc7, 0x64, 0x54, 0x76, 0xfb,
 0x71, 0x70, 0xe8, 0xb2, 0x44, 0xa1, 0x2d, 0x59, 0x17, 0x02, 0xd6, 0x6f, 0x7a, 0xeb, 0xe0,
 0x53, 0x81, 0xf6, 0x5e, 0x7f, 0x37, 0xd4, 0x52, 0x13, 0x04, 0x44, 0xd5, 0xc8, 0xd3, 0xdd,
 0x6f, 0xd5, 0xfb, 0x71, 0x20, 0xe3, 0x0d, 0x0c, 0x47, 0x25, 0xa1, 0x41, 0xd2, 0xc7, 0xe5,
 0xc9, 0xd9, 0x27, 0xa5, 0x38, 0xe4, 0x30, 0xbb, 0x86, 0x07, 0x84, 0xef, 0x24, 0x9f, 0xf9,
 0x52, 0x74, 0xd2, 0x50, 0x73, 0xc4, 0x27, 0x73, 0x3b, 0x8d, 0x9c, 0xa6, 0xf6, 0x4b, 0x25,
 0x91, 0xc5, 0x9e, 0x1e, 0xb2, 0x78, 0x0c, 0x23, 0x80, 0xdd, 0xa3, 0x21, 0xf5, 0xa9, 0x9e,
 0x00, 0x16, 0x19, 0xbc, 0xd9, 0x55, 0x09, 0x90, 0xa2, 0xc6, 0xef, 0x3d, 0xf8, 0x72, 0x66,
 0x2f, 0xdc, 0x3a, 0xf6, 0x4f, 0xfd, 0x59, 0x30, 0xe2, 0x27, 0xcc, 0xfb, 0x55, 0x09, 0x71,
 0x41, 0xe1, 0x21, 0xa1, 0xa1, 0xc0, 0xe3, 0x25, 0xa9, 0xd0, 0x22, 0xc6, 0xef, 0x5c, 0x1b,
 0xb4, 0xea, 0x56, 0x2e, 0xbf, 0xfc, 0x5b, 0x34, 0xcb, 0x14, 0x8b, 0x94, 0xaa, 0xb7, 0xec,
 0x5a, 0x36, 0xcf, 0x1c, 0xba, 0xf6, 0x4d, 0xdb, 0x35, 0xf3 };
@@ -0,0 +1,255 @@
 /*
 Copyright 2020 Alexander Tulloh
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation, either version 2 of the License, or
 (at your option) any later version.
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 #pragma once
 #include "config_common.h"
 /* USB Device descriptor parameter */
 #define VENDOR_ID 0xFEED
 #define PRODUCT_ID 0xCA49
 #define DEVICE_VER 0x0001
 #define MANUFACTURER Alexander Tulloh
 #define PRODUCT Oddball
 #define DESCRIPTION A ballin keyboard
 /* key matrix size */
 #define MATRIX_ROWS 8
 #define MATRIX_COLS 6
 /*
 * Keyboard Matrix Assignments
 *
 * Change this to how you wired your keyboard
 * COLS: AVR pins used for columns, left to right
 * ROWS: AVR pins used for rows, top to bottom
 * DIODE_DIRECTION: COL2ROW = COL = Anode (+), ROW = Cathode (-, marked on diode)
 *                  ROW2COL = ROW = Anode (+), COL = Cathode (-, marked on diode)
 *
 */
 #define MATRIX_ROW_PINS { F6, B5, B6, F7 }
 #define MATRIX_COL_PINS { D6, D7, B4, D3, C6, C7 }
 #define UNUSED_PINS { B7, D4, D5, E6, F0, F1, F4, F5 }
 /* COL2ROW, ROW2COL*/
 #define DIODE_DIRECTION COL2ROW
 /*
 * Split Keyboard specific options, make sure you have 'SPLIT_KEYBOARD = yes' in your rules.mk, and define SOFT_SERIAL_PIN.
 */
 // #define SOFT_SERIAL_PIN D0  // or D1, D2, D3, E6
 #define USE_I2C
 #define SPLIT_USB_DETECT
 #define MASTER_RIGHT
 // #define BACKLIGHT_PIN B7
 // #define BACKLIGHT_BREATHING
 // #define BACKLIGHT_LEVELS 3
 // #define RGB_DI_PIN E2
 // #ifdef RGB_DI_PIN
 //   #define RGBLED_NUM 16
 //   #define RGBLIGHT_HUE_STEP 8
 //   #define RGBLIGHT_SAT_STEP 8
 //   #define RGBLIGHT_VAL_STEP 8
 //   #define RGBLIGHT_LIMIT_VAL 255 /* The maximum brightness level */
 //   #define RGBLIGHT_SLEEP  /* If defined, the RGB lighting will be switched off when the host goes to sleep */
 // /*== all animations enable ==*/
 //   #define RGBLIGHT_ANIMATIONS
 // /*== or choose animations ==*/
 //   #define RGBLIGHT_EFFECT_BREATHING
 //   #define RGBLIGHT_EFFECT_RAINBOW_MOOD
 //   #define RGBLIGHT_EFFECT_RAINBOW_SWIRL
 //   #define RGBLIGHT_EFFECT_SNAKE
 //   #define RGBLIGHT_EFFECT_KNIGHT
 //   #define RGBLIGHT_EFFECT_CHRISTMAS
 //   #define RGBLIGHT_EFFECT_STATIC_GRADIENT
 //   #define RGBLIGHT_EFFECT_RGB_TEST
 //   #define RGBLIGHT_EFFECT_ALTERNATING
 // /*== customize breathing effect ==*/
 //   /*==== (DEFAULT) use fixed table instead of exp() and sin() ====*/
 //   #define RGBLIGHT_BREATHE_TABLE_SIZE 256      // 256(default) or 128 or 64
 //   /*==== use exp() and sin() ====*/
 //   #define RGBLIGHT_EFFECT_BREATHE_CENTER 1.85  // 1 to 2.7
 //   #define RGBLIGHT_EFFECT_BREATHE_MAX    255   // 0 to 255
 // #endif
 /* Debounce reduces chatter (unintended double-presses) - set 0 if debouncing is not needed */
 #define DEBOUNCE 5
 /* define if matrix has ghost (lacks anti-ghosting diodes) */
 //#define MATRIX_HAS_GHOST
 /* Mechanical locking support. Use KC_LCAP, KC_LNUM or KC_LSCR instead in keymap */
 #define LOCKING_SUPPORT_ENABLE
 /* Locking resynchronize hack */
 #define LOCKING_RESYNC_ENABLE
 /* If defined, GRAVE_ESC will always act as ESC when CTRL is held.
 * This is userful for the Windows task manager shortcut (ctrl+shift+esc).
 */
 // #define GRAVE_ESC_CTRL_OVERRIDE
 /*
 * Force NKRO
 *
 * Force NKRO (nKey Rollover) to be enabled by default, regardless of the saved
 * state in the bootmagic EEPROM settings. (Note that NKRO must be enabled in the
 * makefile for this to work.)
 *
 * If forced on, NKRO can be disabled via magic key (default = LShift+RShift+N)
 * until the next keyboard reset.
 *
 * NKRO may prevent your keystrokes from being detected in the BIOS, but it is
 * fully operational during normal computer usage.
 *
 * For a less heavy-handed approach, enable NKRO via magic key (LShift+RShift+N)
 * or via bootmagic (hold SPACE+N while plugging in the keyboard). Once set by
 * bootmagic, NKRO mode will always be enabled until it is toggled again during a
 * power-up.
 *
 */
 //#define FORCE_NKRO
 /*
 * Magic Key Options
 *
 * Magic keys are hotkey commands that allow control over firmware functions of
 * the keyboard. They are best used in combination with the HID Listen program,
 * found here: https://www.pjrc.com/teensy/hid_listen.html
 *
 * The options below allow the magic key functionality to be changed. This is
 * useful if your keyboard/keypad is missing keys and you want magic key support.
 *
 */
 /* key combination for magic key command */
 /* defined by default; to change, uncomment and set to the combination you want */
 // #define IS_COMMAND() (get_mods() == MOD_MASK_SHIFT)
 /* control how magic key switches layers */
 //#define MAGIC_KEY_SWITCH_LAYER_WITH_FKEYS  true
 //#define MAGIC_KEY_SWITCH_LAYER_WITH_NKEYS  true
 //#define MAGIC_KEY_SWITCH_LAYER_WITH_CUSTOM false
 /* override magic key keymap */
 //#define MAGIC_KEY_SWITCH_LAYER_WITH_FKEYS
 //#define MAGIC_KEY_SWITCH_LAYER_WITH_NKEYS
 //#define MAGIC_KEY_SWITCH_LAYER_WITH_CUSTOM
 //#define MAGIC_KEY_HELP           H
 //#define MAGIC_KEY_HELP_ALT       SLASH
 //#define MAGIC_KEY_DEBUG          D
 //#define MAGIC_KEY_DEBUG_MATRIX   X
 //#define MAGIC_KEY_DEBUG_KBD      K
 //#define MAGIC_KEY_DEBUG_MOUSE    M
 //#define MAGIC_KEY_VERSION        V
 //#define MAGIC_KEY_STATUS         S
 //#define MAGIC_KEY_CONSOLE        C
 //#define MAGIC_KEY_LAYER0         0
 //#define MAGIC_KEY_LAYER0_ALT     GRAVE
 //#define MAGIC_KEY_LAYER1         1
 //#define MAGIC_KEY_LAYER2         2
 //#define MAGIC_KEY_LAYER3         3
 //#define MAGIC_KEY_LAYER4         4
 //#define MAGIC_KEY_LAYER5         5
 //#define MAGIC_KEY_LAYER6         6
 //#define MAGIC_KEY_LAYER7         7
 //#define MAGIC_KEY_LAYER8         8
 //#define MAGIC_KEY_LAYER9         9
 //#define MAGIC_KEY_BOOTLOADER     B
 //#define MAGIC_KEY_BOOTLOADER_ALT ESC
 //#define MAGIC_KEY_LOCK           CAPS
 //#define MAGIC_KEY_EEPROM         E
 //#define MAGIC_KEY_EEPROM_CLEAR   BSPACE
 //#define MAGIC_KEY_NKRO           N
 //#define MAGIC_KEY_SLEEP_LED      Z
 /*
 * Feature disable options
 *  These options are also useful to firmware size reduction.
 */
 /* disable debug print */
 //#define NO_DEBUG
 /* disable print */
 //#define NO_PRINT
 /* disable action features */
 //#define NO_ACTION_LAYER
 //#define NO_ACTION_TAPPING
 //#define NO_ACTION_ONESHOT
 /* disable these deprecated features by default */
 #ifndef LINK_TIME_OPTIMIZATION_ENABLE
  #define NO_ACTION_MACRO
  #define NO_ACTION_FUNCTION
 #endif
 /*
 * MIDI options
 */
 /* Prevent use of disabled MIDI features in the keymap */
 //#define MIDI_ENABLE_STRICT 1
 /* enable basic MIDI features:
   - MIDI notes can be sent when in Music mode is on
 */
 //#define MIDI_BASIC
 /* enable advanced MIDI features:
   - MIDI notes can be added to the keymap
   - Octave shift and transpose
   - Virtual sustain, portamento, and modulation wheel
   - etc.
 */
 //#define MIDI_ADVANCED
 /* override number of MIDI tone keycodes (each octave adds 12 keycodes and allocates 12 bytes) */
 //#define MIDI_TONE_KEYCODE_OCTAVES 1
 /*
 * HD44780 LCD Display Configuration
 */
 /*
 #define LCD_LINES           2     //< number of visible lines of the display
 #define LCD_DISP_LENGTH    16     //< visibles characters per line of the display
 #define LCD_IO_MODE      1            //< 0: memory mapped mode, 1: IO port mode
 #if LCD_IO_MODE
 #define LCD_PORT         PORTB        //< port for the LCD lines
 #define LCD_DATA0_PORT   LCD_PORT     //< port for 4bit data bit 0
 #define LCD_DATA1_PORT   LCD_PORT     //< port for 4bit data bit 1
 #define LCD_DATA2_PORT   LCD_PORT     //< port for 4bit data bit 2
 #define LCD_DATA3_PORT   LCD_PORT     //< port for 4bit data bit 3
 #define LCD_DATA0_PIN    4            //< pin for 4bit data bit 0
 #define LCD_DATA1_PIN    5            //< pin for 4bit data bit 1
 #define LCD_DATA2_PIN    6            //< pin for 4bit data bit 2
 #define LCD_DATA3_PIN    7            //< pin for 4bit data bit 3
 #define LCD_RS_PORT      LCD_PORT     //< port for RS line
 #define LCD_RS_PIN       3            //< pin  for RS line
 #define LCD_RW_PORT      LCD_PORT     //< port for RW line
 #define LCD_RW_PIN       2            //< pin  for RW line
 #define LCD_E_PORT       LCD_PORT     //< port for Enable line
 #define LCD_E_PIN        1            //< pin  for Enable line
 #endif
 */
 /* Bootmagic Lite key configuration */
 // #define BOOTMAGIC_LITE_ROW 0
 // #define BOOTMAGIC_LITE_COLUMN 0
@@ -0,0 +1,21 @@
 {
    "keyboard_name": "Oddball",
    "url": "https://atulloh.github.io/oddball",
    "maintainer": "Alexander Tulloh",
    "width": 14,
    "height": 4.75,
    "layouts": {
        "LAYOUT": {
            "layout": [
                {"label":"sw1", "x":0, "y":0.37}, {"label":"sw2", "x":1, "y":0.37}, {"label":"sw3", "x":2, "y":0.12}, {"label":"sw4", "x":3, "y":0}, {"label":"sw5", "x":4, "y":0.12}, {"label":"sw6", "x":5, "y":0.25},
                {"label":"sw6", "x":8 , "y":0.25}, {"label":"sw5", "x":9 , "y":0.12}, {"label":"sw4", "x":10, "y":0}, {"label":"sw3", "x":11, "y":0.12}, {"label":"sw2", "x":12, "y":0.37}, {"label":"sw1", "x":13, "y":0.37},
                {"label":"sw7", "x":0, "y":1.37}, {"label":"sw8", "x":1, "y":1.37}, {"label":"sw9", "x":2, "y":1.12}, {"label":"sw10", "x":3, "y":1}, {"label":"sw11", "x":4, "y":1.12}, {"label":"sw12", "x":5, "y":1.25},
                {"label":"sw12", "x":8, "y":1.25}, {"label":"sw11", "x":9, "y":1.12}, {"label":"sw10", "x":10, "y":1}, {"label":"sw9", "x":11, "y":1.12}, {"label":"sw8", "x":12, "y":1.37}, {"label":"sw7", "x":13, "y":1.37},
                {"label":"sw13", "x":0, "y":2.37}, {"label":"sw14", "x":1, "y":2.37}, {"label":"sw15", "x":2, "y":2.12}, {"label":"sw16", "x":3, "y":2}, {"label":"sw17", "x":4, "y":2.12}, {"label":"sw18", "x":5, "y":2.25},
                {"label":"sw18", "x":8, "y":2.25}, {"label":"sw17", "x":9, "y":2.12}, {"label":"sw16", "x":10, "y":2}, {"label":"sw15", "x":11, "y":2.12}, {"label":"sw14", "x":12, "y":2.37}, {"label":"sw13", "x":13, "y":2.37},
                {"label":"sw19", "x":4.5, "y":3.5, "h":1.25}, {"label":"sw20", "x":5.5, "y":3.5, "h":1.25},
                {"label":"sw20", "x":7.5, "y":3.5, "h":1.25}, {"label":"sw19", "x":8.5, "y":3.5, "h":1.25}
            ]
        }
    }
 }
@@ -0,0 +1,46 @@
 /* Copyright 2020 Alexander Tulloh
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 #include QMK_KEYBOARD_H
 enum layer_names {
    _QWERTY,
    _LOWER,
    _RAISE
 };
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
  [_QWERTY] = LAYOUT(
     KC_BSPC,   KC_Q,    KC_W,    KC_E,    KC_R,       KC_T,          KC_Y,     KC_U,     KC_I,    KC_O,    KC_P,    KC_TAB,
     KC_LALT,   KC_A,    KC_S,    KC_D,    KC_F,       KC_G,          KC_H,     KC_J,     KC_K,    KC_L,    KC_SCLN, KC_SPC,
     KC_LSFT,   KC_Z,    KC_X,    KC_C,    KC_V,       KC_B,          KC_N,     KC_M,     KC_COMM, KC_DOT,  KC_SLSH, KC_RSFT,
                                           MO(_LOWER), KC_LCTL,       _______,  MO(_RAISE)
  ),
  [_LOWER] = LAYOUT(
     KC_DEL,    KC_EXLM, KC_AT,   KC_LCBR, KC_RCBR, KC_BTN3,       KC_DQUO,  KC_7,    KC_8,    KC_9,    KC_ASTR, KC_UNDS,
     _______,   KC_HASH, KC_DLR,  KC_LPRN, KC_RPRN, KC_BTN2,       KC_QUOT,  KC_4,    KC_5,    KC_6,    KC_PLUS, KC_ENT,
     _______,   KC_PERC, KC_CIRC, KC_LBRC, KC_RBRC, KC_BTN1,       KC_0,     KC_1,    KC_2,    KC_3,    KC_MINS, _______,
                                           _______, _______,       _______,  _______
  ),
  [_RAISE] = LAYOUT(
     _______,   KC_ESC,  KC_F7,   KC_F9,   KC_F9,   KC_F10,        KC_PIPE,  KC_PGUP, KC_UP,   KC_PGDN, KC_GRAVE, _______,
     _______,   KC_LGUI, KC_F4,   KC_F5,   KC_F6,   KC_F11,        KC_AMPR,  KC_LEFT, KC_DOWN, KC_RGHT, KC_TILD,  _______,
     _______,   KC_INS,  KC_F1,   KC_F2,   KC_F3,   KC_F12,        KC_EQUAL, KC_HOME, _______, KC_END,  KC_BSLS,  _______,
                                           _______, _______,       _______,  _______
  )
 };
@@ -0,0 +1,17 @@
 /* Copyright 2020 Alexander Tulloh
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 #include "oddball.h"
@@ -0,0 +1,44 @@
 /* Copyright 2020 Alexander Tulloh
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 #pragma once
 #include "quantum.h"
 /* This is a shortcut to help you visually see your layout.
 *
 * The first section contains all of the arguments representing the physical
 * layout of the board and position of the keys.
 *
 * The second converts the arguments into a two-dimensional array which
 * represents the switch matrix.
 */
 #define LAYOUT( \
    L00, L01, L02, L03, L04, L05,   R00, R01, R02, R03, R04, R05, \
    L10, L11, L12, L13, L14, L15,   R10, R11, R12, R13, R14, R15, \
    L20, L21, L22, L23, L24, L25,   R20, R21, R22, R23, R24, R25, \
                        LT1, LT2,   RT1, RT2 \
    ) \
    { \
        { L00, L01, L02, L03, L04, L05 }, \
        { L10, L11, L12, L13, L14, L15 }, \
        { L20, L21, L22, L23, L24, L25 }, \
        { KC_NO, KC_NO, KC_NO, KC_NO, LT1, LT2 }, \
        { R05, R04, R03, R02, R01, R00 }, \
        { R15, R14, R13, R12, R11, R10 }, \
        { R25, R24, R23, R22, R21, R20 }, \
        { KC_NO, KC_NO, KC_NO, KC_NO, RT2, RT1 } \
    }
@@ -0,0 +1,13 @@
 # Oddball
 A split keyboard with trackball support.
 * Keyboard Maintainer: [Alexander Tulloh](https://github.com/atulloh)
 * Hardware Supported: Oddball PCB and plates, and using an [ADNS9800 and breakout board for mouse](https://www.tindie.com/products/jkicklighter/adns-9800-laser-motion-sensor/)
 * Hardware Availability: [atulloh.github.io/oddball](https://atulloh.github.io/oddball)
 Make example for this keyboard (after setting up your build environment):
    make oddball:default
 See the [build environment setup](https://docs.qmk.fm/#/getting_started_build_tools) and the [make instructions](https://docs.qmk.fm/#/getting_started_make_guide) for more information. Brand new to QMK? Start with our [Complete Newbs Guide](https://docs.qmk.fm/#/newbs).
@@ -0,0 +1,39 @@
 # MCU name
 MCU = atmega32u4
 # Bootloader selection
 #   Teensy       halfkay
 #   Pro Micro    caterina
 #   Atmel DFU    atmel-dfu
 #   LUFA DFU     lufa-dfu
 #   QMK DFU      qmk-dfu
 #   ATmega32A    bootloadHID
 #   ATmega328P   USBasp
 BOOTLOADER = halfkay
 # Build Options
 #   change yes to no to disable
 #
 BOOTMAGIC_ENABLE = no       # Virtual DIP switch configuration
 MOUSEKEY_ENABLE = yes       # Mouse keys
 EXTRAKEY_ENABLE = yes       # Audio control and System control
 CONSOLE_ENABLE = no        # Console for debug
 COMMAND_ENABLE = yes        # Commands for debug and configuration
 # Do not enable SLEEP_LED_ENABLE. it uses the same timer as BACKLIGHT_ENABLE
 SLEEP_LED_ENABLE = no       # Breathing sleep LED during USB suspend
 # if this doesn't work, see here: https://github.com/tmk/tmk_keyboard/wiki/FAQ#nkro-doesnt-work
 NKRO_ENABLE = no            # USB Nkey Rollover
 BACKLIGHT_ENABLE = no       # Enable keyboard backlight functionality
 RGBLIGHT_ENABLE = no        # Enable keyboard RGB underglow
 MIDI_ENABLE = no            # MIDI support
 BLUETOOTH_ENABLE = no       # Enable Bluetooth with the Adafruit EZ-Key HID
 AUDIO_ENABLE = no           # Audio output on port C6
 FAUXCLICKY_ENABLE = no      # Use buzzer to emulate clicky switches
 HD44780_ENABLE = no         # Enable support for HD44780 based LCDs
 DEBOUNCE_TYPE = eager_pk
 SPLIT_KEYBOARD = yes
 # Add trackball support
 POINTING_DEVICE_ENABLE = yes
 SRC += adns.c
@@ -0,0 +1,6 @@
 #pragma once
 #define IGNORE_MOD_TAP_INTERRUPT
 #define TAPPING_TERM 200
 #undef ONESHOT_TIMEOUT
 #define ONESHOT_TIMEOUT 1500
@@ -0,0 +1,159 @@
 #include QMK_KEYBOARD_H
 #include "danielo515.h"
 // Shortcut to make keymap more readable
 # define SYM_L   OSL(_SYMB)
 # define KC_ALAS LALT_T(KC_PAST) // alt or keypad *
 # define KC_CTPL LCTL_T(KC_BSLS) // <C-\>
 # define KC_NAGR LT(_NAV, KC_GRV)
 # define KC_NAMI LT(_NAV, KC_MINS)
 # define AD_ESC LT(_ADJUST, KC_ESC)
 # define NAV_SPC LT(_NAV, KC_SPACE)
 # define KC_ADPU LT(_ADJUST, KC_PGUP)
 # define WIN_LEFT WIN_TO_LEFT
 # define WIN_RIGHT WIN_TO_RIGHT
 # define COPY_CUT TD(COPY_CUT)
 # define TD_PASTE TD(PASTE_DANCE)
 # define CTL OSM(MOD_LCTL)
 # define ALT OSM(MOD_LALT)
 # define GUI OSM(MOD_LGUI)
 # define ENT_SYM LT(_SYMB, KC_ENT)
 # define __S LT(_S,KC_S)
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
  [_QWERTY] = LAYOUT(
  //┌────────┬────────┬────────┬────────┬────────┬────────┐                                           ┌────────┬────────┬────────┬────────┬────────┬────────┐
 	 KC_NAGR ,KC_1    ,KC_2    ,KC_3    ,KC_4    ,KC_5    ,                                            KC_6    ,KC_7    ,KC_8    ,KC_9    ,KC_0    ,KC_DQUO ,
  //├────────┼────────┼────────┼────────┼────────┼────────┼────────┐                         ┌────────┼────────┼────────┼────────┼────────┼────────┼────────┤
 	 KC_TAB  ,KC_Q    ,KC_W    ,KC_E    ,KC_R    ,KC_T    ,TD_PASTE,                          ALT_TAB ,KC_Y    ,KC_U    ,KC_I    ,KC_O    ,KC_P    ,SFT_MINS,
  //├────────┼────────┼────────┼────────┼────────┼────────┼────────┤                         ├────────┼────────┼────────┼────────┼────────┼────────┼────────┤
 	 SHIFT   ,KC_A    ,__S     ,FN_D    ,FN_F    ,KC_G    ,COPY_CUT,                          KC_UNDS ,HYPR_H  ,ALT_J   ,CTL_K   ,KC_L    ,TD_CLN  ,CMD_QUOT,
  //├────────┼────────┼────────┼────────┼────────┼────────┼────────┼────────┐       ┌────────┼────────┼────────┼────────┼────────┼────────┼────────┼────────┤
 	 KC_BSLS ,KC_Z    ,KC_X    ,KC_C    ,KC_V    ,KC_B    ,KC_DEL  ,KC_PGDN ,        ALT_TAB ,AD_ESC  ,KC_N    ,KC_M    ,KC_COMM ,KC_DOT  ,KC_SLSH ,KC_ASTR ,
  //├────────┼────────┼────────┼────────┼────┬───┴────┬───┼────────┼────────┤       ├────────┼────────┼───┬────┴───┬────┼────────┼────────┼────────┼────────┤
 	 CTL     ,ALT     ,KC_LEFT ,KC_RIGHT,     GUI     ,    SHIFT   ,KC_BSPC ,        KC_LEAD ,NAV_SPC ,    ENT_SYM,     KC_LBRC ,KC_RBRC ,KC_DOWN ,KC_UP
  //└────────┴────────┴────────┴────────┘    └────────┘   └────────┴────────┘       └────────┴────────┘   └────────┘    └────────┴────────┴────────┴────────┘
  ),
  [_SYMB] = LAYOUT(
  //┌────────┬────────┬────────┬────────┬────────┬────────┐                                           ┌────────┬────────┬────────┬────────┬────────┬────────┐
 	 _______ ,KC_F1   ,KC_F2   ,KC_F3   ,KC_F4   ,KC_F5   ,                                            KC_F6   ,KC_F7   ,KC_F8   ,KC_F9   ,KC_F10  ,KC_F11  ,
  //├────────┼────────┼────────┼────────┼────────┼────────┼────────┐                         ┌────────┼────────┼────────┼────────┼────────┼────────┼────────┤
 	 _______ ,KC_EXLM ,KC_DLR   ,KC_LCBR ,KC_RCBR ,KC_PIPE ,_______ ,                         _______ ,KC_PSLS ,KC_P7 	,KC_P8 	 ,KC_P9   ,KC_PERC ,KC_PMNS ,
  //├────────┼────────┼────────┼────────┼────────┼────────┼────────┤                         ├────────┼────────┼────────┼────────┼────────┼────────┼────────┤
 	 _______ ,KC_AT   ,KC_DLR  , KC_LPRN, KC_RPRN,KC_GRV  ,_______ ,                          _______ ,KC_PAST ,KC_P4 	,KC_P5   ,KC_P6   ,KC_PPLS ,KC_BSPC ,
  //├────────┼────────┼────────┼────────┼────────┼────────┼────────┼────────┐       ┌────────┼────────┼────────┼────────┼────────┼────────┼────────┼────────┤
 	 _______ ,KC_PERC ,KC_CIRC ,KC_LBRC ,KC_RBRC ,KC_TILD ,_______ ,_______ ,        _______ ,_______ ,KC_COLN ,KC_P1 	,KC_P2   ,KC_P3   ,KC_PENT ,XXXXXXX ,
  //├────────┼────────┼────────┼────────┼────┬───┴────┬───┼────────┼────────┤       ├────────┼────────┼───┬────┴───┬────┼────────┼────────┼────────┼────────┤
 	 _______ ,_______ ,_______ ,_______ ,     _______ ,    _______ ,_______ ,        _______ ,_______ ,    KC_P0   ,     KC_P0   ,KC_PDOT ,KC_PENT ,XXXXXXX
  //└────────┴────────┴────────┴────────┘    └────────┘   └────────┴────────┘       └────────┴────────┘   └────────┘    └────────┴────────┴────────┴────────┘
  ),
  [_NAV] = LAYOUT(
  //┌────────┬────────┬────────┬────────┬────────┬────────┐                                           ┌────────┬────────┬────────┬────────┬────────┬────────┐
 	 _______ ,_______ ,_______ ,_______ ,_______ ,_______ ,                                            _______ ,_______ ,_______ ,_______ ,_______ ,_______ ,
  //├────────┼────────┼────────┼────────┼────────┼────────┼────────┐                         ┌────────┼────────┼────────┼────────┼────────┼────────┼────────┤
 	 XXXXXXX ,XXXXXXX ,KC_MS_U ,XXXXXXX ,KC_WH_U ,XXXXXXX ,_______ ,                          _______ ,XXXXXXX,SFT_LEFT,SFT_RIGHT,XXXXXXX ,XXXXXXX ,XXXXXXX ,
  //├────────┼────────┼────────┼────────┼────────┼────────┼────────┤                         ├────────┼────────┼────────┼────────┼────────┼────────┼────────┤
 	 XXXXXXX ,KC_MS_L ,KC_MS_D ,KC_MS_R ,KC_WH_D ,XXXXXXX ,_______ ,                          _______ ,KC_LEFT ,KC_DOWN ,KC_UP   ,KC_RIGHT,XXXXXXX ,XXXXXXX ,
  //├────────┼────────┼────────┼────────┼────────┼────────┼────────┼────────┐       ┌────────┼────────┼────────┼────────┼────────┼────────┼────────┼────────┤
 	 XXXXXXX ,XXXXXXX ,XXXXXXX ,XXXXXXX ,XXXXXXX ,XXXXXXX ,_______ ,_______ ,        _______ ,XXXXXXX ,KC_HOME ,CTL_LEFT,CTL_RIGHT,XXXXXXX,XXXXXXX ,XXXXXXX ,
  //├────────┼────────┼────────┼────────┼────┬───┴────┬───┼────────┼────────┤       ├────────┼────────┼───┬────┴───┬────┼────────┼────────┼────────┼────────┤
 	 XXXXXXX ,XXXXXXX ,XXXXXXX ,XXXXXXX ,     KC_BTN1 ,    KC_BTN2 ,_______ ,        _______ ,_______ ,    XXXXXXX ,     XXXXXXX ,XXXXXXX ,WIN_LEFT,WIN_RIGHT
  //└────────┴────────┴────────┴────────┘    └────────┘   └────────┴────────┘       └────────┴────────┘   └────────┘    └────────┴────────┴────────┴────────┘
  ),
  [_ADJUST] = LAYOUT(
  //┌────────┬────────┬────────┬────────┬────────┬────────┐                                           ┌────────┬────────┬────────┬────────┬────────┬────────┐
 	 XXXXXXX ,XXXXXXX ,XXXXXXX ,XXXXXXX ,XXXXXXX ,XXXXXXX ,                                            XXXXXXX ,XXXXXXX ,XXXXXXX ,XXXXXXX ,XXXXXXX ,XXXXXXX ,
  //├────────┼────────┼────────┼────────┼────────┼────────┼────────┐                         ┌────────┼────────┼────────┼────────┼────────┼────────┼────────┤
 	 XXXXXXX ,RESET   ,XXXXXXX ,XXXXXXX ,XXXXXXX ,XXXXXXX ,XXXXXXX ,                          XXXXXXX ,XXXXXXX ,XXXXXXX ,XXXXXXX ,XXXXXXX ,XXXXXXX ,KC_F12  ,
  //├────────┼────────┼────────┼────────┼────────┼────────┼────────┤                         ├────────┼────────┼────────┼────────┼────────┼────────┼────────┤
 	 XXXXXXX ,XXXXXXX ,XXXXXXX ,XXXXXXX ,XXXXXXX ,XXXXXXX ,XXXXXXX ,                          XXXXXXX ,XXXXXXX ,XXXXXXX ,XXXXXXX ,XXXXXXX ,XXXXXXX ,XXXXXXX ,
  //├────────┼────────┼────────┼────────┼────────┼────────┼────────┼────────┐       ┌────────┼────────┼────────┼────────┼────────┼────────┼────────┼────────┤
 	 XXXXXXX ,XXXXXXX ,XXXXXXX ,XXXXXXX ,XXXXXXX ,XXXXXXX ,XXXXXXX ,XXXXXXX ,        KC_MUTE ,_______ ,XXXXXXX ,XXXXXXX ,XXXXXXX ,XXXXXXX ,XXXXXXX ,XXXXXXX ,
  //├────────┼────────┼────────┼────────┼────┬───┴────┬───┼────────┼────────┤       ├────────┼────────┼───┬────┴───┬────┼────────┼────────┼────────┼────────┤
 	 XXXXXXX ,XXXXXXX ,XXXXXXX ,XXXXXXX ,     XXXXXXX ,    XXXXXXX ,XXXXXXX ,        XXXXXXX ,XXXXXXX ,    XXXXXXX ,     XXXXXXX ,XXXXXXX ,XXXXXXX ,XXXXXXX
  //└────────┴────────┴────────┴────────┘    └────────┘   └────────┴────────┘       └────────┴────────┘   └────────┘    └────────┴────────┴────────┴────────┘
  ),
 [_F] = LAYOUT(
  //┌────────┬────────┬────────┬────────┬────────┬────────┐                                           ┌────────┬────────┬────────┬────────┬────────┬────────┐
 	 XXXXXXX ,KC_F1   ,KC_F2   ,KC_F3   ,KC_F4   ,KC_F5   ,                                            KC_F6   ,KC_F7   ,KC_F8   ,KC_F9   ,KC_F10  ,KC_F11  ,
  //├────────┼────────┼────────┼────────┼────────┼────────┼────────┐                         ┌────────┼────────┼────────┼────────┼────────┼────────┼────────┤
 	 XXXXXXX ,XXXXXXX ,ALL_WIN ,EXPOSE  ,XXXXXXX ,XXXXXXX ,XXXXXXX ,                          XXXXXXX ,XXXXXXX ,XXXXXXX ,XXXXXXX ,XXXXXXX ,XXXXXXX ,XXXXXXX ,
  //├────────┼────────┼────────┼────────┼────────┼────────┼────────┤                         ├────────┼────────┼────────┼────────┼────────┼────────┼────────┤
 	 XXXXXXX ,XXXXXXX ,XXXXXXX ,XXXXXXX ,_______ ,XXXXXXX ,XXXXXXX ,                          XXXXXXX ,XXXXXXX ,XXXXXXX ,XXXXXXX ,XXXXXXX ,XXXXXXX ,XXXXXXX ,
  //├────────┼────────┼────────┼────────┼────────┼────────┼────────┼────────┐       ┌────────┼────────┼────────┼────────┼────────┼────────┼────────┼────────┤
 	 XXXXXXX ,XXXXXXX ,XXXXXXX ,XXXXXXX ,XXXXXXX ,XXXXXXX ,XXXXXXX ,XXXXXXX ,        XXXXXXX ,_______ ,XXXXXXX ,XXXXXXX ,XXXXXXX ,XXXXXXX ,XXXXXXX ,XXXXXXX ,
  //├────────┼────────┼────────┼────────┼────┬───┴────┬───┼────────┼────────┤       ├────────┼────────┼───┬────┴───┬────┼────────┼────────┼────────┼────────┤
 	 XXXXXXX ,XXXXXXX ,XXXXXXX ,XXXXXXX ,     XXXXXXX ,    XXXXXXX ,XXXXXXX ,        XXXXXXX ,_______ ,    XXXXXXX ,     XXXXXXX ,XXXXXXX ,XXXXXXX ,XXXXXXX
  //└────────┴────────┴────────┴────────┘    └────────┘   └────────┴────────┘       └────────┴────────┘   └────────┘    └────────┴────────┴────────┴────────┘
  ),
  [_D] = LAYOUT(
  //┌────────┬────────┬────────┬────────┬────────┬────────┐                                           ┌────────┬────────┬────────┬────────┬────────┬────────┐
 	 XXXXXXX ,KC_F1   ,KC_F2   ,KC_F3   ,KC_F4   ,KC_F5   ,                                            KC_F6   ,KC_F7   ,KC_F8   ,KC_F9   ,KC_F10  ,KC_F12  ,
  //├────────┼────────┼────────┼────────┼────────┼────────┼────────┐                         ┌────────┼────────┼────────┼────────┼────────┼────────┼────────┤
 	 XXXXXXX ,XXXXXXX ,XXXXXXX ,XXXXXXX ,XXXXXXX ,XXXXXXX ,XXXXXXX ,                          _______ ,KC_PSLS ,KC_P7 	,KC_P8 	 ,KC_P9   ,KC_PERC ,KC_PMNS ,
  //├────────┼────────┼────────┼────────┼────────┼────────┼────────┤                         ├────────┼────────┼────────┼────────┼────────┼────────┼────────┤
 	 XXXXXXX ,XXXXXXX ,XXXXXXX ,_______ ,XXXXXXX ,XXXXXXX ,XXXXXXX ,                          _______ ,KC_PAST ,KC_P4 	,KC_P5   ,KC_P6   ,KC_PPLS ,KC_BSPC ,
  //├────────┼────────┼────────┼────────┼────────┼────────┼────────┼────────┐       ┌────────┼────────┼────────┼────────┼────────┼────────┼────────┼────────┤
 	 XXXXXXX ,XXXXXXX ,XXXXXXX ,XXXXXXX ,XXXXXXX ,XXXXXXX ,XXXXXXX ,XXXXXXX ,        _______ ,_______ ,KC_COLN ,KC_P1 	,KC_P2   ,KC_P3   ,KC_PENT ,XXXXXXX ,
  //├────────┼────────┼────────┼────────┼────┬───┴────┬───┼────────┼────────┤       ├────────┼────────┼───┬────┴───┬────┼────────┼────────┼────────┼────────┤
 	 XXXXXXX ,XXXXXXX ,XXXXXXX ,XXXXXXX ,     XXXXXXX ,    XXXXXXX ,_______ ,        _______ ,_______ ,    KC_P0   ,     KC_P0   ,KC_PDOT ,KC_PENT ,XXXXXXX
  //└────────┴────────┴────────┴────────┘    └────────┘   └────────┴────────┘       └────────┴────────┘   └────────┘    └────────┴────────┴────────┴────────┘
  ),
 	[_S] = LAYOUT(
  //┌────────┬────────┬────────┬────────┬────────┬────────┐                                           ┌────────┬────────┬────────┬────────┬────────┬────────┐
 	 XXXXXXX ,KC_F1   ,KC_F2   ,KC_F3   ,KC_F4   ,KC_F5   ,                                            KC_F6   ,KC_F7   ,KC_F8   ,KC_F9   ,KC_F10  ,XXXXXXX ,
  //├────────┼────────┼────────┼────────┼────────┼────────┼────────┐                         ┌────────┼────────┼────────┼────────┼────────┼────────┼────────┤
 	 XXXXXXX ,XXXXXXX ,XXXXXXX ,KC_LT   ,KC_GT   ,XXXXXXX ,XXXXXXX ,                          XXXXXXX ,KC_HASH ,KC_LCBR ,KC_RCBR ,KC_ASTR ,KC_PERC ,KC_DLR ,
  //├────────┼────────┼────────┼────────┼────────┼────────┼────────┤                         ├────────┼────────┼────────┼────────┼────────┼────────┼────────┤
 	 XXXXXXX ,XXXXXXX ,_______ ,KC_EQL  ,F_ARROW ,KC_GRAVE,XXXXXXX ,                          XXXXXXX ,KC_AMPR ,KC_LPRN ,KC_RPRN ,CLN_EQ  ,KC_PLUS ,KC_PIPE ,
  //├────────┼────────┼────────┼────────┼────────┼────────┼────────┼────────┐       ┌────────┼────────┼────────┼────────┼────────┼────────┼────────┼────────┤
 	 XXXXXXX ,XXXXXXX ,XXXXXXX ,KC_CIRC ,KC_DLR  ,XXXXXXX ,XXXXXXX ,XXXXXXX ,        XXXXXXX ,XXXXXXX ,KC_EXLM ,KC_TILD ,KC_CIRC ,ARROW  ,KC_BSLASH,IARROW  ,
  //├────────┼────────┼────────┼────────┼────┬───┴────┬───┼────────┼────────┤       ├────────┼────────┼───┬────┴───┬────┼────────┼────────┼────────┼────────┤
 	 XXXXXXX ,XXXXXXX ,XXXXXXX ,XXXXXXX ,     XXXXXXX ,    XXXXXXX ,_______ ,        XXXXXXX ,_______ ,    XXXXXXX ,     XXXXXXX ,XXXXXXX ,XXXXXXX ,XXXXXXX
  //└────────┴────────┴────────┴────────┘    └────────┘   └────────┴────────┘       └────────┴────────┘   └────────┘    └────────┴────────┴────────┴────────┘
  )
 };
 void alt_tab_activated(void){
    layer_on(_NAV);
 };
 void alt_tab_deactivated(void){
    layer_off(_NAV);
 };
 layer_state_t layer_state_set_user(layer_state_t state) {
 	switch (get_highest_layer(state)) {
 		case _QWERTY:
 			set_led_off;
 			break;
 		case _SYMB:
        case _D:
 			set_led_green;
 			break;
 		case _NAV:
 			set_led_blue;
 			break;
 		case _ADJUST:
 			set_led_red;
 			break;
 		case _S:
 			set_led_magenta;
 			break;
 		case _F:
 			set_led_white;
 			break;
 		default:
 			break;
 	}
  return state;
 }
@@ -0,0 +1,2 @@
 # Danielo keymap for Redox Wireless
 Most of the custom functionality is on my user-space `users/danielo515`
@@ -0,0 +1,6 @@
 TAP_DANCE_ENABLE = yes # Enable the tap dance feature.
 COMBO_ENABLE = yes
 LEADER_ENABLE = yes
 CONSOLE_ENABLE = no
 LTO_ENABLE = yes # link time optimizations
@@ -1,15 +1,14 @@
-#ifndef CONFIG_H
+#pragma once
 #define CONFIG_H
 #include "config_common.h"
 /* USB Device descriptor parameter */
-#define VENDOR_ID       0xFEED
+#define VENDOR_ID       0x5436 // "T6"
-#define PRODUCT_ID      0x6060
+#define PRODUCT_ID      0x6060 // Tokyo60
 #define DEVICE_VER      0x0001
 #define MANUFACTURER    Tokyo Keyboard
-#define PRODUCT         tokyo60
+#define PRODUCT         Tokyo60
-#define DESCRIPTION     q.m.k. keyboard firmware for tokyo60
+#define DESCRIPTION     q.m.k. keyboard firmware for Tokyo60
 /* key matrix size */
 #define MATRIX_ROWS 5
@@ -54,5 +53,3 @@
 /* For Production */
 #define QMK_ESC_OUTPUT F0 // usually COL
 #define QMK_ESC_INPUT D0 // usually ROW
 #endif
@@ -1,12 +1,320 @@
 {
    "keyboard_name": "Tokyo60",
-    "url": "", 
+    "url": "https://tokyokeyboard.com/",
    "maintainer": "qmk",
    "width": 15,
    "height": 5,
    "layouts": {
        "LAYOUT_60_hhkb": {
-            "layout": [{"label":"Esc", "x":0, "y":0}, {"label":"!", "x":1, "y":0}, {"label":"@", "x":2, "y":0}, {"label":"#", "x":3, "y":0}, {"label":"$", "x":4, "y":0}, {"label":"%", "x":5, "y":0}, {"label":"^", "x":6, "y":0}, {"label":"&", "x":7, "y":0}, {"label":"*", "x":8, "y":0}, {"label":"(", "x":9, "y":0}, {"label":")", "x":10, "y":0}, {"label":"_", "x":11, "y":0}, {"label":"+", "x":12, "y":0}, {"label":"|", "x":13, "y":0}, {"label":"~", "x":14, "y":0}, {"label":"Tab", "x":0, "y":1, "w":1.5}, {"label":"Q", "x":1.5, "y":1}, {"label":"W", "x":2.5, "y":1}, {"label":"E", "x":3.5, "y":1}, {"label":"R", "x":4.5, "y":1}, {"label":"T", "x":5.5, "y":1}, {"label":"Y", "x":6.5, "y":1}, {"label":"U", "x":7.5, "y":1}, {"label":"I", "x":8.5, "y":1}, {"label":"O", "x":9.5, "y":1}, {"label":"P", "x":10.5, "y":1}, {"label":"{", "x":11.5, "y":1}, {"label":"}", "x":12.5, "y":1}, {"label":"Delete", "x":13.5, "y":1, "w":1.5}, {"label":"Control", "x":0, "y":2, "w":1.75}, {"label":"A", "x":1.75, "y":2}, {"label":"S", "x":2.75, "y":2}, {"label":"D", "x":3.75, "y":2}, {"label":"F", "x":4.75, "y":2}, {"label":"G", "x":5.75, "y":2}, {"label":"H", "x":6.75, "y":2}, {"label":"J", "x":7.75, "y":2}, {"label":"K", "x":8.75, "y":2}, {"label":"L", "x":9.75, "y":2}, {"label":":", "x":10.75, "y":2}, {"label":"\"", "x":11.75, "y":2}, {"label":"Enter", "x":12.75, "y":2, "w":2.25}, {"label":"Shift", "x":0, "y":3, "w":2.25}, {"label":"Z", "x":2.25, "y":3}, {"label":"X", "x":3.25, "y":3}, {"label":"C", "x":4.25, "y":3}, {"label":"V", "x":5.25, "y":3}, {"label":"B", "x":6.25, "y":3}, {"label":"N", "x":7.25, "y":3}, {"label":"M", "x":8.25, "y":3}, {"label":"<", "x":9.25, "y":3}, {"label":">", "x":10.25, "y":3}, {"label":"?", "x":11.25, "y":3}, {"label":"Shift", "x":12.25, "y":3, "w":1.75}, {"label":"Fn", "x":14, "y":3}, {"label":"Os", "x":1.5, "y":4}, {"label":"Alt", "x":2.5, "y":4, "w":1.5}, {"x":4, "y":4, "w":7}, {"label":"Alt", "x":11, "y":4, "w":1.5}, {"label":"Os", "x":12.5, "y":4}]
+            "layout": [{
                    "label": "Esc",
                    "x": 0,
                    "y": 0
                },
                {
                    "label": "!",
                    "x": 1,
                    "y": 0
                },
                {
                    "label": "@",
                    "x": 2,
                    "y": 0
                },
                {
                    "label": "#",
                    "x": 3,
                    "y": 0
                },
                {
                    "label": "$",
                    "x": 4,
                    "y": 0
                },
                {
                    "label": "%",
                    "x": 5,
                    "y": 0
                },
                {
                    "label": "^",
                    "x": 6,
                    "y": 0
                },
                {
                    "label": "&",
                    "x": 7,
                    "y": 0
                },
                {
                    "label": "*",
                    "x": 8,
                    "y": 0
                },
                {
                    "label": "(",
                    "x": 9,
                    "y": 0
                },
                {
                    "label": ")",
                    "x": 10,
                    "y": 0
                },
                {
                    "label": "_",
                    "x": 11,
                    "y": 0
                },
                {
                    "label": "+",
                    "x": 12,
                    "y": 0
                },
                {
                    "label": "|",
                    "x": 13,
                    "y": 0
                },
                {
                    "label": "~",
                    "x": 14,
                    "y": 0
                },
                {
                    "label": "Tab",
                    "x": 0,
                    "y": 1,
                    "w": 1.5
                },
                {
                    "label": "Q",
                    "x": 1.5,
                    "y": 1
                },
                {
                    "label": "W",
                    "x": 2.5,
                    "y": 1
                },
                {
                    "label": "E",
                    "x": 3.5,
                    "y": 1
                },
                {
                    "label": "R",
                    "x": 4.5,
                    "y": 1
                },
                {
                    "label": "T",
                    "x": 5.5,
                    "y": 1
                },
                {
                    "label": "Y",
                    "x": 6.5,
                    "y": 1
                },
                {
                    "label": "U",
                    "x": 7.5,
                    "y": 1
                },
                {
                    "label": "I",
                    "x": 8.5,
                    "y": 1
                },
                {
                    "label": "O",
                    "x": 9.5,
                    "y": 1
                },
                {
                    "label": "P",
                    "x": 10.5,
                    "y": 1
                },
                {
                    "label": "{",
                    "x": 11.5,
                    "y": 1
                },
                {
                    "label": "}",
                    "x": 12.5,
                    "y": 1
                },
                {
                    "label": "Delete",
                    "x": 13.5,
                    "y": 1,
                    "w": 1.5
                },
                {
                    "label": "Control",
                    "x": 0,
                    "y": 2,
                    "w": 1.75
                },
                {
                    "label": "A",
                    "x": 1.75,
                    "y": 2
                },
                {
                    "label": "S",
                    "x": 2.75,
                    "y": 2
                },
                {
                    "label": "D",
                    "x": 3.75,
                    "y": 2
                },
                {
                    "label": "F",
                    "x": 4.75,
                    "y": 2
                },
                {
                    "label": "G",
                    "x": 5.75,
                    "y": 2
                },
                {
                    "label": "H",
                    "x": 6.75,
                    "y": 2
                },
                {
                    "label": "J",
                    "x": 7.75,
                    "y": 2
                },
                {
                    "label": "K",
                    "x": 8.75,
                    "y": 2
                },
                {
                    "label": "L",
                    "x": 9.75,
                    "y": 2
                },
                {
                    "label": ":",
                    "x": 10.75,
                    "y": 2
                },
                {
                    "label": "\"",
                    "x": 11.75,
                    "y": 2
                },
                {
                    "label": "Enter",
                    "x": 12.75,
                    "y": 2,
                    "w": 2.25
                },
                {
                    "label": "Shift",
                    "x": 0,
                    "y": 3,
                    "w": 2.25
                },
                {
                    "label": "Z",
                    "x": 2.25,
                    "y": 3
                },
                {
                    "label": "X",
                    "x": 3.25,
                    "y": 3
                },
                {
                    "label": "C",
                    "x": 4.25,
                    "y": 3
                },
                {
                    "label": "V",
                    "x": 5.25,
                    "y": 3
                },
                {
                    "label": "B",
                    "x": 6.25,
                    "y": 3
                },
                {
                    "label": "N",
                    "x": 7.25,
                    "y": 3
                },
                {
                    "label": "M",
                    "x": 8.25,
                    "y": 3
                },
                {
                    "label": "<",
                    "x": 9.25,
                    "y": 3
                },
                {
                    "label": ">",
                    "x": 10.25,
                    "y": 3
                },
                {
                    "label": "?",
                    "x": 11.25,
                    "y": 3
                },
                {
                    "label": "Shift",
                    "x": 12.25,
                    "y": 3,
                    "w": 1.75
                },
                {
                    "label": "Fn",
                    "x": 14,
                    "y": 3
                },
                {
                    "label": "Os",
                    "x": 1.5,
                    "y": 4
                },
                {
                    "label": "Alt",
                    "x": 2.5,
                    "y": 4,
                    "w": 1.5
                },
                {
                    "x": 4,
                    "y": 4,
                    "w": 7
                },
                {
                    "label": "Alt",
                    "x": 11,
                    "y": 4,
                    "w": 1.5
                },
                {
                    "label": "Os",
                    "x": 12.5,
                    "y": 4
                }
            ]
        }
    }
 }
@@ -0,0 +1,37 @@
 #include QMK_KEYBOARD_H
 #define BL 0
 #define FN 1
 /*
 * Default HHKB Layout
 */
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 [BL] = LAYOUT_60_hhkb(
        KC_ESC,    KC_1,    KC_2,   KC_3,   KC_4,   KC_5,   KC_6,   KC_7,   KC_8,    KC_9,    KC_0, KC_MINS,  KC_EQL, KC_BSLS, KC_GRV, \
        KC_TAB,    KC_Q,    KC_W,   KC_E,   KC_R,   KC_T,   KC_Y,   KC_U,   KC_I,    KC_O,    KC_P, KC_LBRC, KC_RBRC, KC_BSPC,      \
        KC_LCTL,   KC_A,    KC_S,   KC_D,   KC_F,   KC_G,   KC_H,   KC_J,   KC_K,    KC_L,    KC_SCLN, KC_QUOT,       KC_ENT,      \
        KC_LSFT,            KC_Z,   KC_X,   KC_C,   KC_V,   KC_B,   KC_N,   KC_M, KC_COMM,  KC_DOT, KC_SLSH,      KC_RSFT, MO(FN), \
             KC_LALT, KC_LGUI,              KC_SPC,                         KC_RGUI, KC_RALT ),
 [FN]= LAYOUT_60_hhkb(
       KC_PWR,   KC_F1,   KC_F2,   KC_F3,   KC_F4,   KC_F5,   KC_F6,   KC_F7,   KC_F8,   KC_F9,  KC_F10,  KC_F11,  KC_F12,  KC_INS,  KC_DEL, \
       KC_CAPS, RGB_TOG, RGB_MOD, RGB_RMOD, BL_TOGG, BL_STEP, KC_TRNS, KC_TRNS, KC_PSCR, KC_SLCK, KC_PAUS,   KC_UP, KC_TRNS, KC_TRNS,  \
       KC_TRNS, KC_VOLD, KC_VOLU, KC_MUTE, KC_EJCT, KC_TRNS, KC_PAST, KC_PSLS, KC_HOME, KC_PGUP, KC_LEFT, KC_RGHT,       KC_PENT,       \
       KC_TRNS,       KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_PPLS, KC_PMNS,  KC_END, KC_PGDN, KC_DOWN,       KC_TRNS, KC_TRNS, \
             KC_TRNS, KC_TRNS,                   KC_TRNS,                         KC_TRNS, KC_TRNS ),
 [2]= LAYOUT_60_hhkb(
       _______,   _______,   _______,   _______,   _______,   _______,   _______,   _______,   _______,   _______,  _______,  _______,  _______,  _______,  _______, \
       _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,   _______, _______, _______,  \
       _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,       _______,       \
       _______,       _______, _______, _______, _______, _______, _______, _______,  _______, _______, _______,       _______, _______, \
             _______, _______,                   _______,                         _______, _______ ),
 [3]= LAYOUT_60_hhkb(
       _______,   _______,   _______,   _______,   _______,   _______,   _______,   _______,   _______,   _______,  _______,  _______,  _______,  _______,  _______, \
       _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,   _______, _______, _______,  \
       _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,       _______,       \
       _______,       _______, _______, _______, _______, _______, _______, _______,  _______, _______, _______,       _______, _______, \
             _______, _______,                   _______,                         _______, _______ ),
 };
@@ -0,0 +1 @@
 VIA_ENABLE = yes
@@ -1,15 +1,15 @@
-# tokyo60
+# Tokyo60
-![tokyo60](http://tokyokeyboard.com/wp-content/uploads/2018/02/AI7B4543_copy_page_20180215141449-1200x800.jpg)
+![Tokyo60](http://tokyokeyboard.com/wp-content/uploads/2018/02/AI7B4543_copy_page_20180215141449-1200x800.jpg)
 Minimal hacker style mechanical keyboard designed in Tokyo. Full aluminum hi-pro construction with integrated top-plate. Cherry MX compatible. More Info at [Tokyo Keyboard](http://tokyokeyboard.com).
-Keyboard Maintainer: [Tokyo Keyboard](http://tokyokeyboard.com)  
+* Keyboard Maintainer: [Tokyo Keyboard](http://tokyokeyboard.com)
-Hardware Supported: tokyo60 rev1  
+* Hardware Supported: Tokyo60 Rev.1
-Hardware Availability: [Tokyo Keyboard](http://tokyokeyboard.com), [Massdrop](https://www.massdrop.com/buy/massdrop-x-tokyo-keyboard-tokyo60-keyboard-kit?mode=guest_open)   
+* Hardware Availability: [Drop](https://drop.com/buy/massdrop-x-tokyo-keyboard-tokyo60-keyboard-kit?mode=guest_open)
 Make example for this keyboard (after setting up your build environment):
    make tokyo60:default
-See [build environment setup](https://docs.qmk.fm/#/getting_started_build_tools) then the [make instructions](https://docs.qmk.fm/#/getting_started_make_guide) for more information.
+See the [build environment setup](https://docs.qmk.fm/#/getting_started_build_tools) and the [make instructions](https://docs.qmk.fm/#/getting_started_make_guide) for more information. Brand new to QMK? Start with our [Complete Newbs Guide](https://docs.qmk.fm/#/newbs).
@@ -14,7 +14,7 @@ BOOTLOADER = atmel-dfu
 # Build Options
 #   change yes to no to disable
 #
-BOOTMAGIC_ENABLE = no      # Virtual DIP switch configuration
+BOOTMAGIC_ENABLE = lite      # Virtual DIP switch configuration
 MOUSEKEY_ENABLE = no       # Mouse keys
 EXTRAKEY_ENABLE = yes       # Audio control and System control
 # Do not enable SLEEP_LED_ENABLE. it uses the same timer as BACKLIGHT_ENABLE
@@ -1,8 +1,9 @@
-#ifndef TOKYO60_H
+#pragma once
 #define TOKYO60_H
 #include "quantum.h"
 #define XXX KC_NO
 #define LAYOUT_60_hhkb( \
    K00, K01, K02, K03, K04, K05, K06, K07, K08, K09, K0A, K0B, K0C, K0D, K1D,\
    K10, K11, K12, K13, K14, K15, K16, K17, K18, K19, K1A, K1B, K1C, K2D, \
@@ -12,9 +13,7 @@
 ) { \
    { K00, K01, K02, K03, K04, K05, K06, K07, K08, K09, K0A, K0B, K0C, K0D }, \
    { K10, K11, K12, K13, K14, K15, K16, K17, K18, K19, K1A, K1B, K1C, K1D }, \
-    { K20, K21, K22, K23, K24, K25, K26, K27, K28, K29, K2A, K2B, KC_NO, K2D }, \
+    { K20, K21, K22, K23, K24, K25, K26, K27, K28, K29, K2A, K2B, XXX, K2D }, \
-    { K30, KC_NO, K32, K33, K34, K35, K36, K37, K38, K39, K3A, K3B, K3C, K3D }, \
+    { K30, XXX, K32, K33, K34, K35, K36, K37, K38, K39, K3A, K3B, K3C, K3D }, \
-    { KC_NO, K42, K43, KC_NO, KC_NO, K46, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, K4B, K4C, K4D }  \
+    { XXX, K42, K43, XXX, XXX, K46, XXX, XXX, XXX, XXX, XXX, K4B, K4C, K4D }  \
 }
 #endif
@@ -10,6 +10,7 @@ from . import doctor
 from . import flash
 from . import hello
 from . import json
 from . import json2c
 from . import list
 from . import kle2json
 from . import new
@@ -1,56 +1,16 @@
 """Generate a keymap.c from a configurator export.
 """
 import json
 from pathlib import Path
 from milc import cli
 import qmk.keymap
 import qmk.path
@cli.argument('-o', '--output', arg_only=True, type=Path, help='File to write to')
@cli.argument('-q', '--quiet', arg_only=True, action='store_true', help="Quiet mode, only output error messages")
@cli.argument('filename', arg_only=True, help='Configurator JSON file')
@cli.subcommand('Creates a keymap.c from a QMK Configurator export.')
 def json_keymap(cli):
-    """Generate a keymap.c from a configurator export.
+    """Renamed to `qmk json2c`.
    This command uses the `qmk.keymap` module to generate a keymap.c from a configurator export. The generated keymap is written to stdout, or to a file if -o is provided.
    """
-    cli.args.filename = qmk.path.normpath(cli.args.filename)
+    cli.log.error('This command has been renamed to `qmk json2c`.')
-
+    exit(1)
    # Error checking
    if not cli.args.filename.exists():
        cli.log.error('JSON file does not exist!')
        cli.print_usage()
        exit(1)
    if str(cli.args.filename) == '-':
        # TODO(skullydazed/anyone): Read file contents from STDIN
        cli.log.error('Reading from STDIN is not (yet) supported.')
        cli.print_usage()
        exit(1)
    # Environment processing
    if cli.args.output == ('-'):
        cli.args.output = None
    # Parse the configurator json
    with cli.args.filename.open('r') as fd:
        user_keymap = json.load(fd)
    # Generate the keymap
    keymap_c = qmk.keymap.generate(user_keymap['keyboard'], user_keymap['layout'], user_keymap['layers'])
    if cli.args.output:
        cli.args.output.parent.mkdir(parents=True, exist_ok=True)
        if cli.args.output.exists():
            cli.args.output.replace(cli.args.output.name + '.bak')
        cli.args.output.write_text(keymap_c)
        if not cli.args.quiet:
            cli.log.info('Wrote keymap to %s.', cli.args.output)
    else:
        print(keymap_c)
@@ -0,0 +1,56 @@
 """Generate a keymap.c from a configurator export.
 """
 import json
 from pathlib import Path
 from milc import cli
 import qmk.keymap
 import qmk.path
@cli.argument('-o', '--output', arg_only=True, type=Path, help='File to write to')
@cli.argument('-q', '--quiet', arg_only=True, action='store_true', help="Quiet mode, only output error messages")
@cli.argument('filename', arg_only=True, help='Configurator JSON file')
@cli.subcommand('Creates a keymap.c from a QMK Configurator export.')
 def json2c(cli):
    """Generate a keymap.c from a configurator export.
    This command uses the `qmk.keymap` module to generate a keymap.c from a configurator export. The generated keymap is written to stdout, or to a file if -o is provided.
    """
    cli.args.filename = qmk.path.normpath(cli.args.filename)
    # Error checking
    if not cli.args.filename.exists():
        cli.log.error('JSON file does not exist!')
        cli.print_usage()
        exit(1)
    if str(cli.args.filename) == '-':
        # TODO(skullydazed/anyone): Read file contents from STDIN
        cli.log.error('Reading from STDIN is not (yet) supported.')
        cli.print_usage()
        exit(1)
    # Environment processing
    if cli.args.output == ('-'):
        cli.args.output = None
    # Parse the configurator json
    with cli.args.filename.open('r') as fd:
        user_keymap = json.load(fd)
    # Generate the keymap
    keymap_c = qmk.keymap.generate(user_keymap['keyboard'], user_keymap['layout'], user_keymap['layers'])
    if cli.args.output:
        cli.args.output.parent.mkdir(parents=True, exist_ok=True)
        if cli.args.output.exists():
            cli.args.output.replace(cli.args.output.name + '.bak')
        cli.args.output.write_text(keymap_c)
        if not cli.args.quiet:
            cli.log.info('Wrote keymap to %s.', cli.args.output)
    else:
        print(keymap_c)
@@ -38,17 +38,23 @@
 #    include "velocikey.h"
 #endif
 #ifndef MIN
 #    define MIN(a, b) (((a) < (b)) ? (a) : (b))
 #endif
 #ifdef RGBLIGHT_SPLIT
 /* for split keyboard */
 #    define RGBLIGHT_SPLIT_SET_CHANGE_MODE rgblight_status.change_flags |= RGBLIGHT_STATUS_CHANGE_MODE
 #    define RGBLIGHT_SPLIT_SET_CHANGE_HSVS rgblight_status.change_flags |= RGBLIGHT_STATUS_CHANGE_HSVS
 #    define RGBLIGHT_SPLIT_SET_CHANGE_MODEHSVS rgblight_status.change_flags |= (RGBLIGHT_STATUS_CHANGE_MODE | RGBLIGHT_STATUS_CHANGE_HSVS)
 #    define RGBLIGHT_SPLIT_SET_CHANGE_LAYERS rgblight_status.change_flags |= RGBLIGHT_STATUS_CHANGE_LAYERS
 #    define RGBLIGHT_SPLIT_SET_CHANGE_TIMER_ENABLE rgblight_status.change_flags |= RGBLIGHT_STATUS_CHANGE_TIMER
 #    define RGBLIGHT_SPLIT_ANIMATION_TICK rgblight_status.change_flags |= RGBLIGHT_STATUS_ANIMATION_TICK
 #else
 #    define RGBLIGHT_SPLIT_SET_CHANGE_MODE
 #    define RGBLIGHT_SPLIT_SET_CHANGE_HSVS
 #    define RGBLIGHT_SPLIT_SET_CHANGE_MODEHSVS
 #    define RGBLIGHT_SPLIT_SET_CHANGE_LAYERS
 #    define RGBLIGHT_SPLIT_SET_CHANGE_TIMER_ENABLE
 #    define RGBLIGHT_SPLIT_ANIMATION_TICK
 #endif
@@ -97,6 +103,10 @@ LED_TYPE led[RGBLED_NUM];
 #    define LED_ARRAY led
 #endif
 #ifdef RGBLIGHT_LAYERS
 rgblight_segment_t const *const *rgblight_layers = NULL;
 #endif
 static uint8_t clipping_start_pos = 0;
 static uint8_t clipping_num_leds  = RGBLED_NUM;
 static uint8_t effect_start_pos   = 0;
@@ -604,11 +614,67 @@ void rgblight_sethsv_master(uint8_t hue, uint8_t sat, uint8_t val) { rgblight_se
 void rgblight_sethsv_slave(uint8_t hue, uint8_t sat, uint8_t val) { rgblight_sethsv_range(hue, sat, val, (uint8_t)RGBLED_NUM / 2, (uint8_t)RGBLED_NUM); }
 #endif  // ifndef RGBLIGHT_SPLIT
 #ifdef RGBLIGHT_LAYERS
 void rgblight_set_layer_state(uint8_t layer, bool enabled) {
    uint8_t mask = 1 << layer;
    if (enabled) {
        rgblight_status.enabled_layer_mask |= mask;
    } else {
        rgblight_status.enabled_layer_mask &= ~mask;
    }
    RGBLIGHT_SPLIT_SET_CHANGE_LAYERS;
    // Static modes don't have a ticker running to update the LEDs
    if (rgblight_status.timer_enabled == false) {
        rgblight_mode_noeeprom(rgblight_config.mode);
    }
 }
 bool rgblight_get_layer_state(uint8_t layer) {
    uint8_t mask = 1 << layer;
    return (rgblight_status.enabled_layer_mask & mask) != 0;
 }
 // Write any enabled LED layers into the buffer
 static void rgblight_layers_write(void) {
    uint8_t i = 0;
    // For each layer
    for (const rgblight_segment_t *const *layer_ptr = rgblight_layers; i < RGBLIGHT_MAX_LAYERS; layer_ptr++, i++) {
        if (!rgblight_get_layer_state(i)) {
            continue;  // Layer is disabled
        }
        const rgblight_segment_t *segment_ptr = pgm_read_ptr(layer_ptr);
        if (segment_ptr == NULL) {
            break;  // No more layers
        }
        // For each segment
        while (1) {
            rgblight_segment_t segment;
            memcpy_P(&segment, segment_ptr, sizeof(rgblight_segment_t));
            if (segment.index == RGBLIGHT_END_SEGMENT_INDEX) {
                break;  // No more segments
            }
            // Write segment.count LEDs
            LED_TYPE *const limit = &led[MIN(segment.index + segment.count, RGBLED_NUM)];
            for (LED_TYPE *led_ptr = &led[segment.index]; led_ptr < limit; led_ptr++) {
                sethsv(segment.hue, segment.sat, segment.val, led_ptr);
            }
            segment_ptr++;
        }
    }
 }
 #endif
 #ifndef RGBLIGHT_CUSTOM_DRIVER
 void rgblight_set(void) {
    LED_TYPE *start_led;
    uint16_t  num_leds = clipping_num_leds;
 #    ifdef RGBLIGHT_LAYERS
    if (rgblight_layers != NULL) {
        rgblight_layers_write();
    }
 #    endif
    if (!rgblight_config.enable) {
        for (uint8_t i = effect_start_pos; i < effect_end_pos; i++) {
            led[i].r = 0;
@@ -652,6 +718,11 @@ void rgblight_get_syncinfo(rgblight_syncinfo_t *syncinfo) {
 /* for split keyboard slave side */
 void rgblight_update_sync(rgblight_syncinfo_t *syncinfo, bool write_to_eeprom) {
 #    ifdef RGBLIGHT_LAYERS
    if (syncinfo->status.change_flags & RGBLIGHT_STATUS_CHANGE_LAYERS) {
        rgblight_status.enabled_layer_mask = syncinfo->status.enabled_layer_mask;
    }
 #    endif
    if (syncinfo->status.change_flags & RGBLIGHT_STATUS_CHANGE_MODE) {
        if (syncinfo->config.enable) {
            rgblight_config.enable = 1;  // == rgblight_enable_noeeprom();
@@ -170,6 +170,32 @@ enum RGBLIGHT_EFFECT_MODE {
 #        include <avr/pgmspace.h>
 #    endif
 #    ifdef RGBLIGHT_LAYERS
 typedef struct {
    uint8_t index;  // The first LED to light
    uint8_t count;  // The number of LEDs to light
    uint8_t hue;
    uint8_t sat;
    uint8_t val;
 } rgblight_segment_t;
 #        define RGBLIGHT_END_SEGMENT_INDEX (255)
 #        define RGBLIGHT_END_SEGMENTS \
            { RGBLIGHT_END_SEGMENT_INDEX, 0, 0, 0 }
 #        define RGBLIGHT_MAX_LAYERS 8
 #        define RGBLIGHT_LAYER_SEGMENTS(...) \
            { __VA_ARGS__, RGBLIGHT_END_SEGMENTS }
 #        define RGBLIGHT_LAYERS_LIST(...) \
            { __VA_ARGS__, NULL }
 // Get/set enabled rgblight layers
 void rgblight_set_layer_state(uint8_t layer, bool enabled);
 bool rgblight_get_layer_state(uint8_t layer);
 // Point this to an array of rgblight_segment_t arrays in keyboard_post_init_user to use rgblight layers
 extern const rgblight_segment_t *const *rgblight_layers;
 #    endif
 extern LED_TYPE led[RGBLED_NUM];
 extern const uint8_t  RGBLED_BREATHING_INTERVALS[4] PROGMEM;
@@ -199,6 +225,9 @@ typedef struct _rgblight_status_t {
 #    ifdef RGBLIGHT_SPLIT
    uint8_t change_flags;
 #    endif
 #    ifdef RGBLIGHT_LAYERS
    uint8_t enabled_layer_mask;
 #    endif
 } rgblight_status_t;
 /* === Utility Functions ===*/
@@ -294,25 +323,26 @@ void rgblight_mode_eeprom_helper(uint8_t mode, bool write_to_eeprom);
 #    define EZ_RGB(val) rgblight_show_solid_color((val >> 16) & 0xFF, (val >> 8) & 0xFF, val & 0xFF)
 void rgblight_show_solid_color(uint8_t r, uint8_t g, uint8_t b);
-#ifdef RGBLIGHT_USE_TIMER
+#    ifdef RGBLIGHT_USE_TIMER
 void rgblight_task(void);
 void rgblight_timer_init(void);
 void rgblight_timer_enable(void);
 void rgblight_timer_disable(void);
 void rgblight_timer_toggle(void);
-#else
+#    else
-#define rgblight_task()
+#        define rgblight_task()
-#define rgblight_timer_init()
+#        define rgblight_timer_init()
-#define rgblight_timer_enable()
+#        define rgblight_timer_enable()
-#define rgblight_timer_disable()
+#        define rgblight_timer_disable()
-#define rgblight_timer_toggle()
+#        define rgblight_timer_toggle()
-#endif
+#    endif
 #    ifdef RGBLIGHT_SPLIT
 #        define RGBLIGHT_STATUS_CHANGE_MODE (1 << 0)
 #        define RGBLIGHT_STATUS_CHANGE_HSVS (1 << 1)
 #        define RGBLIGHT_STATUS_CHANGE_TIMER (1 << 2)
 #        define RGBLIGHT_STATUS_ANIMATION_TICK (1 << 3)
 #        define RGBLIGHT_STATUS_CHANGE_LAYERS (1 << 4)
 typedef struct _rgblight_syncinfo_t {
    rgblight_config_t config;
@@ -0,0 +1,38 @@
 #include "danielo515.h"
 #include "alt_tab.h"
 bool                       altPressed = false;
 __attribute__((weak)) void alt_tab_activated(void){};
 __attribute__((weak)) void alt_tab_deactivated(void){};
 extern bool                onMac;
 // =============== ALT_TAB single key handling
 bool process_alt_tab(uint16_t keycode, keyrecord_t *record) {
    switch (keycode) {
        case ALT_TAB:
            if (!record->event.pressed) {
                return false;
            }
            if (altPressed) {
                tap_code(KC_TAB);
            } else {
                altPressed = true;
                onMac ? register_code(KC_LGUI) : register_code(KC_LALT);
                tap_code(KC_TAB);
                alt_tab_activated();
            }
        // avoid alt releasing if the key is of movement
        case KC_RIGHT ... KC_UP:
            if (altPressed) {
                return true;  // yes QMK, do your stuff
            }
    }
    // Reset sticky alt tab when any other key is pressed
    if (altPressed) {
        onMac ? unregister_code(KC_LGUI) : unregister_code(KC_LALT);
        altPressed = false;
        alt_tab_deactivated();
        return false;
    }
    return true;
 };
@@ -0,0 +1,4 @@
 #pragma once
 #include "quantum.h"
 bool process_alt_tab(uint16_t keycode, keyrecord_t *record);
@@ -1,21 +1,36 @@
 #include "combo.h"
 enum combos {
-  JK_ESC,
+    JK_ESC,
-  YU_COM,
+    YU_COM,
-  UI_COM,
+    UI_COM,
-  IO_COM,
+    IO_COM,
-  OP_COM,
+    QW_COM,
-  QW_COM
+    COM_SLS,
    COM_DOT,
    M_COMM,
    N_M,
    OP_COM,
 };
 const uint16_t PROGMEM ui_combo[] = {KC_U, KC_I, COMBO_END};
 const uint16_t PROGMEM jk_combo[] = {KC_J, KC_K, COMBO_END};
 const uint16_t PROGMEM yu_combo[] = {KC_Y, KC_U, COMBO_END};
 const uint16_t PROGMEM io_combo[] = {KC_I, KC_O, COMBO_END};
 const uint16_t PROGMEM qw_combo[] = {KC_Q, KC_W, COMBO_END};
 const uint16_t PROGMEM com_sls[] = {KC_COMMA, KC_SLSH, COMBO_END};
 const uint16_t PROGMEM com_dot[] = {KC_COMMA, KC_DOT, COMBO_END};
 const uint16_t PROGMEM m_comm[] = {KC_M,KC_COMMA,  COMBO_END};
 const uint16_t PROGMEM n_m[] = {KC_N, KC_M,COMBO_END};
 combo_t key_combos[COMBO_COUNT] = {
-  [JK_ESC] = COMBO(jk_combo, KC_ESC),
+    [JK_ESC] = COMBO(jk_combo, KC_ESC),
-  [YU_COM] = COMBO(yu_combo, KC_CIRC),
+    [YU_COM] = COMBO(yu_combo, KC_CIRC),
-  [UI_COM] = COMBO(ui_combo, KC_ESC),
+    [UI_COM] = COMBO(ui_combo, KC_DLR),
-  [IO_COM] = COMBO(io_combo, KC_TILD)
+    [IO_COM] = COMBO(io_combo, KC_TILD),
    [QW_COM] = COMBO(qw_combo, KC_AT),
    [COM_SLS] = COMBO(com_sls, KC_QUES),
    [COM_DOT] = COMBO(com_dot, KC_QUES),
    [M_COMM] = COMBO(m_comm, KC_ESC),
    [N_M] = COMBO(n_m, KC_DLR),
 };
@@ -1,6 +1,10 @@
 #pragma once
 #if defined(COMBO_ENABLE)
-  #define COMBO_COUNT 4
+  #define COMBO_COUNT 9
-  #define COMBO_TERM  50
+  #define COMBO_TERM  40
 #endif // !COMBO_ENABLE
 // Timeout settings for leader key
 #undef  LEADER_TIMEOUT
 #define LEADER_TIMEOUT 350
 #define LEADER_PER_KEY_TIMING
@@ -1,373 +1,87 @@
 #include "danielo515.h"
 bool onMac = true;
 // Send control or GUI depending if we are on windows or mac
 bool CMD(uint16_t kc) {
  if(onMac){ tap_code16(LGUI(kc)); } else { tap_code16(LCTL(kc)); }
  return false;
 }
 //**************** Handle keys function *********************//
 bool altPressed = false;
 bool process_record_user(uint16_t keycode, keyrecord_t *record)
 {
  bool pressed = record->event.pressed;
  if(pressed){
    refresh_incremental_macros(keycode);
    if(process_incremental_macro(keycode)){
      return false;
    }
    if(is_macro(keycode)){
      return handle_macro(keycode);
    }
   switch (keycode) {
        case MAC_TGL:
        onMac = !onMac;
        onMac ? SEND_STRING("On mac") : SEND_STRING("Not on MAC");
        return false;
      }
  }
  switch (keycode)
  {
    case QWERTY:
        if (record->event.pressed) {
        #ifdef AUDIO_ENABLE
        PLAY_SONG(tone_qwerty);
        #endif
        layer_on(_QWERTY);
        }
        return false;
    case LOWER:
        if (record->event.pressed) {
        layer_on(_LOWER);
        update_tri_layer(_LOWER, _RAISE, _ADJUST);
        } else {
        layer_off(_LOWER);
        update_tri_layer(_LOWER, _RAISE, _ADJUST);
        }
        return false;
    case RAISE:
        if (record->event.pressed) {
        layer_on(_RAISE);
        update_tri_layer(_LOWER, _RAISE, _ADJUST);
        } else {
        layer_off(_RAISE);
        update_tri_layer(_LOWER, _RAISE, _ADJUST);
        }
        return false;
    case ADJUST:
    if (record->event.pressed) {
        layer_on(_ADJUST);
        } else {
        layer_off(_ADJUST);
        }
        return false;
 // == Macros START ===
  case ARROW:
    if (record->event.pressed) SEND_STRING("->");
    return false;
  case F_ARROW:
    if (record->event.pressed) SEND_STRING("=>");
    return false;
  case GREP:
    if (record->event.pressed) SEND_STRING(" | grep "); return false;
 // == Macros END ===
 // == Multi Os START ===
  case KC_HOME:// make the home behave the same on OSX
    if (record->event.pressed && onMac) {
        SEND_STRING(SS_LCTRL("a"));
        return false;
    }
  case KC_END:// make the end behave the same on OSX
    if (record->event.pressed && onMac) {
        tap_code16(C(KC_E));
        return false;
    }
  case AC_A:// Accent á
    if (record->event.pressed) SEND_STRING(SS_LALT("e") "a"); return false;
  case AC_E:// Accent é
    if (record->event.pressed) SEND_STRING(SS_LALT("e") "e"); return false;
  case AC_I:// Accent í
    if (record->event.pressed) SEND_STRING(SS_LALT("e") "i"); return false;
  case AC_O:// Accent ó
    if (record->event.pressed) SEND_STRING(SS_LALT("e") "o"); return false;
  case CUT: if (record->event.pressed) return CMD(KC_X);
  case COPY:
    if (record->event.pressed) {
     onMac ?  SEND_STRING(SS_LGUI("c")) : SEND_STRING(SS_LCTRL("c"));
    }
    return false;
  case PASTE:
    if (record->event.pressed) {
     onMac ?  SEND_STRING(SS_LGUI("v")) : SEND_STRING(SS_LCTRL("v"));
    }
    return false;
  case SAVE:
    if (record->event.pressed) {
     onMac ?  SEND_STRING(SS_LGUI("s")) : SEND_STRING(SS_LCTRL("s"));
    }
    return false;
  case UNDO:
    if (record->event.pressed) {
     onMac ?  SEND_STRING(SS_LGUI("z")) : SEND_STRING(SS_LCTRL("z"));
    }
    return false;
  case FIND:
    if (record->event.pressed) {
     onMac ?  SEND_STRING(SS_LGUI("f")) : SEND_STRING(SS_LCTRL("f"));
    }
    return false;
  case CHG_LAYOUT:
    if (record->event.pressed) {
     onMac ?  SEND_STRING(SS_LCTRL(" ")) : SEND_STRING(SS_LCTRL("f"));
    }
    return false;
 // == Multi Os END ===
 #ifdef RGBLIGHT_ENABLE
  case RGB_SLD:
    if (record->event.pressed) { rgblight_mode(1); }
    return false;
    break;
    //First time alt + tab, and alt stays sticky. Next press we just send tab. Any other key releases the alt
 #endif
  case ALT_TAB:
    if (record->event.pressed)
    {
      if (altPressed)
      {
        tap_code(KC_TAB);
      }
      else
      {
        altPressed = true;
        layer_on(7); // go to movement layer
        onMac ? register_code(KC_LGUI) : register_code(KC_LALT);
        tap_code(KC_TAB);
      }
    }
    return false;
  // avoid alt releasing if the key is of movement
  case KC_RIGHT ... KC_UP:
    if (altPressed)
    {
      return true; // yes QMK, do your stuff
    }
  }
  // Reset sticky alt tab
  if (altPressed)
  {
    onMac ?  unregister_code(KC_LGUI) : unregister_code(KC_LALT);
    altPressed = false;
    layer_off(7);
    return false;
  }
  return true;
 };
 //**************** LEADER *********************//
 #ifdef LEADER_ENABLE
 LEADER_EXTERNS();
-#ifdef RGBLIGHT_ENABLE
+#    ifdef RGBLIGHT_ENABLE
-void leader_start() {
+void leader_start() { rgblight_setrgb_range(5, 100, 199, 10, 15); };
  rgblight_setrgb_range(5, 100, 199, 10,15);
 };
-void leader_end(){
+void leader_end() { rgblight_setrgb_range(200, 200, 255, 10, 15); };
-  rgblight_setrgb_range(200, 200, 255, 10,15);
+#    endif
 };
 #endif
-void matrix_scan_user(void)
+void matrix_scan_user(void) {
-{
+    if (leading && leader_sequence_size > 0 && timer_elapsed(leader_time) > LEADER_TIMEOUT) {
-  if (leading && leader_sequence_size > 0 && timer_elapsed(leader_time) > LEADER_TIMEOUT)
+        leading = false;
-  {
+        SEQ_ONE_KEY(KC_T) { SEND_STRING("``" SS_TAP(X_LEFT)); }
-    leading = false;
+        // Triple ticks
-    SEQ_ONE_KEY(KC_T) {
+        SEQ_TWO_KEYS(KC_T, KC_T) { SEND_STRING("```" SS_TAP(X_ENTER) SS_TAP(X_ENTER) "```" SS_TAP(X_UP)); }
-      SEND_STRING("``" SS_TAP(X_LEFT));
+        // ==== International spanish accent vowels ====
-    }
+        SEQ_ONE_KEY(KC_A) { SEND_STRING(SS_LALT("e") "a"); }
-    // Triple ticks
+        SEQ_ONE_KEY(KC_E) { SEND_STRING(SS_LALT("e") "e"); }
-    SEQ_TWO_KEYS(KC_T, KC_T) {
+        SEQ_ONE_KEY(KC_I) { SEND_STRING(SS_LALT("e") "i"); }
-      SEND_STRING("```" SS_TAP(X_ENTER) SS_TAP(X_ENTER) "```" SS_TAP(X_UP));
+        SEQ_ONE_KEY(KC_O) { SEND_STRING(SS_LALT("e") "o"); }
-    }
+        SEQ_ONE_KEY(KC_U) { SEND_STRING(SS_LALT("e") "u"); }
-    // ==== International spanish accent vowels ====
+        SEQ_ONE_KEY(KC_N) { SEND_STRING(SS_LALT("n") "n"); }
-    SEQ_ONE_KEY(KC_A) {
+        // ==== MACROS ===
-      SEND_STRING(SS_LALT("e") "a");
+        SEQ_ONE_KEY(KC_G) { SEND_STRING(" | grep "); }
-    }
+        SEQ_ONE_KEY(KC_K) { onMac ? SEND_STRING(SS_LCTRL(" ")) : SEND_STRING(SS_LCTRL("f")); }
-    SEQ_ONE_KEY(KC_E) {
+        // vim delete all
-      SEND_STRING(SS_LALT("e") "e");
+        SEQ_TWO_KEYS(KC_D, KC_G) {
-    }
+            if (onMac) {
-    SEQ_ONE_KEY(KC_I) {
+                SEND_STRING(SS_LGUI("a") SS_TAP(X_D));
-      SEND_STRING(SS_LALT("e") "i");
+            } else {
-    }
+                SEND_STRING(SS_LCTRL("a") SS_TAP(X_D));
-    SEQ_ONE_KEY(KC_O) {
+            }
-      SEND_STRING(SS_LALT("e") "o");
+        }
-    }
+        // tripe delete!
-    SEQ_ONE_KEY(KC_U) {
+        SEQ_ONE_KEY(KC_BSPACE) { SEND_STRING(SS_TAP(X_BSPACE) SS_TAP(X_BSPACE) SS_TAP(X_BSPACE)); }
-      SEND_STRING(SS_LALT("e") "u");
+        SEQ_TWO_KEYS(KC_P, KC_G) { SEND_STRING("ps -ef | grep "); }
-    }
+        SEQ_TWO_KEYS(KC_J, KC_A) { SEND_STRING("() => {}" SS_TAP(X_LEFT) SS_TAP(X_LEFT) SS_TAP(X_LEFT) SS_TAP(X_LEFT) SS_TAP(X_LEFT) SS_TAP(X_LEFT) SS_TAP(X_LEFT)); }
-    SEQ_ONE_KEY(KC_N) { // ñ
+        // this is a pain to type
-      SEND_STRING(SS_LALT("n") "n");
+        SEQ_TWO_KEYS(KC_S, KC_S) { SEND_STRING("~/.ssh/ "); }
-    }
+        SEQ_TWO_KEYS(KC_F, KC_T) { SEND_STRING("feat():" SS_TAP(X_LEFT) SS_TAP(X_LEFT)); }
-    // ==== MACROS ===
+        // ### LAYER CHANGE
-    SEQ_ONE_KEY(KC_G) { // grep
+        SEQ_ONE_KEY(KC_1) { layer_on(1); }
-      SEND_STRING(" | grep ");
+        // control enter, because yes
-    }
+        SEQ_ONE_KEY(KC_H) { SEND_STRING(SS_DOWN(X_LCTRL) SS_TAP(X_ENTER) SS_UP(X_LCTRL)); }
-    SEQ_ONE_KEY(KC_K) {
+        // paste all
-        onMac ?  SEND_STRING(SS_LCTRL(" ")) : SEND_STRING(SS_LCTRL("f"));
+        SEQ_ONE_KEY(KC_P) {
-    }
+            if (onMac) {
-    SEQ_TWO_KEYS(KC_D, KC_G) { // vim delete all
+                SEND_STRING(SS_LGUI("a") SS_LGUI("v"));
-      if(onMac){
+            } else {
-        SEND_STRING(SS_LGUI("a") SS_TAP(X_D));
+                SEND_STRING(SS_LCTRL("a") SS_LCTRL("v"));
-      } else {
+            }
-        SEND_STRING(SS_LCTRL("a") SS_TAP(X_D));
+        }
-      }
+        SEQ_THREE_KEYS(KC_M, KC_A, KC_C) {
-    }
+            onMac = true;
-    SEQ_ONE_KEY(KC_BSPACE) { // tripe delete!
+#    ifdef RGBLIGHT_ENABLE
-      SEND_STRING(SS_TAP(X_BSPACE) SS_TAP(X_BSPACE) SS_TAP(X_BSPACE));
+            rgblight_setrgb(255, 255, 255);
-    }
+#    endif
-    SEQ_TWO_KEYS(KC_P, KC_G) {
+        }
-      SEND_STRING("ps -ef | grep ");
+        SEQ_THREE_KEYS(KC_W, KC_I, KC_N) {
-    }
+            onMac = false;
-    SEQ_TWO_KEYS(KC_J, KC_A) {
+#    ifdef RGBLIGHT_ENABLE
-      SEND_STRING("() => {}"SS_TAP(X_LEFT) SS_TAP(X_LEFT)SS_TAP(X_LEFT) SS_TAP(X_LEFT)SS_TAP(X_LEFT) SS_TAP(X_LEFT)SS_TAP(X_LEFT));
+            rgblight_setrgb(255, 255, 0);
-    }
+#    endif
-    SEQ_TWO_KEYS(KC_S, KC_S) {
+        }
-      SEND_STRING("~/.ssh/ "); // this is a pain to type
+        /*  Copy all */
-    }
+        SEQ_ONE_KEY(KC_Y) {
-    SEQ_TWO_KEYS(KC_F, KC_T) {
+            if (onMac) {
-      SEND_STRING("feat():" SS_TAP(X_LEFT) SS_TAP(X_LEFT));
+                SEND_STRING(SS_LGUI("a") SS_LGUI("c"));
-    }
+            } else {
-    // ### LAYER CHANGE
+                SEND_STRING(SS_LCTRL("a") SS_LCTRL("c"));
-    SEQ_ONE_KEY(KC_1) {
+            }
-      layer_on(1);
+        }
-    }
+        // emoji bar
-    SEQ_ONE_KEY(KC_H) { // control enter, because yes
+        SEQ_TWO_KEYS(KC_E, KC_E) { SEND_STRING(SS_DOWN(X_LGUI) SS_LCTRL(" ") SS_UP(X_LGUI)); }
      SEND_STRING(SS_DOWN(X_LCTRL) SS_TAP(X_ENTER) SS_UP(X_LCTRL));
    }
    // paste all
    SEQ_ONE_KEY(KC_P) {
      if(onMac){
        SEND_STRING(SS_LGUI("a") SS_LGUI("v"));
      } else {
        SEND_STRING(SS_LCTRL("a") SS_LCTRL("v"));
      }
    }
    SEQ_THREE_KEYS(KC_M, KC_A, KC_C) {
      onMac = true;
    #ifdef RGBLIGHT_ENABLE
      rgblight_setrgb(255, 255, 255);
    #endif
    }
    SEQ_THREE_KEYS(KC_W, KC_I, KC_N) {
      onMac = false;
    #ifdef RGBLIGHT_ENABLE
      rgblight_setrgb(255, 255, 0);
    #endif
    }
    /*  Copy all */
    SEQ_ONE_KEY(KC_Y) {
      if(onMac){
        SEND_STRING(SS_LGUI("a") SS_LGUI("c"));
      } else {
        SEND_STRING(SS_LCTRL("a") SS_LCTRL("c"));
      }
    }
    //emoji bar
    SEQ_TWO_KEYS(KC_E, KC_E) {
      SEND_STRING(SS_DOWN(X_LGUI) SS_LCTRL(" ") SS_UP(X_LGUI));
    }
-    SEQ_TWO_KEYS(KC_F, KC_F) {
+        SEQ_TWO_KEYS(KC_F, KC_F) { SEND_STRING("ps -ef | grep "); }
-      SEND_STRING("ps -ef | grep ");
+        SEQ_TWO_KEYS(KC_H, KC_T) { SEND_STRING("https://"); }
    }
    SEQ_TWO_KEYS(KC_H, KC_T) {
      SEND_STRING("https://");
    }
-    leader_end();
+        leader_end();
-  }
+    }
 }
-#endif // LEADER
+#endif  // LEADER
 // ======== INCREMENTAL MACROS STUFF =============
 #define MAX_INCREMENTAL_MACRO 20
 #define TAP_ROTATION_TIMEOUT 400
 uint16_t latest_kc = 0;
 uint16_t latest_rotation = 0;
 int key_count = 0;
 const char incremental_macros[][MAX_INCREMENTAL_MACRO] = { "String1"SS_TAP(X_HOME)"X-", "String2"SS_TAP(X_HOME) };
 bool process_incremental_macro (uint16_t kc) {
  if( kc < INC_MACROS_START || kc > INC_MACROS_END ){
    return false;
  }
  int macro_idx = (int) (kc - INC_MACROS_START) - 1;
  char tempstring[3] = {0};
  tempstring[0] = incremental_macros[macro_idx][key_count];
  // Special cases of SS_TAP SS_UP and SS_DOWN, they require two characters so get both once and skip on next iteration
  if( tempstring[0] == '\1' || tempstring[0] == '\2' || tempstring[0] == '\3'){
    tempstring[1] = incremental_macros[macro_idx][++key_count];
  }
  if( tempstring[0] == '\0'){
    key_count = 0;
  }
  send_string(tempstring);
  return true;
 };
 void refresh_incremental_macros (uint16_t kc) {
  if (kc == latest_kc)
    {
      if ( (timer_elapsed(latest_rotation) > TAP_ROTATION_TIMEOUT) || (key_count >= MAX_INCREMENTAL_MACRO) ) key_count = 0;
      else key_count++;
    } else {
      key_count = 0;
      latest_kc = kc;
    }
  latest_rotation = timer_read();
 }
 // ======== VISUAL STUDIO CODE SHORTCUTS STUFF
 bool is_macro (uint16_t kc){
  return kc > MACRO_START && kc < MACRO_END;
 };
 bool command_shift_p (bool isMac) {
   isMac
   ? SEND_STRING(SS_DOWN(X_LSHIFT)SS_LGUI("p")SS_UP(X_LSHIFT))
   : SEND_STRING(SS_DOWN(X_LSHIFT)SS_LCTRL("p")SS_UP(X_LSHIFT));
   return false;
 };
 bool VSCommand(bool isMac, char *cmd)
 {
  command_shift_p (isMac);
  send_string(cmd);
  SEND_STRING(SS_TAP(X_ENTER));
  return false;
 };
 bool handle_macro(uint16_t kc)
 {
  switch (kc)
  {
    case T_TERM: return VSCommand(onMac, "toit");
    case FIX_ALL: return VSCommand(onMac, "faap");
    case BLK_CMNT: return VSCommand(onMac, "tbc");
    case LN_CMNT: return VSCommand(onMac, "tlic");
    case CMD_S_P: return command_shift_p(onMac);
    case TRI_TICKS: SEND_STRING("[[[ "); break;
  }
  return false;
 };
@@ -1,104 +1,6 @@
 #pragma once
 #include "quantum.h"
-
+#include "process_records.h"
 bool handle_macro(uint16_t kc);
 bool is_macro (uint16_t kc);
 bool process_incremental_macro (uint16_t);
 void refresh_incremental_macros (uint16_t);
 //**************** KEYCODES *********************//
 enum custom_keycodes
 {
  PLACEHOLDER = SAFE_RANGE, // can always be here
  EPRM,
  RGB_SLD,
  ALT_TAB,
  // Macros
  ARROW,
  F_ARROW,
  QWERTY,
  GREP,
  // Accented characters
  AC_A,
  AC_E,
  AC_I,
  AC_O,
  // Custom multi-os key-codes
  CUT,
  COPY,
  PASTE,
  SAVE,
  UNDO,
  CHG_LAYOUT,
  FIND,
  // OTHER OLD STUFF
  LOWER,
  RAISE,
  ADJUST,
  MAC_TGL,
  MACRO_START,  // START OF VSC DECLARATIONS
  T_TERM,
  FIX_ALL,
  BLK_CMNT,
  LN_CMNT,
  CMD_S_P,
  TRI_TICKS,
  MACRO_END,  // END OF VSC DECLARATIONS
  INC_MACROS_START,
  INC_MACROS_END,
 };
 enum layers {
  _QWERTY,
  _LOWER,
  _RAISE,
  _F,
  _D,
  _A,
  _S,
  _J,
  _K,
  _MACROS,
  _ADJUST,
  _SAFE_LAYER
 };
 // Function letters
 #define FN_F LT(_F,KC_F)
 #define FN_D LT(_D,KC_D)
 #define FN_S LT(_S,KC_S)
 #define FN_A LT(_A,KC_A)
 #define FN_K LT(_K,KC_K)
 #define FN_J LT(_J,KC_J)
 #define KC_FN_D FN_D
 #define KC_FN_S FN_S
 #define KC_FN_F FN_F
 #define KC_MACROS OSL(_MACROS)
 #define KC_E_COLN LSFT(KC_DOT)
 #define KC_E_EQL ES_EQL
 #define KC_GUI OSM(MOD_RGUI)
 #define KC_R_NUB S(KC_NUBS)
 #define KC_E_LT KC_NUBS
 #define KC_E_GT S(KC_NUBS)
 #define KC_E_TILD ES_TILD
 #define KC_E_MINS ES_MINS
 #define KC_S_SPC SFT_T(KC_SPC)  // Tap for Space, hold for Shift
 #define KC_E_OVRR ES_OVRR
 #define KC_E_APOS ES_APOS
 #define KC_E_IEXL ES_IEXL
 // Short hand for complex key combinations
 # define WIN_LEFT_HALF LALT(LGUI(KC_LEFT))
 # define WIN_RIGHT_HALF LALT(LGUI(KC_RIGHT))
 # define WIN_TO_LEFT LALT(LSFT( LGUI(KC_LEFT) ))
 # define WIN_TO_RIGHT LALT(LSFT( LGUI(KC_RIGHT) ))
 // Ready to use Tap dance definitions, just put them on your layout
 #ifdef TAP_DANCE_ENABLE
    #include "tap_dance.h"
@@ -0,0 +1,167 @@
 #include "process_records.h"
 #include "alt_tab.h"
 extern bool onMac;
 // ======== INCREMENTAL MACROS STUFF =============
 #define MAX_INCREMENTAL_MACRO 20
 #define TAP_ROTATION_TIMEOUT 400
 uint16_t latest_kc = 0;
 uint16_t latest_rotation = 0;
 int key_count = 0;
 const char incremental_macros[][MAX_INCREMENTAL_MACRO] = { "String1"SS_TAP(X_HOME)"X-", "String2"SS_TAP(X_HOME) };
 bool process_incremental_macro(uint16_t kc) {
    if (kc < INC_MACROS_START || kc > INC_MACROS_END) {
        return false;
    }
    int  macro_idx     = (int)(kc - INC_MACROS_START) - 1;
    char tempstring[3] = {0};
    tempstring[0]      = incremental_macros[macro_idx][key_count];
    // Special cases of SS_TAP SS_UP and SS_DOWN, they require two characters so get both once and skip on next iteration
    if (tempstring[0] == '\1' || tempstring[0] == '\2' || tempstring[0] == '\3') {
        tempstring[1] = incremental_macros[macro_idx][++key_count];
    }
    if (tempstring[0] == '\0') {
        key_count = 0;
    }
    send_string(tempstring);
    return true;
 };
 void refresh_incremental_macros(uint16_t kc) {
    if (kc == latest_kc) {
        if ((timer_elapsed(latest_rotation) > TAP_ROTATION_TIMEOUT) || (key_count >= MAX_INCREMENTAL_MACRO))
            key_count = 0;
        else
            key_count++;
    } else {
        key_count = 0;
        latest_kc = kc;
    }
    latest_rotation = timer_read();
 }
 // Send control or GUI depending if we are on windows or mac
 bool CMD(uint16_t kc) {
    if(onMac){ tap_code16(LGUI(kc)); } else { tap_code16(LCTL(kc)); }
    return false;
 }
 bool process_record_user(uint16_t keycode, keyrecord_t *record) {
    bool pressed = record->event.pressed;
    if(pressed){
        refresh_incremental_macros(keycode);
        if(process_incremental_macro(keycode)){
            return false;
        }
        switch (keycode) {
            case MAC_TGL:
            onMac = !onMac;
            onMac ? SEND_STRING("On mac") : SEND_STRING("Not on MAC");
            return false;
        }
    }
    switch (keycode) {
    case QWERTY:
        if (record->event.pressed) {
        #ifdef AUDIO_ENABLE
        PLAY_SONG(tone_qwerty);
        #endif
        layer_on(_QWERTY);
        }
        return false;
    case LOWER:
        if (record->event.pressed) {
        layer_on(_LOWER);
        } else {
        layer_off(_LOWER);
        }
        return false;
    case RAISE:
        if (record->event.pressed) {
        layer_on(_RAISE);
        } else {
        layer_off(_RAISE);
        }
        return false;
    case ADJUST:
    if (record->event.pressed) {
        layer_on(_ADJUST);
        } else {
        layer_off(_ADJUST);
        }
        return false;
 // == Macros START ===
    case IARROW: if (record->event.pressed) SEND_STRING("<-"); return false;
    case ARROW: if (record->event.pressed) SEND_STRING("->"); return false;
    case F_ARROW: if (record->event.pressed) SEND_STRING("=>"); return false;
    case GREP: if (record->event.pressed) SEND_STRING(" | grep "); return false;
    case CLN_EQ: if (record->event.pressed) SEND_STRING(":="); return false;
 // == Macros END ===
 // == Multi Os START ===
  case KC_HOME:// make the home behave the same on OSX
    if (record->event.pressed && onMac) {
        SEND_STRING(SS_LCTRL("a"));
        return false;
    }
  case KC_END:// make the end behave the same on OSX
    if (record->event.pressed && onMac) {
        tap_code16(C(KC_E));
        return false;
    }
  case AC_A:// Accent á
    if (record->event.pressed) SEND_STRING(SS_LALT("e") "a"); return false;
  case AC_E:// Accent é
    if (record->event.pressed) SEND_STRING(SS_LALT("e") "e"); return false;
  case AC_I:// Accent í
    if (record->event.pressed) SEND_STRING(SS_LALT("e") "i"); return false;
  case AC_O:// Accent ó
    if (record->event.pressed) SEND_STRING(SS_LALT("e") "o"); return false;
  case CUT: if (record->event.pressed) return CMD(KC_X);
  case COPY:
    if (record->event.pressed) {
     onMac ?  SEND_STRING(SS_LGUI("c")) : SEND_STRING(SS_LCTRL("c"));
    }
    return false;
  case PASTE:
    if (record->event.pressed) {
     onMac ?  SEND_STRING(SS_LGUI("v")) : SEND_STRING(SS_LCTRL("v"));
    }
    return false;
  case SAVE:
    if (record->event.pressed) {
     onMac ?  SEND_STRING(SS_LGUI("s")) : SEND_STRING(SS_LCTRL("s"));
    }
    return false;
  case UNDO:
    if (record->event.pressed) {
     onMac ?  SEND_STRING(SS_LGUI("z")) : SEND_STRING(SS_LCTRL("z"));
    }
    return false;
  case FIND:
    if (record->event.pressed) {
     onMac ?  SEND_STRING(SS_LGUI("f")) : SEND_STRING(SS_LCTRL("f"));
    }
    return false;
  case CHG_LAYOUT:
    if (record->event.pressed) {
     onMac ?  SEND_STRING(SS_LCTRL(" ")) : SEND_STRING(SS_LCTRL("f"));
    }
    return false;
 // == Multi Os END ===
 #ifdef RGBLIGHT_ENABLE
  case RGB_SLD:
    if (record->event.pressed) { rgblight_mode(1); }
    return false;
    break;
    //First time alt + tab, and alt stays sticky. Next press we just send tab. Any other key releases the alt
 #endif
  }
 // =============== ALT_TAB single key handling
  return process_alt_tab(keycode, record);
 };
@@ -0,0 +1,104 @@
 #pragma once
 #include "quantum.h"
 enum custom_keycodes
 {
    EPRM = SAFE_RANGE, 
    RGB_SLD,
    ALT_TAB,
    QWERTY,
    SYM,
    NAV,
    ADJUST,
 // Macros
    ARROW,
    IARROW,
    CLN_EQ,
    F_ARROW,
    GREP,
 // Accented characters
    AC_A,
    AC_E,
    AC_I,
    AC_O,
 // Custom multi-os key-codes
    CUT,
    COPY,
    PASTE,
    SAVE,
    UNDO,
    CHG_LAYOUT,
    FIND,
 // OTHER OLD STUFF
    LOWER,
    RAISE,
    MAC_TGL,
    INC_MACROS_START,
    INC_MACROS_END,
 };
 //**************** KEYCODES *********************//
 enum layers {
    _QWERTY,
    _SYMB,
    _NAV,
    _ADJUST,
    _F,
    _D,
    _S,
    _A,
    _J,
    _K,
    // iris specific - TBD
    _LOWER,
    _RAISE,
    _MACROS,
    _SAFE_LAYER
 };
 //===== Function letters
 # define FN_F LT(_F,KC_F)
 # define FN_D LT(_D,KC_D)
 # define FN_S LT(_S,KC_S)
 # define FN_A LT(_A,KC_A)
 # define FN_K LT(_K,KC_K)
 # define FN_J LT(_J,KC_J)
 # define KC_FN_D FN_D
 # define KC_FN_S FN_S
 # define KC_FN_F FN_F
 # define KC_MACROS OSL(_MACROS)
 # define KC_E_COLN LSFT(KC_DOT)
 # define KC_E_EQL ES_EQL
 # define KC_GUI OSM(MOD_RGUI)
 # define KC_R_NUB S(KC_NUBS)
 # define KC_E_LT KC_NUBS
 # define KC_E_GT S(KC_NUBS)
 # define KC_E_TILD ES_TILD
 # define KC_E_MINS ES_MINS
 # define KC_E_OVRR ES_OVRR
 # define KC_E_APOS ES_APOS
 # define KC_E_IEXL ES_IEXL
 //==========  Short hand for complex key combinations
 # define WIN_LEFT_HALF LALT(LGUI(KC_LEFT))
 # define WIN_RIGHT_HALF LALT(LGUI(KC_RIGHT))
 # define WIN_TO_LEFT LALT(LSFT( LGUI(KC_LEFT) ))
 # define WIN_TO_RIGHT LALT(LSFT( LGUI(KC_RIGHT) ))
 # define ALL_WIN LCTL(KC_DOWN)
 # define EXPOSE LGUI(KC_DOWN)
 // ========== Modifiers!!
 # define SHIFT OSM(MOD_LSFT)
 //=============== tap for key hold for mod
 # define HYPR_H HYPR_T(KC_H)
 # define CTL_K RCTL_T(KC_K)
 # define ALT_J ALT_T(KC_J)
 # define SFT_MINS LSFT_T(KC_MINS) // tap - hold shift
 # define CMD_QUOT GUI_T(KC_QUOTE) // tap ' hold cmd
 //=============== Movement modified
 # define CTL_LEFT LCTL(KC_LEFT)
 # define CTL_RIGHT LCTL(KC_RIGHT)
 # define SFT_LEFT LSFT(KC_LEFT)
 # define SFT_RIGHT LSFT(KC_RIGHT)
@@ -1,4 +1,6 @@
-SRC += danielo515.c
+SRC +=  danielo515.c \
        alt_tab.c \
 		process_records.c
 ifeq ($(strip $(COMBO_ENABLE)), yes)
    SRC += combo.c
@@ -57,6 +57,7 @@ void dance_cut (qk_tap_dance_state_t *state, void *user_data);
 void dance_copy (qk_tap_dance_state_t *state, void *user_data);
 void dance_paste (qk_tap_dance_state_t *state, void *user_data);
 // Ready to use Tap dance definitions, just put them on your layout
 #define TD_COPY TD(_TD_COPY)
 #define TD_CUT TD(_TD_CUT)
 #define KC_TD_COPY TD(_TD_COPY) // Declarations for macros that add KC_
Author	SHA1	Message	Date
Joel Challis	cd9a430d66	Force "blank" issue template to end of list (#8387 ) * force ascii sort of issue templates to add blank to end of list	2020-03-12 01:27:33 -07:00
Nick Brassel Ryan skullY	1b267d4840	Fix darkmode (#8393 ) * Rearrange the custom CSS a bit. * fix css name * add missing quote * Fix up dark mode rendering. (#8392) * Fix up dark mode rendering. * Update index.html * Fix up code blocks * Fix code in page toc * Update docs/qmk_custom_dark.css Co-Authored-By: Ryan <[email protected]> Co-authored-by: skullY <[email protected]> Co-authored-by: Ryan <[email protected]>	2020-03-12 18:17:47 +11:00
Daniel Rodríguez RiveroandDrashna Jaelre	32d03eef90	Danielo515/redox (#8232 ) * feat(build): added script for compiling with docker easily * chore: bring my own build with docker to master * chore: delete a file that does not make sense anymore * feat: first redox for danielo * chore: basic compatibility between redox and my space * refactor: removed some old stuff * feat: added go coding symbols * feat: name control_k and alt_j * chore: reduce combo term * feat: improved first layer of redox * feat: add configurations to the redox * feat: make alt tab more portable * feat: small improvements to redox layout * feat: added leader * refactor: move leader defs to my userspace config * chore: movement modified * feat: more predefined keys and a a new combo * feat: redox alt tab functionality * refactor: move alt_tab processing to a separate file * refactor: early return * refactor: move process record to a separate file * format leader function * chore: backspace on digits layer * feat: add extra combo * feat: added more combos * implement guard proposed by @drashna Co-Authored-By: Drashna Jaelre <[email protected]> * chore: include @drashna placeholder suggestion Co-Authored-By: Drashna Jaelre <[email protected]> Co-authored-by: Drashna Jaelre <[email protected]>	2020-03-12 02:50:19 +00:00
Nick BrasselandJoel Challis	f2f2afe13b	Add support for STM32L0/L1 onboard EEPROM. (#8002 ) * Add support for STM32L0/L1 onboard EEPROM. * Update docs/eeprom_driver.md Co-Authored-By: Joel Challis <[email protected]> Co-authored-by: Joel Challis <[email protected]>	2020-03-12 12:59:55 +11:00
Erkki Halinen	3a3ea03b6e	[Keymap] Add Erkhal keymap to PRKL30 (#8355 ) * Add Erkhal keymap * Fix comment of layer * Update keyboards/handwired/prkl30/keymaps/erkhal/readme.md	2020-03-11 16:06:47 -07:00
Takeshi ISHII	f3afc716cb	fix keyboards/mxss/rgblight.h (#8388 ) Since #7773 caused a build error for `mxss:default`, I made similar changes to 'keyboards/mxss/rgblight.h' as #7773 did to 'quantum/rgblight.h'. This commit does not change the build result. Testing script ```shell # build on versions earlier than PR #7773 git checkout 0.8.24 echo master > /tmp/master_md5.txt make mxss:default:clean make mxss:default md5 mxss_default.hex >> /tmp/master_md5.txt # build on this commit git checkout fix-keyboards-mxss-rgblight.h echo fix-keyboards-mxss-rgblight.h > /tmp/branch_md5.txt make mxss:default:clean make mxss:default md5 mxss_default.hex >> /tmp/branch_md5.txt diff -u /tmp/master_md5.txt /tmp/branch_md5.txt ``` Test result: ``` --- /tmp/master_md5.txt 2020-03-12 05:51:39.000000000 +0900 +++ /tmp/branch_md5.txt 2020-03-12 05:51:49.000000000 +0900 @@ -1,2 +1,2 @@ -master +fix-keyboards-mxss-rgblight.h MD5 (mxss_default.hex) = 3034b2504d0c7fc6bd8bf1dffb6b8486 ```	2020-03-11 21:23:31 +00:00
Alexander Tulloh	e72562fe6f	[Keyboard] Oddball keyboard (#8352 ) * Initial commit of oddball keyboard * Update oddball project url * Update pointer functions to only run on master side * Add unique product version * Capitalise product name * Convert oddball keymap layer flags to enum * Remove commented keyboard boilerplate code * Remove unused keymap config * Fix incorrect layout in info.json * Add markdown link text in readme	2020-03-11 00:56:05 -07:00
QMK Bot	2b66acf04a	format code according to conventions [skip ci]	2020-03-11 05:11:02 +00:00
Drew Mills	5ac6fe1888	Add ADC support for STM32F3 and STM32F0 devices (#7681 ) * Add ADC support for STM32F3 and STM32F0 devices * Add section about configration options available to the ARM ADC implementation * Fix STM32 typo	2020-03-11 15:38:39 +11:00
ZambumonandJames Young	979ac0d8da	Add VIA support to Tokyo60. (#8362 ) * VIA_ENABLE Tokyo60 PCB * Update config.h * Apply suggestions from code review Co-Authored-By: James Young <[email protected]> Co-authored-by: James Young <[email protected]>	2020-03-11 00:44:20 +00:00
elmo-space	7a89b51018	fix kira80 matrix mapping and add more preset layouts (#8361 ) * fix kira80 matrix mapping * add more preset keymaps * remove uselesss rgb mod keys	2020-03-10 15:10:14 -07:00
skullydazed	2a05d433c9	Rename qmk json-keymap to qmk json2c (#8372 )	2020-03-10 13:51:19 -07:00
QMK Bot	1aa40dde46	format code according to conventions [skip ci]	2020-03-10 20:24:13 +00:00
Nathan Gray	2ffb08843b	Feature: RGBLight layers (#7768 ) * New feature: RGBLIGHT_LAYERS This feature allows users to define multiple independent layers of lighting that can be toggled on and off individually, making it easy to use your RGB lighting to indicate things like active keyboard layer & modifier state. * Demonstrate built in functions for layer state checking Also link the video in the docs. * Follow existing pattern for setting rgblight_status flags * Eliminate rgblight_is_static_mode since it's not needed Just check to see if the timer is enabled directly.	2020-03-10 12:50:01 -07:00
Wilba	2a8ccafe6e	Refactor Equinox PCB revisions (#8266 ) * Refactor Equinox PCB revisions * typo	2020-03-10 11:34:19 -07:00
Alvin See	1757960b7b	Replace tab indentation with spaces in is0 default keymap. (#8368 )	2020-03-10 20:30:34 +11:00
		`@@ -0,0 +1 @@`
							`# Dummy rules.mk, rev0 uses parent rules.mk as is`
		`@@ -0,0 +1 @@`
							`# Dummy rules.mk, rev1 uses parent rules.mk as is`
		`@@ -1 +1 @@`
			`# The default keymap for kira80`				`# The default keymap for Kira 80`
		`@@ -0,0 +1,2 @@`
							`# Danielo keymap for Redox Wireless`
							Most of the custom functionality is on my user-space `users/danielo515`