my_crkbd_firmware/keymaps/default/keymap.c

#include QMK_KEYBOARD_H
#if __has_include("keymap.h")
#    include "keymap.h"
#endif

// --- tap dance definitions ---
// taken from https://docs.qmk.fm/features/tap_dance

typedef enum {
    TD_NONE,
    TD_UNKNOWN,
    TD_SINGLE_TAP,
    TD_SINGLE_HOLD,
    TD_DOUBLE_TAP,
    TD_DOUBLE_HOLD,
    TD_DOUBLE_SINGLE_TAP, // Send two single taps
    TD_TRIPLE_TAP,
    TD_TRIPLE_HOLD
} td_state_t;

typedef struct {
    bool is_press_action;
    td_state_t state;
} td_tap_t;

// Tap dance enums
// enum {
//     // X_RMAIN,
//     // X_CHECK
// };

td_state_t cur_dance(tap_dance_state_t *state);

// For the x tap dance. Put it here so it can be used in any keymap
void x_finished(tap_dance_state_t *state, void *user_data);
void x_reset(tap_dance_state_t *state, void *user_data);

// --- keymap ---

/* THIS FILE WAS GENERATED!
 *
 * This file was generated by qmk json2c. You may or may not want to
 * edit it directly.
 */

const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
    /*DEFAULT WITH TAP DANCES*/
    [0] = LAYOUT_split_3x6_3(KC_NO/*SH_TOGG*//*TD(0)*/, KC_NO/*TD(1)*/, TD(2), TD(3), TD(4), KC_NO/*TD(5)*/, /**/ KC_NO/*TD(6)*/, TD(7), TD(8), TD(9), KC_NO/*TD(10)*/, KC_NO/*SH_TOGG*//*TD(11)*/,
                             LCTL(KC_LGUI)/*QK_AREP*//*TD(12)*/, KC_A/*TD(13)*/, TD(14), TD(15), TD(16), TD(17), /**/ TD(18),  TD(19), TD(20), TD(21), KC_SCLN/*TD(22)*/, LCTL(KC_APP)/*QK_REP*//*TD(23)*/,
                             KC_NO/*TD(24)*/, KC_Z/*TD(25)*/, KC_X/*TD(26)*/, TD(27), TD(28), TD(29), /**/ TD(30),  TD(31), TD(32), TD(33), KC_Q/*TD(34)*/, KC_NO/*TD(35)*/,
                             /**/ LGUI_T(KC_TAB), TT(4), LSFT_T(KC_SPC), /**/ LCTL_T(KC_ENT), TT(6), LT(5,KC_DEL) /**/),

    /*DEFAULT*/
    [1] = LAYOUT_split_3x6_3(
                             SH_TOGG, KC_NO, KC_W, KC_E, KC_R, KC_NO, /**/ KC_NO, KC_U, KC_I, KC_O, KC_NO, SH_TOGG,
                             KC_GRV, KC_A, KC_S, KC_D, KC_F, KC_G, /**/ KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT,
                             KC_NO, KC_Z, KC_X, KC_C, KC_V, KC_B, /**/ KC_N, KC_M, KC_T, KC_Y, KC_Q, KC_NO,
                             /**/ LGUI_T(KC_TAB), TT(4), LSFT_T(KC_SPC), /**/ LCTL_T(KC_ENT), TT(6), LT(5,KC_DEL) /**/),

    /*QWERTY*/
    [2] = LAYOUT_split_3x6_3(
                             TG(3), KC_NO, KC_W, KC_F, KC_P, KC_TRNS, /**/ KC_TRNS, KC_L, KC_U, KC_Y, KC_NO, KC_NO,
                              KC_TRNS, KC_A, KC_R, KC_S, KC_T, KC_D, /**/ KC_H, KC_N, KC_E, KC_I, KC_O, KC_TRNS,
                              TG(2), KC_Z, KC_X, KC_C, KC_V, KC_B, /**/ KC_K, KC_M, KC_G, KC_J, KC_Q, KC_NO,
                              /**/ KC_TRNS, KC_TRNS, KC_TRNS, /**/ KC_TRNS, KC_TRNS, KC_TRNS /**/),

    /*RUSSIAN*/
    [3] = LAYOUT_split_3x6_3(
                             TG(3), KC_NO, KC_SCLN, KC_A, KC_G, KC_TRNS, /**/ KC_TRNS, KC_K, KC_E, KC_S, KC_DOT, KC_NO,
                             KC_TRNS, KC_F, KC_H, KC_C, KC_N, KC_L, /**/ KC_X, KC_Y, KC_T, KC_B, KC_J, KC_TRNS,
                             KC_NO, KC_P, KC_LBRC, KC_C, KC_D, KC_COMM, /**/ KC_R, KC_V, KC_U, KC_Q, KC_Z, KC_NO,
                             /**/ KC_TRNS, KC_TRNS, KC_TRNS, /**/ KC_TRNS, KC_TRNS, KC_TRNS /**/),

    /*NUMBERS*/
    [4] = LAYOUT_split_3x6_3(
                             KC_NO, OSM(MOD_LSFT), KC_2, KC_3, KC_4, KC_TRNS, /**/ KC_TRNS, KC_7, KC_8, KC_9, KC_DEL, KC_NO,
                             OSM(MOD_LALT), KC_HOME, KC_PGDN, KC_PGUP, KC_END, KC_1, /**/ KC_0, KC_LEFT, KC_DOWN, KC_UP, KC_RGHT, KC_PSCR,
                             KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_5, /**/ KC_6, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12,
                             /**/ KC_NO, KC_TRNS, KC_TRNS, /**/ KC_BSPC, KC_ESC, MO(7) /**/),

    /*SYMBOLS*/
    [5] = LAYOUT_split_3x6_3(
                             KC_NO, KC_NO, LSFT(KC_COMM), LSFT(KC_DOT), KC_DLR, KC_NO, /**/ KC_NO, KC_BSLS, KC_AMPR, KC_NO, KC_NO, KC_NO,
                             KC_NO, KC_ASTR, KC_COMM/*KC_LPRN*/, KC_DOT/*KC_RPRN*/, KC_MINS, KC_SLSH, /**/ KC_EXLM, KC_EQL, KC_LBRC, KC_RBRC, KC_P, RALT(KC_QUOT),
                             KC_NO, KC_NO, KC_NO, KC_CIRC, LALT(KC_LEFT), LALT(KC_RGHT), /**/ LSFT(KC_LEFT), LSFT(KC_RGHT), KC_AT, RALT(KC_QUOT), KC_NO, KC_NO,
                             /**/ KC_NO, MO(7), KC_DEL, /**/ KC_TRNS, KC_NO, KC_TRNS /**/),

    /*MOUSE*/
    [6] = LAYOUT_split_3x6_3(
                             KC_NO, KC_MPRV, KC_VOLD, KC_VOLU, KC_MNXT, KC_NO, /**/ KC_NO,  LCTL(KC_W), LALT(KC_C), KC_NO, KC_NO, MS_ACL0,
                             KC_MPLY, MS_LEFT, MS_DOWN, MS_UP, MS_RGHT, LALT(KC_SPC), /**/ LALT(KC_TAB), LCA(KC_LEFT), MS_WHLD, MS_WHLU, LCA(KC_RGHT), MS_ACL1,
                             KC_NO, LSFT(KC_LALT), MS_WHLD, MS_WHLU, LALT(KC_LEFT), LALT(KC_RGHT), /**/ LSFT(KC_LEFT), LSFT(KC_RGHT), KC_NO, KC_NO, KC_NO, MS_ACL2,
                             /**/ MS_BTN3, MS_BTN2, MS_BTN1, /**/ KC_TRNS, KC_TRNS, KC_NO /**/ ),

    /*ADJUST*/
    [7] = LAYOUT_split_3x6_3(
                             KC_NO, KC_MPRV, KC_VOLD, KC_VOLU, KC_MNXT, KC_NO, /**/ KC_NO, KC_MUTE, KC_BRID, KC_BRIU, KC_NO, KC_NO,
                             KC_MPLY, LALT(KC_C), KC_NO, LSFT(KC_LALT), LALT(KC_TAB), LALT(KC_SPC), /**/ KC_NO, LSFT(KC_LEFT), LSFT(KC_DOWN), LSFT(KC_UP), LSFT(KC_RGHT), KC_NO,
                             TG(2), KC_NO, KC_NO, KC_NO, LCA(KC_LEFT), LCA(KC_RGHT), /**/ KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, TG(1),
                             /**/ KC_NO, KC_TRNS, KC_NO, /**/ KC_NO, KC_TRNS, KC_NO /**/),

    // /*TAP DANCES*/
    // [7] = LAYOUT_split_3x6_3(TD(0), TD(1), TD(2), TD(3), TD(4), TD(5), /**/ TD(6),  TD(7), TD(8), TD(9), TD(10), TD(11),
    //                          TD(12), TD(13), TD(14), TD(15), TD(16), TD(17), /**/ TD(18),  TD(19), TD(20), TD(21), TD(22), TD(23),
    //                          TD(24), TD(25), TD(26), TD(27), TD(28), TD(29), /**/ TD(30),  TD(31), TD(32), TD(33), TD(34), TD(35),
    //                          /**/ KC_TRNS, KC_TRNS, KC_TRNS, /**/ KC_TRNS, KC_TRNS, KC_TRNS /**/ )
};



#ifdef OTHER_KEYMAP_C
#    include OTHER_KEYMAP_C
#endif // OTHER_KEYMAP_C

// --- custom auto shift ---

bool get_custom_auto_shifted_key(uint16_t keycode, keyrecord_t *record) {
    switch(keycode) {
        case KC_LPRN:
        case KC_RPRN:
        case KC_COMM:
        case KC_DOT:
        case KC_ASTR:
        case KC_EXLM:
            return true;
        default:
            return false;
    }
}

void autoshift_press_user(uint16_t keycode, bool shifted, keyrecord_t *record) {
    switch(keycode) {
        case KC_LPRN:
            register_code16((!shifted) ? KC_LPRN : KC_COMM);
            break;
        case KC_RPRN:
            register_code16((!shifted) ? KC_RPRN : KC_DOT);
            break;
        case KC_COMM:
            register_code16((!shifted) ? KC_COMM : KC_LPRN);
            break;
        case KC_DOT:
            register_code16((!shifted) ? KC_DOT : KC_RPRN);
            break;
        case KC_ASTR:
            register_code16((!shifted) ? KC_ASTR : KC_PERC);
            break;
        case KC_EXLM:
            register_code16((!shifted) ? KC_EXLM : KC_HASH);
            break;
        default:
            if (shifted) {
                add_weak_mods(MOD_BIT(KC_LSFT));
            }
            // & 0xFF gets the Tap key for Tap Holds, required when using Retro Shift
            register_code16((IS_RETRO(keycode)) ? keycode & 0xFF : keycode);
    }
}

void autoshift_release_user(uint16_t keycode, bool shifted, keyrecord_t *record) {
    switch(keycode) {
        case KC_LPRN:
            unregister_code16((!shifted) ? KC_LPRN : KC_COMM);
            break;
        case KC_RPRN:
            unregister_code16((!shifted) ? KC_RPRN : KC_DOT);
            break;
        case KC_COMM:
            unregister_code16((!shifted) ? KC_COMM : KC_LPRN);
            break;
        case KC_DOT:
            unregister_code16((!shifted) ? KC_DOT : KC_RPRN);
            break;
        case KC_ASTR:
            unregister_code16((!shifted) ? KC_ASTR : KC_PERC);
            break;
        case KC_EXLM:
            unregister_code16((!shifted) ? KC_EXLM : KC_HASH);
            break;
        default:
            // & 0xFF gets the Tap key for Tap Holds, required when using Retro Shift
            // The IS_RETRO check isn't really necessary here, always using
            // keycode & 0xFF would be fine.
            unregister_code16((IS_RETRO(keycode)) ? keycode & 0xFF : keycode);
    }
}

// --- key overrides ---

const key_override_t bspc_key_override = ko_make_basic(MOD_MASK_SHIFT, KC_BSPC, KC_DEL);

// This globally defines all key overrides to be used
const key_override_t *key_overrides[] = {
    &bspc_key_override,
};

// --- tap dance ---
// taken from https://docs.qmk.fm/features/tap_dance

/* Return an integer that corresponds to what kind of tap dance should be executed.
 *
 * How to figure out tap dance state: interrupted and pressed.
 *
 * Interrupted: If the state of a dance is "interrupted", that means that another key has been hit
 *  under the tapping term. This is typically indicative that you are trying to "tap" the key.
 *
 * Pressed: Whether or not the key is still being pressed. If this value is true, that means the tapping term
 *  has ended, but the key is still being pressed down. This generally means the key is being "held".
 *
 * One thing that is currently not possible with qmk software in regards to tap dance is to mimic the "permissive hold"
 *  feature. In general, advanced tap dances do not work well if they are used with commonly typed letters.
 *  For example "A". Tap dances are best used on non-letter keys that are not hit while typing letters.
 *
 * Good places to put an advanced tap dance:
 *  z,q,x,j,k,v,b, any function key, home/end, comma, semi-colon
 *
 * Criteria for "good placement" of a tap dance key:
 *  Not a key that is hit frequently in a sentence
 *  Not a key that is used frequently to double tap, for example 'tab' is often double tapped in a terminal, or
 *    in a web form. So 'tab' would be a poor choice for a tap dance.
 *  Letters used in common words as a double. For example 'p' in 'pepper'. If a tap dance function existed on the
 *    letter 'p', the word 'pepper' would be quite frustrating to type.
 *
 * For the third point, there does exist the 'TD_DOUBLE_SINGLE_TAP', however this is not fully tested
 *
 */
td_state_t cur_dance(tap_dance_state_t *state) {
    if (state->count == 1) {
        if (state->interrupted || !state->pressed) return TD_SINGLE_TAP;
        // Key has not been interrupted, but the key is still held. Means you want to send a 'HOLD'.
        else return TD_SINGLE_HOLD;
    } else if (state->count == 2) {
        // TD_DOUBLE_SINGLE_TAP is to distinguish between typing "pepper", and actually wanting a double tap
        // action when hitting 'pp'. Suggested use case for this return value is when you want to send two
        // keystrokes of the key, and not the 'double tap' action/macro.
        if (state->interrupted) return TD_DOUBLE_SINGLE_TAP;
        else if (state->pressed) return TD_DOUBLE_HOLD;
        else return TD_DOUBLE_TAP;
    }

    // Assumes no one is trying to type the same letter three times (at least not quickly).
    // If your tap dance key is 'KC_W', and you want to type "www." quickly - then you will need to add
    // an exception here to return a 'TD_TRIPLE_SINGLE_TAP', and define that enum just like 'TD_DOUBLE_SINGLE_TAP'
    if (state->count == 3) {
        if (state->interrupted || !state->pressed) return TD_TRIPLE_TAP;
        else return TD_TRIPLE_HOLD;
    } else return TD_UNKNOWN;
}

// Create an instance of 'td_tap_t' for the 'x' tap dance.
static td_tap_t xtap_state = {
    .is_press_action = true,
    .state = TD_NONE
};

uint16_t t_layer[] = {
    KC_NO, KC_NO, KC_W, KC_E, KC_R, SH_TOGG, /**/ SH_TOGG, KC_U, KC_I, KC_O, KC_NO, KC_NO,
    KC_GRV, KC_A, KC_S, KC_D, KC_F, KC_G, /**/ KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT,
    KC_NO, KC_Z, KC_X, KC_C, KC_V, KC_B, /**/ KC_N, KC_M, KC_T, KC_Y, KC_Q, KC_NO,
    // thumb cluster
    KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO,
};

uint16_t tt_layer[] = {
    KC_NO, KC_NO, LSFT(KC_COMM), LSFT(KC_DOT), KC_DLR, KC_NO, /**/ KC_NO, KC_BSLS, KC_AMPR, KC_NO, KC_NO, KC_NO,
    KC_NO, KC_NO/*KC_ASTR*//*13*/, KC_COMM/*KC_LPRN*//*14*/, KC_DOT/*KC_RPRN*//*15*/, KC_MINS, KC_SLSH, /**/ KC_EXLM/*18*/, KC_EQL, KC_LBRC, KC_RBRC, KC_NO/*KC_P*/, RALT(KC_QUOT),
    KC_NO, KC_NO, KC_NO, KC_CIRC, KC_ASTR/*28*/, KC_GRV, /**/ KC_QUOT, KC_P, KC_AT, RALT(KC_QUOT)/*33*/, KC_NO, KC_NO,
    // thumb cluster
    KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO,
};

#define TAP_DANCE_FUNC(NAME, KEY_T, KEY_TH, KEY_TT, KEY_TTH) \
void x_finished##NAME (tap_dance_state_t *state, void *user_data) { \
    xtap_state.state = cur_dance(state); \
    switch (xtap_state.state) { \
        case TD_SINGLE_TAP: register_code16(KEY_T); break; \
        case TD_SINGLE_HOLD: register_code16(KEY_TH); break; \
        case TD_DOUBLE_TAP: register_code16(KEY_TT); break; \
        case TD_DOUBLE_HOLD: register_code16(KEY_TTH); break; \
        case TD_DOUBLE_SINGLE_TAP: tap_code16(KEY_T); register_code16(KEY_T); break; \
        default: break; \
    } \
} \
void x_reset##NAME (tap_dance_state_t *state, void *user_data) { \
    switch (xtap_state.state) { \
        case TD_SINGLE_TAP: unregister_code16(KEY_T); break; \
        case TD_SINGLE_HOLD: unregister_code16(KEY_TH); break; \
        case TD_DOUBLE_TAP: unregister_code16(KEY_TT); break; \
        case TD_DOUBLE_HOLD: unregister_code16(KEY_TTH); break; \
        case TD_DOUBLE_SINGLE_TAP: unregister_code16(KEY_T); break; \
        default: break; \
    } \
    xtap_state.state = TD_NONE; \
}

#define TAP_DANCE_LAYER_FUNC_ALT(ID, KEY_TTH) \
void x_finished##ID (tap_dance_state_t *state, void *user_data) { \
    xtap_state.state = cur_dance(state); \
    switch (xtap_state.state) { \
        case TD_SINGLE_TAP: register_code16(t_layer[ID]); break; \
        case TD_SINGLE_HOLD: tap_code16(LSFT(t_layer[ID])); break; \
        case TD_DOUBLE_TAP: register_code16(tt_layer[ID]); break; \
        case TD_DOUBLE_HOLD: tap_code16(KEY_TTH); break; \
        case TD_DOUBLE_SINGLE_TAP: register_code16(tt_layer[ID]); break; \
        case TD_TRIPLE_TAP: tap_code16(t_layer[ID]); register_code16(t_layer[ID]); break; \
        case TD_TRIPLE_HOLD: tap_code16(LSFT(t_layer[ID])); tap_code16(LSFT(t_layer[ID])); break; \
        default: break; \
    } \
} \
void x_reset##ID (tap_dance_state_t *state, void *user_data) { \
    switch (xtap_state.state) { \
        case TD_SINGLE_TAP: unregister_code16(t_layer[ID]); break; \
        case TD_SINGLE_HOLD: break; \
        case TD_DOUBLE_TAP: unregister_code16(tt_layer[ID]); break; \
        case TD_DOUBLE_HOLD: break; \
        case TD_DOUBLE_SINGLE_TAP: unregister_code16(tt_layer[ID]); break; \
        case TD_TRIPLE_TAP: unregister_code16(t_layer[ID]); break; \
        case TD_TRIPLE_HOLD: break; \
        default: break; \
    } \
    xtap_state.state = TD_NONE; \
}

#define TAP_DANCE_LAYER_FUNC(ID) \
    TAP_DANCE_LAYER_FUNC_ALT(ID, LSFT(tt_layer[ID]))

/*
// void x_finished##ID (tap_dance_state_t *state, void *user_data) { \
//     xtap_state.state = cur_dance(state); \
//     switch (xtap_state.state) { \
//         case TD_SINGLE_TAP: register_code16(t_layer[ID]); break; \
//         case TD_SINGLE_HOLD: tap_code16(LSFT(t_layer[ID])); break; \
//         case TD_DOUBLE_TAP: register_code16(tt_layer[ID]); break; \
//         case TD_DOUBLE_HOLD: tap_code16(LSFT(tt_layer[ID])); break; \
//         case TD_DOUBLE_SINGLE_TAP: register_code16(tt_layer[ID]); break; \
//         default: break; \
//     } \
// } \
// void x_reset##ID (tap_dance_state_t *state, void *user_data) { \
//     switch (xtap_state.state) { \
//         case TD_SINGLE_TAP: unregister_code16(t_layer[ID]); break; \
//         case TD_SINGLE_HOLD: break; \
//         case TD_DOUBLE_TAP: unregister_code16(tt_layer[ID]); break; \
//         case TD_DOUBLE_HOLD: break; \
//         case TD_DOUBLE_SINGLE_TAP: unregister_code16(tt_layer[ID]); break; \
//         default: break; \
//     } \
//     xtap_state.state = TD_NONE; \
// }
*/

#define TAP_DANCE_ENT(NAME) \
    [NAME] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, x_finished##NAME, x_reset##NAME),

// void x_finished(tap_dance_state_t *state, void *user_data) {
//     xtap_state.state = cur_dance(state);
//     switch (xtap_state.state) {
//         case TD_SINGLE_TAP: register_code(KC_BSPC); break;
//         case TD_SINGLE_HOLD: register_code(KC_BSPC); break;
//         case TD_DOUBLE_TAP: register_code(KC_ENT); break;
//         case TD_DOUBLE_HOLD: register_code(KC_LCTL); break;
//         // Last case is for fast typing. Assuming your key is `f`:
//         // For example, when typing the word `buffer`, and you want to make sure that you send `ff` and not `Esc`.
//         // In order to type `ff` when typing fast, the next character will have to be hit within the `TAPPING_TERM`, which by default is 200ms.
//         case TD_DOUBLE_SINGLE_TAP: tap_code(KC_BSPC); register_code(KC_BSPC); break;
//         default: break;
//     }
// }

// void x_reset(tap_dance_state_t *state, void *user_data) {
//     switch (xtap_state.state) {
//         case TD_SINGLE_TAP: unregister_code(KC_BSPC); break;
//         case TD_SINGLE_HOLD: unregister_code(KC_BSPC); break;
//         case TD_DOUBLE_TAP: unregister_code(KC_ENT); break;
//         case TD_DOUBLE_HOLD: unregister_code(KC_LCTL); break;
//         case TD_DOUBLE_SINGLE_TAP: unregister_code(KC_BSPC); break;
//         default: break;
//     }
//     xtap_state.state = TD_NONE;
// }

// ------- mods -------

void x_finished37 (tap_dance_state_t *state, void *user_data) {
    xtap_state.state = cur_dance(state);
    switch (xtap_state.state) {
        case TD_SINGLE_TAP: tap_code16(get_last_keycode()); break;
        case TD_SINGLE_HOLD: layer_on(4); break;
        default: break;
    }
}
void x_reset37 (tap_dance_state_t *state, void *user_data) {
    switch (xtap_state.state) {
        case TD_SINGLE_TAP: /*unregister_code16(QK_REP);*/ break;
        case TD_SINGLE_HOLD: layer_off(4); break;
        default: break;
    }
    xtap_state.state = TD_NONE;
}

void x_finished40 (tap_dance_state_t *state, void *user_data) {
    xtap_state.state = cur_dance(state);
    switch (xtap_state.state) {
        case TD_SINGLE_TAP: register_code16(QK_REP); break;
        case TD_SINGLE_HOLD: layer_on(5); break;
        default: break;
    }
}
void x_reset40 (tap_dance_state_t *state, void *user_data) {
    switch (xtap_state.state) {
        case TD_SINGLE_TAP: unregister_code16(QK_REP); break;
        case TD_SINGLE_HOLD: layer_off(5); break;
        default: break;
    }
    xtap_state.state = TD_NONE;
}

// -------


// TAP_DANCE_FUNC(X_RMAIN, KC_BSPC, KC_BSPC, KC_ENT, KC_LCTL)

TAP_DANCE_LAYER_FUNC(0)
TAP_DANCE_LAYER_FUNC(1)
TAP_DANCE_LAYER_FUNC(2)
TAP_DANCE_LAYER_FUNC(3)
TAP_DANCE_LAYER_FUNC(4)
TAP_DANCE_LAYER_FUNC(5)

TAP_DANCE_LAYER_FUNC(6)
TAP_DANCE_LAYER_FUNC(7)
TAP_DANCE_LAYER_FUNC(8)
TAP_DANCE_LAYER_FUNC(9)
TAP_DANCE_LAYER_FUNC(10)
TAP_DANCE_LAYER_FUNC(11)

TAP_DANCE_LAYER_FUNC(12)
TAP_DANCE_LAYER_FUNC_ALT(13, KC_PERC)
TAP_DANCE_LAYER_FUNC_ALT(14, KC_LPRN) //KC_COMM)
TAP_DANCE_LAYER_FUNC_ALT(15, KC_RPRN) //KC_DOT)
TAP_DANCE_LAYER_FUNC(16)
TAP_DANCE_LAYER_FUNC(17)

TAP_DANCE_LAYER_FUNC_ALT(18, KC_HASH)
TAP_DANCE_LAYER_FUNC(19)
TAP_DANCE_LAYER_FUNC(20)
TAP_DANCE_LAYER_FUNC(21)
TAP_DANCE_LAYER_FUNC(22)
TAP_DANCE_LAYER_FUNC(23)

TAP_DANCE_LAYER_FUNC(24)
TAP_DANCE_LAYER_FUNC(25)
TAP_DANCE_LAYER_FUNC(26)
TAP_DANCE_LAYER_FUNC(27)
TAP_DANCE_LAYER_FUNC_ALT(28, KC_PERC)
TAP_DANCE_LAYER_FUNC(29)

TAP_DANCE_LAYER_FUNC(30)
TAP_DANCE_LAYER_FUNC(31)
TAP_DANCE_LAYER_FUNC(32)
TAP_DANCE_LAYER_FUNC_ALT(33, RALT(KC_QUOT))
TAP_DANCE_LAYER_FUNC(34)
TAP_DANCE_LAYER_FUNC(35)

TAP_DANCE_LAYER_FUNC(36)
// TAP_DANCE_FUNC(37, QK_AREP, MO(4), QK_AREP, MO(4)) //TAP_DANCE_LAYER_FUNC(37)
TAP_DANCE_LAYER_FUNC(38)
TAP_DANCE_LAYER_FUNC(39)
// TAP_DANCE_FUNC(40, QK_REP, MO(5), QK_REP, MO(5)) //TAP_DANCE_LAYER_FUNC(40)
TAP_DANCE_LAYER_FUNC(41)

tap_dance_action_t tap_dance_actions[] = {
    TAP_DANCE_ENT(0)
    TAP_DANCE_ENT(1)
    TAP_DANCE_ENT(2)
    TAP_DANCE_ENT(3)
    TAP_DANCE_ENT(4)
    TAP_DANCE_ENT(5)

    TAP_DANCE_ENT(6)
    TAP_DANCE_ENT(7)
    TAP_DANCE_ENT(8)
    TAP_DANCE_ENT(9)
    TAP_DANCE_ENT(10)
    TAP_DANCE_ENT(11)

    TAP_DANCE_ENT(12)
    TAP_DANCE_ENT(13)
    TAP_DANCE_ENT(14)
    TAP_DANCE_ENT(15)
    TAP_DANCE_ENT(16)
    TAP_DANCE_ENT(17)

    TAP_DANCE_ENT(18)
    TAP_DANCE_ENT(19)
    TAP_DANCE_ENT(20)
    TAP_DANCE_ENT(21)
    TAP_DANCE_ENT(22)
    TAP_DANCE_ENT(23)

    TAP_DANCE_ENT(24)
    TAP_DANCE_ENT(25)
    TAP_DANCE_ENT(26)
    TAP_DANCE_ENT(27)
    TAP_DANCE_ENT(28)
    TAP_DANCE_ENT(29)

    TAP_DANCE_ENT(30)
    TAP_DANCE_ENT(31)
    TAP_DANCE_ENT(32)
    TAP_DANCE_ENT(33)
    TAP_DANCE_ENT(34)
    TAP_DANCE_ENT(35)

    // thumb keys
    TAP_DANCE_ENT(36)
    TAP_DANCE_ENT(37)
    TAP_DANCE_ENT(38)
    TAP_DANCE_ENT(39)
    TAP_DANCE_ENT(40)
    TAP_DANCE_ENT(41)

    // TAP_DANCE_ENT(X_RMAIN)
    // [X_RMAIN] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, x_finished, x_reset),
    // [X_CHECK] = ACTION_TAP_DANCE_DOUBLE(KC_X, LSFT(KC_MINS))
};