diff --git a/doc-dev/reference-manual.md b/doc-dev/reference-manual.md
index f6ae84b22..430818acb 100644
--- a/doc-dev/reference-manual.md
+++ b/doc-dev/reference-manual.md
@@ -202,7 +202,7 @@ CONDITION = {ifShortcut | ifNotShortcut} [IFSHORTCUT_OPTIONS]* [KEYID]+
 CONDITION = {ifGesture | ifNotGesture} [IFSHORTCUT_OPTIONS]* [KEYID]+
 CONDITION = {ifPrimary | ifSecondary} [ simpleStrategy | advancedStrategy | ignoreTriggersFromSameHalf | acceptTriggersFromSameHalf ]
 CONDITION = {ifHold | ifTap}
-CONDITION = {ifDoubletap | ifNotDoubletap}
+CONDITION = {ifDoubletap | ifNotDoubletap} [taps <number of taps (INT)>]
 CONDITION = {ifInterrupted | ifNotInterrupted}
 CONDITION = {ifReleased | ifNotReleased}
 CONDITION = {ifKeyActive | ifNotKeyActive} KEYID
@@ -541,7 +541,7 @@ Conditions are checked before processing the rest of the command. If the conditi
 
 - `if BOOL` allows switching based on a custom expression. E.g., `if ($keystrokeDelay > 10) ...`
 - `else` condition is true if the previous command ended due to a failed condition.
-- `ifDoubletap/ifNotDoubletap` is true if the macro was started at most 300ms after the start of another instance of the same macro.
+- `ifDoubletap/ifNotDoubletap` is true if the macro was started at most 300ms after the start of another instance of the same macro.  If `taps` is provided, test for that number of rapid taps in a row, for example `ifDoubletap taps 3` will test for a tripletap.
 - `ifInterrupted/ifNotInterrupted` is true if a keystroke action or mouse action was triggered during macro runtime. Allows fake implementation of secondary roles. Also allows interruption of cycles.
 - `ifReleased/ifNotReleased` is true if the key which activated current macro has been released. If the key has been physically released but the release has been postponed by another key, the conditien yields false. If the key has been physically released and the postponing mode was initiated by this macro (e.g., `postponeKeys ifReleased goTo ($currentAddress+2)`), it returns non-postponed release state (i.e., true if there's a matching release event in the postponing queue).
 - `ifPending/ifNotPending <n>` is true if there is at least `n` postponed keys in the postponing queue. In context of postponing mechanism, this condition acts similar in place of ifInterrupted.
@@ -620,7 +620,7 @@ Key actions can be parametrized with macro arguments. These arguments can be exp
   This allows the user to trigger chorded shortcuts in an arbitrary order (all at the "same" time). E.g., if `A+Ctrl` is pressed instead of `Ctrl+A`, the keyboard will still send `Ctrl+A` if the two key presses follow within the specified time.
 - `set autoShiftDelay 0 | <time in ms (INT)>` If nonzero, the autoshift feature is turned on. This adds shift to a scancode when the key is held for at least `autoShiftDelay` ms. (E.g., tapping 'a' results in 'a', pressing 'a' for a little bit longer results in 'A'.)
 - `set debounceDelay <time in ms, at most 250>` prevents key state from changing for some time after every state change. This is needed because contacts of mechanical switches can bounce after contact and therefore change state multiple times in span of a few milliseconds. Official firmware debounce time is 50 ms for both press and release. Recommended value is 10-50, default is 50.
-- `set doubletapTimeout <time in ms, at most 65535>` controls doubletap timeouts for both layer switchers and for the `ifDoubletap` condition.
+- `set doubletapTimeout <time in ms, at most 65535>` controls doubletap interval limit for layer switchers, secondary role doubletap to primary, and for the `ifDoubletap` condition.
 - `set keystrokeDelay <time in ms, at most 65535>` allows slowing down keyboard output. This is handy for lousily written RDP clients and other software which just scans keys once a while and processes them in wrong order if multiple keys have been pressed inbetween. In more detail, this setting adds a delay whenever a basic usb report is sent. During this delay, key matrix is still scanned and keys are debounced, but instead of activating, the keys are added into a queue to be replayed later. Recommended value is 10 if you have issues with RDP missing modifier keys, 0 otherwise.
 - `set autoRepeatDelay <time in ms, at most 65535>` and `set autoRepeatRate <time in ms, at most 65535>` allows you to set the initial delay (default: 500 ms) and the repeat delay (default: 50 ms) when using `autoRepeat`. When you run the command `autoRepeat <command>`, the `<command>` is first run without delay. Then, it will waits `autoRepeatDelay` amount of time before running `<command>` again. Then and thereafter, it will waits `autoRepeatRate` amount of time before repeating `<command>` again. This is consistent with typical OS keyrepeat feature.
 - `set oneShotTimeout <time in ms, at most 65535>` sets the timeout for `oneShot` modifier. Zero means infinite.
@@ -782,6 +782,8 @@ Key actions can be parametrized with macro arguments. These arguments can be exp
     - `$currentTime` returns current time in milliseconds in 31 bit range.
     - `$queuedKeyId.<index (NUMBER)>` which stands for a zero-indexed position in the postponer queue.
     - `$uhk.name` returns a reference to the uhk name string.
+    - `$previousKeyId` returns the id of the last key that was pressed previously to the one which started the macro
+    - `$previousKeyPressTime` returns the time activation time of the last key pressed previously to the one which started the macro
 - `KEYMAPID` - is assumed to be 3 characters long abbreviation of a keymap.
 - `MACROID` - macro slot identifier is either a number or a single ascii character (interpreted as a one-byte value). `$thisKeyId` can be used so that the same macro refers to different slots when assigned to different keys.
 - `custom text` is an arbitrary text starting on the next non-space character and ending at the end of the text action. (Yes, this should be refactored in the future.)
diff --git a/right/src/key_history.c b/right/src/key_history.c
index 4734dc30a..4c8c91c3d 100644
--- a/right/src/key_history.c
+++ b/right/src/key_history.c
@@ -2,54 +2,57 @@
 #include "key_history.h"
 #include "postponer.h"
 
-typedef enum {
-    DoubletapState_Blocked,
-    DoubletapState_First,
-    DoubletapState_Multitap,
-    DoubletapState_Doubletap,
-} doubletap_state_t;
+#define HISTORY_SIZE 2
+#define LAST (position % HISTORY_SIZE)
+#define POS(p) ((position + HISTORY_SIZE - p) % HISTORY_SIZE) // Proceeding backwards in time
 
-typedef struct {
-    const key_state_t *keyState;
-    uint8_t keyActivationId;
-    uint32_t timestamp;
-    doubletap_state_t doubletapState;
-} previous_key_event_type_t;
-
-static previous_key_event_type_t lastPress;
+static key_press_event_t history[HISTORY_SIZE];
+static uint8_t position = 0;
 
 void KeyHistory_RecordPress(const key_state_t *keyState)
 {
+    const key_press_event_t * const lastPress = &history[LAST];
     const bool isMultitap = 
-        keyState == lastPress.keyState
-        && lastPress.doubletapState != DoubletapState_Blocked
-        && CurrentPostponedTime < lastPress.timestamp + Cfg.DoubletapTimeout;
-    const bool isDoubletap = isMultitap &&
-        (lastPress.doubletapState == DoubletapState_First || lastPress.doubletapState == DoubletapState_Multitap);
+        keyState == lastPress->keyState
+        && !lastPress->multiTapBreaker
+        && CurrentPostponedTime < lastPress->timestamp + Cfg.DoubletapTimeout;
 
-    lastPress = (previous_key_event_type_t){
+    position = (position + 1) % HISTORY_SIZE;
+    
+    history[LAST] = (key_press_event_t) {
         .keyState = keyState,
         .keyActivationId = keyState->activationId,
         .timestamp = CurrentPostponedTime,
-        .doubletapState = isDoubletap ? DoubletapState_Doubletap :
-            isMultitap ? DoubletapState_Multitap :
-            DoubletapState_First,
+        .multiTapCount = 1 + (isMultitap ? lastPress->multiTapCount : 0),
+        .multiTapBreaker = false,
     };
 }
 
 void KeyHistory_RecordRelease(const key_state_t *keyState)
 {
-    if (keyState != lastPress.keyState) {
-        lastPress.doubletapState = DoubletapState_Blocked;
+    if (keyState != history[LAST].keyState) {
+        history[LAST].multiTapBreaker = true;
     }
 }
 
-bool KeyHistory_WasLastDoubletap()
+const key_press_event_t * KeyHistory_GetPreceedingPress(const key_state_t *keyState, uint8_t activationId)
 {
-    return lastPress.doubletapState == DoubletapState_Doubletap;
+    for (uint8_t i = 0; i < HISTORY_SIZE - 1; ++i) {
+        if(history[POS(i)].keyState == keyState && history[POS(i)].keyActivationId == activationId) {
+            if (history[POS(++i)].keyState != NULL) {
+                return &history[POS(i)];
+            }
+            return NULL;
+        }
+    }
+    return NULL;
 }
 
-bool KeyHistory_WasLastMultitap()
-{
-    return lastPress.doubletapState >= DoubletapState_Multitap;
+uint8_t KeyHistory_GetMultitapCount(const key_state_t *keyState, uint8_t activationId) {
+    for (uint8_t i = 0; i < HISTORY_SIZE - 1; ++i) {
+        if(history[POS(i)].keyState == keyState && history[POS(i)].keyActivationId == activationId) {
+            return history[POS(i)].multiTapCount;
+        }
+    }
+    return 0;
 }
\ No newline at end of file
diff --git a/right/src/key_history.h b/right/src/key_history.h
index cba1547f3..4e5a56f5d 100644
--- a/right/src/key_history.h
+++ b/right/src/key_history.h
@@ -9,14 +9,26 @@
 
 // Typedefs:
 
+typedef struct {
+    const key_state_t *keyState;
+    uint32_t timestamp;
+    uint8_t multiTapCount : 6;
+    uint8_t keyActivationId : 4;
+    bool multiTapBreaker : 1;
+} key_press_event_t;
+
 // Variables:
 
 // Functions:
 
+// Recording events
 void KeyHistory_RecordPress(const key_state_t *keyState);
 void KeyHistory_RecordRelease(const key_state_t *keyState);
-bool KeyHistory_WasLastDoubletap();
-bool KeyHistory_WasLastMultitap();
 
+// Querying whole events
+const key_press_event_t * KeyHistory_GetPreceedingPress(const key_state_t *keyState, uint8_t activationId);
+
+// Querying specific info
+uint8_t KeyHistory_GetMultitapCount(const key_state_t *keyState, uint8_t activationId);
 
 #endif
\ No newline at end of file
diff --git a/right/src/key_states.h b/right/src/key_states.h
index 97ac8dbdb..ff9b1d0dc 100644
--- a/right/src/key_states.h
+++ b/right/src/key_states.h
@@ -43,7 +43,7 @@
         bool debouncing : 1;
         secondary_role_state_t secondaryState : 2;
         bool padding : 1; // This allows the KEY_INACTIVE() macro to not trigger false because of sequence
-        uint8_t activationId: 4;
+        uint8_t activationId : 4;
     } key_state_t;
 
 // Variables:
diff --git a/right/src/layer_switcher.c b/right/src/layer_switcher.c
index aca3f70c3..b128f686a 100644
--- a/right/src/layer_switcher.c
+++ b/right/src/layer_switcher.c
@@ -117,7 +117,7 @@ void LayerSwitcher_DoubleTapToggle(layer_id_t layer, key_state_t *keyState) {
 
     if(KeyState_ActivatedNow(keyState)) {
         LayerStack_LegacyPop(layer);
-        if (KeyHistory_WasLastDoubletap()) {
+        if (KeyHistory_GetMultitapCount(keyState, keyState->activationId) % 2 == 0) {
             LayerStack_LegacyPush(layer);
             doubleTapSwitchLayerKey = keyState;
             doubleTapSwitchLayerTriggerTime = Timer_GetCurrentTime();
diff --git a/right/src/macro_events.c b/right/src/macro_events.c
index b36711a55..6a1a6d8b2 100644
--- a/right/src/macro_events.c
+++ b/right/src/macro_events.c
@@ -54,7 +54,7 @@ void MacroEvent_OnInit()
     const char* name = "$onInit";
     uint8_t idx = FindMacroIndexByName(name, name + strlen(name), false);
     if (idx != 255) {
-        previousEventMacroSlot = Macros_StartMacro(idx, NULL, 0, 255, 255, false, NULL);
+        previousEventMacroSlot = Macros_StartMacro(idx, NULL, 0, 255, false, NULL);
     }
 
     registerJoinSplitEvents();
@@ -67,7 +67,7 @@ static void startMacroInSlot(macro_index_t macroIndex, uint8_t* slotId) {
         if (*slotId != 255 && MacroState[*slotId].ms.macroPlaying) {
             *slotId = Macros_QueueMacro(macroIndex, NULL, 255, *slotId);
         } else {
-            *slotId = Macros_StartMacro(macroIndex, NULL, 0, 255, 255, false, NULL);
+            *slotId = Macros_StartMacro(macroIndex, NULL, 0, 255, false, NULL);
         }
     }
 }
diff --git a/right/src/macros/commands.c b/right/src/macros/commands.c
index d3416c6ec..e6475947a 100644
--- a/right/src/macros/commands.c
+++ b/right/src/macros/commands.c
@@ -550,12 +550,22 @@ static macro_result_t processRecordMacroDelayCommand()
     return MacroResult_Finished;
 }
 
-static bool processIfDoubletapCommand(bool negate)
+static bool processIfDoubletapCommand(parser_context_t *ctx, bool negate)
 {
+    uint8_t n = 2;
+    if (ConsumeToken(ctx, "taps")) {
+        n = Macros_ConsumeInt(ctx);
+    }
+
     if (Macros_DryRun) {
         return true;
     }
-    return S->ms.isDoubletap != negate;
+
+    if (S->ms.currentMacroKey == NULL) {
+        return false;
+    }
+
+    return (S->ms.multitapCount % n == 0) != negate;
 }
 
 static bool processIfModifierCommand(bool negate, uint8_t modmask)
@@ -2093,9 +2103,9 @@ static macro_result_t processCommand(parser_context_t* ctx)
         case CommandId_if:
             PROCESS_CONDITION(processIfCommand(ctx))
         case CommandId_ifDoubletap:
-            PROCESS_CONDITION(processIfDoubletapCommand(false))
+            PROCESS_CONDITION(processIfDoubletapCommand(ctx, false))
         case CommandId_ifNotDoubletap:
-            PROCESS_CONDITION(processIfDoubletapCommand(true))
+            PROCESS_CONDITION(processIfDoubletapCommand(ctx, true))
         case CommandId_ifInterrupted:
             PROCESS_CONDITION(processIfInterruptedCommand(false))
         case CommandId_ifNotInterrupted:
diff --git a/right/src/macros/core.c b/right/src/macros/core.c
index d06c088e6..216004ff0 100644
--- a/right/src/macros/core.c
+++ b/right/src/macros/core.c
@@ -419,10 +419,21 @@ macro_result_t Macros_ExecMacro(uint8_t macroIndex)
     return MacroResult_JumpedForward;
 }
 
+uint8_t startMacro(
+    uint8_t index,
+    key_state_t *keyState,
+    uint16_t argumentOffset,
+    uint8_t keyActivationId,
+    uint8_t parentMacroSlot,
+    bool runFirstAction,
+    const char *inlineText,
+    const macro_state_t *parentMacroState
+);
+
 macro_result_t Macros_CallMacro(uint8_t macroIndex)
 {
     uint32_t parentSlotIndex = S - MacroState;
-    uint8_t childSlotIndex = Macros_StartMacro(macroIndex, S->ms.currentMacroKey, 0, S->ms.keyActivationId, parentSlotIndex, true, NULL);
+    uint8_t childSlotIndex = startMacro(macroIndex, S->ms.currentMacroKey, 0, S->ms.keyActivationId, parentSlotIndex, true, NULL, S);
 
     if (childSlotIndex != 255) {
         unscheduleCurrentSlot();
@@ -436,7 +447,7 @@ macro_result_t Macros_CallMacro(uint8_t macroIndex)
 
 macro_result_t Macros_ForkMacro(uint8_t macroIndex)
 {
-    Macros_StartMacro(macroIndex, S->ms.currentMacroKey, 0, S->ms.keyActivationId, 255, true, NULL);
+    startMacro(macroIndex, S->ms.currentMacroKey, 0, S->ms.keyActivationId, 255, true, NULL, S);
     return MacroResult_Finished;
 }
 
@@ -446,7 +457,8 @@ uint8_t initMacro(
     uint16_t argumentOffset,
     uint8_t keyActivationId,
     uint8_t parentMacroSlot,
-    const char *inlineText
+    const char *inlineText,
+    const macro_state_t *parentMacroState
 ) {
     if (!macroIsValid(index) || !findFreeStateSlot() || !findFreeScopeStateSlot())  {
        return 255;
@@ -460,10 +472,30 @@ uint8_t initMacro(
     S->ms.currentMacroIndex = index;
     S->ms.currentMacroKey = keyState;
     S->ms.keyActivationId = keyActivationId;
-    S->ms.currentMacroStartTime = CurrentPostponedTime;
     S->ms.currentMacroArgumentOffset = argumentOffset;
     S->ms.parentMacroSlot = parentMacroSlot;
-    S->ms.isDoubletap = keyState != NULL && KeyHistory_WasLastDoubletap();
+
+    if(parentMacroState != NULL) {
+        S->ms.currentMacroStartTime = parentMacroState->ms.currentMacroStartTime;
+        S->ms.multitapCount = parentMacroState->ms.multitapCount;
+        S->ms.previousKeyPressTime = parentMacroState->ms.previousKeyPressTime;
+        S->ms.previousKeyId = parentMacroState->ms.previousKeyId;
+        S->ms.secondaryRoleState = parentMacroState->ms.secondaryRoleState;
+    }
+    else {
+        S->ms.currentMacroStartTime = CurrentPostponedTime;
+        S->ms.multitapCount = 0;
+        S->ms.previousKeyPressTime = 0;
+        S->ms.previousKeyId = 255;
+        if (keyState != NULL) {
+            S->ms.multitapCount = KeyHistory_GetMultitapCount(keyState, keyActivationId);
+            const key_press_event_t * const prevEvt = KeyHistory_GetPreceedingPress(keyState, keyActivationId);
+            if (prevEvt != NULL) {
+                S->ms.previousKeyId = Utils_KeyStateToKeyId(prevEvt->keyState);
+                S->ms.previousKeyPressTime = prevEvt->timestamp;
+            }
+        }
+    }
 
     // If inline text is provided, set up the action before resetToAddressZero
     if (inlineText != NULL) {
@@ -488,18 +520,19 @@ uint8_t initMacro(
 
 
 //partentMacroSlot == 255 means no parent
-uint8_t Macros_StartMacro(
+uint8_t startMacro(
     uint8_t index,
     key_state_t *keyState,
     uint16_t argumentOffset,
     uint8_t keyActivationId,
     uint8_t parentMacroSlot,
     bool runFirstAction,
-    const char *inlineText
+    const char *inlineText,
+    const macro_state_t *parentMacroState
 ) {
     macro_state_t* oldState = S;
 
-    uint8_t slotIndex = initMacro(index, keyState, argumentOffset, keyActivationId, parentMacroSlot, inlineText);
+    uint8_t slotIndex = initMacro(index, keyState, argumentOffset, keyActivationId, parentMacroSlot, inlineText, parentMacroState);
 
     if (slotIndex == 255) {
         S = oldState;
@@ -523,14 +556,25 @@ uint8_t Macros_StartMacro(
     return slotIndex;
 }
 
+uint8_t Macros_StartMacro(
+    uint8_t index,
+    key_state_t *keyState,
+    uint16_t argumentOffset,
+    uint8_t keyActivationId,
+    bool runFirstAction,
+    const char *inlineText
+) {
+    return startMacro(index, keyState, argumentOffset, keyActivationId, MacroIndex_None, runFirstAction, inlineText, NULL);
+}
+
 uint8_t Macros_StartInlineMacro(const char *text, key_state_t *keyState, uint8_t keyActivationId)
 {
-    return Macros_StartMacro(MacroIndex_InlineMacro, keyState, 0, keyActivationId, 255, true, text);
+    return startMacro(MacroIndex_InlineMacro, keyState, 0, keyActivationId, MacroIndex_None, true, text, NULL);
 }
 
 void Macros_ValidateMacro(uint8_t macroIndex, uint16_t argumentOffset, uint8_t moduleId, uint8_t keyIdx, uint8_t keymapIdx, uint8_t layerIdx) {
     bool wasValid = true;
-    uint8_t slotIndex = initMacro(macroIndex, NULL, argumentOffset, 255, 255, NULL);
+    uint8_t slotIndex = initMacro(macroIndex, NULL, argumentOffset, 255, MacroIndex_None, NULL, NULL);
 
     if (slotIndex == 255) {
         S = NULL;
@@ -611,7 +655,7 @@ uint8_t Macros_QueueMacro(uint8_t index, key_state_t *keyState, uint8_t keyActiv
 {
     macro_state_t* oldState = S;
 
-    uint8_t slotIndex = initMacro(index, keyState, 0, keyActivationId, 255, NULL);
+    uint8_t slotIndex = initMacro(index, keyState, 0, keyActivationId, MacroIndex_None, NULL, NULL);
 
     if (slotIndex == 255) {
         return slotIndex;
diff --git a/right/src/macros/core.h b/right/src/macros/core.h
index 30e545194..83b17bc5d 100644
--- a/right/src/macros/core.h
+++ b/right/src/macros/core.h
@@ -145,6 +145,8 @@
             macro_action_t currentMacroAction;
             key_state_t *currentMacroKey;
             uint32_t currentMacroStartTime;
+            uint8_t previousKeyId;
+            uint32_t previousKeyPressTime;
             uint16_t currentMacroActionIndex;
             uint16_t currentMacroArgumentOffset;
             uint16_t bufferOffset;
@@ -155,9 +157,10 @@
             uint8_t nextSlot;
             uint8_t oneShot : 2;
             bool macroInterrupted : 1;
-            uint8_t keyActivationId: 4;
             // TODO: refactor macroSleeping, macroBroken and macroPlaying into a single state?
             bool macroSleeping : 1;
+            uint8_t keyActivationId: 4;
+
             bool macroBroken : 1;
             bool macroPlaying : 1;
             bool macroScheduled : 1;
@@ -166,7 +169,8 @@
             bool wakeMeOnKeystateChange: 1;
             bool autoRepeatInitialDelayPassed: 1;
             macro_autorepeat_state_t autoRepeatPhase: 1;
-            bool isDoubletap: 1;
+
+            uint8_t multitapCount : 6;
             secondary_role_state_t secondaryRoleState: 2;
             // ---- 4-aligned ----
 
@@ -277,7 +281,7 @@
     macro_result_t Macros_SleepTillTime(uint32_t time, const char* reason);
     uint8_t Macros_ConsumeLayerId(parser_context_t* ctx);
     uint8_t Macros_QueueMacro(uint8_t index, key_state_t *keyState, uint8_t keyActivationId, uint8_t queueAfterSlot);
-    uint8_t Macros_StartMacro(uint8_t index, key_state_t *keyState, uint16_t argumentOffset, uint8_t keyActivationId, uint8_t parentMacroSlot, bool runFirstAction, const char *inlineText);
+    uint8_t Macros_StartMacro(uint8_t index, key_state_t *keyState, uint16_t argumentOffset, uint8_t keyActivationId, bool runFirstAction, const char *inlineText);
     uint8_t Macros_StartInlineMacro(const char *text, key_state_t *keyState, uint8_t keyActivationId);
     uint8_t Macros_TryConsumeKeyId(parser_context_t* ctx);
     void Macros_ContinueMacro(void);
diff --git a/right/src/macros/vars.c b/right/src/macros/vars.c
index 727bf8889..4c1044bad 100644
--- a/right/src/macros/vars.c
+++ b/right/src/macros/vars.c
@@ -342,6 +342,12 @@ static macro_variable_t consumeDollarExpression(parser_context_t* ctx)
     else if (ConsumeToken(ctx, "thisKeyId")) {
         return intVar(Utils_KeyStateToKeyId(ctx->macroState->ms.currentMacroKey));
     }
+    else if (ConsumeToken(ctx, "previousKeyId")) {
+        return intVar(ctx->macroState->ms.previousKeyId);
+    }
+    else if (ConsumeToken(ctx, "previousKeyPressTime")) {
+        return intVar(ctx->macroState->ms.previousKeyPressTime);
+    }
     else if (ConsumeToken(ctx, "currentAddress")) {
         return intVar(ctx->macroState->ls->ms.commandAddress);
     }
diff --git a/right/src/secondary_role_driver.c b/right/src/secondary_role_driver.c
index dec039d4c..371a90437 100644
--- a/right/src/secondary_role_driver.c
+++ b/right/src/secondary_role_driver.c
@@ -250,7 +250,7 @@ static void startResolution(
 {
     // store current state
     currentlyResolving = true;
-    isDoubletap = KeyHistory_WasLastMultitap();
+    isDoubletap = KeyHistory_GetMultitapCount(keyState, keyState->activationId) > 1;
     resolutionKey = keyState;
     resolutionStartTime = CurrentPostponedTime;
     resolutionCallerIsMacroEngine = isMacroResolution;
diff --git a/right/src/usb_commands/usb_command_exec_macro_command.c b/right/src/usb_commands/usb_command_exec_macro_command.c
index 836494bb2..ff3bb1c3b 100644
--- a/right/src/usb_commands/usb_command_exec_macro_command.c
+++ b/right/src/usb_commands/usb_command_exec_macro_command.c
@@ -42,7 +42,7 @@ static bool canExecute()
 
 void UsbMacroCommand_ExecuteSynchronously()
 {
-    Macros_StartMacro(MacroIndex_InlineMacro, &dummyState, 0, 255, MacroIndex_None, false, UsbMacroCommand);
+    Macros_StartMacro(MacroIndex_InlineMacro, &dummyState, 0, 255, false, UsbMacroCommand);
     EventVector_Unset(EventVector_UsbMacroCommandWaitingForExecution);
 }
 
diff --git a/right/src/usb_report_updater.c b/right/src/usb_report_updater.c
index f372b458d..5cebd6b71 100644
--- a/right/src/usb_report_updater.c
+++ b/right/src/usb_report_updater.c
@@ -469,7 +469,7 @@ void ApplyKeyAction(key_state_t *keyState, key_action_cached_t *cachedAction, ke
         case KeyActionType_PlayMacro:
             if (KeyState_ActivatedNow(keyState)) {
                 resetStickyMods(cachedAction);
-                Macros_StartMacro(action->playMacro.macroId, keyState, action->playMacro.offset, keyState->activationId, 255, true, NULL);
+                Macros_StartMacro(action->playMacro.macroId, keyState, action->playMacro.offset, keyState->activationId, true, NULL);
             }
             break;
         case KeyActionType_InlineMacro:
diff --git a/right/src/utils.c b/right/src/utils.c
index cb73664e0..419d7886f 100644
--- a/right/src/utils.c
+++ b/right/src/utils.c
@@ -26,24 +26,18 @@
 #if !DEVICE_IS_UHK_DONGLE
 //this is noop at the moment, prepared for time when MAX_KEY_COUNT_PER_MODULE changes
 //the purpose is to preserve current keyids
-static uint16_t recodeId(uint16_t newFormat, uint16_t fromBase, uint16_t toBase)
-{
-    return toBase * (newFormat / fromBase) + (newFormat % fromBase);
-}
+#define RECODE_ID(id, oldBase, newBase) (newBase * (id / oldBase) + id % oldBase)
 #endif
 
-uint16_t Utils_KeyStateToKeyId(key_state_t* key)
-{
+uint16_t Utils_KeyStateToKeyId(const key_state_t *key) {
 #if DEVICE_IS_UHK_DONGLE
     return 0;
 #else
     if (key == NULL) {
-        return 0;
+        return 255;
     }
-    uint32_t ptr1 = (uint32_t)(key_state_t*)key;
-    uint32_t ptr2 = (uint32_t)(key_state_t*)&(KeyStates[0][0]);
-    uint32_t res = (ptr1 - ptr2) / sizeof(key_state_t);
-    return recodeId(res, MAX_KEY_COUNT_PER_MODULE, 64);
+    uint16_t arrayPos = (uint16_t)(key - (key_state_t*)KeyStates);
+    return RECODE_ID(arrayPos, MAX_KEY_COUNT_PER_MODULE, 64);
 #endif
 }
 
@@ -52,7 +46,7 @@ key_state_t* Utils_KeyIdToKeyState(uint16_t keyid)
 #if DEVICE_IS_UHK_DONGLE
     return NULL;
 #else
-    return &(((key_state_t*)KeyStates)[recodeId(keyid, 64, MAX_KEY_COUNT_PER_MODULE)]);
+    return &(((key_state_t*)KeyStates)[RECODE_ID(keyid, 64, MAX_KEY_COUNT_PER_MODULE)]);
 #endif
 }
 
diff --git a/right/src/utils.h b/right/src/utils.h
index 0a73eeb29..740fb50cb 100644
--- a/right/src/utils.h
+++ b/right/src/utils.h
@@ -35,7 +35,7 @@ if (reentrancyGuard_active) {                    \
 
     uint8_t Utils_SafeStrCopy(char* target, const char* src, uint8_t max);
     key_state_t* Utils_KeyIdToKeyState(uint16_t keyid);
-    uint16_t Utils_KeyStateToKeyId(key_state_t* key);
+    uint16_t Utils_KeyStateToKeyId(const key_state_t* key);
     const char* Utils_KeyStateToKeyAbbreviation(key_state_t* key);
     void Utils_DecodeId(uint16_t keyid, uint8_t* outSlotId, uint8_t* outSlotIdx);
     const char* Utils_GetUsbReportString(const usb_basic_keyboard_report_t* report);