<?xml version="1.0"?>
<root>
  <list>
    <!-- #include "include/local.top.xml" -->
    <item>
      <name>General</name>
      <list>
        <item>
          <name>Don't Remap the Internal Keyboard</name>
          <sysctl>general.dont_remap_internal</sysctl>
        </item>
        <item>
          <name>Don't Remap the External Keyboard</name>
          <sysctl>general.dont_remap_external</sysctl>
        </item>
        <item>
          <name>Don't Remap Third Vendor's Keyboard</name>
          <sysctl>general.dont_remap_thirdvendor_keyboard</sysctl>
        </item>
        <item>
          <name>Don't Remap Third Vendor's Pointing Device</name>
          <sysctl>general.dont_remap_thirdvendor_pointing</sysctl>
        </item>
        <item>
          <name>Enable CapsLock LED Hack</name>
          <appendix>(Keep LED on to prevent a delay of CapsLock at some Apple's keyboard)</appendix>
          <sysctl>general.capslock_led_hack</sysctl>
        </item>
        <item>
          <name>Don't show Modifier lock status on screen</name>
          <sysctl>general.hide_statusmessage</sysctl>
        </item>
        <item>
          <name>Don't restore modifiers in the mouse event</name>
          <appendix></appendix>
          <appendix>For example, when you use Option+Tab to Command+Tab,</appendix>
          <appendix>we send "Command+Click" when you did a mouse click while</appendix>
          <appendix>pushing the Option key after you pushed Option+Tab.</appendix>
          <appendix>"Option+Click" should be output, but this option changes this behavior.</appendix>
          <sysctl>general.lazy_modifiers_with_mouse_event</sysctl>
        </item>
        <item>
          <name>Disable NumPad Hack</name>
          <appendix>(Don't change FN+JKL.. to NumPad, and other FN+key combinations)</appendix>
          <sysctl>general.disable_numpad_hack</sysctl>
        </item>
        <item>
          <name>Excluding Devices</name>
          <list>
            <item>
              <name>Don't Remap Logitech Cordless Presenter</name>
              <sysctl>general.dont_remap_logitech_cordless_presenter</sysctl>
            </item>
          </list>
        </item>
      </list>
    </item>

    <item>
      <name>Pass Through Mode (Disable all settings temporarily)</name>
      <list>
        <item>
          <!-- Pass Through Mode Core -->
          <name>What's "Pass Through Mode".</name>
          <appendix>You can disable all settings temporarily.</appendix>
          <appendix>Turn on a setting below, and toggle "Pass Through Mode".</appendix>
          <sysctl>notsave.passthrough</sysctl>
          <vk_config>true</vk_config>
          <autogen>--ShowStatusMessage-- "Pass Through"</autogen>
        </item>
        <item>
          <name>Change FN+Escape to toggle "Pass Through Mode"</name>
          <sysctl>passthrough.fnescape</sysctl>
          <autogen>--KeyToKey-- KeyCode::ESCAPE, ModifierFlag::FN, KeyCode::VK_LOCK_ALL_FORCE_OFF, KeyCode::VK_CONFIG_TOGGLE_notsave_passthrough</autogen>
        </item>
        <item>
          <name>Simultaneous Key Presses [Escape+Tab] to toggle "Pass Through Mode"</name>
          <sysctl>passthrough.escapetab</sysctl>
          <autogen>--SimultaneousKeyPresses-- KeyCode::ESCAPE, KeyCode::TAB, KeyCode::VK_LOCK_ALL_FORCE_OFF, KeyCode::VK_CONFIG_TOGGLE_notsave_passthrough</autogen>
        </item>
        <item>
          <name>Holding Escape to toggle "Pass Through Mode"</name>
          <sysctl>passthrough.holding_escape</sysctl>
          <autogen>--HoldingKeyToKey-- KeyCode::ESCAPE, KeyCode::ESCAPE, KeyCode::VK_NONE, KeyCode::VK_LOCK_ALL_FORCE_OFF, KeyCode::VK_CONFIG_TOGGLE_notsave_passthrough</autogen>
        </item>
      </list>
    </item>

    <item>
      <name>Pointing Device</name>
      <list>
        <item>
          <name>CursorMove to ScrollWheel</name>
          <list>
            <item>
              <name>We can scroll pages by moving the mouse pointer.</name>
              <appendix>(Also, you can generate a click event if you click without moving)</appendix>
              <sysctl>notsave.pointing_relative_to_scroll</sysctl>
              <vk_config>true</vk_config>
              <autogen>--PointingRelativeToScroll-- PointingButton::NONE</autogen>
            </item>
            <item>
              <name>RightClick+CursorMove to ScrollWheel</name>
              <sysctl>remap.pointing_relative_rightclick_to_scroll</sysctl>
              <autogen>--PointingRelativeToScroll-- PointingButton::RIGHT</autogen>
            </item>
            <item>
              <name>MiddleClick+CursorMove to ScrollWheel</name>
              <sysctl>remap.pointing_relative_middleclick_to_scroll</sysctl>
              <autogen>--PointingRelativeToScroll-- PointingButton::MIDDLE</autogen>
            </item>
            <item>
              <name>MouseButton4+CursorMove to ScrollWheel</name>
              <sysctl>remap.pointing_relative_mousebutton4_to_scroll</sysctl>
              <autogen>--PointingRelativeToScroll-- PointingButton::BUTTON4</autogen>
            </item>
            <item>
              <name>Control+RightClick+CursorMove to ScrollWheel</name>
              <sysctl>remap.pointing_relative_controlRightClick_to_scroll</sysctl>
              <autogen>--PointingRelativeToScroll-- PointingButton::RIGHT, VK_CONTROL</autogen>
            </item>
            <item>
              <name>Shift+RightClick+CursorMove to ScrollWheel</name>
              <sysctl>remap.pointing_relative_shiftRightClick_to_scroll</sysctl>
              <autogen>--PointingRelativeToScroll-- PointingButton::RIGHT, VK_SHIFT</autogen>
            </item>
            <item>
              <name>Command+Control+CursorMove to ScrollWheel</name>
              <sysctl>remap.pointing_relative_commandControl_to_scroll</sysctl>
              <autogen>--PointingRelativeToScroll-- PointingButton::NONE, VK_COMMAND | VK_CONTROL</autogen>
            </item>
            <item>
              <name>FN+CursorMove to ScrollWheel</name>
              <sysctl>remap.pointing_relative_fn_to_scroll</sysctl>
              <autogen>--PointingRelativeToScroll-- PointingButton::NONE, ModifierFlag::FN</autogen>
            </item>
            <item>
              <name>Option+CursorMove to ScrollWheel</name>
              <sysctl>remap.pointing_relative_option_to_scroll</sysctl>
              <autogen>--PointingRelativeToScroll-- PointingButton::NONE, VK_OPTION</autogen>
            </item>
            <item>
              <name>(Simultaneous) LeftClick+RightClick+CursorMove to ScrollWheel</name>
              <sysctl>remap.pointing_relative_LRClick_to_scroll</sysctl>
              <autogen>--SimultaneousKeyPresses-- PointingButton::LEFT, PointingButton::RIGHT, KeyCode::VK_CONFIG_SYNC_KEYDOWNUP_notsave_pointing_relative_to_scroll</autogen>
            </item>
            <item>
              <name>CursorMove to ScrollWheel Option</name>
              <list>
                <item>
                  <name>Enable dynamic scrollwheel direction fixation (Horizontal/Vertical)</name>
                  <sysctl>option.pointing_enable_scrollwheel_fixation</sysctl>
                </item>
                <item>
                  <name>Disable Horizontal ScrollWheel</name>
                  <sysctl>option.pointing_disable_horizontal_scroll</sysctl>
                </item>
                <item>
                  <name>Disable Vertical ScrollWheel</name>
                  <sysctl>option.pointing_disable_vertical_scroll</sysctl>
                </item>
              </list>
            </item>
          </list>
        </item>
        <item>
          <name>Button to Button</name>
          <list>
            <item>
              <name>Control+LeftClick to MiddleClick</name>
              <sysctl>remap.pointing_controlLeftclick2middleclick</sysctl>
              <autogen>--PointingButtonToPointingButton-- PointingButton::LEFT, VK_CONTROL, PointingButton::MIDDLE</autogen>
            </item>
            <item>
              <name>FN+LeftClick to MiddleClick</name>
              <sysctl>remap.pointing_fnLeftclick2middleclick</sysctl>
              <autogen>--PointingButtonToPointingButton-- PointingButton::LEFT, ModifierFlag::FN, PointingButton::MIDDLE</autogen>
            </item>
            <item>
              <name>FN+LeftClick to Option_L+LeftClick</name>
              <sysctl>remap.pointing_fnLeftclick2optionLeftclick</sysctl>
              <autogen>--PointingButtonToPointingButton-- PointingButton::LEFT, ModifierFlag::FN, PointingButton::LEFT, ModifierFlag::OPTION_L</autogen>
            </item>
            <item>
              <name>Option+LeftClick to MiddleClick</name>
              <sysctl>remap.pointing_optionLeftclick2middleclick</sysctl>
              <autogen>--PointingButtonToPointingButton-- PointingButton::LEFT, VK_OPTION, PointingButton::MIDDLE</autogen>
            </item>
            <item>
              <name>RightClick to LeftClick</name>
              <sysctl>remap.pointing_rightclick2leftclick</sysctl>
              <autogen>--PointingButtonToPointingButton-- PointingButton::RIGHT, PointingButton::LEFT</autogen>
            </item>
            <item>
              <name>Control+RightClick to Double-LeftClick</name>
              <sysctl>remap.pointing_controlrightclick2doubleleftclick</sysctl>
              <autogen>--PointingButtonToPointingButton-- PointingButton::RIGHT, VK_CONTROL, PointingButton::LEFT, PointingButton::LEFT</autogen>
            </item>
            <item>
              <name>MiddleClick to Command+LeftClick</name>
              <sysctl>remap.pointing_middleclick2commandLeftclick</sysctl>
              <autogen>--PointingButtonToPointingButton-- PointingButton::MIDDLE, PointingButton::LEFT, ModifierFlag::COMMAND_L</autogen>
            </item>
            <item>
              <name>(Simultaneous) LeftClick+RightClick to MiddleClick</name>
              <sysctl>remap.pointing_leftrightclick2middleclick</sysctl>
              <autogen>--SimultaneousKeyPresses-- PointingButton::LEFT, PointingButton::RIGHT, PointingButton::MIDDLE</autogen>
            </item>
            <item>
              <name>(Simultaneous) LeftClick+RightClick to Button4</name>
              <sysctl>remap.pointing_leftrightclick2button4</sysctl>
              <autogen>--SimultaneousKeyPresses-- PointingButton::LEFT, PointingButton::RIGHT, PointingButton::BUTTON4</autogen>
            </item>
            <item>
              <name>(Simultaneous) LeftClick+RightClick to Button5</name>
              <sysctl>remap.pointing_leftrightclick2button5</sysctl>
              <autogen>--SimultaneousKeyPresses-- PointingButton::LEFT, PointingButton::RIGHT, PointingButton::BUTTON5</autogen>
            </item>
          </list>
        </item>
        <item>
          <name>Button to Key</name>
          <list>
            <item>
              <name>LeftClick to F12 (only in MacBookPro2,1 Trackpad)</name>
              <sysctl>remap.pointing_leftclick2f12_trackpad</sysctl>
              <device_only>DeviceVendorID(0x5ac),DeviceProductID(0x21a)</device_only>
              <autogen>--PointingButtonToKey-- PointingButton::LEFT, KeyCode::F12</autogen>
            </item>
            <item>
              <name>MiddleClick to Dashboard</name>
              <sysctl>remap.pointing_middleclick2dashboard</sysctl>
              <autogen>--PointingButtonToKey-- PointingButton::MIDDLE, KeyCode::DASHBOARD</autogen>
            </item>
            <item>
              <name>MiddleClick to Expose</name>
              <sysctl>remap.pointing_middleclick2expose</sysctl>
              <autogen>--PointingButtonToKey-- PointingButton::MIDDLE, KeyCode::EXPOSE_ALL</autogen>
            </item>
            <item>
              <name>MiddleClick to F8</name>
              <sysctl>remap.pointing_middleclick2f8</sysctl>
              <autogen>--PointingButtonToKey-- PointingButton::MIDDLE, KeyCode::F8</autogen>
            </item>
            <item>
              <name>MiddleClick to Control+F4 (= Move focus to active or next window)</name>
              <sysctl>remap.pointing_middleclick2controlF4</sysctl>
              <autogen>--PointingButtonToKey-- PointingButton::MIDDLE, KeyCode::F4, ModifierFlag::CONTROL_L</autogen>
            </item>
            <item>
              <name>Button4 to Command+[</name>
              <sysctl>remap.pointing_button4_to_command_bracket_left</sysctl>
              <autogen>--PointingButtonToKey-- PointingButton::BUTTON4, KeyCode::BRACKET_LEFT, ModifierFlag::COMMAND_L</autogen>
            </item>
            <item>
              <name>Button5 to Command+]</name>
              <sysctl>remap.pointing_button5_to_command_bracket_right</sysctl>
              <autogen>--PointingButtonToKey-- PointingButton::BUTTON5, KeyCode::BRACKET_RIGHT, ModifierFlag::COMMAND_L</autogen>
            </item>
            <item>
              <name>(Simultaneous) LeftClick+RightClick to Dashboard</name>
              <sysctl>remap.pointing_leftrightclick2dashboard</sysctl>
              <autogen>--SimultaneousKeyPresses-- PointingButton::LEFT, PointingButton::RIGHT, KeyCode::DASHBOARD</autogen>
            </item>
            <item>
              <name>(Simultaneous) LeftClick+RightClick to Expose</name>
              <sysctl>remap.pointing_leftrightclick2expose</sysctl>
              <autogen>--SimultaneousKeyPresses-- PointingButton::LEFT, PointingButton::RIGHT, KeyCode::EXPOSE_ALL</autogen>
            </item>
            <item>
              <name>(Simultaneous) LeftClick+RightClick to F8</name>
              <sysctl>remap.pointing_leftrightclick2f8</sysctl>
              <autogen>--SimultaneousKeyPresses-- PointingButton::LEFT, PointingButton::RIGHT, KeyCode::F8</autogen>
            </item>
          </list>
        </item>
      </list>
    </item>

    <item>
      <name>Change Arrow(Up/Down/Left/Right) Key</name>
      <list>
        <item>
          <name>Arrow(Down/Left/Right) to FN</name>
          <appendix>drop Up-Arrow</appendix>
          <sysctl>remap.arrow2fn</sysctl>
          <autogen>--KeyToKey-- KeyCode::CURSOR_UP, KeyCode::VK_NONE</autogen>
          <autogen>--KeyToKey-- KeyCode::CURSOR_DOWN, KeyCode::FN</autogen>
          <autogen>--KeyToKey-- KeyCode::CURSOR_LEFT, KeyCode::FN</autogen>
          <autogen>--KeyToKey-- KeyCode::CURSOR_RIGHT, KeyCode::FN</autogen>
        </item>
        <item>
          <name>Arrow(Down/Left/Right) to Option_L</name>
          <appendix>drop Up-Arrow</appendix>
          <sysctl>remap.arrow2optionL</sysctl>
          <autogen>--KeyToKey-- KeyCode::CURSOR_UP, KeyCode::VK_NONE</autogen>
          <autogen>--KeyToKey-- KeyCode::CURSOR_DOWN, KeyCode::OPTION_L</autogen>
          <autogen>--KeyToKey-- KeyCode::CURSOR_LEFT, KeyCode::OPTION_L</autogen>
          <autogen>--KeyToKey-- KeyCode::CURSOR_RIGHT, KeyCode::OPTION_L</autogen>
        </item>
        <item>
          <name>Command+Arrow to Option_L+Arrow</name>
          <sysctl>remap.commandArrow2optionLarrow</sysctl>
          <autogen>--KeyToKey-- KeyCode::CURSOR_UP, VK_COMMAND, KeyCode::CURSOR_UP, ModifierFlag::OPTION_L</autogen>
          <autogen>--KeyToKey-- KeyCode::CURSOR_DOWN, VK_COMMAND, KeyCode::CURSOR_DOWN, ModifierFlag::OPTION_L</autogen>
          <autogen>--KeyToKey-- KeyCode::CURSOR_LEFT, VK_COMMAND, KeyCode::CURSOR_LEFT, ModifierFlag::OPTION_L</autogen>
          <autogen>--KeyToKey-- KeyCode::CURSOR_RIGHT, VK_COMMAND, KeyCode::CURSOR_RIGHT, ModifierFlag::OPTION_L</autogen>
        </item>
        <item>
          <name>Command_R+Arrow to PageUp/PageDown/Home/End</name>
          <sysctl>remap.commandR_arrow2PgUpDnHomeEnd</sysctl>
          <autogen>--KeyToKey-- KeyCode::CURSOR_UP,    ModifierFlag::COMMAND_R, KeyCode::PAGEUP</autogen>
          <autogen>--KeyToKey-- KeyCode::CURSOR_DOWN,  ModifierFlag::COMMAND_R, KeyCode::PAGEDOWN</autogen>
          <autogen>--KeyToKey-- KeyCode::CURSOR_LEFT,  ModifierFlag::COMMAND_R, KeyCode::HOME</autogen>
          <autogen>--KeyToKey-- KeyCode::CURSOR_RIGHT, ModifierFlag::COMMAND_R, KeyCode::END</autogen>
        </item>
        <item>
          <name>Option_R+Arrow to PageUp/PageDown/Home/End</name>
          <sysctl>remap.optionR_arrow2PgUpDnHomeEnd</sysctl>
          <autogen>--KeyToKey-- KeyCode::CURSOR_UP, ModifierFlag::OPTION_R, KeyCode::PAGEUP</autogen>
          <autogen>--KeyToKey-- KeyCode::CURSOR_DOWN, ModifierFlag::OPTION_R, KeyCode::PAGEDOWN</autogen>
          <autogen>--KeyToKey-- KeyCode::CURSOR_LEFT, ModifierFlag::OPTION_R, KeyCode::HOME</autogen>
          <autogen>--KeyToKey-- KeyCode::CURSOR_RIGHT, ModifierFlag::OPTION_R, KeyCode::END</autogen>
        </item>
        <item>
          <name>Left-Arrow to Control_L</name>
          <sysctl>remap.leftarrow2controlL</sysctl>
          <autogen>--KeyToKey-- KeyCode::CURSOR_LEFT, KeyCode::CONTROL_L</autogen>
        </item>
        <item>
          <name>Command+Left-Arrow to Shift_L+Home,Command_L+X</name>
          <appendix>(only in virtual machine, RDC)</appendix>
          <sysctl>remap.commandLeftarrow2beginningofline_cut_vm</sysctl>
          <only>VIRTUALMACHINE, REMOTEDESKTOPCONNECTION</only>
          <autogen>--KeyToKey-- KeyCode::CURSOR_LEFT, VK_COMMAND | ModifierFlag::NONE, KeyCode::HOME, ModifierFlag::SHIFT_L, KeyCode::X, ModifierFlag::COMMAND_L</autogen>
        </item>
        <item>
          <name>Command+Left-Arrow to Shift_L+Home,Control_L+X</name>
          <appendix>(only in virtual machine, RDC)</appendix>
          <sysctl>remap.commandLeftarrow2beginningofline_cut2_vm</sysctl>
          <only>VIRTUALMACHINE, REMOTEDESKTOPCONNECTION</only>
          <autogen>--KeyToKey-- KeyCode::CURSOR_LEFT, VK_COMMAND | ModifierFlag::NONE, KeyCode::HOME, ModifierFlag::SHIFT_L, KeyCode::X, ModifierFlag::CONTROL_L</autogen>
        </item>
        <item>
          <name>Command+Left-Arrow to Command_L+Shift_L+Left-Arrow,Command_L+X</name>
          <appendix>(except virtual machine, RDC)</appendix>
          <sysctl>remap.commandLeftarrow2beginningofline_cut</sysctl>
          <not>VIRTUALMACHINE, REMOTEDESKTOPCONNECTION</not>
          <autogen>--KeyToKey-- KeyCode::CURSOR_LEFT, VK_COMMAND | ModifierFlag::NONE, KeyCode::CURSOR_LEFT, ModifierFlag::COMMAND_L | ModifierFlag::SHIFT_L, KeyCode::X, ModifierFlag::COMMAND_L</autogen>
        </item>
        <item>
          <name>Command+Left-Arrow to Command_L+Shift_L+Left-Arrow,Control_L+X</name>
          <appendix>(except virtual machine, RDC)</appendix>
          <sysctl>remap.commandLeftarrow2beginningofline_cut2</sysctl>
          <not>VIRTUALMACHINE, REMOTEDESKTOPCONNECTION</not>
          <autogen>--KeyToKey-- KeyCode::CURSOR_LEFT, VK_COMMAND | ModifierFlag::NONE, KeyCode::CURSOR_LEFT, ModifierFlag::COMMAND_L | ModifierFlag::SHIFT_L, KeyCode::X, ModifierFlag::CONTROL_L</autogen>
        </item>
        <item>
          <name>Command+Right-Arrow to Shift_L+End,Command_L+X</name>
          <appendix>(only in virtual machine, RDC)</appendix>
          <sysctl>remap.commandRightarrow2endofline_cut_vm</sysctl>
          <only>VIRTUALMACHINE, REMOTEDESKTOPCONNECTION</only>
          <autogen>--KeyToKey-- KeyCode::CURSOR_RIGHT, VK_COMMAND | ModifierFlag::NONE, KeyCode::END, ModifierFlag::SHIFT_L, KeyCode::X, ModifierFlag::COMMAND_L</autogen>
        </item>
        <item>
          <name>Command+Right-Arrow to Shift_L+End,Control_L+X</name>
          <appendix>(only in virtual machine, RDC)</appendix>
          <sysctl>remap.commandRightarrow2endofline_cut2_vm</sysctl>
          <only>VIRTUALMACHINE, REMOTEDESKTOPCONNECTION</only>
          <autogen>--KeyToKey-- KeyCode::CURSOR_RIGHT, VK_COMMAND | ModifierFlag::NONE, KeyCode::END, ModifierFlag::SHIFT_L, KeyCode::X, ModifierFlag::CONTROL_L</autogen>
        </item>
        <item>
          <name>Command+Right-Arrow to Command_L+Shift_L+Right-Arrow,Command_L+X</name>
          <appendix>(except virtual machine, RDC)</appendix>
          <sysctl>remap.commandRightarrow2endofline_cut</sysctl>
          <not>VIRTUALMACHINE, REMOTEDESKTOPCONNECTION</not>
          <autogen>--KeyToKey-- KeyCode::CURSOR_RIGHT, VK_COMMAND | ModifierFlag::NONE, KeyCode::CURSOR_RIGHT, ModifierFlag::COMMAND_L | ModifierFlag::SHIFT_L, KeyCode::X, ModifierFlag::COMMAND_L</autogen>
        </item>
        <item>
          <name>Command+Right-Arrow to Command_L+Shift_L+Right-Arrow,Control_L+X</name>
          <appendix>(except virtual machine, RDC)</appendix>
          <sysctl>remap.commandRightarrow2endofline_cut2</sysctl>
          <not>VIRTUALMACHINE, REMOTEDESKTOPCONNECTION</not>
          <autogen>--KeyToKey-- KeyCode::CURSOR_RIGHT, VK_COMMAND | ModifierFlag::NONE, KeyCode::CURSOR_RIGHT, ModifierFlag::COMMAND_L | ModifierFlag::SHIFT_L, KeyCode::X, ModifierFlag::CONTROL_L</autogen>
        </item>
      </list>
    </item>

    <item>
      <name>Change Backquote(`) Key</name>
      <list>
        <item>
          <name>Backquote(`) to CapsLock</name>
          <sysctl>remap.backquote2capslock</sysctl>
          <autogen>--KeyToKey-- KeyCode::BACKQUOTE, KeyCode::CAPSLOCK</autogen>
        </item>
        <item>
          <name>Backquote(`) to Command_L</name>
          <sysctl>remap.backquote2commandL</sysctl>
          <autogen>--KeyToKey-- KeyCode::BACKQUOTE, KeyCode::COMMAND_L</autogen>
        </item>
        <item>
          <name>Backquote(`) to Control_L</name>
          <sysctl>remap.backquote2controlL</sysctl>
          <autogen>--KeyToKey-- KeyCode::BACKQUOTE, KeyCode::CONTROL_L</autogen>
        </item>
        <item>
          <name>Backquote(`) to Option_L</name>
          <sysctl>remap.backquote2optionL</sysctl>
          <autogen>--KeyToKey-- KeyCode::BACKQUOTE, KeyCode::OPTION_L</autogen>
        </item>
        <item>
          <name>Backquote(`) to Delete</name>
          <sysctl>remap.backquote2delete</sysctl>
          <autogen>--KeyToKey-- KeyCode::BACKQUOTE, KeyCode::DELETE</autogen>
        </item>
        <item>
          <name>Backquote(`) to Escape</name>
          <sysctl>remap.backquote2escape</sysctl>
          <autogen>--KeyToKey-- KeyCode::BACKQUOTE, KeyCode::ESCAPE</autogen>
        </item>
        <item>
          <name>Backquote(`) to Escape if no modifiers pressed</name>
          <sysctl>remap.backquote2escape_withoutmodifiers</sysctl>
          <autogen>--KeyToKey-- KeyCode::BACKQUOTE, ModifierFlag::NONE, KeyCode::ESCAPE</autogen>
        </item>
        <item>
          <name>Backquote(`) to Forward Delete</name>
          <sysctl>remap.backquote2forwarddelete</sysctl>
          <autogen>--KeyToKey-- KeyCode::BACKQUOTE, KeyCode::FORWARD_DELETE</autogen>
        </item>
        <item>
          <name>Backquote(`) to F8</name>
          <sysctl>remap.backquote2f8</sysctl>
          <autogen>--KeyToKey-- KeyCode::BACKQUOTE, KeyCode::F8</autogen>
        </item>
        <item>
          <name>Swap Command+Backquote(`) and Option+Backquote(`)</name>
          <sysctl>remap.swap_commandbackquote_optionbackquote</sysctl>
          <autogen>--KeyToKey-- KeyCode::BACKQUOTE, ModifierFlag::COMMAND_L, KeyCode::BACKQUOTE, ModifierFlag::OPTION_L</autogen>
          <autogen>--KeyToKey-- KeyCode::BACKQUOTE, ModifierFlag::OPTION_L,  KeyCode::BACKQUOTE, ModifierFlag::COMMAND_L</autogen>
        </item>
      </list>
    </item>

    <item>
      <name>Change Backslash(\) Key</name>
      <list>
        <item>
          <name>Backslash(\) to Delete</name>
          <sysctl>remap.backslash2delete</sysctl>
          <autogen>--KeyToKey-- KeyCode::BACKSLASH, KeyCode::DELETE</autogen>
        </item>
        <item>
          <name>Backslash(\) to Delete</name>
          <appendix>(+ FN+Backslash(\) to Backslash(\))</appendix>
          <appendix>(+ retain Shift+Backslash(\))</appendix>
          <sysctl>remap.backslash2delete_retain_shiftbackslash</sysctl>
          <autogen>--KeyToKey-- KeyCode::BACKSLASH, ModifierFlag::FN, KeyCode::BACKSLASH</autogen>
          <autogen>--KeyToKey-- KeyCode::BACKSLASH, VK_SHIFT, KeyCode::BACKSLASH, ModifierFlag::SHIFT_L</autogen>
          <autogen>--KeyToKey-- KeyCode::BACKSLASH, KeyCode::DELETE</autogen>
        </item>
        <item>
          <name>Backslash(\) to Enter</name>
          <sysctl>remap.backslash2enter</sysctl>
          <autogen>--KeyToKey-- KeyCode::BACKSLASH, KeyCode::ENTER</autogen>
        </item>
        <item>
          <name>Backslash(\) to Forward Delete</name>
          <appendix>(+ FN+Backslash(\) to Backslash(\))</appendix>
          <sysctl>remap.backslash2forwarddelete</sysctl>
          <autogen>--KeyToKey-- KeyCode::BACKSLASH, ModifierFlag::FN, KeyCode::BACKSLASH</autogen>
          <autogen>--KeyToKey-- KeyCode::BACKSLASH, KeyCode::FORWARD_DELETE</autogen>
        </item>
        <item>
          <name>Backslash(\) to Forward Delete</name>
          <appendix>(+ FN+Backslash(\) to Backslash(\))</appendix>
          <appendix>(+ retain Shift+Backslash(\))</appendix>
          <sysctl>remap.backslash2forwarddelete_retain_shiftbackslash</sysctl>
          <autogen>--KeyToKey-- KeyCode::BACKSLASH, ModifierFlag::FN, KeyCode::BACKSLASH</autogen>
          <autogen>--KeyToKey-- KeyCode::BACKSLASH, VK_SHIFT, KeyCode::BACKSLASH, ModifierFlag::SHIFT_L</autogen>
          <autogen>--KeyToKey-- KeyCode::BACKSLASH, KeyCode::FORWARD_DELETE</autogen>
        </item>
        <item>
          <name>Backslash(\) to Forward Delete (if no other modifiers pressed)</name>
          <sysctl>remap.backslash2forwarddelete_nomods</sysctl>
          <autogen>--KeyToKey-- KeyCode::BACKSLASH, ModifierFlag::NONE, KeyCode::FORWARD_DELETE</autogen>
        </item>
        <item>
          <name>Backslash(\) to Return</name>
          <sysctl>remap.backslash2return</sysctl>
          <autogen>--KeyToKey-- KeyCode::BACKSLASH, KeyCode::RETURN</autogen>
        </item>
      </list>
    </item>

    <item>
      <name>Change CapsLock Key</name>
      <appendix>*** Use "PCKeyboardHack" to change CapsLock key.</appendix>
      <appendix>*** &#8594; http://pqrs.org/macosx/keyremap4macbook/extra.html</appendix>
    </item>

    <item>
      <name>Change Command_L Key (Left Command)</name>
      <list>
        <item>
          <name>Command_L to Control_L</name>
          <sysctl>remap.commandL2controlL</sysctl>
          <autogen>--KeyToKey-- KeyCode::COMMAND_L, KeyCode::CONTROL_L</autogen>
        </item>
        <item>
          <name>Command_L to Control_L (only in virtual machine, RDC)</name>
          <sysctl>remap.commandL2controlL_vm</sysctl>
          <only>VIRTUALMACHINE, REMOTEDESKTOPCONNECTION</only>
          <autogen>--KeyToKey-- KeyCode::COMMAND_L, KeyCode::CONTROL_L</autogen>
        </item>
        <item>
          <name>Command_L to Control_L (only in RDC)</name>
          <sysctl>remap.commandL2controlL_rdc</sysctl>
          <only>REMOTEDESKTOPCONNECTION</only>
          <autogen>--KeyToKey-- KeyCode::COMMAND_L, KeyCode::CONTROL_L</autogen>
        </item>
        <item>
          <name>Command_L to Control_L (only in X11)</name>
          <sysctl>remap.commandL2controlL_x11</sysctl>
          <only>X11</only>
          <autogen>--KeyToKey-- KeyCode::COMMAND_L, KeyCode::CONTROL_L</autogen>
        </item>
        <item>
          <name>Command_L to Control_L (only in Emacs)</name>
          <sysctl>remap.commandL2controlL_emacs</sysctl>
          <only>EMACS</only>
          <autogen>--KeyToKey-- KeyCode::COMMAND_L, KeyCode::CONTROL_L</autogen>
        </item>
        <item>
          <name>Command_L to Control_L (except Emacs)</name>
          <sysctl>remap.commandL2controlL_ex_emacs</sysctl>
          <not>EMACS</not>
          <autogen>--KeyToKey-- KeyCode::COMMAND_L, KeyCode::CONTROL_L</autogen>
        </item>
        <item>
          <name>Command_L to Option_L</name>
          <sysctl>remap.commandL2optionL</sysctl>
          <autogen>--KeyToKey-- KeyCode::COMMAND_L, KeyCode::OPTION_L</autogen>
        </item>
        <item>
          <name>Command_L to Option_L (only in virtual machine, RDC)</name>
          <sysctl>remap.commandL2optionL_vm</sysctl>
          <only>VIRTUALMACHINE, REMOTEDESKTOPCONNECTION</only>
          <autogen>--KeyToKey-- KeyCode::COMMAND_L, KeyCode::OPTION_L</autogen>
        </item>
        <item>
          <name>Command_L to Option_L (only in Emacs)</name>
          <sysctl>remap.commandL2optionL_emacs</sysctl>
          <only>EMACS</only>
          <autogen>--KeyToKey-- KeyCode::COMMAND_L, KeyCode::OPTION_L</autogen>
        </item>
        <item>
          <name>Command_L to Shift_L</name>
          <sysctl>remap.commandL2shiftL</sysctl>
          <autogen>--KeyToKey-- KeyCode::COMMAND_L, KeyCode::SHIFT_L</autogen>
        </item>
        <item>
          <name>Command_L to Backquote(`)</name>
          <sysctl>remap.commandL2backquote</sysctl>
          <autogen>--KeyToKey-- KeyCode::COMMAND_L, KeyCode::BACKQUOTE</autogen>
        </item>
        <item>
          <name>Command_L to Escape</name>
          <sysctl>remap.commandL2escape</sysctl>
          <autogen>--KeyToKey-- KeyCode::COMMAND_L, KeyCode::ESCAPE</autogen>
        </item>
        <item>
          <name>Command_L to Escape (only in Emacs)</name>
          <sysctl>remap.commandL2escape_emacs</sysctl>
          <only>EMACS</only>
          <autogen>--KeyToKey-- KeyCode::COMMAND_L, KeyCode::ESCAPE</autogen>
        </item>
        <item>
          <name>Command_R+Command_L to Escape</name>
          <appendix>(Note: Escape is sent when you release Command_L)</appendix>
          <sysctl>remap.commandRcommandL2escape</sysctl>
          <autogen>--KeyOverlaidModifier-- KeyCode::COMMAND_L, ModifierFlag::COMMAND_R, KeyCode::COMMAND_L, ModifierFlag::COMMAND_R, KeyCode::ESCAPE</autogen>
        </item>
        <item>
          <name>Control_L+Command_L to Escape</name>
          <appendix>(Note: Escape is sent when you release Command_L)</appendix>
          <sysctl>remap.controlLcommandL2escape</sysctl>
          <autogen>--KeyOverlaidModifier-- KeyCode::COMMAND_L, ModifierFlag::CONTROL_L, KeyCode::COMMAND_L, ModifierFlag::CONTROL_L, KeyCode::ESCAPE</autogen>
        </item>
        <item>
          <name>Shift_L+Command_L to Escape</name>
          <appendix>(Note: Escape is sent when you release Command_L)</appendix>
          <sysctl>remap.shiftLcommandL2escape</sysctl>
          <autogen>--KeyOverlaidModifier-- KeyCode::COMMAND_L, ModifierFlag::SHIFT_L, KeyCode::COMMAND_L, ModifierFlag::SHIFT_L, KeyCode::ESCAPE</autogen>
        </item>
      </list>
    </item>

    <item>
      <name>Change Command_R Key (Right Command)</name>
      <list>
        <item>
          <name>Command_R to Command_R</name>
          <appendix>(+ When you type Command_R only, send Command+Space)</appendix>
          <sysctl>remap.commandR2commandR_commandSpace</sysctl>
          <autogen>--KeyOverlaidModifier-- KeyCode::COMMAND_R, KeyCode::COMMAND_R, KeyCode::SPACE, ModifierFlag::COMMAND_L</autogen>
        </item>
        <item>
          <name>Command_R to Command_R</name>
          <appendix>(+ When you type Command_R only, send Enter)</appendix>
          <sysctl>remap.commandR2commandR_enter</sysctl>
          <autogen>--KeyOverlaidModifier-- KeyCode::COMMAND_R, KeyCode::COMMAND_R, KeyCode::ENTER</autogen>
        </item>
        <item>
          <name>Command_R to Command_R</name>
          <appendix>(+ When you type Command_R only, send Enter) + [KeyRepeat]</appendix>
          <sysctl>remap.commandR2commandR_enter_keyrepeat</sysctl>
          <autogen>--KeyOverlaidModifierWithRepeat-- KeyCode::COMMAND_R, KeyCode::COMMAND_R, KeyCode::ENTER</autogen>
        </item>
        <item>
          <name>Command_R to Control_L</name>
          <sysctl>remap.commandR2controlL</sysctl>
          <autogen>--KeyToKey-- KeyCode::COMMAND_R, KeyCode::CONTROL_L</autogen>
        </item>
        <item>
          <name>Command_R to Control_R (only in virtual machine, RDC)</name>
          <sysctl>remap.commandR2controlR_vm</sysctl>
          <only>VIRTUALMACHINE, REMOTEDESKTOPCONNECTION</only>
          <autogen>--KeyToKey-- KeyCode::COMMAND_R, KeyCode::CONTROL_R</autogen>
        </item>
        <item>
          <name>Command_R to Control_L (only in X11)</name>
          <sysctl>remap.commandR2controlL_x11</sysctl>
          <only>X11</only>
          <autogen>--KeyToKey-- KeyCode::COMMAND_R, KeyCode::CONTROL_L</autogen>
        </item>
        <item>
          <name>Command_R to FN</name>
          <sysctl>remap.commandR2fn</sysctl>
          <autogen>--KeyToKey-- KeyCode::COMMAND_R, KeyCode::FN</autogen>
        </item>
        <item>
          <name>Command_R to FN (only in virtual machine)</name>
          <sysctl>remap.commandR2fn_vm</sysctl>
          <only>VIRTUALMACHINE</only>
          <autogen>--KeyToKey-- KeyCode::COMMAND_R, KeyCode::FN</autogen>
        </item>
        <item>
          <name>Option_R+Command_R to FN</name>
          <sysctl>remap.optionRcommandR2fn</sysctl>
          <autogen>--KeyToKey-- KeyCode::COMMAND_R, ModifierFlag::OPTION_R, KeyCode::FN</autogen>
        </item>
        <item>
          <name>Command_R to Option_L</name>
          <sysctl>remap.commandR2optionL</sysctl>
          <autogen>--KeyToKey-- KeyCode::COMMAND_R, KeyCode::OPTION_L</autogen>
        </item>
        <item>
          <name>Command_R to Option_R</name>
          <sysctl>remap.commandR2optionR</sysctl>
          <autogen>--KeyToKey-- KeyCode::COMMAND_R, KeyCode::OPTION_R</autogen>
        </item>
        <item>
          <name>Command_R to Option_R (only in Emacs, Terminal, X11)</name>
          <sysctl>remap.commandR2optionR_etx</sysctl>
          <only>EMACS, TERMINAL, X11</only>
          <autogen>--KeyToKey-- KeyCode::COMMAND_R, KeyCode::OPTION_R</autogen>
        </item>
        <item>
          <name>Command_R to Shift_L</name>
          <sysctl>remap.commandR2shiftL</sysctl>
          <autogen>--KeyToKey-- KeyCode::COMMAND_R, KeyCode::SHIFT_L</autogen>
        </item>
        <item>
          <name>Command_R to Enter</name>
          <sysctl>remap.commandR2enter</sysctl>
          <autogen>--KeyToKey-- KeyCode::COMMAND_R, KeyCode::ENTER</autogen>
        </item>
        <item>
          <name>Command_R to Escape</name>
          <sysctl>remap.commandR2escape</sysctl>
          <autogen>--KeyToKey-- KeyCode::COMMAND_R, KeyCode::ESCAPE</autogen>
        </item>
        <item>
          <name>Command_R to Delete</name>
          <sysctl>remap.commandR2delete</sysctl>
          <autogen>--KeyToKey-- KeyCode::COMMAND_R, KeyCode::DELETE</autogen>
        </item>
        <item>
          <name>Command_R to Forward Delete</name>
          <sysctl>remap.commandR2forwarddelete</sysctl>
          <autogen>--KeyToKey-- KeyCode::COMMAND_R, KeyCode::FORWARD_DELETE</autogen>
        </item>
        <item>
          <name>Command_R to Home</name>
          <sysctl>remap.commandR2home</sysctl>
          <autogen>--KeyToKey-- KeyCode::COMMAND_R, KeyCode::HOME</autogen>
        </item>
        <item>
          <name>Command_R to Home (only in virtual machine, RDC)</name>
          <sysctl>remap.commandR2home_vm</sysctl>
          <only>VIRTUALMACHINE, REMOTEDESKTOPCONNECTION</only>
          <autogen>--KeyToKey-- KeyCode::COMMAND_R, KeyCode::HOME</autogen>
        </item>
        <item>
          <name>Command_R to Home (only in virtual machine, RDC)</name>
          <appendix>(+ Shift+Command_R to Shift+Home,Control_L+C)</appendix>
          <sysctl>remap.commandR2home_vm_ex</sysctl>
          <only>VIRTUALMACHINE, REMOTEDESKTOPCONNECTION</only>
          <autogen>--KeyToKey-- KeyCode::COMMAND_R, VK_SHIFT, KeyCode::HOME, ModifierFlag::SHIFT_L, KeyCode::C, ModifierFlag::CONTROL_L</autogen>
          <autogen>--KeyToKey-- KeyCode::COMMAND_R, KeyCode::HOME</autogen>
        </item>
        <item>
          <name>Command_R to Home (only in virtual machine, RDC)</name>
          <appendix>(+ Shift+Command_R to Shift+Home,Command_L+C)</appendix>
          <sysctl>remap.commandR2home_vm_ex2</sysctl>
          <only>VIRTUALMACHINE, REMOTEDESKTOPCONNECTION</only>
          <autogen>--KeyToKey-- KeyCode::COMMAND_R, VK_SHIFT, KeyCode::HOME, ModifierFlag::SHIFT_L, KeyCode::C, ModifierFlag::COMMAND_L</autogen>
          <autogen>--KeyToKey-- KeyCode::COMMAND_R, KeyCode::HOME</autogen>
        </item>
        <item>
          <name>Command_R to Command_L+Left-Arrow (except virtual machine, RDC)</name>
          <sysctl>remap.commandR2commandLleftarrow</sysctl>
          <not>VIRTUALMACHINE, REMOTEDESKTOPCONNECTION</not>
          <autogen>--KeyToKey-- KeyCode::COMMAND_R, KeyCode::CURSOR_LEFT, ModifierFlag::COMMAND_L</autogen>
        </item>
        <item>
          <name>Command_R to Command_L+Left-Arrow (except virtual machine, RDC)</name>
          <appendix>(+ Shift+Command_R to Command_L+Shift_L+Left-Arrow,Command_L+C)</appendix>
          <sysctl>remap.commandR2commandLleftarrow_ex</sysctl>
          <not>VIRTUALMACHINE, REMOTEDESKTOPCONNECTION</not>
          <autogen>--KeyToKey-- KeyCode::COMMAND_R, VK_SHIFT, KeyCode::CURSOR_LEFT, ModifierFlag::COMMAND_L | ModifierFlag::SHIFT_L, KeyCode::C, ModifierFlag::COMMAND_L</autogen>
          <autogen>--KeyToKey-- KeyCode::COMMAND_R, KeyCode::CURSOR_LEFT, ModifierFlag::COMMAND_L</autogen>
        </item>
        <item>
          <name>Command_R to Command_L+Left-Arrow (except virtual machine, RDC)</name>
          <appendix>(+ Shift+Command_R to Command_L+Shift_L+Left-Arrow,Control_L+C)</appendix>
          <sysctl>remap.commandR2commandLleftarrow_ex2</sysctl>
          <not>VIRTUALMACHINE, REMOTEDESKTOPCONNECTION</not>
          <autogen>--KeyToKey-- KeyCode::COMMAND_R, VK_SHIFT, KeyCode::CURSOR_LEFT, ModifierFlag::COMMAND_L | ModifierFlag::SHIFT_L, KeyCode::C, ModifierFlag::CONTROL_L</autogen>
          <autogen>--KeyToKey-- KeyCode::COMMAND_R, KeyCode::CURSOR_LEFT, ModifierFlag::COMMAND_L</autogen>
        </item>
        <item>
          <name>Command_R to Command_L+Left-Arrow</name>
          <sysctl>remap.commandR2commandLleftarrow_all</sysctl>
          <autogen>--KeyToKey-- KeyCode::COMMAND_R, KeyCode::CURSOR_LEFT, ModifierFlag::COMMAND_L</autogen>
        </item>
        <item>
          <name>Command_R to PageUp</name>
          <sysctl>remap.commandR2pageup</sysctl>
          <autogen>--KeyToKey-- KeyCode::COMMAND_R, KeyCode::PAGEUP</autogen>
        </item>
        <item>
          <name>Command_R to Space</name>
          <sysctl>remap.commandR2space</sysctl>
          <autogen>--KeyToKey-- KeyCode::COMMAND_R, KeyCode::SPACE</autogen>
        </item>
        <item>
          <name>Command_R to LeftClick</name>
          <sysctl>remap.commandR2leftclick</sysctl>
          <autogen>--KeyToPointingButton-- KeyCode::COMMAND_R, PointingButton::LEFT</autogen>
        </item>
        <item>
          <name>Command_R to MiddleClick</name>
          <sysctl>remap.commandR2middleclick</sysctl>
          <autogen>--KeyToPointingButton-- KeyCode::COMMAND_R, PointingButton::MIDDLE</autogen>
        </item>
        <item>
          <name>Command_R to RightClick</name>
          <sysctl>remap.commandR2rightclick</sysctl>
          <autogen>--KeyToPointingButton-- KeyCode::COMMAND_R, PointingButton::RIGHT</autogen>
        </item>
        <item>
          <name>Command_L+Command_R to Return</name>
          <appendix>(Note: Return is sent when you release Command_R)</appendix>
          <sysctl>remap.commandLcommandR2return</sysctl>
          <autogen>--KeyOverlaidModifier-- KeyCode::COMMAND_R, ModifierFlag::COMMAND_L, KeyCode::COMMAND_R, ModifierFlag::COMMAND_L, KeyCode::RETURN</autogen>
        </item>
        <item>
          <name>Command_L+Command_R to Enter</name>
          <appendix>(Note: Enter is sent when you release Command_R)</appendix>
          <sysctl>remap.commandLcommandR2enter</sysctl>
          <autogen>--KeyOverlaidModifier-- KeyCode::COMMAND_R, ModifierFlag::COMMAND_L, KeyCode::COMMAND_R, ModifierFlag::COMMAND_L, KeyCode::ENTER</autogen>
        </item>
        <item>
          <name>Control_L+Command_R to Return</name>
          <appendix>(Note: Return is sent when you release Command_R)</appendix>
          <sysctl>remap.controlLcommandR2return</sysctl>
          <autogen>--KeyOverlaidModifier-- KeyCode::COMMAND_R, ModifierFlag::CONTROL_L, KeyCode::COMMAND_R, ModifierFlag::CONTROL_L, KeyCode::RETURN</autogen>
        </item>
        <item>
          <name>Shift_L+Command_R to Return</name>
          <appendix>(Note: Return is sent when you release Command_R)</appendix>
          <sysctl>remap.shiftLcommandR2return</sysctl>
          <autogen>--KeyOverlaidModifier-- KeyCode::COMMAND_R, ModifierFlag::SHIFT_L, KeyCode::COMMAND_R, ModifierFlag::SHIFT_L, KeyCode::RETURN</autogen>
        </item>
      </list>
    </item>

    <item>
      <name>Change Control_L Key (Left Control)</name>
      <list>
        <item>
          <name>Control_L to Command_L</name>
          <sysctl>remap.controlL2commandL</sysctl>
          <autogen>--KeyToKey-- KeyCode::CONTROL_L, KeyCode::COMMAND_L</autogen>
        </item>
        <item>
          <name>Control_L to Command_L (only in virtual machine, RDC)</name>
          <sysctl>remap.controlL2commandL_vm</sysctl>
          <only>VIRTUALMACHINE, REMOTEDESKTOPCONNECTION</only>
          <autogen>--KeyToKey-- KeyCode::CONTROL_L, KeyCode::COMMAND_L</autogen>
        </item>
        <item>
          <name>Control_L to Command_L (only in X11)</name>
          <sysctl>remap.controlL2commandL_x11</sysctl>
          <only>X11</only>
          <autogen>--KeyToKey-- KeyCode::CONTROL_L, KeyCode::COMMAND_L</autogen>
        </item>
        <item>
          <name>Control_L to Command_L (except Emacs)</name>
          <sysctl>remap.controlL2commandL_ex_emacs</sysctl>
          <not>EMACS</not>
          <autogen>--KeyToKey-- KeyCode::CONTROL_L, KeyCode::COMMAND_L</autogen>
        </item>
        <item>
          <name>Control_L to Control_L</name>
          <appendix>(+ When you type Control_L only, send Delete)</appendix>
          <sysctl>remap.controlL2controlL_delete</sysctl>
          <autogen>--KeyOverlaidModifier-- KeyCode::CONTROL_L, KeyCode::CONTROL_L, KeyCode::DELETE</autogen>
        </item>
        <item>
          <name>Control_L to Control_L</name>
          <appendix>(+ When you type Control_L only, send Delete) + [KeyRepeat]</appendix>
          <sysctl>remap.controlL2controlL_delete_keyrepeat</sysctl>
          <autogen>--KeyOverlaidModifierWithRepeat-- KeyCode::CONTROL_L, KeyCode::CONTROL_L, KeyCode::DELETE</autogen>
        </item>
        <item>
          <name>Control_L to Control_L</name>
          <appendix>(+ When you type Control_L only without other modifiers, send Delete) + [KeyRepeat]</appendix>
          <sysctl>remap.controlL2controlL_delete_nomod_keyrepeat</sysctl>
          <autogen>--KeyOverlaidModifierWithRepeat-- KeyCode::CONTROL_L, ModifierFlag::CONTROL_L | ModifierFlag::NONE, KeyCode::CONTROL_L, KeyCode::DELETE</autogen>
        </item>
        <item>
          <name>Control_L to Control_L</name>
          <appendix>(+ When you type Control_L only, send Escape)</appendix>
          <sysctl>remap.controlL2controlL_escape</sysctl>
          <autogen>--KeyOverlaidModifier-- KeyCode::CONTROL_L, KeyCode::CONTROL_L, KeyCode::ESCAPE</autogen>
        </item>
        <item>
          <name>Control_L to FN</name>
          <sysctl>remap.controlL2fn</sysctl>
          <autogen>--KeyToKey-- KeyCode::CONTROL_L, KeyCode::FN</autogen>
        </item>
        <item>
          <name>Control_L to FN (only in virtual machine, RDC)</name>
          <sysctl>remap.controlL2fn_vm</sysctl>
          <only>VIRTUALMACHINE, REMOTEDESKTOPCONNECTION</only>
          <autogen>--KeyToKey-- KeyCode::CONTROL_L, KeyCode::FN</autogen>
        </item>
        <item>
          <name>Option_L+Control_L to FN</name>
          <sysctl>remap.optionLcontrolL2fn</sysctl>
          <autogen>--KeyToKey-- KeyCode::CONTROL_L, ModifierFlag::OPTION_L, KeyCode::FN</autogen>
        </item>
        <item>
          <name>Control_L to Option_L</name>
          <sysctl>remap.controlL2optionL</sysctl>
          <autogen>--KeyToKey-- KeyCode::CONTROL_L, KeyCode::OPTION_L</autogen>
        </item>
        <item>
          <name>Control_L to Shift_L</name>
          <sysctl>remap.controlL2shiftL</sysctl>
          <autogen>--KeyToKey-- KeyCode::CONTROL_L, KeyCode::SHIFT_L</autogen>
        </item>
        <item>
          <name>Control_L to Delete</name>
          <sysctl>remap.controlL2delete</sysctl>
          <autogen>--KeyToKey-- KeyCode::CONTROL_L, KeyCode::DELETE</autogen>
        </item>
        <item>
          <name>Control_L to Escape</name>
          <sysctl>remap.controlL2escape</sysctl>
          <autogen>--KeyToKey-- KeyCode::CONTROL_L, KeyCode::ESCAPE</autogen>
        </item>
        <item>
          <name>Command_R+Control_L to Escape</name>
          <appendix>(Note: Escape is sent when you release Control_L)</appendix>
          <sysctl>remap.commandRcontrolL2escape</sysctl>
          <autogen>--KeyOverlaidModifier-- KeyCode::CONTROL_L, ModifierFlag::COMMAND_R, KeyCode::CONTROL_L, ModifierFlag::COMMAND_R, KeyCode::ESCAPE</autogen>
        </item>
        <item>
          <name>Shift_L+Control_L to Escape</name>
          <appendix>(Note: Escape is sent when you release Control_L)</appendix>
          <sysctl>remap.shiftLcontrolL2escape</sysctl>
          <autogen>--KeyOverlaidModifier-- KeyCode::CONTROL_L, ModifierFlag::SHIFT_L, KeyCode::CONTROL_L, ModifierFlag::SHIFT_L, KeyCode::ESCAPE</autogen>
        </item>
        <item>
          <name>FN+Control_L to Control_R</name>
          <sysctl>remap.fncontrolL2controlR</sysctl>
          <autogen>--KeyToKey-- KeyCode::CONTROL_L, ModifierFlag::FN, KeyCode::CONTROL_R</autogen>
        </item>
        <item>
          <name>Drop Control_L</name>
          <sysctl>remap.drop_controlL</sysctl>
          <autogen>--KeyToKey-- KeyCode::CONTROL_L, KeyCode::VK_NONE</autogen>
        </item>
        <item>
          <name>Control_L x2 to Control_L+Space</name>
          <sysctl>remap.controlL_x2_to_controlLspace</sysctl>
          <autogen>--DoublePressModifier-- KeyCode::CONTROL_L, KeyCode::CONTROL_L, KeyCode::SPACE, ModifierFlag::CONTROL_L</autogen>
        </item>
        <item>
          <name>Control_L to RightClick</name>
          <sysctl>remap.controlL2rightclick</sysctl>
          <autogen>--KeyToPointingButton-- KeyCode::CONTROL_L, PointingButton::RIGHT</autogen>
        </item>
      </list>
    </item>

    <item>
      <name>Change Control_R Key (Right Control)</name>
      <list>
        <item>
          <name>Control_R to Command_R</name>
          <sysctl>remap.controlR2commandR</sysctl>
          <autogen>--KeyToKey-- KeyCode::CONTROL_R, KeyCode::COMMAND_R</autogen>
        </item>
        <item>
          <name>Control_R to Command_R (only in virtual machine, RDC)</name>
          <sysctl>remap.controlR2commandR_vm</sysctl>
          <only>VIRTUALMACHINE, REMOTEDESKTOPCONNECTION</only>
          <autogen>--KeyToKey-- KeyCode::CONTROL_R, KeyCode::COMMAND_R</autogen>
        </item>
        <item>
          <name>Control_R to RightClick</name>
          <sysctl>remap.controlR2rightclick</sysctl>
          <autogen>--KeyToPointingButton-- KeyCode::CONTROL_R, PointingButton::RIGHT</autogen>
        </item>
      </list>
    </item>

    <item>
      <name>Change Delete Key</name>
      <list>
        <item>
          <name>Delete to Backquote(`)</name>
          <sysctl>remap.delete2backquote</sysctl>
          <autogen>--KeyToKey-- KeyCode::DELETE, KeyCode::BACKQUOTE</autogen>
        </item>
        <item>
          <name>Delete to Backslash(\)</name>
          <sysctl>remap.delete2backslash</sysctl>
          <autogen>--KeyToKey-- KeyCode::DELETE, KeyCode::BACKSLASH</autogen>
        </item>
        <item>
          <name>Command+Delete to Option_L+Delete</name>
          <sysctl>remap.commandDelete2optionLdelete</sysctl>
          <autogen>--KeyToKey-- KeyCode::DELETE, VK_COMMAND, KeyCode::DELETE, ModifierFlag::OPTION_L</autogen>
        </item>
        <item>
          <name>Control+Delete to Command_L+Delete</name>
          <sysctl>remap.controlDelete2commandLdelete</sysctl>
          <autogen>--KeyToKey-- KeyCode::DELETE, VK_CONTROL, KeyCode::DELETE, ModifierFlag::COMMAND_L</autogen>
        </item>
        <item>
          <name>Delete to Forward Delete</name>
          <sysctl>remap.delete2forwarddelete</sysctl>
          <autogen>--KeyToKey-- KeyCode::DELETE, KeyCode::FORWARD_DELETE</autogen>
        </item>
        <item>
          <name>Delete to Forward Delete</name>
          <appendix>(FN+Delete to Delete)</appendix>
          <sysctl>remap.delete2forwarddelete_fnDelete2delete</sysctl>
          <autogen>--KeyToKey-- KeyCode::DELETE, ModifierFlag::FN, KeyCode::DELETE</autogen>
          <autogen>--KeyToKey-- KeyCode::DELETE, KeyCode::FORWARD_DELETE</autogen>
        </item>
        <item>
          <name>Control+Delete to Forward Delete</name>
          <sysctl>remap.controlDelete2forwarddelete</sysctl>
          <autogen>--KeyToKey-- KeyCode::DELETE, VK_CONTROL, KeyCode::FORWARD_DELETE</autogen>
        </item>
        <item>
          <name>Option+Delete to Forward Delete</name>
          <sysctl>remap.optionDelete2forwarddelete</sysctl>
          <autogen>--KeyToKey-- KeyCode::DELETE, VK_OPTION, KeyCode::FORWARD_DELETE</autogen>
        </item>
        <item>
          <name>Shift+Delete to Forward Delete</name>
          <sysctl>remap.shiftDelete2forwarddelete</sysctl>
          <autogen>--KeyToKey-- KeyCode::DELETE, VK_SHIFT, KeyCode::FORWARD_DELETE</autogen>
        </item>
        <item>
          <name>Shift+Delete to Forward Delete (if no other modifiers pressed)</name>
          <sysctl>remap.shiftDelete2forwarddelete_nomodifiers</sysctl>
          <autogen>--KeyToKey-- KeyCode::DELETE, VK_SHIFT | ModifierFlag::NONE, KeyCode::FORWARD_DELETE</autogen>
        </item>
        <item>
          <name>Shift+Delete to Tilde(~)</name>
          <sysctl>remap.shiftDelete2tilde</sysctl>
          <autogen>--KeyToKey-- KeyCode::DELETE, VK_SHIFT, KeyCode::BACKQUOTE, ModifierFlag::SHIFT_L</autogen>
        </item>
        <item>
          <name>Drop Delete</name>
          <sysctl>remap.drop_delete</sysctl>
          <autogen>--KeyToKey-- KeyCode::DELETE, KeyCode::VK_NONE</autogen>
        </item>
      </list>
    </item>

    <item>
      <name>Change Eject Key</name>
      <appendix>*** We recommend to use "NoEjectDelay" together when you change eject key.</appendix>
      <appendix>*** &#8594; http://pqrs.org/macosx/keyremap4macbook/noejectdelay.html</appendix>
      <list>
        <item>
          <name>Eject to Dashboard if no modifiers pressed</name>
          <sysctl>remap.eject2dashboard_withoutmodifiers</sysctl>
          <autogen>--ConsumerToKey-- ConsumerKeyCode::EJECT, ModifierFlag::NONE, KeyCode::DASHBOARD</autogen>
        </item>
        <item>
          <name>Eject to Expose if no modifiers pressed</name>
          <sysctl>remap.eject2expose_withoutmodifiers</sysctl>
          <autogen>--ConsumerToKey-- ConsumerKeyCode::EJECT, ModifierFlag::NONE, KeyCode::EXPOSE_ALL</autogen>
        </item>
        <item>
          <name>Eject to Expose</name>
          <sysctl>remap.eject2expose</sysctl>
          <autogen>--ConsumerToKey-- ConsumerKeyCode::EJECT, KeyCode::EXPOSE_ALL</autogen>
        </item>
        <item>
          <name>Eject to Forward Delete</name>
          <sysctl>remap.eject2forwarddelete</sysctl>
          <autogen>--ConsumerToKey-- ConsumerKeyCode::EJECT, KeyCode::FORWARD_DELETE</autogen>
        </item>
        <item>
          <name>Eject to Forward Delete</name>
          <appendix>(FN+Eject to Eject)</appendix>
          <sysctl>remap.eject2forwarddelete_retain_fnEject</sysctl>
          <autogen>--ConsumerToConsumer-- ConsumerKeyCode::EJECT, ModifierFlag::FN, ConsumerKeyCode::EJECT</autogen>
          <autogen>--ConsumerToKey-- ConsumerKeyCode::EJECT, KeyCode::FORWARD_DELETE</autogen>
        </item>
        <item>
          <name>Eject to Forward Delete if no modifiers pressed</name>
          <sysctl>remap.eject2forwarddelete_withoutmodifiers</sysctl>
          <autogen>--ConsumerToKey-- ConsumerKeyCode::EJECT, ModifierFlag::NONE, KeyCode::FORWARD_DELETE</autogen>
        </item>
        <item>
          <name>Eject to Command+Control+Option+Shift+E</name>
          <sysctl>remap.eject2fccosE</sysctl>
          <autogen>--ConsumerToKey-- ConsumerKeyCode::EJECT, KeyCode::E, ModifierFlag::COMMAND_L | ModifierFlag::CONTROL_L | ModifierFlag::OPTION_L | ModifierFlag::SHIFT_L</autogen>
        </item>
        <item>
          <name>Eject to F14</name>
          <sysctl>remap.eject2f14</sysctl>
          <autogen>--ConsumerToKey-- ConsumerKeyCode::EJECT, KeyCode::F14</autogen>
        </item>
        <item>
          <name>Eject to PageDown</name>
          <sysctl>remap.eject2pagedown</sysctl>
          <autogen>--ConsumerToKey-- ConsumerKeyCode::EJECT, KeyCode::PAGEDOWN</autogen>
        </item>
      </list>
    </item>

    <item>
      <name>Change Enter Key</name>
      <list>
        <item>
          <name>Enter to Command_L</name>
          <sysctl>remap.enter2commandL</sysctl>
          <autogen>--KeyToKey-- KeyCode::ENTER, KeyCode::COMMAND_L</autogen>
        </item>
        <item>
          <name>Enter to Command_L (except virtual machine, RDC)</name>
          <sysctl>remap.enter2commandL_ex_vm</sysctl>
          <not>VIRTUALMACHINE, REMOTEDESKTOPCONNECTION</not>
          <autogen>--KeyToKey-- KeyCode::ENTER, KeyCode::COMMAND_L</autogen>
        </item>
        <item>
          <name>Enter to Control_L</name>
          <sysctl>remap.enter2controlL</sysctl>
          <autogen>--KeyToKey-- KeyCode::ENTER, KeyCode::CONTROL_L</autogen>
        </item>
        <item>
          <name>Enter to Control_L (only in virtual machine, RDC)</name>
          <sysctl>remap.enter2controlL_vm</sysctl>
          <only>VIRTUALMACHINE, REMOTEDESKTOPCONNECTION</only>
          <autogen>--KeyToKey-- KeyCode::ENTER, KeyCode::CONTROL_L</autogen>
        </item>
        <item>
          <name>Enter to Control_R</name>
          <sysctl>remap.enter2controlR</sysctl>
          <autogen>--KeyToKey-- KeyCode::ENTER, KeyCode::CONTROL_R</autogen>
        </item>
        <item>
          <name>Enter to FN</name>
          <sysctl>remap.enter2fn</sysctl>
          <autogen>--KeyToKey-- KeyCode::ENTER, KeyCode::FN</autogen>
        </item>
        <item>
          <name>Enter to Option_L</name>
          <sysctl>remap.enter2optionL</sysctl>
          <autogen>--KeyToKey-- KeyCode::ENTER, KeyCode::OPTION_L</autogen>
        </item>
        <item>
          <name>Enter to Option_L</name>
          <appendix>(+ When you type Enter only, send Command+Space)</appendix>
          <sysctl>remap.enter2optionL_commandSpace</sysctl>
          <autogen>--KeyOverlaidModifier-- KeyCode::ENTER, KeyCode::OPTION_L, KeyCode::SPACE, ModifierFlag::COMMAND_L</autogen>
        </item>
        <item>
          <name>Enter to Option_R</name>
          <sysctl>remap.enter2optionR</sysctl>
          <autogen>--KeyToKey-- KeyCode::ENTER, KeyCode::OPTION_R</autogen>
        </item>
        <item>
          <name>Enter to Option_R</name>
          <appendix>(+ When you type Enter only, send Command+Space)</appendix>
          <sysctl>remap.enter2optionR_commandSpace</sysctl>
          <autogen>--KeyOverlaidModifier-- KeyCode::ENTER, KeyCode::OPTION_R, KeyCode::SPACE, ModifierFlag::COMMAND_L</autogen>
        </item>
        <item>
          <name>Enter to Command_L+Control_L</name>
          <sysctl>remap.enter2commandLcontrolL</sysctl>
          <autogen>--KeyToKey-- KeyCode::ENTER, KeyCode::COMMAND_L, ModifierFlag::CONTROL_L</autogen>
        </item>
        <item>
          <name>Enter to Command_L+Shift_L</name>
          <sysctl>remap.enter2commandLshiftL</sysctl>
          <autogen>--KeyToKey-- KeyCode::ENTER, KeyCode::COMMAND_L, ModifierFlag::SHIFT_L</autogen>
        </item>
        <item>
          <name>Enter to Control_L+Option_L</name>
          <sysctl>remap.enter2controlLoptionL</sysctl>
          <autogen>--KeyToKey-- KeyCode::ENTER, KeyCode::CONTROL_L, ModifierFlag::OPTION_L</autogen>
        </item>
        <item>
          <name>Enter to Delete</name>
          <sysctl>remap.enter2delete</sysctl>
          <autogen>--KeyToKey-- KeyCode::ENTER, KeyCode::DELETE</autogen>
        </item>
        <item>
          <name>Enter to End</name>
          <sysctl>remap.enter2end</sysctl>
          <autogen>--KeyToKey-- KeyCode::ENTER, KeyCode::END</autogen>
        </item>
        <item>
          <name>Enter to Forward Delete</name>
          <sysctl>remap.enter2forwarddelete</sysctl>
          <autogen>--KeyToKey-- KeyCode::ENTER, KeyCode::FORWARD_DELETE</autogen>
        </item>
        <item>
          <name>Enter to Left-Arrow</name>
          <sysctl>remap.enter2leftarrow</sysctl>
          <autogen>--KeyToKey-- KeyCode::ENTER, KeyCode::CURSOR_LEFT</autogen>
        </item>
        <item>
          <name>Enter to Return</name>
          <sysctl>remap.enter2return</sysctl>
          <autogen>--KeyToKey-- KeyCode::ENTER, KeyCode::RETURN</autogen>
        </item>
        <item>
          <name>Enter to Command_L+Right-Arrow</name>
          <sysctl>remap.enter2commandLrightarrow_all</sysctl>
          <autogen>--KeyToKey-- KeyCode::ENTER, KeyCode::CURSOR_RIGHT, ModifierFlag::COMMAND_L</autogen>
        </item>
        <item>
          <name>Enter to Right-Arrow</name>
          <sysctl>remap.enter2rightarrow</sysctl>
          <autogen>--KeyToKey-- KeyCode::ENTER, KeyCode::CURSOR_RIGHT</autogen>
        </item>
        <item>
          <name>Enter to Semicolon</name>
          <sysctl>remap.enter2semicolon</sysctl>
          <autogen>--KeyToKey-- KeyCode::ENTER, KeyCode::SEMICOLON</autogen>
        </item>
        <item>
          <name>Enter to Space</name>
          <sysctl>remap.enter2space</sysctl>
          <autogen>--KeyToKey-- KeyCode::ENTER, KeyCode::SPACE</autogen>
        </item>
        <item>
          <name>Enter to Tab</name>
          <sysctl>remap.enter2tab</sysctl>
          <autogen>--KeyToKey-- KeyCode::ENTER, KeyCode::TAB</autogen>
        </item>
        <item>
          <name>Enter to Up-Arrow</name>
          <sysctl>remap.enter2uparrow</sysctl>
          <autogen>--KeyToKey-- KeyCode::ENTER, KeyCode::CURSOR_UP</autogen>
        </item>
      </list>
    </item>

    <item>
      <name>Change Escape Key</name>
      <list>
        <item>
          <name>Escape to CapsLock</name>
          <sysctl>remap.escape2capslock</sysctl>
          <autogen>--KeyToKey-- KeyCode::ESCAPE, KeyCode::CAPSLOCK</autogen>
        </item>
        <item>
          <name>Escape to Command_L</name>
          <sysctl>remap.escape2commandL</sysctl>
          <autogen>--KeyToKey-- KeyCode::ESCAPE, KeyCode::COMMAND_L</autogen>
        </item>
        <item>
          <name>Escape to Command_R Lock</name>
          <sysctl>remap.escape2commandR_lock</sysctl>
          <autogen>--KeyToKey-- KeyCode::ESCAPE, KeyCode::VK_LOCK_COMMAND_R</autogen>
        </item>
        <item>
          <name>Escape to Option_L</name>
          <sysctl>remap.escape2optionL</sysctl>
          <autogen>--KeyToKey-- KeyCode::ESCAPE, KeyCode::OPTION_L</autogen>
        </item>
        <item>
          <name>Escape to Backquote(`)</name>
          <sysctl>remap.escape2backquote</sysctl>
          <autogen>--KeyToKey-- KeyCode::ESCAPE, KeyCode::BACKQUOTE</autogen>
        </item>
        <item>
          <name>Control+Escape to Control_L+F3</name>
          <sysctl>remap.escape2controlLf3</sysctl>
          <autogen>--KeyToKey-- KeyCode::ESCAPE, VK_CONTROL | ModifierFlag::NONE, KeyCode::F3, ModifierFlag::CONTROL_L</autogen>
        </item>
        <item>
          <name>FN+Escape to Power</name>
          <sysctl>remap.fnEscape2power</sysctl>
          <autogen>--KeyToConsumer-- KeyCode::ESCAPE, ModifierFlag::FN, ConsumerKeyCode::POWER</autogen>
        </item>
        <item>
          <name>Escape to RightClick</name>
          <sysctl>remap.escape2rightclick</sysctl>
          <autogen>--KeyToPointingButton-- KeyCode::ESCAPE, PointingButton::RIGHT</autogen>
        </item>
        <item>
          <name>Drop Escape</name>
          <sysctl>remap.drop_escape</sysctl>
          <autogen>--KeyToKey-- KeyCode::ESCAPE, KeyCode::VK_NONE</autogen>
        </item>
      </list>
    </item>

    <item>
      <name>Change FN Key</name>
      <list>
        <item>
          <name>FN to Command_L</name>
          <sysctl>remap.fn2commandL</sysctl>
          <autogen>--KeyToKey-- KeyCode::FN, KeyCode::COMMAND_L</autogen>
        </item>
        <item>
          <name>FN to Command_L (except virtual machine, RDC)</name>
          <appendix>(+ FN to Control_L (only in virtual machine, RDC))</appendix>
          <sysctl>remap.fn2commandL_fn2controlL_vm</sysctl>
          <block>
            <not>VIRTUALMACHINE, REMOTEDESKTOPCONNECTION</not>
            <autogen>--KeyToKey-- KeyCode::FN, KeyCode::COMMAND_L</autogen>
          </block>
          <block>
            <only>VIRTUALMACHINE, REMOTEDESKTOPCONNECTION</only>
            <autogen>--KeyToKey-- KeyCode::FN, KeyCode::CONTROL_L</autogen>
          </block>
        </item>
        <item>
          <name>FN to Control_L</name>
          <sysctl>remap.fn2controlL</sysctl>
          <autogen>--KeyToKey-- KeyCode::FN, KeyCode::CONTROL_L</autogen>
        </item>
        <item>
          <name>FN to Control_L (only in virtual machine, RDC)</name>
          <sysctl>remap.fn2controlL_vm</sysctl>
          <only>VIRTUALMACHINE, REMOTEDESKTOPCONNECTION</only>
          <autogen>--KeyToKey-- KeyCode::FN, KeyCode::CONTROL_L</autogen>
        </item>
        <item>
          <name>FN to Control_L</name>
          <appendix>(+ Command_R+FN to FN)</appendix>
          <sysctl>remap.fn2controlL_commandR2fn</sysctl>
          <autogen>--KeyToKey-- KeyCode::FN, ModifierFlag::COMMAND_R, KeyCode::FN</autogen>
          <autogen>--KeyToKey-- KeyCode::FN, KeyCode::CONTROL_L</autogen>
        </item>
        <item>
          <name>FN to Control_L</name>
          <appendix>(+ Option_L+FN to FN)</appendix>
          <sysctl>remap.fn2controlL_optionL2fn</sysctl>
          <autogen>--KeyToKey-- KeyCode::FN, ModifierFlag::OPTION_L, KeyCode::FN</autogen>
          <autogen>--KeyToKey-- KeyCode::FN, KeyCode::CONTROL_L</autogen>
        </item>
        <item>
          <name>FN to FN</name>
          <appendix>(+ When you type FN only, send FN_Lock)</appendix>
          <sysctl>remap.fn2fn_fnlock</sysctl>
          <autogen>--KeyOverlaidModifier-- KeyCode::FN, KeyCode::FN, KeyCode::VK_LOCK_FN</autogen>
        </item>
        <item>
          <name>FN to FN_Lock</name>
          <sysctl>remap.fn2fnlock</sysctl>
          <autogen>--KeyToKey-- KeyCode::FN, KeyCode::VK_LOCK_FN</autogen>
        </item>
        <item>
          <name>FN to Option_L</name>
          <sysctl>remap.fn2optionL</sysctl>
          <autogen>--KeyToKey-- KeyCode::FN, KeyCode::OPTION_L</autogen>
        </item>
        <item>
          <name>FN to Option_L</name>
          <appendix>(only in Illustrator, Photoshop, Cheetah3D)</appendix>
          <appendix>(retain FN+F1...FN+F12)</appendix>
          <sysctl>remap.fn2optionL_illphoche</sysctl>
          <only>ILLUSTRATOR, PHOTOSHOP, CHEETAH_3D</only>
          <autogen>--KeyToKey-- KeyCode::BRIGHTNESS_DOWN,                      ModifierFlag::OPTION_L, KeyCode::BRIGHTNESS_DOWN</autogen>
          <autogen>--KeyToKey-- KeyCode::BRIGHTNESS_UP,                        ModifierFlag::OPTION_L, KeyCode::BRIGHTNESS_UP</autogen>
          <autogen>--ConsumerToConsumer-- ConsumerKeyCode::BRIGHTNESS_DOWN,    ModifierFlag::OPTION_L, ConsumerKeyCode::BRIGHTNESS_DOWN</autogen>
          <autogen>--ConsumerToConsumer-- ConsumerKeyCode::BRIGHTNESS_UP,      ModifierFlag::OPTION_L, ConsumerKeyCode::BRIGHTNESS_UP</autogen>
          <autogen>--KeyToKey-- KeyCode::EXPOSE_ALL,                           ModifierFlag::OPTION_L, KeyCode::EXPOSE_ALL</autogen>
          <autogen>--KeyToKey-- KeyCode::DASHBOARD,                            ModifierFlag::OPTION_L, KeyCode::DASHBOARD</autogen>
          <autogen>--ConsumerToConsumer-- ConsumerKeyCode::KEYBOARDLIGHT_LOW,  ModifierFlag::OPTION_L, ConsumerKeyCode::KEYBOARDLIGHT_LOW</autogen>
          <autogen>--ConsumerToConsumer-- ConsumerKeyCode::KEYBOARDLIGHT_HIGH, ModifierFlag::OPTION_L, ConsumerKeyCode::KEYBOARDLIGHT_HIGH</autogen>
          <autogen>--ConsumerToConsumer-- ConsumerKeyCode::MUSIC_PREV,         ModifierFlag::OPTION_L, ConsumerKeyCode::MUSIC_PREV</autogen>
          <autogen>--ConsumerToConsumer-- ConsumerKeyCode::MUSIC_PLAY,         ModifierFlag::OPTION_L, ConsumerKeyCode::MUSIC_PLAY</autogen>
          <autogen>--ConsumerToConsumer-- ConsumerKeyCode::MUSIC_NEXT,         ModifierFlag::OPTION_L, ConsumerKeyCode::MUSIC_NEXT</autogen>
          <autogen>--ConsumerToConsumer-- ConsumerKeyCode::VOLUME_MUTE,        ModifierFlag::OPTION_L, ConsumerKeyCode::VOLUME_MUTE</autogen>
          <autogen>--ConsumerToConsumer-- ConsumerKeyCode::VOLUME_DOWN,        ModifierFlag::OPTION_L, ConsumerKeyCode::VOLUME_DOWN</autogen>
          <autogen>--ConsumerToConsumer-- ConsumerKeyCode::VOLUME_UP,          ModifierFlag::OPTION_L, ConsumerKeyCode::VOLUME_UP</autogen>
          <autogen>--KeyToKey-- KeyCode::FN, KeyCode::OPTION_L</autogen>
        </item>
        <item>
          <name>FN to Control_L+Option_L</name>
          <sysctl>remap.fn2controlLoptionL</sysctl>
          <autogen>--KeyToKey-- KeyCode::FN, KeyCode::OPTION_L, ModifierFlag::CONTROL_L</autogen>
        </item>
        <item>
          <name>FN to Shift_L</name>
          <sysctl>remap.fn2shiftL</sysctl>
          <autogen>--KeyToKey-- KeyCode::FN, KeyCode::SHIFT_L</autogen>
        </item>
        <item>
          <name>FN to Delete</name>
          <sysctl>remap.fn2delete</sysctl>
          <autogen>--KeyToKey-- KeyCode::FN, KeyCode::DELETE</autogen>
        </item>
        <item>
          <name>FN to Enter</name>
          <sysctl>remap.fn2enter</sysctl>
          <autogen>--KeyToKey-- KeyCode::FN, KeyCode::ENTER</autogen>
        </item>
        <item>
          <name>FN to Eject</name>
          <sysctl>remap.fn2eject</sysctl>
          <autogen>--KeyToConsumer-- KeyCode::FN, ConsumerKeyCode::EJECT</autogen>
        </item>
        <item>
          <name>FN to Forward Delete</name>
          <sysctl>remap.fn2forwarddelete</sysctl>
          <autogen>--KeyToKey-- KeyCode::FN, KeyCode::FORWARD_DELETE</autogen>
        </item>
        <item>
          <name>FN to F14</name>
          <sysctl>remap.fn2f14</sysctl>
          <autogen>--KeyToKey-- KeyCode::FN, KeyCode::F14</autogen>
        </item>
        <item>
          <name>FN to Help</name>
          <sysctl>remap.fn2help</sysctl>
          <autogen>--KeyToKey-- KeyCode::FN, KeyCode::HELP</autogen>
        </item>
        <item>
          <name>FN to Tab</name>
          <sysctl>remap.fn2tab</sysctl>
          <autogen>--KeyToKey-- KeyCode::FN, KeyCode::TAB</autogen>
        </item>
      </list>
    </item>

    <item>
      <name>Change Forward Delete Key</name>
      <list>
        <item>
          <name>Forward Delete to Delete</name>
          <sysctl>remap.forwarddelete2delete</sysctl>
          <autogen>--KeyToKey-- FROMKEYCODE_FORWARD_DELETE, KeyCode::DELETE</autogen>
        </item>
      </list>
    </item>

    <item>
      <name>Change Functional Key (Brightness, Volume, ....)</name>
      <list>
        <item>
          <name>Functional Keys to F1..F12</name>
          <appendix>Brightness Down to F1</appendix>
          <appendix>Brightness Up to F2</appendix>
          <appendix>Expose to F3</appendix>
          <appendix>Dashboard to F4</appendix>
          <appendix>Keyboard Light LOW to F5</appendix>
          <appendix>Keyboard Light HIGH to F6</appendix>
          <appendix>Music Prev to F7</appendix>
          <appendix>Music Play/Pause to F8</appendix>
          <appendix>Music Next to F9</appendix>
          <appendix>Volume Mute to F10</appendix>
          <appendix>Volume Down to F11</appendix>
          <appendix>Volume Up to F12</appendix>
          <sysctl>remap.functional2fn_2008</sysctl>
          <!-- F1 -->
          <autogen>--ConsumerToKey-- ConsumerKeyCode::BRIGHTNESS_DOWN,    KeyCode::F1</autogen>
          <autogen>--KeyToKey--      KeyCode::BRIGHTNESS_DOWN,            KeyCode::F1</autogen>
          <!-- F2 -->
          <autogen>--ConsumerToKey-- ConsumerKeyCode::BRIGHTNESS_UP,      KeyCode::F2</autogen>
          <autogen>--KeyToKey--      KeyCode::BRIGHTNESS_UP,              KeyCode::F2</autogen>
          <!-- F3 - F12 -->
          <autogen>--KeyToKey--      KeyCode::EXPOSE_ALL,                 KeyCode::F3</autogen>
          <autogen>--KeyToKey--      KeyCode::DASHBOARD,                  KeyCode::F4</autogen>
          <autogen>--ConsumerToKey-- ConsumerKeyCode::KEYBOARDLIGHT_LOW,  KeyCode::F5</autogen>
          <autogen>--ConsumerToKey-- ConsumerKeyCode::KEYBOARDLIGHT_HIGH, KeyCode::F6</autogen>
          <autogen>--ConsumerToKey-- ConsumerKeyCode::MUSIC_PREV,         KeyCode::F7</autogen>
          <autogen>--ConsumerToKey-- ConsumerKeyCode::MUSIC_PLAY,         KeyCode::F8</autogen>
          <autogen>--ConsumerToKey-- ConsumerKeyCode::MUSIC_NEXT,         KeyCode::F9</autogen>
          <autogen>--ConsumerToKey-- ConsumerKeyCode::VOLUME_MUTE,        KeyCode::F10</autogen>
          <autogen>--ConsumerToKey-- ConsumerKeyCode::VOLUME_DOWN,        KeyCode::F11</autogen>
          <autogen>--ConsumerToKey-- ConsumerKeyCode::VOLUME_UP,          KeyCode::F12</autogen>
        </item>
        <item>
          <name>Brightness Down to F1</name>
          <sysctl>remap.brightnessdown2f1</sysctl>
          <autogen>--ConsumerToKey-- ConsumerKeyCode::BRIGHTNESS_DOWN, KeyCode::F1</autogen>
          <autogen>--KeyToKey-- KeyCode::BRIGHTNESS_DOWN, KeyCode::F1</autogen>
        </item>
        <item>
          <name>Brightness Up to F2</name>
          <sysctl>remap.brightnessup2f2</sysctl>
          <autogen>--ConsumerToKey-- ConsumerKeyCode::BRIGHTNESS_UP, KeyCode::F2</autogen>
          <autogen>--KeyToKey-- KeyCode::BRIGHTNESS_UP, KeyCode::F2</autogen>
        </item>
        <item>
          <name>Expose to F3</name>
          <sysctl>remap.expose2f3</sysctl>
          <autogen>--KeyToKey--      KeyCode::EXPOSE_ALL,                 KeyCode::F3</autogen>
        </item>
        <item>
          <name>Volume Mute to F3</name>
          <sysctl>remap.volumemute2f3</sysctl>
          <autogen>--ConsumerToKey-- ConsumerKeyCode::VOLUME_MUTE, KeyCode::F3</autogen>
        </item>
        <item>
          <name>Dashboard to F4</name>
          <sysctl>remap.dashboard2f4</sysctl>
          <autogen>--KeyToKey--      KeyCode::DASHBOARD,                  KeyCode::F4</autogen>
        </item>
        <item>
          <name>Volume Mute to F4</name>
          <sysctl>remap.volumemute2f4</sysctl>
          <autogen>--ConsumerToKey-- ConsumerKeyCode::VOLUME_MUTE, KeyCode::F4</autogen>
        </item>
        <item>
          <name>Volume Down to F4</name>
          <sysctl>remap.volumedown2f4</sysctl>
          <autogen>--ConsumerToKey-- ConsumerKeyCode::VOLUME_DOWN, KeyCode::F4</autogen>
        </item>
        <item>
          <name>Volume Down to F5</name>
          <sysctl>remap.volumedown2f5</sysctl>
          <autogen>--ConsumerToKey-- ConsumerKeyCode::VOLUME_DOWN, KeyCode::F5</autogen>
        </item>
        <item>
          <name>Volume Up to F5</name>
          <sysctl>remap.volumeup2f5</sysctl>
          <autogen>--ConsumerToKey-- ConsumerKeyCode::VOLUME_UP, KeyCode::F5</autogen>
        </item>
        <item>
          <name>Volume Up to F6</name>
          <sysctl>remap.volumeup2f6</sysctl>
          <autogen>--ConsumerToKey-- ConsumerKeyCode::VOLUME_UP, KeyCode::F6</autogen>
        </item>
        <item>
          <name>Volume Mute to F10</name>
          <sysctl>remap.volumemute2f10</sysctl>
          <autogen>--ConsumerToKey-- ConsumerKeyCode::VOLUME_MUTE, ModifierFlag::FN, KeyCode::F10</autogen>
          <autogen>--ConsumerToKey-- ConsumerKeyCode::VOLUME_MUTE,                   KeyCode::F10</autogen>
        </item>
        <item>
          <name>Volume Down to F11</name>
          <sysctl>remap.volumedown2f11</sysctl>
          <autogen>--ConsumerToKey-- ConsumerKeyCode::VOLUME_DOWN, ModifierFlag::FN, KeyCode::F11</autogen>
          <autogen>--ConsumerToKey-- ConsumerKeyCode::VOLUME_DOWN,                   KeyCode::F11</autogen>
        </item>
        <item>
          <name>Volume Up to F12</name>
          <sysctl>remap.volumeup2f12</sysctl>
          <autogen>--ConsumerToKey-- ConsumerKeyCode::VOLUME_UP, ModifierFlag::FN, KeyCode::F12</autogen>
          <autogen>--ConsumerToKey-- ConsumerKeyCode::VOLUME_UP,                   KeyCode::F12</autogen>
        </item>
        <item>
          <name>NumLock to F6</name>
          <sysctl>remap.numlock2f6</sysctl>
          <autogen>--ConsumerToKey-- ConsumerKeyCode::NUMLOCK, KeyCode::F6</autogen>
        </item>
        <item>
          <name>NumLock to Music Prev</name>
          <sysctl>remap.numlock2musicprev</sysctl>
          <autogen>--ConsumerToConsumer-- ConsumerKeyCode::NUMLOCK, ConsumerKeyCode::MUSIC_PREV</autogen>
        </item>
        <item>
          <name>Video Mirroring to Music Prev</name>
          <sysctl>remap.videomirror2musicprev</sysctl>
          <autogen>--ConsumerToConsumer-- ConsumerKeyCode::VIDEO_MIRROR, ConsumerKeyCode::MUSIC_PREV</autogen>
        </item>
        <item>
          <name>Video Mirroring to Music Play/Pause</name>
          <sysctl>remap.videomirror2musicplay</sysctl>
          <autogen>--ConsumerToConsumer-- ConsumerKeyCode::VIDEO_MIRROR, ConsumerKeyCode::MUSIC_PLAY</autogen>
        </item>
        <item>
          <name>Keyboard Light Off to Music Play/Pause</name>
          <sysctl>remap.keyboardlightoff2musicplay</sysctl>
          <autogen>--ConsumerToConsumer-- ConsumerKeyCode::KEYBOARDLIGHT_OFF, ConsumerKeyCode::MUSIC_PLAY</autogen>
        </item>
        <item>
          <name>Keyboard Light OFF to Music Next</name>
          <sysctl>remap.keyboardlightoff2musicnext</sysctl>
          <autogen>--ConsumerToConsumer-- ConsumerKeyCode::KEYBOARDLIGHT_OFF, ConsumerKeyCode::MUSIC_NEXT</autogen>
        </item>
        <item>
          <name>Keyboard Light LOW to Music Next</name>
          <sysctl>remap.keyboardlightlow2musicnext</sysctl>
          <autogen>--ConsumerToConsumer-- ConsumerKeyCode::KEYBOARDLIGHT_LOW, ConsumerKeyCode::MUSIC_NEXT</autogen>
        </item>
        <item>
          <name>Keyboard Light HIGH to Volume Mute</name>
          <sysctl>remap.keyboardlighthigh2volumemute</sysctl>
          <autogen>--ConsumerToConsumer-- ConsumerKeyCode::KEYBOARDLIGHT_HIGH, ConsumerKeyCode::VOLUME_MUTE</autogen>
        </item>
        <item>
          <name>Volume Mute/Down/Up without click</name>
          <sysctl>remap.voldownup_to_voldownup_woclick</sysctl>
          <autogen>--ConsumerToConsumer-- ConsumerKeyCode::VOLUME_MUTE,                    ModifierFlag::NONE, ConsumerKeyCode::VOLUME_MUTE, ModifierFlag::SHIFT_L</autogen>
          <autogen>--ConsumerToConsumer-- ConsumerKeyCode::VOLUME_MUTE, ModifierFlag::FN | ModifierFlag::NONE, ConsumerKeyCode::VOLUME_MUTE, ModifierFlag::SHIFT_L</autogen>
          <autogen>--ConsumerToConsumer-- ConsumerKeyCode::VOLUME_DOWN,                    ModifierFlag::NONE, ConsumerKeyCode::VOLUME_DOWN, ModifierFlag::SHIFT_L</autogen>
          <autogen>--ConsumerToConsumer-- ConsumerKeyCode::VOLUME_DOWN, ModifierFlag::FN | ModifierFlag::NONE, ConsumerKeyCode::VOLUME_DOWN, ModifierFlag::SHIFT_L</autogen>
          <autogen>--ConsumerToConsumer-- ConsumerKeyCode::VOLUME_UP,                      ModifierFlag::NONE, ConsumerKeyCode::VOLUME_UP, ModifierFlag::SHIFT_L</autogen>
          <autogen>--ConsumerToConsumer-- ConsumerKeyCode::VOLUME_UP,   ModifierFlag::FN | ModifierFlag::NONE, ConsumerKeyCode::VOLUME_UP, ModifierFlag::SHIFT_L</autogen>
        </item>
        <item>
          <name>Command+Functional to Functional</name>
          <appendix>(ex. Command+Volume Mute to Volume Mute</appendix>
          <sysctl>remap.command_functional_to_functional</sysctl>
          <autogen>--ConsumerToConsumer-- ConsumerKeyCode::BRIGHTNESS_DOWN, VK_COMMAND, ConsumerKeyCode::BRIGHTNESS_DOWN</autogen>
          <autogen>--KeyToKey-- KeyCode::BRIGHTNESS_DOWN, VK_COMMAND, KeyCode::BRIGHTNESS_DOWN</autogen>

          <autogen>--ConsumerToConsumer-- ConsumerKeyCode::BRIGHTNESS_UP, VK_COMMAND, ConsumerKeyCode::BRIGHTNESS_UP</autogen>
          <autogen>--KeyToKey-- KeyCode::BRIGHTNESS_UP, VK_COMMAND, KeyCode::BRIGHTNESS_UP</autogen>

          <autogen>--KeyToKey-- KeyCode::EXPOSE_ALL, VK_COMMAND, KeyCode::EXPOSE_ALL</autogen>
          <autogen>--KeyToKey-- KeyCode::DASHBOARD, VK_COMMAND, KeyCode::DASHBOARD</autogen>

          <autogen>--ConsumerToConsumer-- ConsumerKeyCode::MUSIC_PREV, VK_COMMAND, ConsumerKeyCode::MUSIC_PREV</autogen>
          <autogen>--ConsumerToConsumer-- ConsumerKeyCode::MUSIC_PLAY, VK_COMMAND, ConsumerKeyCode::MUSIC_PLAY</autogen>
          <autogen>--ConsumerToConsumer-- ConsumerKeyCode::MUSIC_NEXT, VK_COMMAND, ConsumerKeyCode::MUSIC_NEXT</autogen>
          <autogen>--ConsumerToConsumer-- ConsumerKeyCode::VOLUME_MUTE, VK_COMMAND, ConsumerKeyCode::VOLUME_MUTE</autogen>
          <autogen>--ConsumerToConsumer-- ConsumerKeyCode::VOLUME_DOWN, VK_COMMAND, ConsumerKeyCode::VOLUME_DOWN</autogen>
          <autogen>--ConsumerToConsumer-- ConsumerKeyCode::VOLUME_UP, VK_COMMAND, ConsumerKeyCode::VOLUME_UP</autogen>
        </item>
        <item>
          <name>Change Power Key</name>
          <list>
            <item>
              <name>Power to Command_L</name>
              <sysctl>remap.power2commandL</sysctl>
              <autogen>--ConsumerToKey-- ConsumerKeyCode::POWER, KeyCode::COMMAND_L</autogen>
            </item>
          </list>
        </item>
      </list>
    </item>

    <item>
      <name>Change F1..F16 Key</name>
      <list>
        <item>
          <name>F1..F12 to Functional</name>
          <!-- #include "include/appendix_f1_f12_to_functional.xml" -->
          <!-- #include "include/caution_functionkey.xml" -->
          <sysctl>remap.f1_f12_to_functional_all</sysctl>
          <!-- #include "include/fnF1_F12_to_function.xml" -->
          <!-- #include "include/f1_f12_to_functional.xml" -->
        </item>
        <item>
          <name>F5,F6 to Functional</name>
          <!-- #include "include/appendix_f5_f6_to_functional.xml" -->
          <!-- #include "include/caution_functionkey.xml" -->
          <sysctl>remap.f5_f6_to_functional_all</sysctl>
          <!-- #include "include/fnF5_F6_to_function.xml" -->
          <!-- #include "include/f5_f6_to_functional.xml" -->
        </item>

        <item>
          <name>F1..F12 to Functional (except virtual machine, RDC)</name>
          <!-- #include "include/appendix_f1_f12_to_functional.xml" -->
          <!-- #include "include/caution_functionkey.xml" -->
          <sysctl>remap.f1_f12_to_functional_ex_vm</sysctl>
          <not>VIRTUALMACHINE, REMOTEDESKTOPCONNECTION</not>
          <!-- #include "include/fnF1_F12_to_function.xml" -->
          <!-- #include "include/f1_f12_to_functional.xml" -->
        </item>
        <item>
          <name>F5,F6 to Functional (except virtual machine, RDC)</name>
          <!-- #include "include/appendix_f5_f6_to_functional.xml" -->
          <!-- #include "include/caution_functionkey.xml" -->
          <sysctl>remap.f5_f6_to_functional_ex_vm</sysctl>
          <not>VIRTUALMACHINE, REMOTEDESKTOPCONNECTION</not>
          <!-- #include "include/fnF5_F6_to_function.xml" -->
          <!-- #include "include/f5_f6_to_functional.xml" -->
        </item>

        <item>
          <name>FN+F1..F12 to Functional</name>
          <appendix>There is this setting for "* to FN". (ex: Control_L to FN)</appendix>
          <appendix></appendix>
          <appendix>FN+F1 to Brightness Down</appendix>
          <appendix>FN+F2 to Brightness Up</appendix>
          <appendix>FN+F3 to Expose</appendix>
          <appendix>FN+F4 to Dashboard</appendix>
          <appendix>FN+F5 to Keyboard Light LOW</appendix>
          <appendix>FN+F6 to Keyboard Light HIGH</appendix>
          <appendix>FN+F7 to Music Prev</appendix>
          <appendix>FN+F8 to Music Play/Pause</appendix>
          <appendix>FN+F9 to Music Next</appendix>
          <appendix>FN+F10 to Volume Mute</appendix>
          <appendix>FN+F11 to Volume Down</appendix>
          <appendix>FN+F12 to Volume Up</appendix>
          <!-- #include "include/caution_functionkey.xml" -->
          <sysctl>remap.fnF1_F12_to_functional</sysctl>
          <!-- #include "include/f1_f12_to_functional_withfn.xml" -->
        </item>

        <item>
          <name>F1 to Brightness Down (except virtual machine, RDC)</name>
          <sysctl>remap.f1_to_brightnessdown</sysctl>
          <not>VIRTUALMACHINE, REMOTEDESKTOPCONNECTION</not>
          <autogen>--KeyToConsumer-- KeyCode::F1, ConsumerKeyCode::BRIGHTNESS_DOWN</autogen>
        </item>
        <item>
          <name>F2 to Brightness Up (except virtual machine, RDC)</name>
          <sysctl>remap.f2_to_brightnessup</sysctl>
          <not>VIRTUALMACHINE, REMOTEDESKTOPCONNECTION</not>
          <autogen>--KeyToConsumer-- KeyCode::F2, ConsumerKeyCode::BRIGHTNESS_UP</autogen>
        </item>
        <item>
          <name>F3 to Volume Mute (except virtual machine, RDC)</name>
          <sysctl>remap.f3_to_volumemute</sysctl>
          <not>VIRTUALMACHINE, REMOTEDESKTOPCONNECTION</not>
          <autogen>--KeyToConsumer-- KeyCode::F3, ConsumerKeyCode::VOLUME_MUTE</autogen>
        </item>
        <item>
          <name>F4 to Volume Down (except virtual machine, RDC)</name>
          <sysctl>remap.f4_to_volumedown</sysctl>
          <not>VIRTUALMACHINE, REMOTEDESKTOPCONNECTION</not>
          <autogen>--KeyToConsumer-- KeyCode::F4, ConsumerKeyCode::VOLUME_DOWN</autogen>
        </item>
        <item>
          <name>F4 to Volume Mute</name>
          <sysctl>remap.f4_to_volumemute</sysctl>
          <autogen>--KeyToConsumer-- KeyCode::F4, ConsumerKeyCode::VOLUME_MUTE</autogen>
        </item>
        <item>
          <name>F5 to Volume Up (except virtual machine, RDC)</name>
          <sysctl>remap.f5_to_volumeup</sysctl>
          <not>VIRTUALMACHINE, REMOTEDESKTOPCONNECTION</not>
          <autogen>--KeyToConsumer-- KeyCode::F5, ConsumerKeyCode::VOLUME_UP</autogen>
        </item>
        <item>
          <name>F5 to Volume Down</name>
          <sysctl>remap.f5_to_volumedown</sysctl>
          <autogen>--KeyToConsumer-- KeyCode::F5, ConsumerKeyCode::VOLUME_DOWN</autogen>
        </item>
        <item>
          <name>F5/F6 to Volume Up/Down 1/4</name>
          <sysctl>remap.f5f6_to_volumedownup_quarter</sysctl>
          <autogen>--KeyToConsumer-- KeyCode::F5, ModifierFlag::NONE, ConsumerKeyCode::VOLUME_DOWN, ModifierFlag::SHIFT_L | ModifierFlag::OPTION_L</autogen>
          <autogen>--KeyToConsumer-- KeyCode::F6, ModifierFlag::NONE, ConsumerKeyCode::VOLUME_UP, ModifierFlag::SHIFT_L | ModifierFlag::OPTION_L</autogen>
        </item>
        <item>
          <name>F5/F6 to Volume Down/Up without click</name>
          <sysctl>remap.f5f6_to_voldownup_woclick</sysctl>
          <autogen>--KeyToConsumer-- KeyCode::F5, ModifierFlag::NONE, ConsumerKeyCode::VOLUME_DOWN, ModifierFlag::SHIFT_L</autogen>
          <autogen>--KeyToConsumer-- KeyCode::F6, ModifierFlag::NONE, ConsumerKeyCode::VOLUME_UP, ModifierFlag::SHIFT_L</autogen>
        </item>
        <item>
          <name>F6 to FN_Lock (except virtual machine, RDC)</name>
          <sysctl>remap.f6_to_numlock</sysctl>
          <not>VIRTUALMACHINE, REMOTEDESKTOPCONNECTION</not>
          <autogen>--KeyToKey-- KeyCode::F6, KeyCode::VK_LOCK_FN</autogen>
        </item>
        <item>
          <name>F6 to Volume Up</name>
          <sysctl>remap.f6_to_volumeup</sysctl>
          <autogen>--KeyToConsumer-- KeyCode::F6, ConsumerKeyCode::VOLUME_UP</autogen>
        </item>
        <item>
          <name>F7 to Video Mirror (except virtual machine, RDC)</name>
          <sysctl>remap.f7_to_videomirror</sysctl>
          <not>VIRTUALMACHINE, REMOTEDESKTOPCONNECTION</not>
          <autogen>--KeyToConsumer-- KeyCode::F7, ConsumerKeyCode::VIDEO_MIRROR</autogen>
        </item>
        <item>
          <name>F7 to Music Prev (except virtual machine, RDC)</name>
          <sysctl>remap.f7_to_musicprev</sysctl>
          <not>VIRTUALMACHINE, REMOTEDESKTOPCONNECTION</not>
          <autogen>--KeyToConsumer-- KeyCode::F7, ConsumerKeyCode::MUSIC_PREV</autogen>
        </item>
        <item>
          <name>F8 to Keyboard Light Off (except virtual machine, RDC)</name>
          <sysctl>remap.f8_to_keyboardlightoff</sysctl>
          <not>VIRTUALMACHINE, REMOTEDESKTOPCONNECTION</not>
          <autogen>--KeyToConsumer-- KeyCode::F8, ConsumerKeyCode::KEYBOARDLIGHT_OFF</autogen>
        </item>
        <item>
          <name>F8 to Music Play/Pause (except virtual machine, RDC)</name>
          <sysctl>remap.f8_to_musicplay</sysctl>
          <not>VIRTUALMACHINE, REMOTEDESKTOPCONNECTION</not>
          <autogen>--KeyToConsumer-- KeyCode::F8, ConsumerKeyCode::MUSIC_PLAY</autogen>
        </item>
        <item>
          <name>F9 to Keyboard Light LOW (except virtual machine, RDC)</name>
          <sysctl>remap.f9_to_keyboardlightlow</sysctl>
          <not>VIRTUALMACHINE, REMOTEDESKTOPCONNECTION</not>
          <autogen>--KeyToConsumer-- KeyCode::F9, ConsumerKeyCode::KEYBOARDLIGHT_LOW</autogen>
        </item>
        <item>
          <name>F9 to Music Next (except virtual machine, RDC)</name>
          <sysctl>remap.f9_to_musicplay</sysctl>
          <not>VIRTUALMACHINE, REMOTEDESKTOPCONNECTION</not>
          <autogen>--KeyToConsumer-- KeyCode::F9, ConsumerKeyCode::MUSIC_NEXT</autogen>
        </item>
        <item>
          <name>F10 to Keyboard Light HIGH (except virtual machine, RDC)</name>
          <sysctl>remap.f10_to_keyboardlighthigh</sysctl>
          <not>VIRTUALMACHINE, REMOTEDESKTOPCONNECTION</not>
          <autogen>--KeyToConsumer-- KeyCode::F10, ConsumerKeyCode::KEYBOARDLIGHT_HIGH</autogen>
        </item>
        <item>
          <name>F10 to Volume Mute (except virtual machine, RDC)</name>
          <sysctl>remap.f10_to_volumemute</sysctl>
          <not>VIRTUALMACHINE, REMOTEDESKTOPCONNECTION</not>
          <autogen>--KeyToConsumer-- KeyCode::F10, ConsumerKeyCode::VOLUME_MUTE</autogen>
        </item>
        <item>
          <name>FN+F11 to F11</name>
          <sysctl>remap.FnF11_to_f11</sysctl>
          <autogen>--KeyToKey-- KeyCode::F11, ModifierFlag::FN, KeyCode::F11</autogen>
        </item>
        <item>
          <name>F11 to Volume Down (except virtual machine, RDC)</name>
          <sysctl>remap.f11_to_volumedown</sysctl>
          <not>VIRTUALMACHINE, REMOTEDESKTOPCONNECTION</not>
          <autogen>--KeyToConsumer-- KeyCode::F11, ConsumerKeyCode::VOLUME_DOWN</autogen>
        </item>
        <item>
          <name>F11 to display mirroring</name>
          <sysctl>remap.F11_to_mirroring</sysctl>
          <autogen>--KeyToConsumer-- KeyCode::F11, ConsumerKeyCode::VIDEO_MIRROR</autogen>
        </item>
        <item>
          <name>F12 to Volume Up (except virtual machine, RDC)</name>
          <sysctl>remap.f12_to_volumeup</sysctl>
          <not>VIRTUALMACHINE, REMOTEDESKTOPCONNECTION</not>
          <autogen>--KeyToConsumer-- KeyCode::F12, ConsumerKeyCode::VOLUME_UP</autogen>
        </item>
        <item>
          <name>FN+F12 to F12</name>
          <sysctl>remap.FnF12_to_f12</sysctl>
          <autogen>--KeyToKey-- KeyCode::F12, ModifierFlag::FN, KeyCode::F12</autogen>
        </item>
        <item>
          <name>F12 to Forward Delete</name>
          <sysctl>remap.f12_to_forwarddelete</sysctl>
          <autogen>--KeyToKey-- KeyCode::F12, KeyCode::FORWARD_DELETE</autogen>
        </item>
        <item>
          <name>F12 to Expose</name>
          <sysctl>remap.F12_to_expose</sysctl>
          <autogen>--KeyToKey-- KeyCode::F12, KeyCode::EXPOSE_ALL</autogen>
        </item>
        <item>
          <name>F13 to Volume Mute (except virtual machine, RDC)</name>
          <sysctl>remap.f13_to_volumemute</sysctl>
          <not>VIRTUALMACHINE, REMOTEDESKTOPCONNECTION</not>
          <autogen>--KeyToConsumer-- KeyCode::F13, ConsumerKeyCode::VOLUME_MUTE</autogen>
        </item>
        <item>
          <name>F14 to Volume Down (except virtual machine, RDC)</name>
          <sysctl>remap.f14_to_volumedown</sysctl>
          <not>VIRTUALMACHINE, REMOTEDESKTOPCONNECTION</not>
          <autogen>--KeyToConsumer-- KeyCode::F14, ConsumerKeyCode::VOLUME_DOWN</autogen>
        </item>
        <item>
          <name>F15 to Volume Up (except virtual machine, RDC)</name>
          <sysctl>remap.f15_to_volumeup</sysctl>
          <not>VIRTUALMACHINE, REMOTEDESKTOPCONNECTION</not>
          <autogen>--KeyToConsumer-- KeyCode::F15, ConsumerKeyCode::VOLUME_UP</autogen>
        </item>

        <item>
          <name>FN+F1 to Brightness Down</name>
          <sysctl>remap.fnF1_to_brightnessdown</sysctl>
          <autogen>--KeyToConsumer-- KeyCode::F1, ModifierFlag::FN, ConsumerKeyCode::BRIGHTNESS_DOWN</autogen>
        </item>
        <item>
          <name>FN+F2 to Brightness Up</name>
          <sysctl>remap.fnF2_to_brightnessup</sysctl>
          <autogen>--KeyToConsumer-- KeyCode::F2, ModifierFlag::FN, ConsumerKeyCode::BRIGHTNESS_UP</autogen>
        </item>
        <item>
          <name>FN+F7 to Music Prev</name>
          <sysctl>remap.fnF7_to_musicprev</sysctl>
          <autogen>--KeyToConsumer-- KeyCode::F7, ModifierFlag::FN, ConsumerKeyCode::MUSIC_PREV</autogen>
        </item>
        <item>
          <name>FN+F8 to Music Play/Pause</name>
          <sysctl>remap.fnF8_to_musicplay</sysctl>
          <autogen>--KeyToConsumer-- KeyCode::F8, ModifierFlag::FN, ConsumerKeyCode::MUSIC_PLAY</autogen>
        </item>
        <item>
          <name>FN+F9 to Music Next</name>
          <sysctl>remap.fnF9_to_musicplay</sysctl>
          <autogen>--KeyToConsumer-- KeyCode::F9, ModifierFlag::FN, ConsumerKeyCode::MUSIC_NEXT</autogen>
        </item>
        <item>
          <name>FN+F10 to Volume Mute</name>
          <sysctl>remap.fnF10_to_volumemute</sysctl>
          <autogen>--KeyToConsumer-- KeyCode::F10, ModifierFlag::FN, ConsumerKeyCode::VOLUME_MUTE</autogen>
        </item>
        <item>
          <name>FN+F11 to Volume Down</name>
          <sysctl>remap.fnF11_to_volumedown</sysctl>
          <autogen>--KeyToConsumer-- KeyCode::F11, ModifierFlag::FN, ConsumerKeyCode::VOLUME_DOWN</autogen>
        </item>
        <item>
          <name>FN+F12 to Volume Up</name>
          <sysctl>remap.fnF12_to_volumeup</sysctl>
          <autogen>--KeyToConsumer-- KeyCode::F12, ModifierFlag::FN, ConsumerKeyCode::VOLUME_UP</autogen>
        </item>

        <item>
          <name>Change Command+F1...F12 to Functional Keys</name>
          <appendix>(ex. F10 to Volume Mute, F11 to Volume Down)</appendix>
          <sysctl>remap.command_f1_f12_to_functional</sysctl>
          <autogen>--KeyToKey-- KeyCode::F1,       VK_COMMAND, KeyCode::BRIGHTNESS_DOWN</autogen>
          <autogen>--KeyToKey-- KeyCode::F2,       VK_COMMAND, KeyCode::BRIGHTNESS_UP</autogen>
          <autogen>--KeyToKey-- KeyCode::F3,       VK_COMMAND, KeyCode::EXPOSE_ALL</autogen>
          <autogen>--KeyToKey-- KeyCode::F4,       VK_COMMAND, KeyCode::DASHBOARD</autogen>
          <autogen>--KeyToConsumer-- KeyCode::F7,  VK_COMMAND, ConsumerKeyCode::MUSIC_PREV</autogen>
          <autogen>--KeyToConsumer-- KeyCode::F8,  VK_COMMAND, ConsumerKeyCode::MUSIC_PLAY</autogen>
          <autogen>--KeyToConsumer-- KeyCode::F9,  VK_COMMAND, ConsumerKeyCode::MUSIC_NEXT</autogen>
          <autogen>--KeyToConsumer-- KeyCode::F10, VK_COMMAND, ConsumerKeyCode::VOLUME_MUTE</autogen>
          <autogen>--KeyToConsumer-- KeyCode::F11, VK_COMMAND, ConsumerKeyCode::VOLUME_DOWN</autogen>
          <autogen>--KeyToConsumer-- KeyCode::F12, VK_COMMAND, ConsumerKeyCode::VOLUME_UP</autogen>
        </item>

        <item>
          <name>Change F1...F12 to Functional Keys (except Terminal)</name>
          <appendix>(ex. F10 to Volume Mute, F11 to Volume Down)</appendix>
          <sysctl>remap.f1_f12_to_functional</sysctl>
          <not>TERMINAL</not>
          <!-- #include "include/f1_f12_to_functional_withfn.xml" -->
        </item>

        <item>
          <name>Force change F1..F12 in VMware, Parallels, RDC</name>
          <list>
            <item>
              <name>F1 to Brightness Down</name>
              <sysctl>remap.f1_to_brightnessdown_force</sysctl>
              <autogen>--KeyToConsumer-- KeyCode::F1, ConsumerKeyCode::BRIGHTNESS_DOWN</autogen>
            </item>
            <item>
              <name>F2 to Brightness Up</name>
              <sysctl>remap.f2_to_brightnessup_force</sysctl>
              <autogen>--KeyToConsumer-- KeyCode::F2, ConsumerKeyCode::BRIGHTNESS_UP</autogen>
            </item>
            <item>
              <name>F3 to Volume Mute</name>
              <sysctl>remap.f3_to_volumemute_force</sysctl>
              <autogen>--KeyToConsumer-- KeyCode::F3, ConsumerKeyCode::VOLUME_MUTE</autogen>
            </item>
            <item>
              <name>F4 to Volume Down</name>
              <sysctl>remap.f4_to_volumedown_force</sysctl>
              <autogen>--KeyToConsumer-- KeyCode::F4, ConsumerKeyCode::VOLUME_DOWN</autogen>
            </item>
            <item>
              <name>F5 to Volume Up</name>
              <sysctl>remap.f5_to_volumeup_force</sysctl>
              <autogen>--KeyToConsumer-- KeyCode::F5, ConsumerKeyCode::VOLUME_UP</autogen>
            </item>
          </list>
        </item>
        <item>
          <name>Control+F1 to F16</name>
          <sysctl>remap.controlF1toF16</sysctl>
          <autogen>--KeyToKey-- KeyCode::F1, VK_CONTROL, KeyCode::F16</autogen>
        </item>
        <item>
          <name>F16 to Tab</name>
          <sysctl>remap.f16_to_tab</sysctl>
          <autogen>--KeyToKey-- KeyCode::F16, KeyCode::TAB</autogen>
        </item>
      </list>
    </item>

    <item>
      <name>Change Help Key</name>
      <list>
        <item>
          <name>Change Help to F13</name>
          <sysctl>remap.help2f13</sysctl>
          <autogen>--KeyToKey-- KeyCode::HELP, KeyCode::F13</autogen>
        </item>
      </list>
    </item>

    <item>
      <name>Change KeyPad Key</name>
      <list>
        <item>
          <name>Change Clear Key</name>
          <list>
            <item>
              <name>Clear to Delete</name>
              <sysctl>remap.clear2delete</sysctl>
              <autogen>--KeyToKey-- KeyCode::KEYPAD_CLEAR, KeyCode::DELETE</autogen>
            </item>
            <item>
              <name>Clear to Return</name>
              <sysctl>remap.clear2return</sysctl>
              <autogen>--KeyToKey-- KeyCode::KEYPAD_CLEAR, KeyCode::RETURN</autogen>
            </item>
            <item>
              <name>Clear to Tab</name>
              <sysctl>remap.clear2tab</sysctl>
              <autogen>--KeyToKey-- KeyCode::KEYPAD_CLEAR, KeyCode::TAB</autogen>
            </item>
            <item>
              <name>Clear to Eject</name>
              <sysctl>remap.clear2eject</sysctl>
              <autogen>--KeyToConsumer-- KeyCode::KEYPAD_CLEAR, ConsumerKeyCode::EJECT</autogen>
            </item>
          </list>
        </item>
        <item>
          <name>Change Comma(,) Key</name>
          <list>
            <item>
              <name>Comma to Shift+Comma</name>
              <sysctl>remap.keypadcomma2shiftComma</sysctl>
              <autogen>--KeyToKey-- KeyCode::KEYPAD_COMMA, KeyCode::KEYPAD_COMMA, ModifierFlag::SHIFT_L</autogen>
            </item>
            <item>
              <name>Comma to Equal</name>
              <sysctl>remap.keypadcomma2keypadequal</sysctl>
              <autogen>--KeyToKey-- KeyCode::KEYPAD_COMMA, KeyCode::KEYPAD_EQUAL</autogen>
            </item>
          </list>
        </item>
        <item>
          <name>Keypad_0 to Shift_L</name>
          <appendix>(+ When you type Keypad_0 only, send Keypad_0) + [KeyRepeat]</appendix>
          <sysctl>remap.keypad0_2_shiftL_keypad0_keyrepeat</sysctl>
          <autogen>--KeyOverlaidModifierWithRepeat-- KeyCode::KEYPAD_0, KeyCode::SHIFT_L, KeyCode::KEYPAD_0</autogen>
        </item>
        <item>
          <name>Shift+Dot to Comma</name>
          <sysctl>remap.shift_keypad_dot2comma</sysctl>
          <autogen>--KeyToKey-- KeyCode::KEYPAD_DOT, ModifierFlag::VK_SHIFT, KeyCode::KEYPAD_COMMA</autogen>
        </item>
        <item>
          <name>Shift+Enter to Equal</name>
          <sysctl>remap.shift_enter2equal</sysctl>
          <autogen>--KeyToKey-- KeyCode::ENTER, ModifierFlag::VK_SHIFT, KeyCode::KEYPAD_EQUAL</autogen>
        </item>
        <item>
          <name>Logitech N305 hack / FILCO FKBT22MB hack</name>
          <appendix>(Enable equal, parentheses)</appendix>
          <appendix>(Drop NumLock key)</appendix>
          <sysctl>remap.logitech_n305_hack</sysctl>
          <!--
              ============================================================
              [Device Information]

              The following is the output for the number one key:
              *** An unnecessary Clear key is output ***
              eventType:keyDown code:0x47 name:Clear    flags:FN         misc:
              eventType:keyUp   code:0x47 name:Clear    flags:FN         misc:
              eventType:keyDown code:0x53 name:1        flags:NumPad     misc:
              eventType:keyUp   code:0x53 name:1        flags:NumPad     misc:
              eventType:keyDown code:0x47 name:Clear    flags:FN         misc:
              eventType:keyUp   code:0x47 name:Clear    flags:FN         misc:

              Equal Symbol:
              eventType:keyMod  code:0x3a name:Option_L flags:Opt        misc:
              eventType:keyDown code:0x58 name:6        flags:Opt NumPad misc:
              eventType:keyDown code:0x53 name:1        flags:Opt NumPad misc:
              eventType:keyUp   code:0x58 name:6        flags:Opt NumPad misc:
              eventType:keyUp   code:0x53 name:1        flags:Opt NumPad misc:
              eventType:keyMod  code:0x3a name:Option_L flags:           misc:

              Left Parenthesis:
              eventType:keyMod  code:0x3a name:Option_L flags:Opt        misc:
              eventType:keyDown code:0x56 name:4        flags:Opt NumPad misc:
              eventType:keyUp   code:0x56 name:4        flags:Opt NumPad misc:
              eventType:keyDown code:0x52 name:0        flags:Opt NumPad misc:
              eventType:keyUp   code:0x52 name:0        flags:Opt NumPad misc:
              eventType:keyMod  code:0x3a name:Option_L flags:           misc:

              Right Parenthesis:
              eventType:keyMod  code:0x3a name:Option_L flags:Opt        misc:
              eventType:keyDown code:0x56 name:4        flags:Opt NumPad misc:
              eventType:keyDown code:0x53 name:1        flags:Opt NumPad misc:
              eventType:keyUp   code:0x56 name:4        flags:Opt NumPad misc:
              eventType:keyUp   code:0x53 name:1        flags:Opt NumPad misc:
              eventType:keyMod  code:0x3a name:Option_L flags:           misc:

              ============================================================
              [Our approach]

              We use sticky modifiers to achieve equal, parentheses.

              Option_L+6 to EXTRA1.
              - EXTRA1+1 to Equal

              Option_L+4 to EXTRA2.
              -EXTRA2+0 to Left Parenthesis
              -EXTRA2+1 to Right Parenthesis

              Option_L+1 to EXTRA3.
              - EXTRA3+6 to Equal
              - EXTRA3+4 to Right Parenthesis

              Option_L+0 to EXTRA4.
              - EXTRA4+4 to Left Parenthesis

            -->
          <!-- to Equal -->
          <autogen>--KeyToKey-- KeyCode::KEYPAD_1, ModifierFlag::EXTRA1 | ModifierFlag::OPTION_L, KeyCode::KEYPAD_EQUAL</autogen>
          <autogen>--KeyToKey-- KeyCode::KEYPAD_1, ModifierFlag::EXTRA1,                          KeyCode::KEYPAD_EQUAL</autogen>
          <autogen>--KeyToKey-- KeyCode::KEYPAD_6, ModifierFlag::EXTRA3 | ModifierFlag::OPTION_L, KeyCode::KEYPAD_EQUAL</autogen>
          <autogen>--KeyToKey-- KeyCode::KEYPAD_6, ModifierFlag::EXTRA3,                          KeyCode::KEYPAD_EQUAL</autogen>

          <!-- to Left Parenthesis -->
          <autogen>--KeyToKey-- KeyCode::KEYPAD_0, ModifierFlag::EXTRA2 | ModifierFlag::OPTION_L, KeyCode::KEY_9, ModifierFlag::SHIFT_L</autogen>
          <autogen>--KeyToKey-- KeyCode::KEYPAD_0, ModifierFlag::EXTRA2,                          KeyCode::KEY_9, ModifierFlag::SHIFT_L</autogen>
          <autogen>--KeyToKey-- KeyCode::KEYPAD_4, ModifierFlag::EXTRA4 | ModifierFlag::OPTION_L, KeyCode::KEY_9, ModifierFlag::SHIFT_L</autogen>
          <autogen>--KeyToKey-- KeyCode::KEYPAD_4, ModifierFlag::EXTRA4,                          KeyCode::KEY_9, ModifierFlag::SHIFT_L</autogen>

          <!-- to Right Parenthesis -->
          <autogen>--KeyToKey-- KeyCode::KEYPAD_1, ModifierFlag::EXTRA2 | ModifierFlag::OPTION_L, KeyCode::KEY_0, ModifierFlag::SHIFT_L</autogen>
          <autogen>--KeyToKey-- KeyCode::KEYPAD_1, ModifierFlag::EXTRA2,                          KeyCode::KEY_0, ModifierFlag::SHIFT_L</autogen>
          <autogen>--KeyToKey-- KeyCode::KEYPAD_4, ModifierFlag::EXTRA3 | ModifierFlag::OPTION_L, KeyCode::KEY_0, ModifierFlag::SHIFT_L</autogen>
          <autogen>--KeyToKey-- KeyCode::KEYPAD_4, ModifierFlag::EXTRA3,                          KeyCode::KEY_0, ModifierFlag::SHIFT_L</autogen>

          <!-- to Sticky Modifier -->
          <autogen>--KeyToKey-- KeyCode::KEYPAD_6, ModifierFlag::OPTION_L | ModifierFlag::NONE, KeyCode::VK_STICKY_EXTRA1</autogen>
          <autogen>--KeyToKey-- KeyCode::KEYPAD_4, ModifierFlag::OPTION_L | ModifierFlag::NONE, KeyCode::VK_STICKY_EXTRA2</autogen>
          <autogen>--KeyToKey-- KeyCode::KEYPAD_1, ModifierFlag::OPTION_L | ModifierFlag::NONE, KeyCode::VK_STICKY_EXTRA3</autogen>
          <autogen>--KeyToKey-- KeyCode::KEYPAD_0, ModifierFlag::OPTION_L | ModifierFlag::NONE, KeyCode::VK_STICKY_EXTRA4</autogen>

          <!-- ================================================== -->
          <!-- Drop unnecessary Clear -->
          <autogen>--KeyToKey-- KeyCode::PC_KEYPAD_NUMLOCK, KeyCode::VK_NONE</autogen>
        </item>
        <item>
          <name>Use KeyPad as MS Project Build Keys</name>
          <appendix>Maps some of the keypad keys to standard debugger step thru cmds for Visual Studio</appendix>
          <list>
            <item>
              <name>Change Keypad Enter Key to F5 (Run)</name>
              <sysctl>remap.KPEnter_to_F5</sysctl>
              <autogen>--KeyToKey-- KeyCode::ENTER, KeyCode::F5</autogen>
            </item>
            <item>
              <name>Change Keypad Dot(Del) Key to Shift+F5 (Stop)</name>
              <sysctl>remap.KPDot_to_Shift_F5</sysctl>
              <autogen>--KeyToKey-- KeyCode::KEYPAD_DOT, KeyCode::F5, ModifierFlag::SHIFT_L</autogen>
            </item>
            <item>
              <name>Change Keypad 0 to F11 (Step in)</name>
              <sysctl>remap.KP0_to_F11</sysctl>
              <autogen>--KeyToKey-- KeyCode::KEYPAD_0, KeyCode::F11</autogen>
            </item>
            <item>
              <name>Change Keypad 1 to Shift+F11/Step out (this is intentionally the key above F11)</name>
              <sysctl>remap.KP1_to_Shift_F11</sysctl>
              <autogen>--KeyToKey-- KeyCode::KEYPAD_1, KeyCode::F11, ModifierFlag::SHIFT_L</autogen>
            </item>
            <item>
              <name>Change Keypad 2 to F10 (Step over)</name>
              <sysctl>remap.KP2_to_F10</sysctl>
              <autogen>--KeyToKey-- KeyCode::KEYPAD_2, KeyCode::F10</autogen>
            </item>
          </list>
        </item>
      </list>
    </item>

    <item>
      <name>Change Media Keys (Play/Pause, Prev, Next)</name>
      <list>
        <item>
          <name>Media Keys to F7..F9</name>
          <appendix>Music Prev to F7</appendix>
          <appendix>Music Play/Pause to F8</appendix>
          <appendix>Music Next to F9</appendix>
          <sysctl>remap.mediaKeysToFKeys</sysctl>
          <!-- F7 - F9 -->
          <autogen>--ConsumerToKey-- ConsumerKeyCode::MUSIC_PREV,         KeyCode::F7</autogen>
          <autogen>--ConsumerToKey-- ConsumerKeyCode::MUSIC_PLAY,         KeyCode::F8</autogen>
          <autogen>--ConsumerToKey-- ConsumerKeyCode::MUSIC_NEXT,         KeyCode::F9</autogen>
        </item>
        <item>
          <name>FN+Function Keys to Media Keys</name>
          <appendix>FN+F7 to Music Prev</appendix>
          <appendix>FN+F8 to Music Play/Pause</appendix>
          <appendix>FN+F9 to Music Next</appendix>
          <sysctl>remap.FNFkeysToMediaKeys</sysctl>
          <!-- F7 - F9 -->
          <autogen>--KeyToConsumer-- KeyCode::F7, ModifierFlag::FN, ConsumerKeyCode::MUSIC_PREV</autogen>
          <autogen>--KeyToConsumer-- KeyCode::F8, ModifierFlag::FN, ConsumerKeyCode::MUSIC_PLAY</autogen>
          <autogen>--KeyToConsumer-- KeyCode::F9, ModifierFlag::FN, ConsumerKeyCode::MUSIC_NEXT</autogen>
        </item>
      </list>
    </item>

    <item>
      <name>Change Minus Key</name>
      <list>
        <item>
          <name>Change Minus to Semicolon</name>
          <sysctl>remap.minus2semicolon</sysctl>
          <autogen>--KeyToKey-- KeyCode::MINUS, KeyCode::SEMICOLON</autogen>
        </item>
      </list>
    </item>

    <item>
      <name>Change Num Key (1...0)</name>
      <list>
        <item>
          <name>Holding Shift+1 to F1</name>
          <sysctl>remap.holding_shiftL1_to_f1</sysctl>
          <autogen>--HoldingKeyToKey-- KeyCode::KEY_1, VK_SHIFT, KeyCode::KEY_1, ModifierFlag::SHIFT_L, KeyCode::VK_NONE, KeyCode::F1</autogen>
        </item>
        <item>
          <name>Holding Shift+2 to F2</name>
          <sysctl>remap.holding_shiftL2_to_f2</sysctl>
          <autogen>--HoldingKeyToKey-- KeyCode::KEY_2, VK_SHIFT, KeyCode::KEY_2, ModifierFlag::SHIFT_L, KeyCode::VK_NONE, KeyCode::F2</autogen>
        </item>
        <item>
          <name>Holding Shift+3 to F3</name>
          <sysctl>remap.holding_shiftL3_to_f3</sysctl>
          <autogen>--HoldingKeyToKey-- KeyCode::KEY_3, VK_SHIFT, KeyCode::KEY_3, ModifierFlag::SHIFT_L, KeyCode::VK_NONE, KeyCode::F3</autogen>
        </item>
        <item>
          <name>Holding Shift+4 to F4</name>
          <sysctl>remap.holding_shiftL4_to_f4</sysctl>
          <autogen>--HoldingKeyToKey-- KeyCode::KEY_4, VK_SHIFT, KeyCode::KEY_4, ModifierFlag::SHIFT_L, KeyCode::VK_NONE, KeyCode::F4</autogen>
        </item>
        <item>
          <name>Holding Shift+5 to F5</name>
          <sysctl>remap.holding_shiftL5_to_f5</sysctl>
          <autogen>--HoldingKeyToKey-- KeyCode::KEY_5, VK_SHIFT, KeyCode::KEY_5, ModifierFlag::SHIFT_L, KeyCode::VK_NONE, KeyCode::F5</autogen>
        </item>
        <item>
          <name>Holding Shift+6 to F6</name>
          <sysctl>remap.holding_shiftL6_to_f6</sysctl>
          <autogen>--HoldingKeyToKey-- KeyCode::KEY_6, VK_SHIFT, KeyCode::KEY_6, ModifierFlag::SHIFT_L, KeyCode::VK_NONE, KeyCode::F6</autogen>
        </item>
        <item>
          <name>Holding Shift+7 to F7</name>
          <sysctl>remap.holding_shiftL7_to_f7</sysctl>
          <autogen>--HoldingKeyToKey-- KeyCode::KEY_7, VK_SHIFT, KeyCode::KEY_7, ModifierFlag::SHIFT_L, KeyCode::VK_NONE, KeyCode::F7</autogen>
        </item>
        <item>
          <name>Holding Shift+8 to F8</name>
          <sysctl>remap.holding_shiftL8_to_f8</sysctl>
          <autogen>--HoldingKeyToKey-- KeyCode::KEY_8, VK_SHIFT, KeyCode::KEY_8, ModifierFlag::SHIFT_L, KeyCode::VK_NONE, KeyCode::F8</autogen>
        </item>
        <item>
          <name>Holding Shift+9 to F9</name>
          <sysctl>remap.holding_shiftL9_to_f9</sysctl>
          <autogen>--HoldingKeyToKey-- KeyCode::KEY_9, VK_SHIFT, KeyCode::KEY_9, ModifierFlag::SHIFT_L, KeyCode::VK_NONE, KeyCode::F9</autogen>
        </item>
        <item>
          <name>Holding Shift+0 to F10</name>
          <sysctl>remap.holding_shiftL0_to_f10</sysctl>
          <autogen>--HoldingKeyToKey-- KeyCode::KEY_0, VK_SHIFT, KeyCode::KEY_0, ModifierFlag::SHIFT_L, KeyCode::VK_NONE, KeyCode::F10</autogen>
        </item>

        <item>
          <name>Holding Command+1,2,3,4,... to F1,F2,F3,...,F12</name>
          <appendix>Holding Command+1 to F1</appendix>
          <appendix>Holding Command+2 to F2</appendix>
          <appendix>Holding Command+3 to F3</appendix>
          <appendix>Holding Command+4 to F4</appendix>
          <appendix>Holding Command+5 to F5</appendix>
          <appendix>Holding Command+6 to F6</appendix>
          <appendix>Holding Command+7 to F7</appendix>
          <appendix>Holding Command+8 to F8</appendix>
          <appendix>Holding Command+9 to F9</appendix>
          <appendix>Holding Command+10 to F10</appendix>
          <appendix>Holding Command+- to F11</appendix>
          <appendix>Holding Command+= to F12</appendix>
          <sysctl>remap.holding_command_num_to_function</sysctl>
          <autogen>--HoldingKeyToKey-- KeyCode::KEY_1, VK_COMMAND, KeyCode::KEY_1, ModifierFlag::COMMAND_L, KeyCode::VK_NONE, KeyCode::F1</autogen>
          <autogen>--HoldingKeyToKey-- KeyCode::KEY_2, VK_COMMAND, KeyCode::KEY_2, ModifierFlag::COMMAND_L, KeyCode::VK_NONE, KeyCode::F2</autogen>
          <autogen>--HoldingKeyToKey-- KeyCode::KEY_3, VK_COMMAND, KeyCode::KEY_3, ModifierFlag::COMMAND_L, KeyCode::VK_NONE, KeyCode::F3</autogen>
          <autogen>--HoldingKeyToKey-- KeyCode::KEY_4, VK_COMMAND, KeyCode::KEY_4, ModifierFlag::COMMAND_L, KeyCode::VK_NONE, KeyCode::F4</autogen>
          <autogen>--HoldingKeyToKey-- KeyCode::KEY_5, VK_COMMAND, KeyCode::KEY_5, ModifierFlag::COMMAND_L, KeyCode::VK_NONE, KeyCode::F5</autogen>
          <autogen>--HoldingKeyToKey-- KeyCode::KEY_6, VK_COMMAND, KeyCode::KEY_6, ModifierFlag::COMMAND_L, KeyCode::VK_NONE, KeyCode::F6</autogen>
          <autogen>--HoldingKeyToKey-- KeyCode::KEY_7, VK_COMMAND, KeyCode::KEY_7, ModifierFlag::COMMAND_L, KeyCode::VK_NONE, KeyCode::F7</autogen>
          <autogen>--HoldingKeyToKey-- KeyCode::KEY_8, VK_COMMAND, KeyCode::KEY_8, ModifierFlag::COMMAND_L, KeyCode::VK_NONE, KeyCode::F8</autogen>
          <autogen>--HoldingKeyToKey-- KeyCode::KEY_9, VK_COMMAND, KeyCode::KEY_9, ModifierFlag::COMMAND_L, KeyCode::VK_NONE, KeyCode::F9</autogen>
          <autogen>--HoldingKeyToKey-- KeyCode::KEY_0, VK_COMMAND, KeyCode::KEY_0, ModifierFlag::COMMAND_L, KeyCode::VK_NONE, KeyCode::F10</autogen>
          <autogen>--HoldingKeyToKey-- KeyCode::MINUS, VK_COMMAND, KeyCode::MINUS, ModifierFlag::COMMAND_L, KeyCode::VK_NONE, KeyCode::F11</autogen>
          <autogen>--HoldingKeyToKey-- KeyCode::EQUAL, VK_COMMAND, KeyCode::EQUAL, ModifierFlag::COMMAND_L, KeyCode::VK_NONE, KeyCode::F12</autogen>
        </item>
        <item>
          <name>1234567890 to !@#$%^&amp;*() / Shift+1234567890 to 1234567890</name>
          <sysctl>remap.swap_number_and_symbol</sysctl>
          <autogen>--KeyToKey-- KeyCode::KEY_1, ModifierFlag::NONE, KeyCode::KEY_1, ModifierFlag::SHIFT_L</autogen>
          <autogen>--KeyToKey-- KeyCode::KEY_2, ModifierFlag::NONE, KeyCode::KEY_2, ModifierFlag::SHIFT_L</autogen>
          <autogen>--KeyToKey-- KeyCode::KEY_3, ModifierFlag::NONE, KeyCode::KEY_3, ModifierFlag::SHIFT_L</autogen>
          <autogen>--KeyToKey-- KeyCode::KEY_4, ModifierFlag::NONE, KeyCode::KEY_4, ModifierFlag::SHIFT_L</autogen>
          <autogen>--KeyToKey-- KeyCode::KEY_5, ModifierFlag::NONE, KeyCode::KEY_5, ModifierFlag::SHIFT_L</autogen>
          <autogen>--KeyToKey-- KeyCode::KEY_6, ModifierFlag::NONE, KeyCode::KEY_6, ModifierFlag::SHIFT_L</autogen>
          <autogen>--KeyToKey-- KeyCode::KEY_7, ModifierFlag::NONE, KeyCode::KEY_7, ModifierFlag::SHIFT_L</autogen>
          <autogen>--KeyToKey-- KeyCode::KEY_8, ModifierFlag::NONE, KeyCode::KEY_8, ModifierFlag::SHIFT_L</autogen>
          <autogen>--KeyToKey-- KeyCode::KEY_9, ModifierFlag::NONE, KeyCode::KEY_9, ModifierFlag::SHIFT_L</autogen>
          <autogen>--KeyToKey-- KeyCode::KEY_0, ModifierFlag::NONE, KeyCode::KEY_0, ModifierFlag::SHIFT_L</autogen>
          <autogen>--KeyToKey-- KeyCode::KEY_1, VK_SHIFT | ModifierFlag::NONE, KeyCode::KEY_1</autogen>
          <autogen>--KeyToKey-- KeyCode::KEY_2, VK_SHIFT | ModifierFlag::NONE, KeyCode::KEY_2</autogen>
          <autogen>--KeyToKey-- KeyCode::KEY_3, VK_SHIFT | ModifierFlag::NONE, KeyCode::KEY_3</autogen>
          <autogen>--KeyToKey-- KeyCode::KEY_4, VK_SHIFT | ModifierFlag::NONE, KeyCode::KEY_4</autogen>
          <autogen>--KeyToKey-- KeyCode::KEY_5, VK_SHIFT | ModifierFlag::NONE, KeyCode::KEY_5</autogen>
          <autogen>--KeyToKey-- KeyCode::KEY_6, VK_SHIFT | ModifierFlag::NONE, KeyCode::KEY_6</autogen>
          <autogen>--KeyToKey-- KeyCode::KEY_7, VK_SHIFT | ModifierFlag::NONE, KeyCode::KEY_7</autogen>
          <autogen>--KeyToKey-- KeyCode::KEY_8, VK_SHIFT | ModifierFlag::NONE, KeyCode::KEY_8</autogen>
          <autogen>--KeyToKey-- KeyCode::KEY_9, VK_SHIFT | ModifierFlag::NONE, KeyCode::KEY_9</autogen>
          <autogen>--KeyToKey-- KeyCode::KEY_0, VK_SHIFT | ModifierFlag::NONE, KeyCode::KEY_0</autogen>
        </item>
        <item>
          <name>CapsLock+1234567890 to !@#$%^&amp;*() / CapsLock+Shift+1234567890 to 1234567890</name>
          <sysctl>remap.swap_capslock_number_and_symbol</sysctl>
          <autogen>--KeyToKey-- KeyCode::KEY_1, ModifierFlag::CAPSLOCK | ModifierFlag::NONE, KeyCode::KEY_1, ModifierFlag::SHIFT_L</autogen>
          <autogen>--KeyToKey-- KeyCode::KEY_2, ModifierFlag::CAPSLOCK | ModifierFlag::NONE, KeyCode::KEY_2, ModifierFlag::SHIFT_L</autogen>
          <autogen>--KeyToKey-- KeyCode::KEY_3, ModifierFlag::CAPSLOCK | ModifierFlag::NONE, KeyCode::KEY_3, ModifierFlag::SHIFT_L</autogen>
          <autogen>--KeyToKey-- KeyCode::KEY_4, ModifierFlag::CAPSLOCK | ModifierFlag::NONE, KeyCode::KEY_4, ModifierFlag::SHIFT_L</autogen>
          <autogen>--KeyToKey-- KeyCode::KEY_5, ModifierFlag::CAPSLOCK | ModifierFlag::NONE, KeyCode::KEY_5, ModifierFlag::SHIFT_L</autogen>
          <autogen>--KeyToKey-- KeyCode::KEY_6, ModifierFlag::CAPSLOCK | ModifierFlag::NONE, KeyCode::KEY_6, ModifierFlag::SHIFT_L</autogen>
          <autogen>--KeyToKey-- KeyCode::KEY_7, ModifierFlag::CAPSLOCK | ModifierFlag::NONE, KeyCode::KEY_7, ModifierFlag::SHIFT_L</autogen>
          <autogen>--KeyToKey-- KeyCode::KEY_8, ModifierFlag::CAPSLOCK | ModifierFlag::NONE, KeyCode::KEY_8, ModifierFlag::SHIFT_L</autogen>
          <autogen>--KeyToKey-- KeyCode::KEY_9, ModifierFlag::CAPSLOCK | ModifierFlag::NONE, KeyCode::KEY_9, ModifierFlag::SHIFT_L</autogen>
          <autogen>--KeyToKey-- KeyCode::KEY_0, ModifierFlag::CAPSLOCK | ModifierFlag::NONE, KeyCode::KEY_0, ModifierFlag::SHIFT_L</autogen>
          <autogen>--KeyToKey-- KeyCode::KEY_1, ModifierFlag::CAPSLOCK | VK_SHIFT | ModifierFlag::NONE, KeyCode::KEY_1</autogen>
          <autogen>--KeyToKey-- KeyCode::KEY_2, ModifierFlag::CAPSLOCK | VK_SHIFT | ModifierFlag::NONE, KeyCode::KEY_2</autogen>
          <autogen>--KeyToKey-- KeyCode::KEY_3, ModifierFlag::CAPSLOCK | VK_SHIFT | ModifierFlag::NONE, KeyCode::KEY_3</autogen>
          <autogen>--KeyToKey-- KeyCode::KEY_4, ModifierFlag::CAPSLOCK | VK_SHIFT | ModifierFlag::NONE, KeyCode::KEY_4</autogen>
          <autogen>--KeyToKey-- KeyCode::KEY_5, ModifierFlag::CAPSLOCK | VK_SHIFT | ModifierFlag::NONE, KeyCode::KEY_5</autogen>
          <autogen>--KeyToKey-- KeyCode::KEY_6, ModifierFlag::CAPSLOCK | VK_SHIFT | ModifierFlag::NONE, KeyCode::KEY_6</autogen>
          <autogen>--KeyToKey-- KeyCode::KEY_7, ModifierFlag::CAPSLOCK | VK_SHIFT | ModifierFlag::NONE, KeyCode::KEY_7</autogen>
          <autogen>--KeyToKey-- KeyCode::KEY_8, ModifierFlag::CAPSLOCK | VK_SHIFT | ModifierFlag::NONE, KeyCode::KEY_8</autogen>
          <autogen>--KeyToKey-- KeyCode::KEY_9, ModifierFlag::CAPSLOCK | VK_SHIFT | ModifierFlag::NONE, KeyCode::KEY_9</autogen>
          <autogen>--KeyToKey-- KeyCode::KEY_0, ModifierFlag::CAPSLOCK | VK_SHIFT | ModifierFlag::NONE, KeyCode::KEY_0</autogen>
        </item>
      </list>
    </item>
    <item>
      <name>Change Option_L Key (Left Option)</name>
      <list>
        <item>
          <name>Option_L to Command_L</name>
          <sysctl>remap.optionL2commandL</sysctl>
          <autogen>--KeyToKey-- KeyCode::OPTION_L, KeyCode::COMMAND_L</autogen>
        </item>
        <item>
          <name>Option_L to Command_L (only in virtual machine, RDC)</name>
          <sysctl>remap.optionL2commandL_vm</sysctl>
          <only>VIRTUALMACHINE, REMOTEDESKTOPCONNECTION</only>
          <autogen>--KeyToKey-- KeyCode::OPTION_L, KeyCode::COMMAND_L</autogen>
        </item>
        <item>
          <name>Option_L to Control_L</name>
          <sysctl>remap.optionL2controlL</sysctl>
          <autogen>--KeyToKey-- KeyCode::OPTION_L, KeyCode::CONTROL_L</autogen>
        </item>
        <item>
          <name>Option_L to FN</name>
          <sysctl>remap.optionL2fn</sysctl>
          <autogen>--KeyToKey-- KeyCode::OPTION_L, KeyCode::FN</autogen>
        </item>
        <item>
          <name>Control_L+Option_L to FN</name>
          <sysctl>remap.controlLoptionL2fn</sysctl>
          <autogen>--KeyToKey-- KeyCode::OPTION_L, ModifierFlag::CONTROL_L, KeyCode::FN</autogen>
        </item>
        <item>
          <name>Option_L to Option_L</name>
          <appendix>(+ When you type Option_L only, send Command+Space)</appendix>
          <sysctl>remap.optionL2optionL_commandSpace</sysctl>
          <autogen>--KeyOverlaidModifier-- KeyCode::OPTION_L, KeyCode::OPTION_L, KeyCode::SPACE, ModifierFlag::COMMAND_L</autogen>
        </item>
        <item>
          <name>Option_L to Option_L</name>
          <appendix>(+ When you type Option_L only, send End)</appendix>
          <sysctl>remap.optionL2optionL_End</sysctl>
          <autogen>--KeyOverlaidModifier-- KeyCode::OPTION_L, KeyCode::OPTION_L, KeyCode::END</autogen>
        </item>
        <item>
          <name>Option_L to Option_R</name>
          <sysctl>remap.optionL2optionR</sysctl>
          <autogen>--KeyToKey-- KeyCode::OPTION_L, KeyCode::OPTION_R</autogen>
        </item>
        <item>
          <name>Option_L to Shift_L</name>
          <sysctl>remap.optionL2shiftL</sysctl>
          <autogen>--KeyToKey-- KeyCode::OPTION_L, KeyCode::SHIFT_L</autogen>
        </item>
        <item>
          <name>Option_L to Escape</name>
          <sysctl>remap.optionL2escape</sysctl>
          <autogen>--KeyToKey-- KeyCode::OPTION_L, KeyCode::ESCAPE</autogen>
        </item>
        <item>
          <name>Option_L to Command+Control+Option+Shift+F1</name>
          <sysctl>remap.optionL2allF1</sysctl>
          <autogen>--KeyToKey-- KeyCode::OPTION_L, KeyCode::F1, ModifierFlag::COMMAND_L | ModifierFlag::CONTROL_L | ModifierFlag::OPTION_L | ModifierFlag::SHIFT_L</autogen>
        </item>
        <item>
          <name>Option_L to Space</name>
          <sysctl>remap.optionL2space</sysctl>
          <autogen>--KeyToKey-- KeyCode::OPTION_L, KeyCode::SPACE</autogen>
        </item>
      </list>
    </item>

    <item>
      <name>Change Option_R Key (Right Option)</name>
      <list>
        <item>
          <name>Option_R to Command_L</name>
          <sysctl>remap.optionR2commandL</sysctl>
          <autogen>--KeyToKey-- KeyCode::OPTION_R, KeyCode::COMMAND_L</autogen>
        </item>
        <item>
          <name>Option_R to Control_L</name>
          <sysctl>remap.optionR2controlL</sysctl>
          <autogen>--KeyToKey-- KeyCode::OPTION_R, KeyCode::CONTROL_L</autogen>
        </item>
        <item>
          <name>Option_R to Control_L (only in virtual machine)</name>
          <sysctl>remap.optionR2controlL_vm</sysctl>
          <only>VIRTUALMACHINE</only>
          <autogen>--KeyToKey-- KeyCode::OPTION_R, KeyCode::CONTROL_L</autogen>
        </item>
        <item>
          <name>Option_R to Control_R</name>
          <sysctl>remap.optionR2controlR</sysctl>
          <autogen>--KeyToKey-- KeyCode::OPTION_R, KeyCode::CONTROL_R</autogen>
        </item>
        <item>
          <name>Option_R to Control_R (only in Emacs, Terminal, X11)</name>
          <sysctl>remap.optionR2controlR_etx</sysctl>
          <only>EMACS, TERMINAL, X11</only>
          <autogen>--KeyToKey-- KeyCode::OPTION_R, KeyCode::CONTROL_R</autogen>
        </item>
        <item>
          <name>Option_R to FN</name>
          <sysctl>remap.optionR2fn</sysctl>
          <autogen>--KeyToKey-- KeyCode::OPTION_R, KeyCode::FN</autogen>
        </item>
        <item>
          <name>Command_R+Option_R to FN</name>
          <sysctl>remap.commandRoptionR2fn</sysctl>
          <autogen>--KeyToKey-- KeyCode::OPTION_R, ModifierFlag::COMMAND_R, KeyCode::FN</autogen>
        </item>
        <item>
          <name>Option_R to Option_R</name>
          <appendix>(+ When you type Option_R only, send Command+Space)</appendix>
          <sysctl>remap.optionR2optionR_commandSpace</sysctl>
          <autogen>--KeyOverlaidModifier-- KeyCode::OPTION_R, KeyCode::OPTION_R, KeyCode::SPACE, ModifierFlag::COMMAND_L</autogen>
        </item>
        <item>
          <name>Option_R to Option_R+Shift_L</name>
          <sysctl>remap.optionR2optionRshiftL</sysctl>
          <autogen>--KeyToKey-- KeyCode::OPTION_R, KeyCode::OPTION_R, ModifierFlag::SHIFT_L</autogen>
        </item>
        <item>
          <name>Option_R to Delete</name>
          <sysctl>remap.optionR2delete</sysctl>
          <autogen>--KeyToKey-- KeyCode::OPTION_R, KeyCode::DELETE</autogen>
        </item>
        <item>
          <name>Option_R to End</name>
          <sysctl>remap.optionR2end</sysctl>
          <autogen>--KeyToKey-- KeyCode::OPTION_R, KeyCode::END</autogen>
        </item>
        <item>
          <name>Option_R to End (only in virtual machine, RDC)</name>
          <sysctl>remap.optionR2end_vm</sysctl>
          <only>VIRTUALMACHINE, REMOTEDESKTOPCONNECTION</only>
          <autogen>--KeyToKey-- KeyCode::OPTION_R, KeyCode::END</autogen>
        </item>
        <item>
          <name>Option_R to End (only in virtual machine, RDC)</name>
          <appendix>(+ Shift+Option_R to Shift+End,Control_L+C)</appendix>
          <sysctl>remap.optionR2end_vm_ex</sysctl>
          <only>VIRTUALMACHINE, REMOTEDESKTOPCONNECTION</only>
          <autogen>--KeyToKey-- KeyCode::OPTION_R, VK_SHIFT, KeyCode::END, ModifierFlag::SHIFT_L, KeyCode::C, ModifierFlag::CONTROL_L</autogen>
          <autogen>--KeyToKey-- KeyCode::OPTION_R, KeyCode::END</autogen>
        </item>
        <item>
          <name>Option_R to End (only in virtual machine, RDC)</name>
          <appendix>(+ Shift+Option_R to Shift+End,Command_L+C)</appendix>
          <sysctl>remap.optionR2end_vm_ex2</sysctl>
          <only>VIRTUALMACHINE, REMOTEDESKTOPCONNECTION</only>
          <autogen>--KeyToKey-- KeyCode::OPTION_R, VK_SHIFT, KeyCode::END, ModifierFlag::SHIFT_L, KeyCode::C, ModifierFlag::COMMAND_L</autogen>
          <autogen>--KeyToKey-- KeyCode::OPTION_R, KeyCode::END</autogen>
        </item>
        <item>
          <name>Option_R to Enter</name>
          <sysctl>remap.optionR2enter</sysctl>
          <autogen>--KeyToKey-- KeyCode::OPTION_R, KeyCode::ENTER</autogen>
        </item>
        <item>
          <name>Option_R to Forward Delete</name>
          <sysctl>remap.optionR2forwarddelete</sysctl>
          <autogen>--KeyToKey-- KeyCode::OPTION_R, KeyCode::FORWARD_DELETE</autogen>
        </item>
        <item>
          <name>Option_R to Left-Arrow</name>
          <sysctl>remap.optionR2leftarrow</sysctl>
          <autogen>--KeyToKey-- KeyCode::OPTION_R, KeyCode::CURSOR_LEFT</autogen>
        </item>
        <item>
          <name>Option_R to PageDown</name>
          <sysctl>remap.optionR2pagedown</sysctl>
          <autogen>--KeyToKey-- KeyCode::OPTION_R, KeyCode::PAGEDOWN</autogen>
        </item>
        <item>
          <name>Option_R to Command_L+Right-Arrow (except virtual machine, RDC)</name>
          <sysctl>remap.optionR2commandLrightarrow</sysctl>
          <not>VIRTUALMACHINE, REMOTEDESKTOPCONNECTION</not>
          <autogen>--KeyToKey-- KeyCode::OPTION_R, KeyCode::CURSOR_RIGHT, ModifierFlag::COMMAND_L</autogen>
        </item>
        <item>
          <name>Option_R to Command_L+Right-Arrow (except virtual machine, RDC)</name>
          <appendix>(+ Shift+Option_R to Command_L+Shift_L+Right-Arrow,Command_L+C)</appendix>
          <sysctl>remap.optionR2commandLrightarrow_ex</sysctl>
          <not>VIRTUALMACHINE, REMOTEDESKTOPCONNECTION</not>
          <autogen>--KeyToKey-- KeyCode::OPTION_R, VK_SHIFT, KeyCode::CURSOR_RIGHT, ModifierFlag::COMMAND_L | ModifierFlag::SHIFT_L, KeyCode::C, ModifierFlag::COMMAND_L</autogen>
          <autogen>--KeyToKey-- KeyCode::OPTION_R, KeyCode::CURSOR_RIGHT, ModifierFlag::COMMAND_L</autogen>
        </item>
        <item>
          <name>Option_R to Command_L+Right-Arrow (except virtual machine, RDC)</name>
          <appendix>(+ Shift+Option_R to Command_L+Shift_L+Right-Arrow,Control_L+C)</appendix>
          <sysctl>remap.optionR2commandLrightarrow_ex2</sysctl>
          <not>VIRTUALMACHINE, REMOTEDESKTOPCONNECTION</not>
          <autogen>--KeyToKey-- KeyCode::OPTION_R, VK_SHIFT, KeyCode::CURSOR_RIGHT, ModifierFlag::COMMAND_L | ModifierFlag::SHIFT_L, KeyCode::C, ModifierFlag::CONTROL_L</autogen>
          <autogen>--KeyToKey-- KeyCode::OPTION_R, KeyCode::CURSOR_RIGHT, ModifierFlag::COMMAND_L</autogen>
        </item>
        <item>
          <name>Option_R to Command_L+Right-Arrow</name>
          <sysctl>remap.optionR2commandLrightarrow_all</sysctl>
          <autogen>--KeyToKey-- KeyCode::OPTION_R, KeyCode::CURSOR_RIGHT, ModifierFlag::COMMAND_L</autogen>
        </item>
        <item>
          <name>Option_R to Semicolon</name>
          <sysctl>remap.optionR2semicolon</sysctl>
          <autogen>--KeyToKey-- KeyCode::OPTION_R, KeyCode::SEMICOLON</autogen>
        </item>
        <item>
          <name>Option_R to Space</name>
          <sysctl>remap.optionR2space</sysctl>
          <autogen>--KeyToKey-- KeyCode::OPTION_R, KeyCode::SPACE</autogen>
        </item>
        <item>
          <name>Option_R to Command+Control+Option+Shift+F1</name>
          <sysctl>remap.optionR2allF1</sysctl>
          <autogen>--KeyToKey-- KeyCode::OPTION_R, KeyCode::F1, ModifierFlag::COMMAND_L | ModifierFlag::CONTROL_L | ModifierFlag::OPTION_L | ModifierFlag::SHIFT_L</autogen>
        </item>
      </list>
    </item>

    <item>
      <name>Change PageDown Key</name>
      <list>
        <item>
          <name>PageDown to PageUp</name>
          <sysctl>remap.pagedown2pageup</sysctl>
          <autogen>--KeyToKey-- FROMKEYCODE_PAGEDOWN, KeyCode::PAGEUP</autogen>
        </item>
      </list>
    </item>

    <item>
      <name>Change PageUp Key</name>
      <list>
        <item>
          <name>PageUp to PC Insert Key</name>
          <sysctl>remap.pageup2pcinsert</sysctl>
          <autogen>--KeyToKey-- FROMKEYCODE_PAGEUP, KeyCode::PC_INSERT</autogen>
        </item>
      </list>
    </item>

    <item>
      <name>Change Return Key</name>
      <list>
        <item>
          <name>Return to Command_L</name>
          <sysctl>remap.return2commandL</sysctl>
          <autogen>--KeyToKey-- KeyCode::RETURN, KeyCode::COMMAND_L</autogen>
        </item>
        <item>
          <name>Return to Option_L</name>
          <sysctl>remap.return2optionL</sysctl>
          <autogen>--KeyToKey-- KeyCode::RETURN, KeyCode::OPTION_L</autogen>
        </item>
        <item>
          <name>Return to Option_L</name>
          <appendix>(+ When you type Return only, send Escape)</appendix>
          <sysctl>remap.return2optionL_escape</sysctl>
          <autogen>--KeyOverlaidModifier-- KeyCode::RETURN, KeyCode::OPTION_L, KeyCode::ESCAPE</autogen>
        </item>
        <item>
          <name>FN+Return to Option_L</name>
          <sysctl>remap.fnReturn2optionL</sysctl>
          <autogen>--KeyToKey-- KeyCode::RETURN, ModifierFlag::FN, KeyCode::OPTION_L</autogen>
        </item>
        <item>
          <name>Return to Control_L+F4 (= Move focus to the active (or next) window)</name>
          <sysctl>remap.return2controlLf4</sysctl>
          <autogen>--KeyToKey-- KeyCode::RETURN, KeyCode::F4, ModifierFlag::CONTROL_L</autogen>
        </item>
        <item>
          <name>FN+Return to Shift_L+Insert</name>
          <sysctl>remap.fnReturn2shiftLinsert</sysctl>
          <autogen>--KeyToKey-- KeyCode::RETURN, ModifierFlag::FN, KeyCode::PC_INSERT, ModifierFlag::SHIFT_L</autogen>
        </item>
        <item>
          <name>Return to Semicolon</name>
          <sysctl>remap.return2semicolon</sysctl>
          <autogen>--KeyToKey-- KeyCode::RETURN, KeyCode::SEMICOLON</autogen>
        </item>
        <item>
          <name>Drop Return</name>
          <sysctl>remap.drop_return</sysctl>
          <autogen>--KeyToKey-- KeyCode::RETURN, KeyCode::VK_NONE</autogen>
        </item>
      </list>
    </item>

    <item>
      <name>Change Right Bracket(]) Key</name>
      <list>
        <item>
          <name>Right Bracket(]) to CapsLock</name>
          <sysctl>remap.rightbracket2capslock</sysctl>
          <autogen>--KeyToKey-- KeyCode::BRACKET_RIGHT, KeyCode::CAPSLOCK</autogen>
        </item>
      </list>
    </item>

    <item>
      <name>Change Semicolon Key</name>
      <list>
        <item>
          <name>Semicolon to Minus</name>
          <sysctl>remap.semicolon2minus</sysctl>
          <autogen>--KeyToKey-- KeyCode::SEMICOLON, KeyCode::MINUS</autogen>
        </item>
        <item>
          <name>Semicolon to Return</name>
          <sysctl>remap.semicolon2return</sysctl>
          <autogen>--KeyToKey-- KeyCode::SEMICOLON, KeyCode::RETURN</autogen>
        </item>
        <item>
          <name>Semicolon to Return</name>
          <appendix>(+ Control+Semicolon to Semicolon)</appendix>
          <sysctl>remap.semicolon2return_controlsemicolon2semicolon</sysctl>
          <autogen>--KeyToKey-- KeyCode::SEMICOLON, VK_CONTROL, KeyCode::SEMICOLON</autogen>
          <autogen>--KeyToKey-- KeyCode::SEMICOLON, KeyCode::RETURN</autogen>
        </item>
        <item>
          <name>Semicolon to Return (when there are not any modifiers)</name>
          <appendix>(+ Control+Semicolon to Semicolon)</appendix>
          <sysctl>remap.semicolon2return_nomod</sysctl>
          <autogen>--KeyToKey-- KeyCode::SEMICOLON, VK_CONTROL | ModifierFlag::NONE, KeyCode::SEMICOLON</autogen>
          <autogen>--KeyToKey-- KeyCode::SEMICOLON, ModifierFlag::NONE, KeyCode::RETURN</autogen>
        </item>
        <item>
          <name>Semicolon to Sticky Shift_L</name>
          <sysctl>remap.semicolon2stickyshiftL</sysctl>
          <autogen>--KeyOverlaidModifier-- KeyCode::SEMICOLON, KeyCode::SHIFT_L, KeyCode::VK_STICKY_SHIFT_L</autogen>
        </item>
        <item>
          <name>Swap Semicolon and Colon</name>
          <sysctl>remap.swapcolons</sysctl>
          <autogen>--KeyToKey-- KeyCode::SEMICOLON, VK_SHIFT, KeyCode::SEMICOLON</autogen>
          <autogen>--KeyToKey-- KeyCode::SEMICOLON, KeyCode::SEMICOLON, ModifierFlag::SHIFT_L</autogen>
        </item>
      </list>
    </item>

    <item>
      <name>Change Shift_L Key (Left Shift)</name>
      <list>
        <item>
          <name>Shift_L to Command_L</name>
          <sysctl>remap.shiftL2commandL</sysctl>
          <autogen>--KeyToKey-- KeyCode::SHIFT_L, KeyCode::COMMAND_L</autogen>
        </item>
        <item>
          <name>Shift_L to Control_L</name>
          <sysctl>remap.shiftL2controlL</sysctl>
          <autogen>--KeyToKey-- KeyCode::SHIFT_L, KeyCode::CONTROL_L</autogen>
        </item>
        <item>
          <name>Shift_L to FN</name>
          <sysctl>remap.shiftL2fn</sysctl>
          <autogen>--KeyToKey-- KeyCode::SHIFT_L, KeyCode::FN</autogen>
        </item>
        <item>
          <name>Shift_L to Shift_L</name>
          <appendix>(+ When you type shift_L only without other modifiers, send Escape)</appendix>
          <sysctl>remap.shiftL2shiftL_escape</sysctl>
          <autogen>--KeyOverlaidModifier-- KeyCode::SHIFT_L, ModifierFlag::SHIFT_L | ModifierFlag::NONE, KeyCode::SHIFT_L, KeyCode::ESCAPE</autogen>
        </item>
        <item>
          <name>Shift_L to Shift_L</name>
          <appendix>(+ When you type shiftL only, send Space)</appendix>
          <sysctl>remap.shiftL2shiftL_space</sysctl>
          <autogen>--KeyOverlaidModifier-- KeyCode::SHIFT_L, KeyCode::SHIFT_L, KeyCode::SPACE</autogen>
        </item>
        <item>
          <name>Shift_L to Shift_L</name>
          <appendix>(+ When you type shiftL only, send Space) + [KeyRepeat]</appendix>
          <sysctl>remap.shiftL2shiftL_space_keyrepeat</sysctl>
          <autogen>--KeyOverlaidModifierWithRepeat-- KeyCode::SHIFT_L, KeyCode::SHIFT_L, KeyCode::SPACE</autogen>
        </item>
        <item>
          <name>Shift_L to Lazy_Shift_L</name>
          <sysctl>remap.shiftL2lazy_shiftL</sysctl>
          <autogen>--KeyToKey-- KeyCode::SHIFT_L, KeyCode::VK_LAZY_SHIFT_L</autogen>
        </item>
        <item>
          <name>Shift_L to Option_L</name>
          <sysctl>remap.shiftL2optionL</sysctl>
          <autogen>--KeyToKey-- KeyCode::SHIFT_L, KeyCode::OPTION_L</autogen>
        </item>
        <item>
          <name>Shift_L to Escape</name>
          <sysctl>remap.shiftL2escape</sysctl>
          <autogen>--KeyToKey-- KeyCode::SHIFT_L, KeyCode::ESCAPE</autogen>
        </item>
        <item>
          <name>Shift_L to Space</name>
          <sysctl>remap.shiftL2space</sysctl>
          <autogen>--KeyToKey-- KeyCode::SHIFT_L, KeyCode::SPACE</autogen>
        </item>
        <item>
          <name>Shift_R+Shift_L to Space</name>
          <appendix>(Shift_R+Shift_L to Space, Shift_L+Shift_R to Shift+Space)</appendix>
          <sysctl>remap.shiftRshiftL2space</sysctl>
          <autogen>--KeyToKey-- KeyCode::SHIFT_R, ModifierFlag::SHIFT_L, KeyCode::SPACE, ModifierFlag::SHIFT_L</autogen>
          <autogen>--KeyToKey-- KeyCode::SHIFT_L, ModifierFlag::SHIFT_R, KeyCode::SPACE</autogen>
        </item>
        <item>
          <name>FN+Shift_L to Control_R</name>
          <sysctl>remap.fnshiftL2controlR</sysctl>
          <autogen>--KeyToKey-- KeyCode::SHIFT_L, ModifierFlag::FN, KeyCode::CONTROL_R</autogen>
        </item>
        <item>
          <name>Drop Shift_L</name>
          <sysctl>remap.drop_shiftL</sysctl>
          <autogen>--KeyToKey-- KeyCode::SHIFT_L, KeyCode::VK_NONE</autogen>
        </item>
        <item>
          <name>Drop Shift_L</name>
          <appendix>(+ When you type Shift_L only, send FN_Lock)</appendix>
          <sysctl>remap.drop_shiftL_fn</sysctl>
          <autogen>--KeyOverlaidModifier-- KeyCode::SHIFT_L, KeyCode::VK_NONE, KeyCode::VK_LOCK_FN</autogen>
        </item>
      </list>
    </item>

    <item>
      <name>Change Shift_R Key (Right Shift)</name>
      <list>
        <item>
          <name>Shift_R to Command_L</name>
          <sysctl>remap.shiftR2commandL</sysctl>
          <autogen>--KeyToKey-- KeyCode::SHIFT_R, KeyCode::COMMAND_L</autogen>
        </item>
        <item>
          <name>Shift_R to Control_L</name>
          <sysctl>remap.shiftR2controlL</sysctl>
          <autogen>--KeyToKey-- KeyCode::SHIFT_R, KeyCode::CONTROL_L</autogen>
        </item>
        <item>
          <name>Shift_R to FN</name>
          <sysctl>remap.shiftR2fn</sysctl>
          <autogen>--KeyToKey-- KeyCode::SHIFT_R, KeyCode::FN</autogen>
        </item>
        <item>
          <name>Shift_R to Option_L</name>
          <sysctl>remap.shiftR2optionL</sysctl>
          <autogen>--KeyToKey-- KeyCode::SHIFT_R, KeyCode::OPTION_L</autogen>
        </item>
        <item>
          <name>Shift_R to Shift_R</name>
          <appendix>(+ When you type Shift_R only, send Backslash)</appendix>
          <sysctl>remap.shiftR2shiftR_backslash</sysctl>
          <autogen>--KeyOverlaidModifier-- KeyCode::SHIFT_R, KeyCode::SHIFT_R, KeyCode::BACKSLASH</autogen>
        </item>
        <item>
          <name>Shift_R to Shift_R</name>
          <appendix>(+ When you type Shift_R only, send Enter)</appendix>
          <sysctl>remap.shiftR2shiftR_enter</sysctl>
          <autogen>--KeyOverlaidModifier-- KeyCode::SHIFT_R, KeyCode::SHIFT_R, KeyCode::ENTER</autogen>
        </item>
        <item>
          <name>Shift_R to Shift_R</name>
          <appendix>(+ When you type shiftR only, send Space)</appendix>
          <sysctl>remap.shiftR2shiftR_space</sysctl>
          <autogen>--KeyOverlaidModifier-- KeyCode::SHIFT_R, KeyCode::SHIFT_R, KeyCode::SPACE</autogen>
        </item>
        <item>
          <name>Shift_R to Shift_R</name>
          <appendix>(+ When you type shiftR only, send Space) + [KeyRepeat]</appendix>
          <sysctl>remap.shiftR2shiftR_space_keyrepeat</sysctl>
          <autogen>--KeyOverlaidModifierWithRepeat-- KeyCode::SHIFT_R, KeyCode::SHIFT_R, KeyCode::SPACE</autogen>
        </item>
        <item>
          <name>Shift_R to Lazy_Shift_R</name>
          <sysctl>remap.shiftR2lazy_shiftR</sysctl>
          <autogen>--KeyToKey-- KeyCode::SHIFT_R, KeyCode::VK_LAZY_SHIFT_R</autogen>
        </item>
        <item>
          <name>Shift_R to Enter</name>
          <sysctl>remap.shiftR2enter</sysctl>
          <autogen>--KeyToKey-- KeyCode::SHIFT_R, KeyCode::ENTER</autogen>
        </item>
        <item>
          <name>Shift_R to Escape</name>
          <sysctl>remap.shiftR2escape</sysctl>
          <autogen>--KeyToKey-- KeyCode::SHIFT_R, KeyCode::ESCAPE</autogen>
        </item>
        <item>
          <name>Shift_R to Forward Delete</name>
          <sysctl>remap.shiftR2forwarddelete</sysctl>
          <autogen>--KeyToKey-- KeyCode::SHIFT_R, KeyCode::FORWARD_DELETE</autogen>
        </item>
        <item>
          <name>Shift_R to Return</name>
          <sysctl>remap.shiftR2return</sysctl>
          <autogen>--KeyToKey-- KeyCode::SHIFT_R, KeyCode::RETURN</autogen>
        </item>
        <item>
          <name>Shift_R to Right-Arrow</name>
          <sysctl>remap.shiftR2rightarrow</sysctl>
          <autogen>--KeyToKey-- KeyCode::SHIFT_R, KeyCode::CURSOR_RIGHT</autogen>
        </item>
        <item>
          <name>Shift_R to Space</name>
          <sysctl>remap.shiftR2space</sysctl>
          <autogen>--KeyToKey-- KeyCode::SHIFT_R, KeyCode::SPACE</autogen>
        </item>
        <item>
          <name>Shift_L+Shift_R to Space</name>
          <appendix>(Shift_L+Shift_R to Space, Shift_R+Shift_L to Shift+Space)</appendix>
          <sysctl>remap.shiftLshiftR2space</sysctl>
          <autogen>--KeyToKey-- KeyCode::SHIFT_L, ModifierFlag::SHIFT_R, KeyCode::SPACE, ModifierFlag::SHIFT_R</autogen>
          <autogen>--KeyToKey-- KeyCode::SHIFT_R, ModifierFlag::SHIFT_L, KeyCode::SPACE</autogen>
        </item>
        <item>
          <name>Shift_R to Tab</name>
          <sysctl>remap.shiftR2tab</sysctl>
          <autogen>--KeyToKey-- KeyCode::SHIFT_R, KeyCode::TAB</autogen>
        </item>
        <item>
          <name>Shift_R to Up-Arrow</name>
          <sysctl>remap.shiftR2uparrow</sysctl>
          <autogen>--KeyToKey-- KeyCode::SHIFT_R, KeyCode::CURSOR_UP</autogen>
        </item>
        <item>
          <name>Back/Forward in Finder, Safari, etc. Left/Right Shift in mi.</name>
          <list>
            <item>
              <name>Shift_R to Shift_R</name>
              <appendix>(+ When you type shift_R only without other modifiers, send Command+[ )</appendix>
              <sysctl>remap.shiftR2shiftR_backward_nomod</sysctl>
              <autogen>--KeyOverlaidModifier-- KeyCode::SHIFT_R, ModifierFlag::SHIFT_R | ModifierFlag::NONE, KeyCode::SHIFT_R, KeyCode::BRACKET_LEFT, ModifierFlag::COMMAND_R</autogen>
            </item>
            <item>
              <name>Option_R+Shift_R to Command+]</name>
              <appendix>(only without other modifiers)</appendix>
              <sysctl>remap.optionRshiftR2forward</sysctl>
              <autogen>--KeyOverlaidModifier-- KeyCode::SHIFT_R, ModifierFlag::SHIFT_R | ModifierFlag::OPTION_R | ModifierFlag::NONE, KeyCode::SHIFT_R, ModifierFlag::OPTION_R, KeyCode::BRACKET_RIGHT, ModifierFlag::COMMAND_R</autogen>
            </item>
          </list>
        </item>
      </list>
    </item>

    <item>
      <name>Change Space Key</name>
      <list>
        <item>
          <name>Space to Control_L</name>
          <sysctl>remap.space2controlL</sysctl>
          <autogen>--KeyToKey-- KeyCode::SPACE, KeyCode::CONTROL_L</autogen>
        </item>
        <item>
          <name>Space to Control_L</name>
          <appendix>(+ When you type Space only, send Space)</appendix>
          <sysctl>remap.space2controlL_space</sysctl>
          <autogen>--KeyOverlaidModifier-- KeyCode::SPACE, KeyCode::CONTROL_L, KeyCode::SPACE</autogen>
        </item>
        <item>
          <name>Space to Control_L</name>
          <appendix>(+ When you type Space only, send Space) + [KeyRepeat]</appendix>
          <sysctl>remap.space2controlL_space_keyrepeat</sysctl>
          <autogen>--KeyOverlaidModifierWithRepeat-- KeyCode::SPACE, KeyCode::CONTROL_L, KeyCode::SPACE</autogen>
        </item>
        <item>
          <name>Space to Option_L</name>
          <sysctl>remap.space2optionL</sysctl>
          <autogen>--KeyToKey-- KeyCode::SPACE, KeyCode::OPTION_L</autogen>
        </item>
        <item>
          <name>Space to Option_L</name>
          <appendix>(+ When you type Space only, send Space)</appendix>
          <sysctl>remap.space2optionL_space</sysctl>
          <autogen>--KeyOverlaidModifier-- KeyCode::SPACE, KeyCode::OPTION_L, KeyCode::SPACE</autogen>
        </item>
        <item>
          <name>Control+Space to Option_L</name>
          <sysctl>remap.controlSpace2optionL</sysctl>
          <autogen>--KeyToKey-- KeyCode::SPACE, VK_CONTROL, KeyCode::OPTION_L</autogen>
        </item>
        <item>
          <name>Space to Shift_L</name>
          <sysctl>remap.space2shiftL</sysctl>
          <autogen>--KeyToKey-- KeyCode::SPACE, KeyCode::SHIFT_L</autogen>
        </item>
        <item>
          <name>Space to Shift_L</name>
          <appendix>(+ When you type Space only, send Space)</appendix>
          <sysctl>remap.space2shiftL_space</sysctl>
          <autogen>--KeyOverlaidModifier-- KeyCode::SPACE, KeyCode::SHIFT_L, KeyCode::SPACE</autogen>
        </item>
        <item>
          <name>Space to Shift_L</name>
          <appendix>(+ When you type Space only, send Space) + [KeyRepeat]</appendix>
          <sysctl>remap.space2shiftL_space_keyrepeat</sysctl>
          <autogen>--KeyOverlaidModifierWithRepeat-- KeyCode::SPACE, KeyCode::SHIFT_L, KeyCode::SPACE</autogen>
        </item>
        <item>
          <name>Space to Shift_L</name>
          <appendix>(+ When you type Space only, send Space) (Disable on Adobe Softwares)</appendix>
          <not>ADOBE, PHOTOSHOP, ILLUSTRATOR</not>
          <sysctl>remap.space2shiftL_space_not_adobe</sysctl>
          <autogen>--KeyOverlaidModifier-- KeyCode::SPACE, KeyCode::SHIFT_L, KeyCode::SPACE</autogen>
        </item>
        <item>
          <name>Space to Shift_L</name>
          <appendix>(+ When you type Space only, send Space)</appendix>
          <appendix>FN+Space to Space</appendix>
          <sysctl>remap.space2shiftL_space_fnspace</sysctl>
          <autogen>--KeyToKey-- KeyCode::SPACE, ModifierFlag::FN, KeyCode::SPACE</autogen>
          <autogen>--KeyOverlaidModifier-- KeyCode::SPACE, KeyCode::SHIFT_L, KeyCode::SPACE</autogen>
        </item>
        <item>
          <name>Control+Space to Shift_L_Lock</name>
          <sysctl>remap.controlSpace2shiftL_lock</sysctl>
          <autogen>--KeyToKey-- KeyCode::SPACE, VK_CONTROL, KeyCode::VK_LOCK_SHIFT_L</autogen>
        </item>
        <item>
          <name>Swap Space and Option+Space</name>
          <list>
            <item>
              <!-- Swap Mode Core -->
              <name>You can swap Space and Option+Space temporarily.</name>
              <appendix>Turn on a setting below, and toggle "Swap Mode".</appendix>
              <sysctl>notsave.swap_space_optionspace</sysctl>
              <vk_config>true</vk_config>
              <autogen>--ShowStatusMessage-- "Swap Mode"</autogen>
              <autogen>--KeyToKey-- KeyCode::SPACE, VK_OPTION | ModifierFlag::NONE, KeyCode::SPACE</autogen>
              <autogen>--KeyToKey-- KeyCode::SPACE, ModifierFlag::NONE, KeyCode::SPACE, ModifierFlag::OPTION_L</autogen>
            </item>
            <item>
              <name>FN+Escape to toggle "Swap Space and Option+Space" Mode</name>
              <sysctl>remap.swap_space_optionspace_toggle_fnescape</sysctl>
              <autogen>--KeyToKey-- KeyCode::ESCAPE, ModifierFlag::FN, KeyCode::VK_CONFIG_TOGGLE_notsave_swap_space_optionspace</autogen>
            </item>
            <item>
              <name>FN+Space to toggle "Swap Space and Option+Space" Mode</name>
              <sysctl>remap.swap_space_optionspace_toggle_fnspace</sysctl>
              <autogen>--KeyToKey-- KeyCode::SPACE, ModifierFlag::FN, KeyCode::VK_CONFIG_TOGGLE_notsave_swap_space_optionspace</autogen>
            </item>
          </list>
        </item>
        <item>
          <name>Space to Return</name>
          <sysctl>remap.space2return</sysctl>
          <autogen>--KeyToKey-- KeyCode::SPACE, KeyCode::RETURN</autogen>
        </item>
        <item>
          <name>Shift+Space to Command_L+Space</name>
          <sysctl>remap.shiftSpace2commandLSpace</sysctl>
          <autogen>--KeyToKey-- KeyCode::SPACE, VK_SHIFT, KeyCode::SPACE, ModifierFlag::COMMAND_L</autogen>
        </item>
        <item>
          <name>Control+Space to Option_L+Enter (except Emacs)</name>
          <not>EMACS</not>
          <sysctl>remap.controlSpace2optionLEnter</sysctl>
          <autogen>--KeyToKey-- KeyCode::SPACE, VK_CONTROL, KeyCode::ENTER, ModifierFlag::OPTION_L</autogen>
        </item>
      </list>
    </item>

    <item>
      <name>Change Tab Key</name>
      <list>
        <item>
          <name>Tab to Command_L</name>
          <appendix>(+ When you type Tab only, send Expose All)</appendix>
          <sysctl>remap.tab2commandL_exposeAll</sysctl>
          <autogen>--KeyOverlaidModifier-- KeyCode::TAB, KeyCode::COMMAND_L, KeyCode::EXPOSE_ALL</autogen>
        </item>
        <item>
          <name>Tab to Option_L when you held down Control_L</name>
          <appendix>(+ When you type Control_L+Tab, send Control_L+Tab)</appendix>
          <sysctl>remap.tab2option_withControlL</sysctl>
          <autogen>--KeyOverlaidModifier-- KeyCode::TAB, ModifierFlag::CONTROL_L, KeyCode::OPTION_L, KeyCode::TAB, ModifierFlag::CONTROL_L</autogen>
        </item>
        <item>
          <name>Tab to Expose All</name>
          <sysctl>remap.tab2exposeALL</sysctl>
          <autogen>--KeyToKey-- KeyCode::TAB, KeyCode::EXPOSE_ALL</autogen>
        </item>
        <item>
          <name>Command+Tab to Control+Tab (only in Firefox, Google Chrome, Opera, Safari)</name>
          <sysctl>remap.commandTab2controlTab_browser</sysctl>
          <only>FIREFOX, GOOGLE_CHROME, OPERA, SAFARI</only>
          <autogen>--KeyToKey-- KeyCode::TAB, VK_COMMAND, KeyCode::TAB, ModifierFlag::CONTROL_L</autogen>
        </item>
        <item>
          <name>Command+Tab to Option+Tab</name>
          <sysctl>remap.commandTab2optionTab</sysctl>
          <autogen>--KeyToKey-- KeyCode::TAB, VK_COMMAND, KeyCode::TAB, ModifierFlag::OPTION_L</autogen>
        </item>
        <item>
          <name>Command+Tab to F5</name>
          <sysctl>remap.commandTab2f5</sysctl>
          <autogen>--KeyToKey-- KeyCode::TAB, VK_COMMAND, KeyCode::F5</autogen>
        </item>
        <item>
          <name>Control+Tab to Command+Tab</name>
          <!-- #include "include/lazy_recommendation.xml" -->
          <sysctl>remap.controlTab2commandTab</sysctl>
          <autogen>--KeyToKey-- KeyCode::TAB, VK_CONTROL, KeyCode::TAB, ModifierFlag::COMMAND_L</autogen>
        </item>
        <item>
          <name>Control+Tab to Option+Tab</name>
          <sysctl>remap.controlTab2optionTab</sysctl>
          <autogen>--KeyToKey-- KeyCode::TAB, VK_CONTROL, KeyCode::TAB, ModifierFlag::OPTION_L</autogen>
        </item>
        <item>
          <name>Option+Tab to Command+Tab</name>
          <!-- #include "include/lazy_recommendation.xml" -->
          <sysctl>remap.optionTab2commandTab</sysctl>
          <autogen>--KeyToKey-- KeyCode::TAB, VK_OPTION, KeyCode::TAB, ModifierFlag::COMMAND_L</autogen>
        </item>
        <item>
          <name>Option+Tab to Control+Tab</name>
          <sysctl>remap.optionTab2controlTab</sysctl>
          <autogen>--KeyToKey-- KeyCode::TAB, VK_OPTION, KeyCode::TAB, ModifierFlag::CONTROL_L</autogen>
        </item>
        <item>
          <name>Option+Tab to F5</name>
          <sysctl>remap.optionTab2f5</sysctl>
          <autogen>--KeyToKey-- KeyCode::TAB, VK_OPTION, KeyCode::F5</autogen>
        </item>
        <item>
          <name>Swap Command+Tab and Option+Tab</name>
          <sysctl>remap.swap_commandtaboptiontab</sysctl>
          <autogen>--KeyToKey-- KeyCode::TAB, VK_OPTION, KeyCode::TAB, ModifierFlag::COMMAND_L</autogen>
          <autogen>--KeyToKey-- KeyCode::TAB, VK_COMMAND, KeyCode::TAB, ModifierFlag::OPTION_L</autogen>
        </item>
        <item>
          <name>Swap Command+Tab and Control+Tab</name>
          <sysctl>remap.swap_commandtabcontroltab</sysctl>
          <autogen>--KeyToKey-- KeyCode::TAB, VK_CONTROL, KeyCode::TAB, ModifierFlag::COMMAND_L</autogen>
          <autogen>--KeyToKey-- KeyCode::TAB, VK_COMMAND, KeyCode::TAB, ModifierFlag::CONTROL_L</autogen>
        </item>
        <item>
          <name>Drop Tab</name>
          <sysctl>remap.drop_tab</sysctl>
          <autogen>--KeyToKey-- KeyCode::TAB, KeyCode::VK_NONE</autogen>
        </item>
      </list>
    </item>

    <item>
      <name>Virtual Mouse</name>
      <list>
        <item>
          <name>Control+L to RightClick</name>
          <sysctl>remap.control_l2rightclick</sysctl>
          <autogen>--KeyToPointingButton-- KeyCode::L, VK_CONTROL, PointingButton::RIGHT</autogen>
        </item>
      </list>
    </item>

    <item>
      <name>Diamond Cursor</name>
      <list>
        <item>
          <name>Control_L+WSAD to Up/Down/Left/Right</name>
          <sysctl>remap.diamond_cursor_controlL_wsad</sysctl>
          <autogen>--KeyToKey-- KeyCode::W, ModifierFlag::CONTROL_L, KeyCode::CURSOR_UP</autogen>
          <autogen>--KeyToKey-- KeyCode::S, ModifierFlag::CONTROL_L, KeyCode::CURSOR_DOWN</autogen>
          <autogen>--KeyToKey-- KeyCode::A, ModifierFlag::CONTROL_L, KeyCode::CURSOR_LEFT</autogen>
          <autogen>--KeyToKey-- KeyCode::D, ModifierFlag::CONTROL_L, KeyCode::CURSOR_RIGHT</autogen>
        </item>
        <item>
          <name>Control_R+WSAD to Up/Down/Left/Right</name>
          <sysctl>remap.diamond_cursor_controlR_wsad</sysctl>
          <autogen>--KeyToKey-- KeyCode::W, ModifierFlag::CONTROL_R, KeyCode::CURSOR_UP</autogen>
          <autogen>--KeyToKey-- KeyCode::S, ModifierFlag::CONTROL_R, KeyCode::CURSOR_DOWN</autogen>
          <autogen>--KeyToKey-- KeyCode::A, ModifierFlag::CONTROL_R, KeyCode::CURSOR_LEFT</autogen>
          <autogen>--KeyToKey-- KeyCode::D, ModifierFlag::CONTROL_R, KeyCode::CURSOR_RIGHT</autogen>
        </item>
        <item>
          <name>ModifierFlag::EXTRA1+WXSD to Up/Down/Left/Right</name>
          <appendix>(+ ModifierFlag::EXTRA1+A to Command_L+Left)</appendix>
          <appendix>(+ ModifierFlag::EXTRA1+F to Command_L+Right)</appendix>
          <sysctl>remap.diamond_cursor_extra1_exsd</sysctl>
          <autogen>--KeyToKey-- KeyCode::E, ModifierFlag::EXTRA1, KeyCode::CURSOR_UP</autogen>
          <autogen>--KeyToKey-- KeyCode::X, ModifierFlag::EXTRA1, KeyCode::CURSOR_DOWN</autogen>
          <autogen>--KeyToKey-- KeyCode::S, ModifierFlag::EXTRA1, KeyCode::CURSOR_LEFT</autogen>
          <autogen>--KeyToKey-- KeyCode::D, ModifierFlag::EXTRA1, KeyCode::CURSOR_RIGHT</autogen>
          <autogen>--KeyToKey-- KeyCode::A, ModifierFlag::EXTRA1, KeyCode::CURSOR_LEFT,  ModifierFlag::COMMAND_L</autogen>
          <autogen>--KeyToKey-- KeyCode::F, ModifierFlag::EXTRA1, KeyCode::CURSOR_RIGHT, ModifierFlag::COMMAND_L</autogen>
        </item>
        <item>
          <name>Control_L+EXSD to Up/Down/Left/Right</name>
          <sysctl>remap.diamond_cursor_controlL_exsd</sysctl>
          <autogen>--KeyToKey-- KeyCode::E, ModifierFlag::CONTROL_L, KeyCode::CURSOR_UP</autogen>
          <autogen>--KeyToKey-- KeyCode::X, ModifierFlag::CONTROL_L, KeyCode::CURSOR_DOWN</autogen>
          <autogen>--KeyToKey-- KeyCode::S, ModifierFlag::CONTROL_L, KeyCode::CURSOR_LEFT</autogen>
          <autogen>--KeyToKey-- KeyCode::D, ModifierFlag::CONTROL_L, KeyCode::CURSOR_RIGHT</autogen>
        </item>
        <item>
          <name>Control_R+EXSD to Up/Down/Left/Right</name>
          <sysctl>remap.diamond_cursor_controlR_exsd</sysctl>
          <autogen>--KeyToKey-- KeyCode::E, ModifierFlag::CONTROL_R, KeyCode::CURSOR_UP</autogen>
          <autogen>--KeyToKey-- KeyCode::X, ModifierFlag::CONTROL_R, KeyCode::CURSOR_DOWN</autogen>
          <autogen>--KeyToKey-- KeyCode::S, ModifierFlag::CONTROL_R, KeyCode::CURSOR_LEFT</autogen>
          <autogen>--KeyToKey-- KeyCode::D, ModifierFlag::CONTROL_R, KeyCode::CURSOR_RIGHT</autogen>
        </item>
        <item>
          <name>Control_L+RVDF to Up/Down/Left/Right</name>
          <sysctl>remap.diamond_cursor_controlL_rvdf</sysctl>
          <autogen>--KeyToKey-- KeyCode::R, ModifierFlag::CONTROL_L, KeyCode::CURSOR_UP</autogen>
          <autogen>--KeyToKey-- KeyCode::V, ModifierFlag::CONTROL_L, KeyCode::CURSOR_DOWN</autogen>
          <autogen>--KeyToKey-- KeyCode::D, ModifierFlag::CONTROL_L, KeyCode::CURSOR_LEFT</autogen>
          <autogen>--KeyToKey-- KeyCode::F, ModifierFlag::CONTROL_L, KeyCode::CURSOR_RIGHT</autogen>
        </item>
        <item>
          <name>Control_L+ESDF to Up/Down/Left/Right</name>
          <sysctl>remap.diamond_cursor_controlL_esdf</sysctl>
          <autogen>--KeyToKey-- KeyCode::E, ModifierFlag::CONTROL_L, KeyCode::CURSOR_UP</autogen>
          <autogen>--KeyToKey-- KeyCode::D, ModifierFlag::CONTROL_L, KeyCode::CURSOR_DOWN</autogen>
          <autogen>--KeyToKey-- KeyCode::S, ModifierFlag::CONTROL_L, KeyCode::CURSOR_LEFT</autogen>
          <autogen>--KeyToKey-- KeyCode::F, ModifierFlag::CONTROL_L, KeyCode::CURSOR_RIGHT</autogen>
        </item>
        <item>
          <name>Control_R+ESDF to Up/Down/Left/Right</name>
          <sysctl>remap.diamond_cursor_controlR_esdf</sysctl>
          <autogen>--KeyToKey-- KeyCode::E, ModifierFlag::CONTROL_R, KeyCode::CURSOR_UP</autogen>
          <autogen>--KeyToKey-- KeyCode::D, ModifierFlag::CONTROL_R, KeyCode::CURSOR_DOWN</autogen>
          <autogen>--KeyToKey-- KeyCode::S, ModifierFlag::CONTROL_R, KeyCode::CURSOR_LEFT</autogen>
          <autogen>--KeyToKey-- KeyCode::F, ModifierFlag::CONTROL_R, KeyCode::CURSOR_RIGHT</autogen>
        </item>
        <item>
          <name>Control_L+IKJL to Up/Down/Left/Right</name>
          <sysctl>option.extra_cursor_controlL_jkil</sysctl>
          <autogen>--KeyToKey-- KeyCode::I, ModifierFlag::CONTROL_L, KeyCode::CURSOR_UP</autogen>
          <autogen>--KeyToKey-- KeyCode::K, ModifierFlag::CONTROL_L, KeyCode::CURSOR_DOWN</autogen>
          <autogen>--KeyToKey-- KeyCode::J, ModifierFlag::CONTROL_L, KeyCode::CURSOR_LEFT</autogen>
          <autogen>--KeyToKey-- KeyCode::L, ModifierFlag::CONTROL_L, KeyCode::CURSOR_RIGHT</autogen>
        </item>
        <item>
          <name>Option_L+IKJL to Up/Down/Left/Right</name>
          <sysctl>option.extra_cursor_optionL_jkil</sysctl>
          <autogen>--KeyToKey-- KeyCode::I, ModifierFlag::OPTION_L, KeyCode::CURSOR_UP</autogen>
          <autogen>--KeyToKey-- KeyCode::K, ModifierFlag::OPTION_L, KeyCode::CURSOR_DOWN</autogen>
          <autogen>--KeyToKey-- KeyCode::J, ModifierFlag::OPTION_L, KeyCode::CURSOR_LEFT</autogen>
          <autogen>--KeyToKey-- KeyCode::L, ModifierFlag::OPTION_L, KeyCode::CURSOR_RIGHT</autogen>
        </item>
      </list>
    </item>

    <item>
      <name>Emacs Mode</name>
      <list>
        <item>
          <name>Control+D to Forward Delete</name>
          <sysctl>option.emacsmode_controlD</sysctl>
          <not>EMACS, TERMINAL, VIRTUALMACHINE, REMOTEDESKTOPCONNECTION, X11, ECLIPSE</not>
          <autogen>--KeyToKey-- KeyCode::D, VK_CONTROL, KeyCode::FORWARD_DELETE</autogen>
        </item>
        <item>
          <name>Control+D to Forward Delete</name>
          <appendix>(when there are not other modifiers)</appendix>
          <sysctl>option.emacsmode_controlD_nomodifiers</sysctl>
          <not>EMACS, TERMINAL, VIRTUALMACHINE, REMOTEDESKTOPCONNECTION, X11, ECLIPSE</not>
          <autogen>--KeyToKey-- KeyCode::D, VK_CONTROL | ModifierFlag::NONE, KeyCode::FORWARD_DELETE</autogen>
        </item>
        <item>
          <name>Control+H to Delete</name>
          <sysctl>option.emacsmode_controlH</sysctl>
          <not>EMACS, TERMINAL, VIRTUALMACHINE, REMOTEDESKTOPCONNECTION, X11, ECLIPSE</not>
          <autogen>--KeyToKey-- KeyCode::H, VK_CONTROL, KeyCode::DELETE</autogen>
        </item>
        <item>
          <name>Control+I to Tab</name>
          <sysctl>option.emacsmode_controlI</sysctl>
          <not>EMACS, TERMINAL, VIRTUALMACHINE, REMOTEDESKTOPCONNECTION, X11, ECLIPSE</not>
          <autogen>--KeyToKey-- KeyCode::I, VK_CONTROL, KeyCode::TAB</autogen>
        </item>
        <item>
          <name>Control+[ to Escape</name>
          <sysctl>option.emacsmode_controlLeftbracket</sysctl>
          <not>EMACS, TERMINAL, VIRTUALMACHINE, REMOTEDESKTOPCONNECTION, X11, ECLIPSE</not>
          <autogen>--KeyToKey-- KeyCode::BRACKET_LEFT, VK_CONTROL, KeyCode::ESCAPE</autogen>
        </item>
        <item>
          <name>Control+J to Return</name>
          <sysctl>remap.controlJ2return</sysctl>
          <not>EMACS, TERMINAL, VIRTUALMACHINE, REMOTEDESKTOPCONNECTION, X11, ECLIPSE</not>
          <autogen>--KeyToKey-- KeyCode::J, VK_CONTROL, KeyCode::RETURN</autogen>
        </item>
        <item>
          <name>Control+M to Return</name>
          <sysctl>option.emacsmode_controlM</sysctl>
          <not>EMACS, TERMINAL, VIRTUALMACHINE, REMOTEDESKTOPCONNECTION, X11, ECLIPSE</not>
          <autogen>--KeyToKey-- KeyCode::M, VK_CONTROL, KeyCode::RETURN</autogen>
        </item>
        <item>
          <name>Control+PNBF to Up/Down/Left/Right</name>
          <sysctl>option.emacsmode_controlPNBF</sysctl>
          <not>EMACS, TERMINAL, VIRTUALMACHINE, REMOTEDESKTOPCONNECTION, X11, ECLIPSE</not>
          <!-- #include "include/emacsmode_controlPNBF.xml" -->
        </item>
        <item>
          <name>Control+PNBF to Up/Down/Left/Right</name>
          <appendix>(when there are not other modifiers)</appendix>
          <sysctl>option.emacsmode_controlPNBF_nomodifiers</sysctl>
          <not>EMACS, TERMINAL, VIRTUALMACHINE, REMOTEDESKTOPCONNECTION, X11, ECLIPSE</not>
          <!-- #include "include/emacsmode_controlPNBF_nomodifiers.xml" -->
        </item>
        <item>
          <name>Control+PNBF to Up/Down/Left/Right</name>
          <appendix>(+ Control+AE to Command+Left/Right)</appendix>
          <appendix>(+ Command+Control+PNBF to Shift+Up/Down/Left/Right)</appendix>
          <appendix>(+ Command+Control+AE to Shift+Command+Left/Right)</appendix>
          <appendix>(+ retain Control+Shift+PNBF)</appendix>
          <appendix>(+ retain Control+Shift+AE)</appendix>
          <sysctl>option.emacsmode_controlPNBF_ex</sysctl>
          <not>EMACS, TERMINAL, VIRTUALMACHINE, REMOTEDESKTOPCONNECTION, X11, ECLIPSE</not>
          <!-- #include "include/emacsmode_controlPNBF_ex.xml" -->
        </item>
        <item>
          <name>Control+V to PageDown</name>
          <sysctl>option.emacsmode_controlV</sysctl>
          <not>EMACS, TERMINAL, VIRTUALMACHINE, REMOTEDESKTOPCONNECTION, X11, ECLIPSE</not>
          <autogen>--KeyToKey-- KeyCode::V, VK_CONTROL, KeyCode::PAGEDOWN</autogen>
        </item>
        <item>
          <name>Option+V to PageUp</name>
          <sysctl>option.emacsmode_optionV</sysctl>
          <not>EMACS, TERMINAL, VIRTUALMACHINE, REMOTEDESKTOPCONNECTION, X11, ECLIPSE</not>
          <autogen>--KeyToKey-- KeyCode::V, VK_OPTION, KeyCode::PAGEUP</autogen>
        </item>
        <item>
          <name>Command+V to PageUp</name>
          <sysctl>option.emacsmode_commandV</sysctl>
          <not>EMACS, TERMINAL, VIRTUALMACHINE, REMOTEDESKTOPCONNECTION, X11, ECLIPSE</not>
          <autogen>--KeyToKey-- KeyCode::V, VK_COMMAND, KeyCode::PAGEUP</autogen>
        </item>
        <item>
          <name>Control+Y to Command+V</name>
          <sysctl>option.emacsmode_controlY</sysctl>
          <not>EMACS, TERMINAL, VIRTUALMACHINE, REMOTEDESKTOPCONNECTION, X11, ECLIPSE</not>
          <autogen>--KeyToKey-- KeyCode::Y, VK_CONTROL, KeyCode::V, ModifierFlag::COMMAND_L</autogen>
        </item>
        <item>
          <name>Control+AE to Command+Left/Right</name>
          <sysctl>option.emacsmode_controlAE</sysctl>
          <not>EMACS, TERMINAL, VIRTUALMACHINE, REMOTEDESKTOPCONNECTION, X11, ECLIPSE</not>
          <autogen>--KeyToKey-- KeyCode::A, VK_CONTROL, KeyCode::CURSOR_LEFT, ModifierFlag::COMMAND_L</autogen>
          <autogen>--KeyToKey-- KeyCode::E, VK_CONTROL, KeyCode::CURSOR_RIGHT, ModifierFlag::COMMAND_L</autogen>
        </item>
        <item>
          <name>Control+AE to Command+Shift+Left/Right,Left/Right</name>
          <appendix>(An Alternative way if you use Command+Left/Right for Spaces)</appendix>
          <sysctl>option.emacsmode_controlAE_alternative</sysctl>
          <not>EMACS, TERMINAL, VIRTUALMACHINE, REMOTEDESKTOPCONNECTION, X11, ECLIPSE</not>
          <autogen>--KeyToKey-- KeyCode::A, VK_CONTROL, KeyCode::CURSOR_LEFT, ModifierFlag::COMMAND_L | ModifierFlag::SHIFT_L</autogen>
          <autogen>--KeyToKey-- KeyCode::E, VK_CONTROL, KeyCode::CURSOR_RIGHT, ModifierFlag::COMMAND_L | ModifierFlag::SHIFT_L</autogen>
        </item>
        <item>
          <name>Control+K to Command+Shift+Right,Forward Delete</name>
          <sysctl>option.emacsmode_controlK_ex</sysctl>
          <not>EMACS, TERMINAL, VIRTUALMACHINE, REMOTEDESKTOPCONNECTION, X11, ECLIPSE</not>
          <autogen>--KeyToKey-- KeyCode::K, VK_CONTROL | ModifierFlag::NONE, KeyCode::CURSOR_RIGHT, ModifierFlag::COMMAND_L | ModifierFlag::SHIFT_L, KeyCode::FORWARD_DELETE</autogen>
        </item>
        <item>
          <name>Control+K to Command+Shift+Right,Command+X</name>
          <sysctl>option.emacsmode_controlK</sysctl>
          <not>EMACS, TERMINAL, VIRTUALMACHINE, REMOTEDESKTOPCONNECTION, X11, ECLIPSE</not>
          <autogen>--KeyToKey-- KeyCode::K, VK_CONTROL | ModifierFlag::NONE, KeyCode::CURSOR_RIGHT, ModifierFlag::COMMAND_L | ModifierFlag::SHIFT_L, KeyCode::X, ModifierFlag::COMMAND_L</autogen>
        </item>
        <item>
          <name>Control+W to Command+X</name>
          <sysctl>option.emacsmode_controlW</sysctl>
          <not>EMACS, TERMINAL, VIRTUALMACHINE, REMOTEDESKTOPCONNECTION, X11, ECLIPSE</not>
          <autogen>--KeyToKey-- KeyCode::W, VK_CONTROL, KeyCode::X, ModifierFlag::COMMAND_L</autogen>
        </item>
        <item>
          <name>Option+W to Command+C</name>
          <sysctl>option.emacsmode_OptionWCopy</sysctl>
          <not>EMACS, TERMINAL, VIRTUALMACHINE, REMOTEDESKTOPCONNECTION, X11, ECLIPSE</not>
          <autogen>--KeyToKey-- KeyCode::W, VK_OPTION, KeyCode::C, ModifierFlag::COMMAND_L</autogen>
        </item>
        <item>
          <name>Option+BF to Option+Left/Right</name>
          <sysctl>option.emacsmode_optionBF</sysctl>
          <not>EMACS, TERMINAL, VIRTUALMACHINE, REMOTEDESKTOPCONNECTION, X11, ECLIPSE</not>
          <autogen>--KeyToKey-- KeyCode::B, VK_OPTION, KeyCode::CURSOR_LEFT, ModifierFlag::OPTION_L</autogen>
          <autogen>--KeyToKey-- KeyCode::F, VK_OPTION, KeyCode::CURSOR_RIGHT, ModifierFlag::OPTION_L</autogen>
        </item>
        <item>
          <name>Option+D to Option+Forward Delete</name>
          <sysctl>option.emacsmode_optionD</sysctl>
          <not>EMACS, TERMINAL, VIRTUALMACHINE, REMOTEDESKTOPCONNECTION, X11, ECLIPSE</not>
          <autogen>--KeyToKey-- KeyCode::D, VK_OPTION, KeyCode::FORWARD_DELETE, ModifierFlag::OPTION_L</autogen>
        </item>
        <item>
          <name>Option+&lt; to Home / Option+&gt; to End</name>
          <sysctl>option.emacsmode_optionLtGt</sysctl>
          <not>EMACS, TERMINAL, VIRTUALMACHINE, REMOTEDESKTOPCONNECTION, X11, ECLIPSE</not>
          <autogen>--KeyToKey-- KeyCode::COMMA, VK_OPTION | VK_SHIFT, KeyCode::HOME, ModifierFlag::OPTION_L</autogen>
          <autogen>--KeyToKey-- KeyCode::DOT,   VK_OPTION | VK_SHIFT, KeyCode::END, ModifierFlag::OPTION_L</autogen>
        </item>
        <item>
          <name>Control+/ to Command_Z</name>
          <sysctl>option.emacsmode_controlSlash</sysctl>
          <not>EMACS, TERMINAL, VIRTUALMACHINE, REMOTEDESKTOPCONNECTION, X11, ECLIPSE</not>
          <autogen>--KeyToKey-- KeyCode::SLASH, VK_CONTROL, KeyCode::Z, ModifierFlag::COMMAND_L</autogen>
        </item>
        <item>
          <name>Control+S to Command+F</name>
          <sysctl>option.emacsmode_controlS</sysctl>
          <not>EMACS, TERMINAL, VIRTUALMACHINE, REMOTEDESKTOPCONNECTION, X11, ECLIPSE</not>
          <autogen>--KeyToKey-- KeyCode::S, VK_CONTROL, KeyCode::F, ModifierFlag::COMMAND_L</autogen>
        </item>
        <item>
          <name>[ex] Control+1 to Home / Control+2 to End</name>
          <sysctl>option.emacsmode_ex_control12</sysctl>
          <not>EMACS, TERMINAL, VIRTUALMACHINE, REMOTEDESKTOPCONNECTION, X11, ECLIPSE</not>
          <autogen>--KeyToKey-- KeyCode::KEY_1, VK_CONTROL, KeyCode::HOME</autogen>
          <autogen>--KeyToKey-- KeyCode::KEY_2, VK_CONTROL, KeyCode::END</autogen>
        </item>
        <item>
          <name>[ex] Control+Q to PageUp</name>
          <sysctl>option.emacsmode_ex_controlQ</sysctl>
          <not>EMACS, TERMINAL, VIRTUALMACHINE, REMOTEDESKTOPCONNECTION, X11, ECLIPSE</not>
          <autogen>--KeyToKey-- KeyCode::Q, VK_CONTROL, KeyCode::PAGEUP</autogen>
        </item>
        <item>
          <name>[ex] Control+W to Option+Delete</name>
          <sysctl>option.emacsmode_ex_controlW</sysctl>
          <not>EMACS, TERMINAL, VIRTUALMACHINE, REMOTEDESKTOPCONNECTION, X11, ECLIPSE</not>
          <autogen>--KeyToKey-- KeyCode::W, VK_CONTROL, KeyCode::DELETE, ModifierFlag::OPTION_L</autogen>
        </item>
        <item>
          <name>[ex] Control+U to Command+Shift+Left,Command+X</name>
          <sysctl>option.emacsmode_ex_controlU</sysctl>
          <not>EMACS, TERMINAL, VIRTUALMACHINE, REMOTEDESKTOPCONNECTION, X11, ECLIPSE</not>
          <autogen>--KeyToKey-- KeyCode::U, VK_CONTROL | ModifierFlag::NONE, KeyCode::CURSOR_LEFT, ModifierFlag::COMMAND_L | ModifierFlag::SHIFT_L, KeyCode::X, ModifierFlag::COMMAND_L</autogen>
        </item>
        <item>
          <name>[ex] Control+U to Command+Shift+Left,Delete</name>
          <sysctl>option.emacsmode_ex_controlU_delete</sysctl>
          <not>EMACS, TERMINAL, VIRTUALMACHINE, REMOTEDESKTOPCONNECTION, X11, ECLIPSE</not>
          <autogen>--KeyToKey-- KeyCode::U, VK_CONTROL | ModifierFlag::NONE, KeyCode::CURSOR_LEFT, ModifierFlag::COMMAND_L | ModifierFlag::SHIFT_L, KeyCode::DELETE</autogen>
        </item>
        <item>
          <name>[ex] Control+U to Command+Shift+Left,Forward Delete</name>
          <sysctl>option.emacsmode_ex_controlU_forwarddelete</sysctl>
          <not>EMACS, TERMINAL, VIRTUALMACHINE, REMOTEDESKTOPCONNECTION, X11, ECLIPSE</not>
          <autogen>--KeyToKey-- KeyCode::U, VK_CONTROL | ModifierFlag::NONE, KeyCode::CURSOR_LEFT, ModifierFlag::COMMAND_L | ModifierFlag::SHIFT_L, KeyCode::FORWARD_DELETE</autogen>
        </item>
        <item>
          <name>[ex] Control+U to PageUp</name>
          <sysctl>remap.controlU2pageup</sysctl>
          <not>EMACS, TERMINAL, VIRTUALMACHINE, REMOTEDESKTOPCONNECTION, X11, ECLIPSE</not>
          <autogen>--KeyToKey-- KeyCode::U, VK_CONTROL, KeyCode::PAGEUP</autogen>
        </item>
        <item>
          <name>[ex] Control+G to Escape</name>
          <sysctl>option.emacsmode_ex_controlG</sysctl>
          <not>EMACS, TERMINAL, VIRTUALMACHINE, REMOTEDESKTOPCONNECTION, X11, ECLIPSE</not>
          <autogen>--KeyToKey-- KeyCode::G, VK_CONTROL, KeyCode::ESCAPE</autogen>
        </item>
        <item>
          <name>[ex] Control+AE to Home/End</name>
          <sysctl>option.emacsmode_ex_controlAE</sysctl>
          <not>EMACS, TERMINAL, VIRTUALMACHINE, REMOTEDESKTOPCONNECTION, X11, ECLIPSE</not>
          <autogen>--KeyToKey-- KeyCode::A, VK_CONTROL, KeyCode::HOME</autogen>
          <autogen>--KeyToKey-- KeyCode::E, VK_CONTROL, KeyCode::END</autogen>
        </item>
        <item>
          <name>[ex] Command+W to Command+C</name>
          <sysctl>option.emacsmode_ex_commandW</sysctl>
          <not>EMACS, TERMINAL, VIRTUALMACHINE, REMOTEDESKTOPCONNECTION, X11, ECLIPSE</not>
          <autogen>--KeyToKey-- KeyCode::W, VK_COMMAND, KeyCode::C, ModifierFlag::COMMAND_L</autogen>
        </item>
        <item>
          <name>[ex] Command+W to Control+X,Control+M,Command+C (only in Xcode)</name>
          <appendix>(+ Command+W to Command+C (except Xcode))</appendix>
          <sysctl>option.emacsmode_ex_commandW_xcode</sysctl>
          <block>
            <only>XCODE</only>
            <autogen>--KeyToKey-- KeyCode::W, VK_COMMAND, KeyCode::X, ModifierFlag::CONTROL_L, KeyCode::M, ModifierFlag::CONTROL_L, KeyCode::C, ModifierFlag::COMMAND_L</autogen>
          </block>
          <block>
            <not>EMACS, TERMINAL, VIRTUALMACHINE, REMOTEDESKTOPCONNECTION, X11, ECLIPSE, XCODE</not>
            <autogen>--KeyToKey-- KeyCode::W, VK_COMMAND, KeyCode::C, ModifierFlag::COMMAND_L</autogen>
          </block>
        </item>
        <item>
          <name>[ex] Control+W to Control+X,Control+M,Command+X (only in Xcode)</name>
          <appendix>(+ Control+W to Command+X (except Xcode))</appendix>
          <sysctl>option.emacsmode_ex_controlW_xcode</sysctl>
          <block>
            <only>XCODE</only>
            <autogen>--KeyToKey-- KeyCode::W, VK_CONTROL, KeyCode::X, ModifierFlag::CONTROL_L, KeyCode::M, ModifierFlag::CONTROL_L, KeyCode::X, ModifierFlag::COMMAND_L</autogen>
          </block>
          <block>
            <not>EMACS, TERMINAL, VIRTUALMACHINE, REMOTEDESKTOPCONNECTION, X11, ECLIPSE</not>
            <autogen>--KeyToKey-- KeyCode::W, VK_CONTROL, KeyCode::X, ModifierFlag::COMMAND_L</autogen>
          </block>
        </item>
        <item>
          <name>[ex] Option+W to Command+W</name>
          <sysctl>option.emacsmode_ex_optionW</sysctl>
          <autogen>--KeyToKey-- KeyCode::W, VK_OPTION, KeyCode::W, ModifierFlag::COMMAND_L</autogen>
        </item>
        <item>
          <name>[ex] Use Control+X as prefix key</name>
          <list>
            <item>
              <!-- C-x Mode Core -->
              <name>Control+X detail</name>
              <appendix>C-x C-s to Command_L+S</appendix>
              <appendix>C-x C-f to Command_L+O</appendix>
              <appendix>C-x k to Command_L+W</appendix>
              <appendix>C-x C-c to Command_L+Q</appendix>
              <appendix>C-x C-g to turn off Control+X Mode</appendix>
              <sysctl>notsave.emacsmode_ex_controlX_core</sysctl>
              <vk_config>true</vk_config>
              <autogen>--ShowStatusMessage-- "C-x Mode"</autogen>
              <autogen>--KeyToKey-- KeyCode::S, VK_CONTROL | ModifierFlag::NONE, KeyCode::S, ModifierFlag::COMMAND_L, KeyCode::VK_CONFIG_FORCE_OFF_notsave_emacsmode_ex_controlX_core</autogen>
              <autogen>--KeyToKey-- KeyCode::C, VK_CONTROL | ModifierFlag::NONE, KeyCode::Q, ModifierFlag::COMMAND_L, KeyCode::VK_CONFIG_FORCE_OFF_notsave_emacsmode_ex_controlX_core</autogen>
              <autogen>--KeyToKey-- KeyCode::F, VK_CONTROL | ModifierFlag::NONE, KeyCode::O, ModifierFlag::COMMAND_L, KeyCode::VK_CONFIG_FORCE_OFF_notsave_emacsmode_ex_controlX_core</autogen>
              <autogen>--KeyToKey-- KeyCode::K, ModifierFlag::NONE,              KeyCode::W, ModifierFlag::COMMAND_L, KeyCode::VK_CONFIG_FORCE_OFF_notsave_emacsmode_ex_controlX_core</autogen>
              <autogen>--KeyToKey-- KeyCode::G, VK_CONTROL | ModifierFlag::NONE,                                      KeyCode::VK_CONFIG_FORCE_OFF_notsave_emacsmode_ex_controlX_core</autogen>
            </item>
            <item>
              <name>Enable Control+X</name>
              <sysctl>option.emacsmode_ex_controlX</sysctl>
              <not>EMACS, TERMINAL, VIRTUALMACHINE, REMOTEDESKTOPCONNECTION, X11, ECLIPSE</not>
              <autogen>--KeyToKey-- KeyCode::X, VK_CONTROL | ModifierFlag::NONE, KeyCode::VK_CONFIG_FORCE_ON_notsave_emacsmode_ex_controlX_core</autogen>
            </item>
          </list>
        </item>
        <item>
          <name>[ex] Use Control+Space as MarkSet</name>
          <list>
            <item>
              <!-- MarkSet Mode Core -->
              <name>MarkSet Mode detail</name>
              <appendix>Control+W to Command_L+X</appendix>
              <appendix>Option+W to Command_L+C</appendix>
              <appendix>Control+G to turn off MarkSet</appendix>
              <appendix>Control+Space to turn off MarkSet</appendix>
              <sysctl>notsave.emacsmode_ex_controlSpace_core</sysctl>
              <vk_config>true</vk_config>
              <autogen>--ShowStatusMessage-- "MarkSet"</autogen>
              <autogen>--KeyToKey-- KeyCode::W,     VK_CONTROL | ModifierFlag::SHIFT_L | ModifierFlag::NONE, KeyCode::VK_LOCK_SHIFT_L_FORCE_OFF, KeyCode::X, ModifierFlag::COMMAND_L, KeyCode::VK_CONFIG_FORCE_OFF_notsave_emacsmode_ex_controlSpace_core</autogen>
              <autogen>--KeyToKey-- KeyCode::W,     VK_OPTION  | ModifierFlag::SHIFT_L | ModifierFlag::NONE, KeyCode::VK_LOCK_SHIFT_L_FORCE_OFF, KeyCode::C, ModifierFlag::COMMAND_L, KeyCode::VK_CONFIG_FORCE_OFF_notsave_emacsmode_ex_controlSpace_core</autogen>
              <autogen>--KeyToKey-- KeyCode::G,     VK_CONTROL | ModifierFlag::SHIFT_L | ModifierFlag::NONE, KeyCode::VK_LOCK_SHIFT_L_FORCE_OFF,                                      KeyCode::VK_CONFIG_FORCE_OFF_notsave_emacsmode_ex_controlSpace_core</autogen>
              <autogen>--KeyToKey-- KeyCode::SPACE, VK_CONTROL | ModifierFlag::SHIFT_L | ModifierFlag::NONE, KeyCode::VK_LOCK_SHIFT_L_FORCE_OFF,                                      KeyCode::VK_CONFIG_FORCE_OFF_notsave_emacsmode_ex_controlSpace_core</autogen>
            </item>
            <item>
              <name>Enable Control+Space</name>
              <sysctl>option.emacsmode_ex_controlSpace</sysctl>
              <not>EMACS, TERMINAL, VIRTUALMACHINE, REMOTEDESKTOPCONNECTION, X11, ECLIPSE</not>
              <autogen>--KeyToKey-- KeyCode::SPACE, VK_CONTROL | ModifierFlag::NONE, KeyCode::VK_LOCK_SHIFT_L_FORCE_ON, KeyCode::VK_CONFIG_FORCE_ON_notsave_emacsmode_ex_controlSpace_core</autogen>
            </item>
          </list>
        </item>
        <item>
          <name>Behavior in Emacs, Terminal, X11, VMware, Parallels, RDC, Eclipse</name>
          <list>
            <item>
              <name>Force change C-d to Forward Delete</name>
              <list>
                <item>
                  <name>In Emacs, Terminal</name>
                  <sysctl>option.emacsmode_force_controlD_term</sysctl>
                  <only>EMACS, TERMINAL</only>
                  <autogen>--KeyToKey-- KeyCode::D, VK_CONTROL, KeyCode::FORWARD_DELETE</autogen>
                </item>
                <item>
                  <name>In X11</name>
                  <sysctl>option.emacsmode_force_controlD_x11</sysctl>
                  <only>X11</only>
                  <autogen>--KeyToKey-- KeyCode::D, VK_CONTROL, KeyCode::FORWARD_DELETE</autogen>
                </item>
                <item>
                  <name>In VMware Fusion, Parallels Desktop, Remote Desktop Connection</name>
                  <sysctl>option.emacsmode_force_controlD_vm</sysctl>
                  <only>VIRTUALMACHINE, REMOTEDESKTOPCONNECTION</only>
                  <autogen>--KeyToKey-- KeyCode::D, VK_CONTROL, KeyCode::FORWARD_DELETE</autogen>
                </item>
                <item>
                  <name>In Eclipse</name>
                  <sysctl>option.emacsmode_force_controlD_eclipse</sysctl>
                  <only>ECLIPSE</only>
                  <autogen>--KeyToKey-- KeyCode::D, VK_CONTROL, KeyCode::FORWARD_DELETE</autogen>
                </item>
              </list>
            </item>
            <item>
              <name>Force change C-h to Delete</name>
              <list>
                <item>
                  <name>In Emacs, Terminal</name>
                  <sysctl>option.emacsmode_force_controlH_term</sysctl>
                  <only>EMACS, TERMINAL</only>
                  <autogen>--KeyToKey-- KeyCode::H, VK_CONTROL, KeyCode::DELETE</autogen>
                </item>
                <item>
                  <name>In X11</name>
                  <sysctl>option.emacsmode_force_controlH_x11</sysctl>
                  <only>X11</only>
                  <autogen>--KeyToKey-- KeyCode::H, VK_CONTROL, KeyCode::DELETE</autogen>
                </item>
                <item>
                  <name>In VMware Fusion, Parallels Desktop, Remote Desktop Connection</name>
                  <sysctl>option.emacsmode_force_controlH_vm</sysctl>
                  <only>VIRTUALMACHINE, REMOTEDESKTOPCONNECTION</only>
                  <autogen>--KeyToKey-- KeyCode::H, VK_CONTROL, KeyCode::DELETE</autogen>
                </item>
                <item>
                  <name>In Eclipse</name>
                  <sysctl>option.emacsmode_force_controlH_eclipse</sysctl>
                  <only>ECLIPSE</only>
                  <autogen>--KeyToKey-- KeyCode::H, VK_CONTROL, KeyCode::DELETE</autogen>
                </item>
              </list>
            </item>
            <item>
              <name>Force change C-i to Tab</name>
              <list>
                <item>
                  <name>In Emacs, Terminal</name>
                  <sysctl>option.emacsmode_force_controlI_term</sysctl>
                  <only>EMACS, TERMINAL</only>
                  <autogen>--KeyToKey-- KeyCode::I, VK_CONTROL, KeyCode::TAB</autogen>
                </item>
                <item>
                  <name>In X11</name>
                  <sysctl>option.emacsmode_force_controlI_x11</sysctl>
                  <only>X11</only>
                  <autogen>--KeyToKey-- KeyCode::I, VK_CONTROL, KeyCode::TAB</autogen>
                </item>
                <item>
                  <name>In VMware Fusion, Parallels Desktop, Remote Desktop Connection</name>
                  <sysctl>option.emacsmode_force_controlI_vm</sysctl>
                  <only>VIRTUALMACHINE, REMOTEDESKTOPCONNECTION</only>
                  <autogen>--KeyToKey-- KeyCode::I, VK_CONTROL, KeyCode::TAB</autogen>
                </item>
                <item>
                  <name>In Eclipse</name>
                  <sysctl>option.emacsmode_force_controlI_eclipse</sysctl>
                  <only>ECLIPSE</only>
                  <autogen>--KeyToKey-- KeyCode::I, VK_CONTROL, KeyCode::TAB</autogen>
                </item>
              </list>
            </item>
            <item>
              <name>Force change C-m to Return</name>
              <list>
                <item>
                  <name>In Emacs, Terminal</name>
                  <sysctl>option.emacsmode_force_controlM_term</sysctl>
                  <only>EMACS, TERMINAL</only>
                  <autogen>--KeyToKey-- KeyCode::M, VK_CONTROL, KeyCode::RETURN</autogen>
                </item>
                <item>
                  <name>In X11</name>
                  <sysctl>option.emacsmode_force_controlM_x11</sysctl>
                  <only>X11</only>
                  <autogen>--KeyToKey-- KeyCode::M, VK_CONTROL, KeyCode::RETURN</autogen>
                </item>
                <item>
                  <name>In VMware Fusion, Parallels Desktop, Remote Desktop Connection</name>
                  <sysctl>option.emacsmode_force_controlM_vm</sysctl>
                  <only>VIRTUALMACHINE, REMOTEDESKTOPCONNECTION</only>
                  <autogen>--KeyToKey-- KeyCode::M, VK_CONTROL, KeyCode::RETURN</autogen>
                </item>
                <item>
                  <name>In Eclipse</name>
                  <sysctl>option.emacsmode_force_controlM_eclipse</sysctl>
                  <only>ECLIPSE</only>
                  <autogen>--KeyToKey-- KeyCode::M, VK_CONTROL, KeyCode::RETURN</autogen>
                </item>
              </list>
            </item>
            <item>
              <name>Force change C-[ to Escape</name>
              <list>
                <item>
                  <name>In Emacs, Terminal</name>
                  <sysctl>option.emacsmode_force_controlLeftbracket_term</sysctl>
                  <only>EMACS, TERMINAL</only>
                  <autogen>--KeyToKey-- KeyCode::BRACKET_LEFT, VK_CONTROL, KeyCode::ESCAPE</autogen>
                </item>
                <item>
                  <name>In X11</name>
                  <sysctl>option.emacsmode_force_controlLeftbracket_x11</sysctl>
                  <only>X11</only>
                  <autogen>--KeyToKey-- KeyCode::BRACKET_LEFT, VK_CONTROL, KeyCode::ESCAPE</autogen>
                </item>
                <item>
                  <name>In VMware Fusion, Parallels Desktop, Remote Desktop Connection</name>
                  <sysctl>option.emacsmode_force_controlLeftbracket_vm</sysctl>
                  <only>VIRTUALMACHINE, REMOTEDESKTOPCONNECTION</only>
                  <autogen>--KeyToKey-- KeyCode::BRACKET_LEFT, VK_CONTROL, KeyCode::ESCAPE</autogen>
                </item>
                <item>
                  <name>In Eclipse</name>
                  <sysctl>option.emacsmode_force_controlLeftbracket_eclipse</sysctl>
                  <only>ECLIPSE</only>
                  <autogen>--KeyToKey-- KeyCode::BRACKET_LEFT, VK_CONTROL, KeyCode::ESCAPE</autogen>
                </item>
              </list>
            </item>
            <item>
              <name>Force change C-pnbf to Up/Down/Left/Right</name>
              <list>
                <item>
                  <name>In Emacs, Terminal</name>
                  <sysctl>option.emacsmode_force_controlPNBF_term</sysctl>
                  <only>EMACS, TERMINAL</only>
                  <!-- #include "include/emacsmode_controlPNBF.xml" -->
                </item>
                <item>
                  <name>In X11</name>
                  <sysctl>option.emacsmode_force_controlPNBF_x11</sysctl>
                  <only>X11</only>
                  <!-- #include "include/emacsmode_controlPNBF.xml" -->
                </item>
                <item>
                  <name>In VMware Fusion, Parallels Desktop, Remote Desktop Connection</name>
                  <sysctl>option.emacsmode_force_controlPNBF_vm</sysctl>
                  <only>VIRTUALMACHINE, REMOTEDESKTOPCONNECTION</only>
                  <!-- #include "include/emacsmode_controlPNBF.xml" -->
                </item>
                <item>
                  <name>In Eclipse</name>
                  <sysctl>option.emacsmode_force_controlPNBF_eclipse</sysctl>
                  <only>ECLIPSE</only>
                  <!-- #include "include/emacsmode_controlPNBF.xml" -->
                </item>
              </list>
            </item>
            <item>
              <name>Force change C-pnbf to Up/Down/Left/Right</name>
              <appendix>(+ Control+AE to Command+Left/Right)</appendix>
              <appendix>(+ Command+Control+PNBF to Shift+Up/Down/Left/Right)</appendix>
              <appendix>(+ Command+Control+AE to Shift+Command+Left/Right)</appendix>
              <appendix>(+ retain Control+Shift+PNBF)</appendix>
              <appendix>(+ retain Control+Shift+AE)</appendix>
              <list>
                <item>
                  <name>In Emacs, Terminal</name>
                  <sysctl>option.emacsmode_force_controlPNBF_ex_term</sysctl>
                  <only>EMACS, TERMINAL</only>
                  <!-- #include "include/emacsmode_controlPNBF_ex.xml" -->
                </item>
                <item>
                  <name>In X11</name>
                  <sysctl>option.emacsmode_force_controlPNBF_ex_x11</sysctl>
                  <only>X11</only>
                  <!-- #include "include/emacsmode_controlPNBF_ex.xml" -->
                </item>
                <item>
                  <name>In VMware Fusion, Parallels Desktop, Remote Desktop Connection</name>
                  <sysctl>option.emacsmode_force_controlPNBF_ex_vm</sysctl>
                  <only>VIRTUALMACHINE, REMOTEDESKTOPCONNECTION</only>
                  <!-- #include "include/emacsmode_controlPNBF_ex.xml" -->
                </item>
                <item>
                  <name>In Eclipse</name>
                  <sysctl>option.emacsmode_force_controlPNBF_ex_eclipse</sysctl>
                  <only>ECLIPSE</only>
                  <!-- #include "include/emacsmode_controlPNBF_ex.xml" -->
                </item>
              </list>
            </item>
            <item>
              <name>Control+AE to Home/End</name>
              <list>
                <item>
                  <name>In VMware Fusion, Parallels Desktop, Remote Desktop Connection</name>
                  <sysctl>option.emacsmode_controlAE_vm</sysctl>
                  <only>VIRTUALMACHINE, REMOTEDESKTOPCONNECTION</only>
                  <autogen>--KeyToKey-- KeyCode::A, VK_CONTROL, KeyCode::HOME</autogen>
                  <autogen>--KeyToKey-- KeyCode::E, VK_CONTROL, KeyCode::END</autogen>
                </item>
              </list>
            </item>
            <item>
              <name>[Terminal] Control+/ to C-_ and Control+' to C-M-_</name>
              <sysctl>option.emacsmode_controlSlashTerminal</sysctl>
              <only>TERMINAL</only>
              <autogen>--KeyToKey-- KeyCode::SLASH, VK_CONTROL, KeyCode::MINUS, ModifierFlag::CONTROL_L | ModifierFlag::SHIFT_L</autogen>
              <autogen>--KeyToKey-- KeyCode::QUOTE, VK_CONTROL, KeyCode::MINUS, ModifierFlag::CONTROL_L | ModifierFlag::SHIFT_L | ModifierFlag::OPTION_L</autogen>
            </item>
          </list>
        </item>
      </list>
    </item>

    <item>
      <name>Vi Mode</name>
      <list>
        <item>
          <name>Command_R+hjkl to Left/Down/Up/Right</name>
          <sysctl>option.vimode_hjkl</sysctl>
          <autogen>--KeyToKey-- KeyCode::H, ModifierFlag::COMMAND_R, KeyCode::CURSOR_LEFT</autogen>
          <autogen>--KeyToKey-- KeyCode::J, ModifierFlag::COMMAND_R, KeyCode::CURSOR_DOWN</autogen>
          <autogen>--KeyToKey-- KeyCode::K, ModifierFlag::COMMAND_R, KeyCode::CURSOR_UP</autogen>
          <autogen>--KeyToKey-- KeyCode::L, ModifierFlag::COMMAND_R, KeyCode::CURSOR_RIGHT</autogen>
        </item>
        <item>
          <name>Control_L+hjkl to Left/Down/Up/Right</name>
          <sysctl>option.vimode_control_hjkl</sysctl>
          <autogen>--KeyToKey-- KeyCode::H, ModifierFlag::CONTROL_L, KeyCode::CURSOR_LEFT</autogen>
          <autogen>--KeyToKey-- KeyCode::J, ModifierFlag::CONTROL_L, KeyCode::CURSOR_DOWN</autogen>
          <autogen>--KeyToKey-- KeyCode::K, ModifierFlag::CONTROL_L, KeyCode::CURSOR_UP</autogen>
          <autogen>--KeyToKey-- KeyCode::L, ModifierFlag::CONTROL_L, KeyCode::CURSOR_RIGHT</autogen>
        </item>
        <item>
          <name>FN+hjkl to Left/Down/Up/Right</name>
          <sysctl>option.vimode_fn_hjkl</sysctl>
          <autogen>--KeyToKey-- KeyCode::H, ModifierFlag::FN, KeyCode::CURSOR_LEFT</autogen>
          <autogen>--KeyToKey-- KeyCode::J, ModifierFlag::FN, KeyCode::CURSOR_DOWN</autogen>
          <autogen>--KeyToKey-- KeyCode::K, ModifierFlag::FN, KeyCode::CURSOR_UP</autogen>
          <autogen>--KeyToKey-- KeyCode::L, ModifierFlag::FN, KeyCode::CURSOR_RIGHT</autogen>
        </item>
        <item>
          <name>Option_L+hjkl to Left/Down/Up/Right</name>
          <sysctl>option.extra_cursor_optionL_kjhl</sysctl>
          <autogen>--KeyToKey-- KeyCode::H, ModifierFlag::OPTION_L, KeyCode::CURSOR_LEFT</autogen>
          <autogen>--KeyToKey-- KeyCode::J, ModifierFlag::OPTION_L, KeyCode::CURSOR_DOWN</autogen>
          <autogen>--KeyToKey-- KeyCode::K, ModifierFlag::OPTION_L, KeyCode::CURSOR_UP</autogen>
          <autogen>--KeyToKey-- KeyCode::L, ModifierFlag::OPTION_L, KeyCode::CURSOR_RIGHT</autogen>
        </item>
        <item>
          <name>Command_R+g/G to Home/End</name>
          <sysctl>option.vimode_gG</sysctl>
          <autogen>--KeyToKey-- KeyCode::G, ModifierFlag::COMMAND_R | ModifierFlag::NONE, KeyCode::HOME</autogen>
          <autogen>--KeyToKey-- KeyCode::G, ModifierFlag::COMMAND_R | VK_SHIFT, KeyCode::END</autogen>
        </item>
        <item>
          <name>Control_L+g/G to Home/End</name>
          <sysctl>option.vimode_control_gG</sysctl>
          <autogen>--KeyToKey-- KeyCode::G, ModifierFlag::CONTROL_L | ModifierFlag::NONE, KeyCode::HOME</autogen>
          <autogen>--KeyToKey-- KeyCode::G, ModifierFlag::CONTROL_L | VK_SHIFT, KeyCode::END</autogen>
        </item>
        <item>
          <name>Command_R+bf to PageUp/PageDown</name>
          <sysctl>option.vimode_bf</sysctl>
          <autogen>--KeyToKey-- KeyCode::B, ModifierFlag::COMMAND_R, KeyCode::PAGEUP</autogen>
          <autogen>--KeyToKey-- KeyCode::F, ModifierFlag::COMMAND_R, KeyCode::PAGEDOWN</autogen>
        </item>
        <item>
          <name>Coltrol_L+bf to PageUp/PageDown</name>
          <sysctl>option.vimode_control_bf</sysctl>
          <autogen>--KeyToKey-- KeyCode::B, ModifierFlag::CONTROL_L, KeyCode::PAGEUP</autogen>
          <autogen>--KeyToKey-- KeyCode::F, ModifierFlag::CONTROL_L, KeyCode::PAGEDOWN</autogen>
        </item>
        <item>
          <name>Command_R+0$ to Command+Left/Right</name>
          <sysctl>option.vimode_0dollar</sysctl>
          <autogen>--KeyToKey-- KeyCode::KEY_0, ModifierFlag::COMMAND_R, KeyCode::CURSOR_LEFT, ModifierFlag::COMMAND_L</autogen>
          <autogen>--KeyToKey-- KeyCode::KEY_4, ModifierFlag::COMMAND_R | VK_SHIFT, KeyCode::CURSOR_RIGHT, ModifierFlag::COMMAND_L</autogen>
        </item>
        <item>
          <name>Control_L+0$ to Command+Left/Right</name>
          <sysctl>option.vimode_control_0dollar</sysctl>
          <autogen>--KeyToKey-- KeyCode::KEY_0, ModifierFlag::CONTROL_L, KeyCode::CURSOR_LEFT, ModifierFlag::CONTROL_L</autogen>
          <autogen>--KeyToKey-- KeyCode::KEY_4, ModifierFlag::CONTROL_L, KeyCode::CURSOR_RIGHT, ModifierFlag::CONTROL_L</autogen>
          <autogen>--KeyToKey-- KeyCode::KEY_4, ModifierFlag::CONTROL_L | VK_SHIFT, KeyCode::CURSOR_RIGHT, ModifierFlag::CONTROL_L</autogen>
        </item>
        <item>
          <name>Option_L+hjkl to Option+Left/Down/Up/Right</name>
          <sysctl>option.vimode_option_hjkl</sysctl>
          <autogen>--KeyToKey-- KeyCode::H, ModifierFlag::OPTION_L, KeyCode::CURSOR_LEFT, ModifierFlag::OPTION_L</autogen>
          <autogen>--KeyToKey-- KeyCode::J, ModifierFlag::OPTION_L, KeyCode::CURSOR_DOWN, ModifierFlag::OPTION_L</autogen>
          <autogen>--KeyToKey-- KeyCode::K, ModifierFlag::OPTION_L, KeyCode::CURSOR_UP, ModifierFlag::OPTION_L</autogen>
          <autogen>--KeyToKey-- KeyCode::L, ModifierFlag::OPTION_L, KeyCode::CURSOR_RIGHT, ModifierFlag::OPTION_L</autogen>
        </item>
      </list>
    </item>

    <item>
      <name>Complete Vi Mode</name>
      <list>
        <item>
          <name>What's "Complete Vi Mode".</name>
          <appendix>You can use Vi style navigation on any applications when "Complete Vi Mode" is on.</appendix>
          <appendix>Turn on a setting below, and toggle "Complete Vi Mode".</appendix>
          <appendix></appendix>
          <appendix>It is a list of the operation.</appendix>
          <appendix>- hjkl to Left/Down/Up/Right</appendix>
          <appendix>- b to Option_L+Left</appendix>
          <appendix>- e to Option_L+Right</appendix>
          <appendix>- w to Option_L+Right,Option_L+Right,Option_L+Left</appendix>
          <appendix>- Control+F to PageDown</appendix>
          <appendix>- Control+B to PageUp</appendix>
          <appendix>- g to Home</appendix>
          <appendix>- Shift+g to End</appendix>
          <appendix>- 0 to Command_L+Left</appendix>
          <appendix>- $ to Command_L+Right ($ == Shift+4)</appendix>
          <appendix>- / to Command_L+F (+ turn off Vi Mode)</appendix>
          <appendix>- n to Command_L+G</appendix>
          <appendix>- x to Forward Delete</appendix>
          <appendix>- Shift+x to Delete</appendix>
          <appendix>- f to FN</appendix>
          <appendix>- i to turn off Vi Mode</appendix>
          <sysctl>notsave.complete_vimode</sysctl>
          <vk_config>true</vk_config>
          <autogen>--ShowStatusMessage-- "Vi Mode"</autogen>
          <block>
            <config_not>option.complete_vimode_dvorak</config_not>
            <!-- HJKL -->
            <autogen>--KeyToKey-- KeyCode::H, KeyCode::CURSOR_LEFT</autogen>
            <autogen>--KeyToKey-- KeyCode::J, KeyCode::CURSOR_DOWN</autogen>
            <autogen>--KeyToKey-- KeyCode::K, KeyCode::CURSOR_UP</autogen>
            <autogen>--KeyToKey-- KeyCode::L, KeyCode::CURSOR_RIGHT</autogen>

            <!-- 0, Shift+4 -->
            <autogen>--KeyToKey-- KeyCode::KEY_0, KeyCode::CURSOR_LEFT, ModifierFlag::COMMAND_L</autogen>
            <autogen>--KeyToKey-- KeyCode::KEY_4, VK_SHIFT, KeyCode::CURSOR_RIGHT, ModifierFlag::COMMAND_L</autogen>

            <!-- C-f, C-b -->
            <autogen>--KeyToKey-- KeyCode::F, VK_CONTROL, KeyCode::PAGEDOWN</autogen>
            <autogen>--KeyToKey-- KeyCode::B, VK_CONTROL, KeyCode::PAGEUP</autogen>

            <!-- B, E -->
            <autogen>--KeyToKey-- KeyCode::B, KeyCode::CURSOR_LEFT, ModifierFlag::OPTION_L</autogen>
            <autogen>--KeyToKey-- KeyCode::E, KeyCode::CURSOR_RIGHT, ModifierFlag::OPTION_L</autogen>

            <!-- W -->
            <autogen>--KeyToKey-- KeyCode::W, KeyCode::CURSOR_RIGHT, ModifierFlag::OPTION_L, KeyCode::CURSOR_RIGHT, ModifierFlag::OPTION_L, KeyCode::CURSOR_LEFT, ModifierFlag::OPTION_L</autogen>

            <!-- G, Shift+G -->
            <autogen>--KeyToKey-- KeyCode::G, VK_SHIFT, KeyCode::END</autogen>
            <autogen>--KeyToKey-- KeyCode::G, KeyCode::HOME</autogen>

            <!-- SLASH, N -->
            <autogen>--KeyToKey-- KeyCode::SLASH, KeyCode::F, ModifierFlag::COMMAND_L, KeyCode::VK_CONFIG_FORCE_OFF_notsave_complete_vimode</autogen>
            <autogen>--KeyToKey-- KeyCode::N, KeyCode::G, ModifierFlag::COMMAND_L</autogen>

            <!-- X -->
            <autogen>--KeyToKey-- KeyCode::X, VK_SHIFT | ModifierFlag::NONE, KeyCode::DELETE</autogen>
            <autogen>--KeyToKey-- KeyCode::X, ModifierFlag::NONE, KeyCode::FORWARD_DELETE</autogen>

            <!-- F, I -->
            <autogen>--KeyToKey-- KeyCode::F, KeyCode::FN</autogen>
            <autogen>--KeyToKey-- KeyCode::I, KeyCode::VK_CONFIG_TOGGLE_notsave_complete_vimode</autogen>
          </block>
          <block>
            <config_only>option.complete_vimode_dvorak</config_only>
            <!-- HJKL -->
            <autogen>--KeyToKey-- KeyCode::J, KeyCode::CURSOR_LEFT</autogen>
            <autogen>--KeyToKey-- KeyCode::C, KeyCode::CURSOR_DOWN</autogen>
            <autogen>--KeyToKey-- KeyCode::V, KeyCode::CURSOR_UP</autogen>
            <autogen>--KeyToKey-- KeyCode::P, KeyCode::CURSOR_RIGHT</autogen>

            <!-- 0, Shift+4 -->
            <autogen>--KeyToKey-- KeyCode::KEY_0, KeyCode::CURSOR_LEFT, ModifierFlag::COMMAND_L</autogen>
            <autogen>--KeyToKey-- KeyCode::KEY_4, VK_SHIFT, KeyCode::CURSOR_RIGHT, ModifierFlag::COMMAND_L</autogen>

            <!-- C-f, C-b -->
            <autogen>--KeyToKey-- KeyCode::Y, VK_CONTROL, KeyCode::PAGEDOWN</autogen>
            <autogen>--KeyToKey-- KeyCode::N, VK_CONTROL, KeyCode::PAGEUP</autogen>

            <!-- B, E -->
            <autogen>--KeyToKey-- KeyCode::N, KeyCode::CURSOR_LEFT, ModifierFlag::OPTION_L</autogen>
            <autogen>--KeyToKey-- KeyCode::D, KeyCode::CURSOR_RIGHT, ModifierFlag::OPTION_L</autogen>

            <!-- W -->
            <autogen>--KeyToKey-- KeyCode::COMMA, KeyCode::CURSOR_RIGHT, ModifierFlag::OPTION_L, KeyCode::CURSOR_RIGHT, ModifierFlag::OPTION_L, KeyCode::CURSOR_LEFT, ModifierFlag::OPTION_L</autogen>

            <!-- G, Shift+G -->
            <autogen>--KeyToKey-- KeyCode::U, VK_SHIFT, KeyCode::END</autogen>
            <autogen>--KeyToKey-- KeyCode::U, KeyCode::HOME</autogen>

            <!-- SLASH, N -->
            <autogen>--KeyToKey-- KeyCode::BRACKET_LEFT, KeyCode::Y, ModifierFlag::COMMAND_L, KeyCode::VK_CONFIG_FORCE_OFF_notsave_complete_vimode</autogen>
            <autogen>--KeyToKey-- KeyCode::L, KeyCode::U, ModifierFlag::COMMAND_L</autogen>

            <!-- X -->
            <autogen>--KeyToKey-- KeyCode::B, VK_SHIFT | ModifierFlag::NONE, KeyCode::DELETE</autogen>
            <autogen>--KeyToKey-- KeyCode::B, ModifierFlag::NONE, KeyCode::FORWARD_DELETE</autogen>

            <!-- F, I -->
            <autogen>--KeyToKey-- KeyCode::Y, KeyCode::FN</autogen>
            <autogen>--KeyToKey-- KeyCode::G, KeyCode::VK_CONFIG_TOGGLE_notsave_complete_vimode</autogen>
          </block>
        </item>

        <item>
          <name>Option</name>
          <list>
            <item>
              <name>Dvorak logical HJKL to navigate</name>
              <sysctl>option.complete_vimode_dvorak</sysctl>
            </item>
          </list>
        </item>

        <item>
          <name>Simultaneous Key Presses [Command_L+Command_R] to toggle Vi Mode</name>
          <sysctl>remap.vimode_toggle_commandLR</sysctl>
          <autogen>--SimultaneousKeyPresses-- KeyCode::COMMAND_R, KeyCode::COMMAND_L, KeyCode::VK_CONFIG_TOGGLE_notsave_complete_vimode</autogen>
        </item>
        <item>
          <name>Arrow(Down/Left/Right) to Option_L</name>
          <appendix>drop Up-Arrow</appendix>
          <appendix>(+ When you type Arrow only, toggle Vi Mode)</appendix>
          <sysctl>remap.vimode_toggle_arrow2optionL</sysctl>
          <autogen>--KeyOverlaidModifier-- KeyCode::CURSOR_UP,    KeyCode::VK_NONE,  KeyCode::VK_CONFIG_TOGGLE_notsave_complete_vimode</autogen>
          <autogen>--KeyOverlaidModifier-- KeyCode::CURSOR_DOWN,  KeyCode::OPTION_L, KeyCode::VK_CONFIG_TOGGLE_notsave_complete_vimode</autogen>
          <autogen>--KeyOverlaidModifier-- KeyCode::CURSOR_LEFT,  KeyCode::OPTION_L, KeyCode::VK_CONFIG_TOGGLE_notsave_complete_vimode</autogen>
          <autogen>--KeyOverlaidModifier-- KeyCode::CURSOR_RIGHT, KeyCode::OPTION_L, KeyCode::VK_CONFIG_TOGGLE_notsave_complete_vimode</autogen>
        </item>
        <item>
          <name>Command_L to Command_L</name>
          <appendix>(+ When you type Command_L only, toggle Vi Mode)</appendix>
          <sysctl>remap.vimode_toggle_commandL</sysctl>
          <autogen>--KeyOverlaidModifier-- KeyCode::COMMAND_L, KeyCode::COMMAND_L, KeyCode::VK_CONFIG_TOGGLE_notsave_complete_vimode</autogen>
        </item>
        <item>
          <name>Command_R to Command_R</name>
          <appendix>(+ When you type Command_R only, toggle Vi Mode)</appendix>
          <sysctl>remap.vimode_toggle_commandR</sysctl>
          <autogen>--KeyOverlaidModifier-- KeyCode::COMMAND_R, KeyCode::COMMAND_R, KeyCode::VK_CONFIG_TOGGLE_notsave_complete_vimode</autogen>
        </item>
        <item>
          <name>Control_R to Control_R</name>
          <appendix>(+ When you type Control_R only, toggle Vi Mode)</appendix>
          <sysctl>remap.vimode_toggle_controlR</sysctl>
          <autogen>--KeyOverlaidModifier-- KeyCode::CONTROL_R, KeyCode::CONTROL_R, KeyCode::VK_CONFIG_TOGGLE_notsave_complete_vimode</autogen>
        </item>
        <item>
          <name>Shift_R to Shift_R</name>
          <appendix>(+ When you type Shift_R only, toggle Vi Mode)</appendix>
          <sysctl>remap.vimode_toggle_shiftR</sysctl>
          <autogen>--KeyOverlaidModifier-- KeyCode::SHIFT_R, KeyCode::SHIFT_R, KeyCode::VK_CONFIG_TOGGLE_notsave_complete_vimode</autogen>
        </item>
        <item>
          <name>Escape to turn on Vi Mode</name>
          <appendix>(except in Vim)</appendix>
          <sysctl>remap.vimode_turnon_escape</sysctl>
          <not>VI</not>
          <config_not>notsave.complete_vimode</config_not>
          <autogen>--KeyToKey-- KeyCode::ESCAPE, KeyCode::VK_CONFIG_FORCE_ON_notsave_complete_vimode</autogen>
        </item>
        <item>
          <name>Escape to turn off Vi Mode</name>
          <appendix>(+ turn off Modifier Lock)</appendix>
          <sysctl>option.vimode_turnoff_escape</sysctl>
          <config_only>notsave.complete_vimode</config_only>
          <autogen>--KeyToKey-- KeyCode::ESCAPE, KeyCode::VK_LOCK_ALL_FORCE_OFF, KeyCode::VK_CONFIG_FORCE_OFF_notsave_complete_vimode</autogen>
        </item>
        <item>
          <name>Option+Escape to toggle Vi Mode</name>
          <sysctl>option.vimode_turnoff_optionEsc</sysctl>
          <autogen>--KeyToKey-- KeyCode::ESCAPE, VK_OPTION, KeyCode::VK_CONFIG_TOGGLE_notsave_complete_vimode</autogen>
        </item>
        <item>
          <name>FN to FN</name>
          <appendix>(+ When you type FN only, toggle Vi Mode)</appendix>
          <sysctl>remap.vimode_toggle_fn2fn</sysctl>
          <autogen>--KeyOverlaidModifier-- KeyCode::FN, KeyCode::FN, KeyCode::VK_CONFIG_TOGGLE_notsave_complete_vimode</autogen>
        </item>
        <item>
          <name>Option+V to toggle Vi Mode</name>
          <sysctl>option.vimode_toggle_optionV</sysctl>
          <autogen>--KeyToKey-- KeyCode::V, VK_OPTION, KeyCode::VK_CONFIG_TOGGLE_notsave_complete_vimode</autogen>
        </item>
        <item>
          <name>Option+V to turn on Vi Mode</name>
          <sysctl>option.vimode_turnon_optionV</sysctl>
          <autogen>--KeyToKey-- KeyCode::V, VK_OPTION, KeyCode::VK_CONFIG_FORCE_ON_notsave_complete_vimode</autogen>
        </item>
        <item>
          <name>Drop Shift_L</name>
          <appendix>(+ When you type Shift_L only, toggle Vi Mode)</appendix>
          <sysctl>remap.vimode_toggle_drop_shiftL</sysctl>
          <autogen>--KeyOverlaidModifier-- KeyCode::SHIFT_L, KeyCode::VK_NONE, KeyCode::VK_CONFIG_TOGGLE_notsave_complete_vimode</autogen>
        </item>
      </list>
    </item>

    <item>
      <name>Simultaneous Key Presses</name>
      <list>
        <item>
          <name>Simultaneous Key Presses [F+HJKL] to Left/Down/Up/Right</name>
          <appendix>(F+H to Left)</appendix>
          <appendix>(F+J to Down)</appendix>
          <appendix>(F+K to Up)</appendix>
          <appendix>(F+L to Right)</appendix>
          <sysctl>remap.simultaneouskeypresses_vimode_f</sysctl>
          <autogen>--SimultaneousKeyPresses-- KeyCode::H, KeyCode::F, KeyCode::CURSOR_LEFT</autogen>
          <autogen>--SimultaneousKeyPresses-- KeyCode::J, KeyCode::F, KeyCode::CURSOR_DOWN</autogen>
          <autogen>--SimultaneousKeyPresses-- KeyCode::K, KeyCode::F, KeyCode::CURSOR_UP</autogen>
          <autogen>--SimultaneousKeyPresses-- KeyCode::L, KeyCode::F, KeyCode::CURSOR_RIGHT</autogen>
        </item>
        <item>
          <name>Simultaneous Key Presses [S+D] to ModifierFlag::EXTRA1</name>
          <appendix>(EXTRA1+H to Left)</appendix>
          <appendix>(EXTRA1+J to Down)</appendix>
          <appendix>(EXTRA1+K to Up)</appendix>
          <appendix>(EXTRA1+L to Right)</appendix>
          <appendix>(EXTRA1+F to FN)</appendix>
          <sysctl>remap.simultaneouskeypresses_vimode_sd</sysctl>
          <autogen>--SimultaneousKeyPresses-- KeyCode::D, KeyCode::S, KeyCode::VK_MODIFIER_EXTRA1</autogen>
          <autogen>--KeyToKey-- KeyCode::H, ModifierFlag::EXTRA1, KeyCode::CURSOR_LEFT</autogen>
          <autogen>--KeyToKey-- KeyCode::J, ModifierFlag::EXTRA1, KeyCode::CURSOR_DOWN</autogen>
          <autogen>--KeyToKey-- KeyCode::K, ModifierFlag::EXTRA1, KeyCode::CURSOR_UP</autogen>
          <autogen>--KeyToKey-- KeyCode::L, ModifierFlag::EXTRA1, KeyCode::CURSOR_RIGHT</autogen>
          <autogen>--KeyToKey-- KeyCode::F, ModifierFlag::EXTRA1, KeyCode::FN, ModifierFlag::EXTRA1</autogen>
        </item>
        <item>
          <name>Simultaneous Key Presses [F+J] to Return</name>
          <sysctl>remap.simultaneouskeypresses_fj_to_return</sysctl>
          <autogen>--SimultaneousKeyPresses-- KeyCode::F, KeyCode::J, KeyCode::RETURN</autogen>
        </item>
        <item>
          <name>Simultaneous Key Presses [X+C] to Escape</name>
          <sysctl>remap.simultaneouskeypresses_xc2escape</sysctl>
          <autogen>--SimultaneousKeyPresses-- KeyCode::C, KeyCode::X, KeyCode::ESCAPE</autogen>
        </item>
        <item>
          <name>Simultaneous Key Presses [Z+X] to LeftClick</name>
          <sysctl>remap.simultaneouskeypresses_zx2leftclick</sysctl>
          <autogen>--SimultaneousKeyPresses-- KeyCode::X, KeyCode::Z, PointingButton::LEFT</autogen>
        </item>
        <item>
          <name>Simultaneous Key Presses [M+N] to F13</name>
          <sysctl>remap.simultaneouskeypresses_mn2f13</sysctl>
          <autogen>--SimultaneousKeyPresses-- KeyCode::N, KeyCode::M, KeyCode::F13</autogen>
        </item>
        <item>
          <name>Simultaneous Key Presses [F+N] to FN_Lock</name>
          <sysctl>remap.simultaneouskeypresses_fn_to_fnlock</sysctl>
          <autogen>--SimultaneousKeyPresses-- KeyCode::F, KeyCode::N, KeyCode::VK_LOCK_FN</autogen>
        </item>
        <item>
          <name>Simultaneous Key Presses [V+I] to toggle Complete Vi Mode</name>
          <sysctl>remap.simultaneouskeypresses_vi_to_vimode</sysctl>
          <autogen>--SimultaneousKeyPresses-- KeyCode::V, KeyCode::I, KeyCode::VK_CONFIG_TOGGLE_notsave_complete_vimode</autogen>
        </item>
        <item>
          <name>Simultaneous Key Presses [Q+P] to M</name>
          <sysctl>remap.simultaneouskeypresses_pq2m</sysctl>
          <autogen>--SimultaneousKeyPresses-- KeyCode::P, KeyCode::Q, KeyCode::M</autogen>
        </item>
        <item>
          <name>Simultaneous Key Presses [K+L] to Control_L+F4 (= Move focus to the active (or next) window)</name>
          <appendix>(+ Shift+[K+L] to EXPOSE_ALL)</appendix>
          <appendix>(+ Control+[K+L] to F8)</appendix>
          <sysctl>remap.simultaneouskeypresses_kl2controlLf4</sysctl>
          <autogen>--SimultaneousKeyPresses-- KeyCode::K, KeyCode::L, VK_SHIFT,   KeyCode::EXPOSE_ALL</autogen>
          <autogen>--SimultaneousKeyPresses-- KeyCode::K, KeyCode::L, VK_CONTROL, KeyCode::F8</autogen>
          <autogen>--SimultaneousKeyPresses-- KeyCode::K, KeyCode::L,             KeyCode::F4, ModifierFlag::CONTROL_L</autogen>
        </item>
        <item>
          <name>Simultaneous Key Presses [K+L] to PC Application Key</name>
          <appendix>(We can change the key once again)</appendix>
          <sysctl>remap.simultaneouskeypresses_kl2pc_application</sysctl>
          <autogen>--SimultaneousKeyPresses-- KeyCode::K, KeyCode::L, KeyCode::PC_APPLICATION, SimultaneousKeyPresses::Option::RAW</autogen>
        </item>
        <item>
          <name>Simultaneous Key Presses [Shift_R+Up Arrow] to PC Application Key</name>
          <appendix>(We can change the key once again)</appendix>
          <sysctl>remap.simultaneouskeypresses_shiftRuparrow2pc_application</sysctl>
          <autogen>--SimultaneousKeyPresses-- KeyCode::CURSOR_UP, KeyCode::SHIFT_R, KeyCode::PC_APPLICATION, SimultaneousKeyPresses::Option::RAW</autogen>
        </item>
        <item>
          <name>Simultaneous Key Presses [Up-Arrow+Down-Arrow] to PC Application Key</name>
          <appendix>(We can change the key once again)</appendix>
          <sysctl>remap.simultaneouskeypresses_UpDown2pc_application</sysctl>
          <autogen>--SimultaneousKeyPresses-- KeyCode::CURSOR_UP, KeyCode::CURSOR_DOWN, KeyCode::PC_APPLICATION, SimultaneousKeyPresses::Option::RAW</autogen>
        </item>
        <item>
          <name>Simultaneous Key Presses [K+L] to Return</name>
          <appendix>(We can change the key once again)</appendix>
          <sysctl>remap.simultaneouskeypresses_kl2return</sysctl>
          <autogen>--SimultaneousKeyPresses-- KeyCode::K, KeyCode::L, KeyCode::RETURN, SimultaneousKeyPresses::Option::RAW</autogen>
        </item>
      </list>
    </item>

    <item>
      <name>For Expose, Spaces</name>
      <list>
        <item>
          <name>Disable Slow-Expose (Drop Shift+Expose, Shift+Dashboard, Shift+F8,...,Shift+F12)</name>
          <sysctl>option.drop_slowexpose</sysctl>
          <autogen>--DropKeyAfterRemap-- KeyCode::EXPOSE_ALL, VK_SHIFT</autogen>
          <autogen>--DropKeyAfterRemap-- KeyCode::DASHBOARD,  VK_SHIFT</autogen>
          <autogen>--DropKeyAfterRemap-- KeyCode::F8,         VK_SHIFT</autogen>
          <autogen>--DropKeyAfterRemap-- KeyCode::F9,         VK_SHIFT</autogen>
          <autogen>--DropKeyAfterRemap-- KeyCode::F10,        VK_SHIFT</autogen>
          <autogen>--DropKeyAfterRemap-- KeyCode::F11,        VK_SHIFT</autogen>
          <autogen>--DropKeyAfterRemap-- KeyCode::F12,        VK_SHIFT</autogen>
        </item>
        <item>
          <name>For Spaces</name>
          <list>
            <item>
              <name>Use Command_R+[ASD FGH JKL] for Spaces</name>
              <appendix>(Command+Control+Option+Shift+[123 456 789])</appendix>
              <sysctl>remap.spaces_special</sysctl>
              <autogen>--KeyToKey-- KeyCode::A, ModifierFlag::COMMAND_R | ModifierFlag::NONE, KeyCode::KEY_1, VK_MOD_CCOS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::S, ModifierFlag::COMMAND_R | ModifierFlag::NONE, KeyCode::KEY_2, VK_MOD_CCOS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::D, ModifierFlag::COMMAND_R | ModifierFlag::NONE, KeyCode::KEY_3, VK_MOD_CCOS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::F, ModifierFlag::COMMAND_R | ModifierFlag::NONE, KeyCode::KEY_4, VK_MOD_CCOS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::G, ModifierFlag::COMMAND_R | ModifierFlag::NONE, KeyCode::KEY_5, VK_MOD_CCOS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::H, ModifierFlag::COMMAND_R | ModifierFlag::NONE, KeyCode::KEY_6, VK_MOD_CCOS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::J, ModifierFlag::COMMAND_R | ModifierFlag::NONE, KeyCode::KEY_7, VK_MOD_CCOS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::K, ModifierFlag::COMMAND_R | ModifierFlag::NONE, KeyCode::KEY_8, VK_MOD_CCOS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::L, ModifierFlag::COMMAND_R | ModifierFlag::NONE, KeyCode::KEY_9, VK_MOD_CCOS_L</autogen>
            </item>
            <item>
              <name>Use Command_R+[123 QWE ASD] for Spaces (3x3)</name>
              <appendix>(Command+Control+Option+Shift+[123 456 789])</appendix>
              <sysctl>remap.spaces_special_123qweasd</sysctl>
              <autogen>--KeyToKey-- KeyCode::KEY_1, ModifierFlag::COMMAND_R | ModifierFlag::NONE, KeyCode::KEY_1, VK_MOD_CCOS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEY_2, ModifierFlag::COMMAND_R | ModifierFlag::NONE, KeyCode::KEY_2, VK_MOD_CCOS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEY_3, ModifierFlag::COMMAND_R | ModifierFlag::NONE, KeyCode::KEY_3, VK_MOD_CCOS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::Q,     ModifierFlag::COMMAND_R | ModifierFlag::NONE, KeyCode::KEY_4, VK_MOD_CCOS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::W,     ModifierFlag::COMMAND_R | ModifierFlag::NONE, KeyCode::KEY_5, VK_MOD_CCOS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::E,     ModifierFlag::COMMAND_R | ModifierFlag::NONE, KeyCode::KEY_6, VK_MOD_CCOS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::A,     ModifierFlag::COMMAND_R | ModifierFlag::NONE, KeyCode::KEY_7, VK_MOD_CCOS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::S,     ModifierFlag::COMMAND_R | ModifierFlag::NONE, KeyCode::KEY_8, VK_MOD_CCOS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::D,     ModifierFlag::COMMAND_R | ModifierFlag::NONE, KeyCode::KEY_9, VK_MOD_CCOS_L</autogen>
            </item>
            <item>
              <name>Use Command_R+[123 QWE ASD] for Spaces (4x4)</name>
              <appendix>(Cmd+Ctrl+Shift+[123 567 90], Cmd+Ctrl+Option+Shift[1])</appendix>
              <sysctl>remap.spaces_special_123qweasd_4x4</sysctl>
              <autogen>--KeyToKey-- KeyCode::KEY_1, ModifierFlag::COMMAND_R | ModifierFlag::NONE, KeyCode::KEY_1, VK_MOD_CCS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEY_2, ModifierFlag::COMMAND_R | ModifierFlag::NONE, KeyCode::KEY_2, VK_MOD_CCS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEY_3, ModifierFlag::COMMAND_R | ModifierFlag::NONE, KeyCode::KEY_3, VK_MOD_CCS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::Q,     ModifierFlag::COMMAND_R | ModifierFlag::NONE, KeyCode::KEY_5, VK_MOD_CCS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::W,     ModifierFlag::COMMAND_R | ModifierFlag::NONE, KeyCode::KEY_6, VK_MOD_CCS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::E,     ModifierFlag::COMMAND_R | ModifierFlag::NONE, KeyCode::KEY_7, VK_MOD_CCS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::A,     ModifierFlag::COMMAND_R | ModifierFlag::NONE, KeyCode::KEY_9, VK_MOD_CCS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::S,     ModifierFlag::COMMAND_R | ModifierFlag::NONE, KeyCode::KEY_0, VK_MOD_CCS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::D,     ModifierFlag::COMMAND_R | ModifierFlag::NONE, KeyCode::KEY_1, VK_MOD_CCOS_L</autogen>
            </item>
            <item>
              <name>Use Command_R+[QWE ASD ZXC] for Spaces (3x3)</name>
              <appendix>(Command+Control+Option+Shift+[123 456 789])</appendix>
              <sysctl>remap.spaces_special_qweasdzxc</sysctl>
              <autogen>--KeyToKey-- KeyCode::Q, ModifierFlag::COMMAND_R | ModifierFlag::NONE, KeyCode::KEY_1, VK_MOD_CCOS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::W, ModifierFlag::COMMAND_R | ModifierFlag::NONE, KeyCode::KEY_2, VK_MOD_CCOS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::E, ModifierFlag::COMMAND_R | ModifierFlag::NONE, KeyCode::KEY_3, VK_MOD_CCOS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::A, ModifierFlag::COMMAND_R | ModifierFlag::NONE, KeyCode::KEY_4, VK_MOD_CCOS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::S, ModifierFlag::COMMAND_R | ModifierFlag::NONE, KeyCode::KEY_5, VK_MOD_CCOS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::D, ModifierFlag::COMMAND_R | ModifierFlag::NONE, KeyCode::KEY_6, VK_MOD_CCOS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::Z, ModifierFlag::COMMAND_R | ModifierFlag::NONE, KeyCode::KEY_7, VK_MOD_CCOS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::X, ModifierFlag::COMMAND_R | ModifierFlag::NONE, KeyCode::KEY_8, VK_MOD_CCOS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::C, ModifierFlag::COMMAND_R | ModifierFlag::NONE, KeyCode::KEY_9, VK_MOD_CCOS_L</autogen>
            </item>
            <item>
              <name>Use Command_R+[QWE ASD ZXC] for Spaces (3x3)</name>
              <appendix>(Command+Control+Option+[123 456 789])</appendix>
              <sysctl>remap.spaces_special_qweasdzxc_without_shift</sysctl>
              <autogen>--KeyToKey-- KeyCode::Q, ModifierFlag::COMMAND_R | ModifierFlag::NONE, KeyCode::KEY_1, VK_MOD_CCO_L</autogen>
              <autogen>--KeyToKey-- KeyCode::W, ModifierFlag::COMMAND_R | ModifierFlag::NONE, KeyCode::KEY_2, VK_MOD_CCO_L</autogen>
              <autogen>--KeyToKey-- KeyCode::E, ModifierFlag::COMMAND_R | ModifierFlag::NONE, KeyCode::KEY_3, VK_MOD_CCO_L</autogen>
              <autogen>--KeyToKey-- KeyCode::A, ModifierFlag::COMMAND_R | ModifierFlag::NONE, KeyCode::KEY_4, VK_MOD_CCO_L</autogen>
              <autogen>--KeyToKey-- KeyCode::S, ModifierFlag::COMMAND_R | ModifierFlag::NONE, KeyCode::KEY_5, VK_MOD_CCO_L</autogen>
              <autogen>--KeyToKey-- KeyCode::D, ModifierFlag::COMMAND_R | ModifierFlag::NONE, KeyCode::KEY_6, VK_MOD_CCO_L</autogen>
              <autogen>--KeyToKey-- KeyCode::Z, ModifierFlag::COMMAND_R | ModifierFlag::NONE, KeyCode::KEY_7, VK_MOD_CCO_L</autogen>
              <autogen>--KeyToKey-- KeyCode::X, ModifierFlag::COMMAND_R | ModifierFlag::NONE, KeyCode::KEY_8, VK_MOD_CCO_L</autogen>
              <autogen>--KeyToKey-- KeyCode::C, ModifierFlag::COMMAND_R | ModifierFlag::NONE, KeyCode::KEY_9, VK_MOD_CCO_L</autogen>
            </item>
            <item>
              <name>Use FN+[123456789] for Spaces</name>
              <appendix>(Command+Control+Option+Shift+[123456789])</appendix>
              <sysctl>remap.spaces_special_fn</sysctl>
              <autogen>--KeyToKey-- KeyCode::KEY_1, ModifierFlag::FN | ModifierFlag::NONE, KeyCode::KEY_1, VK_MOD_CCOS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEY_2, ModifierFlag::FN | ModifierFlag::NONE, KeyCode::KEY_2, VK_MOD_CCOS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEY_3, ModifierFlag::FN | ModifierFlag::NONE, KeyCode::KEY_3, VK_MOD_CCOS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEY_4, ModifierFlag::FN | ModifierFlag::NONE, KeyCode::KEY_4, VK_MOD_CCOS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEY_5, ModifierFlag::FN | ModifierFlag::NONE, KeyCode::KEY_5, VK_MOD_CCOS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEY_6, ModifierFlag::FN | ModifierFlag::NONE, KeyCode::KEY_6, VK_MOD_CCOS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEY_7, ModifierFlag::FN | ModifierFlag::NONE, KeyCode::KEY_7, VK_MOD_CCOS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEY_8, ModifierFlag::FN | ModifierFlag::NONE, KeyCode::KEY_8, VK_MOD_CCOS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEY_9, ModifierFlag::FN | ModifierFlag::NONE, KeyCode::KEY_9, VK_MOD_CCOS_L</autogen>
            </item>
            <item>
              <name>Use FN+[1234 QWER ASDF ZXCV] for Spaces (4x4)</name>
              <appendix>(Cmd+Ctrl+Shift+[1234 5678 90], Cmd+Ctrl+Option+Shift[12 3456])</appendix>
              <sysctl>remap.spaces_special_1234qwerasdfzxcv</sysctl>
              <autogen>--KeyToKey-- KeyCode::KEY_1, ModifierFlag::FN | ModifierFlag::NONE, KeyCode::KEY_1, VK_MOD_CCS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEY_2, ModifierFlag::FN | ModifierFlag::NONE, KeyCode::KEY_2, VK_MOD_CCS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEY_3, ModifierFlag::FN | ModifierFlag::NONE, KeyCode::KEY_3, VK_MOD_CCS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEY_4, ModifierFlag::FN | ModifierFlag::NONE, KeyCode::KEY_4, VK_MOD_CCS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::Q,     ModifierFlag::FN | ModifierFlag::NONE, KeyCode::KEY_5, VK_MOD_CCS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::W,     ModifierFlag::FN | ModifierFlag::NONE, KeyCode::KEY_6, VK_MOD_CCS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::E,     ModifierFlag::FN | ModifierFlag::NONE, KeyCode::KEY_7, VK_MOD_CCS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::R,     ModifierFlag::FN | ModifierFlag::NONE, KeyCode::KEY_8, VK_MOD_CCS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::A,     ModifierFlag::FN | ModifierFlag::NONE, KeyCode::KEY_9, VK_MOD_CCS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::S,     ModifierFlag::FN | ModifierFlag::NONE, KeyCode::KEY_0, VK_MOD_CCS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::D,     ModifierFlag::FN | ModifierFlag::NONE, KeyCode::KEY_1, VK_MOD_CCOS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::F,     ModifierFlag::FN | ModifierFlag::NONE, KeyCode::KEY_2, VK_MOD_CCOS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::Z,     ModifierFlag::FN | ModifierFlag::NONE, KeyCode::KEY_3, VK_MOD_CCOS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::X,     ModifierFlag::FN | ModifierFlag::NONE, KeyCode::KEY_4, VK_MOD_CCOS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::C,     ModifierFlag::FN | ModifierFlag::NONE, KeyCode::KEY_5, VK_MOD_CCOS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::V,     ModifierFlag::FN | ModifierFlag::NONE, KeyCode::KEY_6, VK_MOD_CCOS_L</autogen>
            </item>
            <item>
              <name>Use FN+[7890 UIOP JKL; M,./] for Spaces (4x4)</name>
              <appendix>(Cmd+Ctrl+Shift+[1234 5678 90], Cmd+Ctrl+Option+Shift[12 3456])</appendix>
              <sysctl>remap.spaces_special_7890uiopjklm</sysctl>
              <autogen>--KeyToKey-- KeyCode::KEY_7,     ModifierFlag::FN | ModifierFlag::NONE, KeyCode::KEY_1, VK_MOD_CCS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEY_8,     ModifierFlag::FN | ModifierFlag::NONE, KeyCode::KEY_2, VK_MOD_CCS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEY_9,     ModifierFlag::FN | ModifierFlag::NONE, KeyCode::KEY_3, VK_MOD_CCS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEY_0,     ModifierFlag::FN | ModifierFlag::NONE, KeyCode::KEY_4, VK_MOD_CCS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::U,         ModifierFlag::FN | ModifierFlag::NONE, KeyCode::KEY_5, VK_MOD_CCS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::I,         ModifierFlag::FN | ModifierFlag::NONE, KeyCode::KEY_6, VK_MOD_CCS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::O,         ModifierFlag::FN | ModifierFlag::NONE, KeyCode::KEY_7, VK_MOD_CCS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::P,         ModifierFlag::FN | ModifierFlag::NONE, KeyCode::KEY_8, VK_MOD_CCS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::J,         ModifierFlag::FN | ModifierFlag::NONE, KeyCode::KEY_9, VK_MOD_CCS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::K,         ModifierFlag::FN | ModifierFlag::NONE, KeyCode::KEY_0, VK_MOD_CCS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::L,         ModifierFlag::FN | ModifierFlag::NONE, KeyCode::KEY_1, VK_MOD_CCOS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::SEMICOLON, ModifierFlag::FN | ModifierFlag::NONE, KeyCode::KEY_2, VK_MOD_CCOS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::M,         ModifierFlag::FN | ModifierFlag::NONE, KeyCode::KEY_3, VK_MOD_CCOS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::COMMA,     ModifierFlag::FN | ModifierFlag::NONE, KeyCode::KEY_4, VK_MOD_CCOS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::DOT,       ModifierFlag::FN | ModifierFlag::NONE, KeyCode::KEY_5, VK_MOD_CCOS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::SLASH,     ModifierFlag::FN | ModifierFlag::NONE, KeyCode::KEY_6, VK_MOD_CCOS_L</autogen>
            </item>
            <item>
              <name>Use KeyPad numbers for Spaces(3x3)</name>
              <appendix>(Command+Control+Option+Shift+[123456789])</appendix>
              <sysctl>remap.spaces_special_keypad</sysctl>
              <autogen>--KeyToKey-- KeyCode::KEYPAD_1, KeyCode::KEY_7, VK_MOD_CCOS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEYPAD_2, KeyCode::KEY_8, VK_MOD_CCOS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEYPAD_3, KeyCode::KEY_9, VK_MOD_CCOS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEYPAD_4, KeyCode::KEY_4, VK_MOD_CCOS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEYPAD_5, KeyCode::KEY_5, VK_MOD_CCOS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEYPAD_6, KeyCode::KEY_6, VK_MOD_CCOS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEYPAD_7, KeyCode::KEY_1, VK_MOD_CCOS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEYPAD_8, KeyCode::KEY_2, VK_MOD_CCOS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEYPAD_9, KeyCode::KEY_3, VK_MOD_CCOS_L</autogen>
            </item>
            <item>
              <name>Use Command+KeyPad numbers for Spaces(3x3)</name>
              <appendix>(Command+Control+Option+Shift+[123456789])</appendix>
              <sysctl>option.keypad2spaces_modifier_command</sysctl>
              <autogen>--KeyToKey-- KeyCode::KEYPAD_1, VK_COMMAND, KeyCode::KEY_7, VK_MOD_CCOS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEYPAD_2, VK_COMMAND, KeyCode::KEY_8, VK_MOD_CCOS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEYPAD_3, VK_COMMAND, KeyCode::KEY_9, VK_MOD_CCOS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEYPAD_4, VK_COMMAND, KeyCode::KEY_4, VK_MOD_CCOS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEYPAD_5, VK_COMMAND, KeyCode::KEY_5, VK_MOD_CCOS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEYPAD_6, VK_COMMAND, KeyCode::KEY_6, VK_MOD_CCOS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEYPAD_7, VK_COMMAND, KeyCode::KEY_1, VK_MOD_CCOS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEYPAD_8, VK_COMMAND, KeyCode::KEY_2, VK_MOD_CCOS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEYPAD_9, VK_COMMAND, KeyCode::KEY_3, VK_MOD_CCOS_L</autogen>
            </item>
            <item>
              <name>Use Control+KeyPad numbers for Spaces(3x3)</name>
              <appendix>(Command+Control+Option+Shift+[123456789])</appendix>
              <sysctl>option.keypad2spaces_modifier_control</sysctl>
              <autogen>--KeyToKey-- KeyCode::KEYPAD_1, VK_CONTROL, KeyCode::KEY_7, VK_MOD_CCOS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEYPAD_2, VK_CONTROL, KeyCode::KEY_8, VK_MOD_CCOS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEYPAD_3, VK_CONTROL, KeyCode::KEY_9, VK_MOD_CCOS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEYPAD_4, VK_CONTROL, KeyCode::KEY_4, VK_MOD_CCOS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEYPAD_5, VK_CONTROL, KeyCode::KEY_5, VK_MOD_CCOS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEYPAD_6, VK_CONTROL, KeyCode::KEY_6, VK_MOD_CCOS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEYPAD_7, VK_CONTROL, KeyCode::KEY_1, VK_MOD_CCOS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEYPAD_8, VK_CONTROL, KeyCode::KEY_2, VK_MOD_CCOS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEYPAD_9, VK_CONTROL, KeyCode::KEY_3, VK_MOD_CCOS_L</autogen>
            </item>
            <item>
              <name>Use Option+KeyPad numbers for Spaces(3x3)</name>
              <appendix>(Command+Control+Option+Shift+[123456789])</appendix>
              <sysctl>option.keypad2spaces_modifier_option</sysctl>
              <autogen>--KeyToKey-- KeyCode::KEYPAD_1, VK_OPTION, KeyCode::KEY_7, VK_MOD_CCOS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEYPAD_2, VK_OPTION, KeyCode::KEY_8, VK_MOD_CCOS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEYPAD_3, VK_OPTION, KeyCode::KEY_9, VK_MOD_CCOS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEYPAD_4, VK_OPTION, KeyCode::KEY_4, VK_MOD_CCOS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEYPAD_5, VK_OPTION, KeyCode::KEY_5, VK_MOD_CCOS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEYPAD_6, VK_OPTION, KeyCode::KEY_6, VK_MOD_CCOS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEYPAD_7, VK_OPTION, KeyCode::KEY_1, VK_MOD_CCOS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEYPAD_8, VK_OPTION, KeyCode::KEY_2, VK_MOD_CCOS_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEYPAD_9, VK_OPTION, KeyCode::KEY_3, VK_MOD_CCOS_L</autogen>
            </item>
          </list>
        </item>
      </list>
    </item>

    <item>
      <name>For Applications</name>
      <list>
        <item>
          <name>Enable at only VMware Fusion, Parallels Desktop</name>
          <list>
            <item>
              <name>Change Enter to Control_L</name>
              <sysctl>remap.app_vm_enter2controlL</sysctl>
              <only>VIRTUALMACHINE</only>
              <autogen>--KeyToKey-- KeyCode::ENTER, KeyCode::CONTROL_L</autogen>
            </item>
            <item>
              <name>Change FN+Return to Insert</name>
              <sysctl>remap.app_vm_fnReturn2insert</sysctl>
              <only>VIRTUALMACHINE</only>
              <autogen>--KeyToKey-- KeyCode::RETURN, ModifierFlag::FN, KeyCode::HELP</autogen>
            </item>
            <item>
              <name>Change Option_R to Control_R</name>
              <sysctl>remap.app_vm_optionR2controlR</sysctl>
              <only>VIRTUALMACHINE</only>
              <autogen>--KeyToKey-- KeyCode::OPTION_R, KeyCode::CONTROL_R</autogen>
            </item>
            <item>
              <name>Change Ctrl+Q to Alt+F4</name>
              <only>VIRTUALMACHINE</only>
              <sysctl>remap.Ctrl_Q_to_Alt_F4</sysctl>
              <autogen>--KeyToKey-- KeyCode::Q, VK_CONTROL, KeyCode::F4, ModifierFlag::OPTION_L</autogen>
            </item>
            <item>
              <name>Change Command+Space to Option+Backquote(`)</name>
              <sysctl>remap.app_vm_commandspace2optionbackquote</sysctl>
              <only>VIRTUALMACHINE</only>
              <autogen>--KeyToKey-- KeyCode::SPACE, VK_COMMAND, KeyCode::BACKQUOTE, ModifierFlag::OPTION_L</autogen>
            </item>
            <item>
              <name>Change Command+Space to Option_L+Shift_L</name>
              <sysctl>remap.app_vm_commandspace2optionLshiftL</sysctl>
              <only>VIRTUALMACHINE</only>
              <autogen>--KeyToKey-- KeyCode::SPACE, VK_COMMAND, KeyCode::SHIFT_L, ModifierFlag::OPTION_L</autogen>
            </item>
            <item>
              <name>Change Command_L Keys</name>
              <appendix>(To support Emacs on Fusion. This allows controlling individual key translations)</appendix>
              <list>
                <item>
                  <name>Change Command_L to Option_L</name>
                  <sysctl>remap.app_vm_commandL2optionL</sysctl>
                  <appendix>(Option_L is translated to Alt_L by Fusion)</appendix>
                  <only>VIRTUALMACHINE</only>
                  <autogen>--KeyToKey-- KeyCode::COMMAND_L, KeyCode::OPTION_L</autogen>
                </item>
                <item>
                  <name>Change Command_L+A to Control+A</name>
                  <sysctl>remap.app_vm_commandLA</sysctl>
                  <only>VIRTUALMACHINE</only>
                  <autogen>--KeyToKey-- KeyCode::A, ModifierFlag::COMMAND_L, KeyCode::A, ModifierFlag::CONTROL_L</autogen>
                </item>
                <item>
                  <name>Change Command_L+C to Control+C</name>
                  <sysctl>remap.app_vm_commandLC</sysctl>
                  <only>VIRTUALMACHINE</only>
                  <autogen>--KeyToKey-- KeyCode::C, ModifierFlag::COMMAND_L, KeyCode::C, ModifierFlag::CONTROL_L</autogen>
                </item>
                <item>
                  <name>Change Command_L+F to Control+F</name>
                  <sysctl>remap.app_vm_commandLF</sysctl>
                  <only>VIRTUALMACHINE</only>
                  <autogen>--KeyToKey-- KeyCode::F, ModifierFlag::COMMAND_L, KeyCode::F, ModifierFlag::CONTROL_L</autogen>
                </item>
                <item>
                  <name>Change Command_L+P to Control+P</name>
                  <sysctl>remap.app_vm_commandLP</sysctl>
                  <only>VIRTUALMACHINE</only>
                  <autogen>--KeyToKey-- KeyCode::P, ModifierFlag::COMMAND_L, KeyCode::P, ModifierFlag::CONTROL_L</autogen>
                </item>
                <item>
                  <name>Change Command_L+V to Control+V</name>
                  <sysctl>remap.app_vm_commandLV</sysctl>
                  <only>VIRTUALMACHINE</only>
                  <autogen>--KeyToKey-- KeyCode::V, ModifierFlag::COMMAND_L, KeyCode::V, ModifierFlag::CONTROL_L</autogen>
                </item>
                <item>
                  <name>Change Command_L+X to Control+X</name>
                  <sysctl>remap.app_vm_commandLX</sysctl>
                  <appendix>(Leave it unchecked for using left Meta+X in Emacs on Fusion)</appendix>
                  <only>VIRTUALMACHINE</only>
                  <autogen>--KeyToKey-- KeyCode::X, ModifierFlag::COMMAND_L, KeyCode::X, ModifierFlag::CONTROL_L</autogen>
                </item>
                <item>
                  <name>Change Command_L+Z to Control+Z</name>
                  <sysctl>remap.app_vm_commandLZ</sysctl>
                  <only>VIRTUALMACHINE</only>
                  <autogen>--KeyToKey-- KeyCode::Z, ModifierFlag::COMMAND_L, KeyCode::Z, ModifierFlag::CONTROL_L</autogen>
                </item>
              </list>
            </item>
            <item>
              <name>Change Command_R Keys</name>
              <appendix>(To support Emacs on Fusion. This allows controlling individual key translations)</appendix>
              <list>
                <item>
                  <name>Change Command_R to Option_R</name>
                  <appendix>(This allows controlling individual key translations)</appendix>
                  <sysctl>remap.app_vm_commandR2optionR</sysctl>
                  <only>VIRTUALMACHINE</only>
                  <autogen>--KeyToKey-- KeyCode::COMMAND_R, KeyCode::OPTION_R</autogen>
                </item>
                <item>
                  <name>Change Command_R+A to Control+A</name>
                  <sysctl>remap.app_vm_commandRA</sysctl>
                  <only>VIRTUALMACHINE</only>
                  <autogen>--KeyToKey-- KeyCode::A, ModifierFlag::COMMAND_R, KeyCode::A, ModifierFlag::CONTROL_L</autogen>
                </item>
                <item>
                  <name>Change Command_R+C to Control+C</name>
                  <sysctl>remap.app_vm_commandRC</sysctl>
                  <only>VIRTUALMACHINE</only>
                  <autogen>--KeyToKey-- KeyCode::C, ModifierFlag::COMMAND_R, KeyCode::C, ModifierFlag::CONTROL_L</autogen>
                </item>
                <item>
                  <name>Change Command_R+F to Control+F</name>
                  <sysctl>remap.app_vm_commandRF</sysctl>
                  <only>VIRTUALMACHINE</only>
                  <autogen>--KeyToKey-- KeyCode::F, ModifierFlag::COMMAND_R, KeyCode::F, ModifierFlag::CONTROL_L</autogen>
                </item>
                <item>
                  <name>Change Command_R+P to Control+P</name>
                  <sysctl>remap.app_vm_commandRP</sysctl>
                  <only>VIRTUALMACHINE</only>
                  <autogen>--KeyToKey-- KeyCode::P, ModifierFlag::COMMAND_R, KeyCode::P, ModifierFlag::CONTROL_L</autogen>
                </item>
                <item>
                  <name>Change Command_R+V to Control+V</name>
                  <sysctl>remap.app_vm_commandRV</sysctl>
                  <only>VIRTUALMACHINE</only>
                  <autogen>--KeyToKey-- KeyCode::V, ModifierFlag::COMMAND_R, KeyCode::V, ModifierFlag::CONTROL_L</autogen>
                </item>
                <item>
                  <name>Change Command_R+X to Control+X</name>
                  <appendix>(Leave it unchecked for using right Meta+X in Emacs on Fusion)</appendix>
                  <sysctl>remap.app_vm_commandRX</sysctl>
                  <only>VIRTUALMACHINE</only>
                  <autogen>--KeyToKey-- KeyCode::X, ModifierFlag::COMMAND_R, KeyCode::X, ModifierFlag::CONTROL_L</autogen>
                </item>
                <item>
                  <name>Change Command_R+Z to Control+Z </name>
                  <sysctl>remap.app_vm_commandRZ</sysctl>
                  <only>VIRTUALMACHINE</only>
                  <autogen>--KeyToKey-- KeyCode::Z, ModifierFlag::COMMAND_R, KeyCode::Z, ModifierFlag::CONTROL_L</autogen>
                </item>
              </list>
            </item>
          </list>
        </item>
        <item>
          <name>Enable at only Finder</name>
          <list>
            <item>
              <name>Windows Explorer Navigation for Finder</name>
              <list>
                <item>
                  <name>Use Command+R as Rename</name>
                  <appendix>(Change Command+R to Return)</appendix>
                  <sysctl>remap.app_finder_command_R_to_return</sysctl>
                  <only>FINDER</only>
                  <autogen>--KeyToKey-- KeyCode::R, VK_COMMAND, KeyCode::RETURN</autogen>
                </item>
                <item>
                  <name>Use F2 to Rename (Use Tab to complete Rename)</name>
                  <appendix>(Change F2 to Return)</appendix>
                  <sysctl>remap.app_finder_f2_to_return</sysctl>
                  <only>FINDER</only>
                  <autogen>--KeyToKey-- KeyCode::F2, KeyCode::RETURN</autogen>
                </item>
                <item>
                  <name>Use Forward Delete as Delete Files</name>
                  <appendix>(Change Forward Delete to Command_L+Delete)</appendix>
                  <sysctl>remap.app_finder_forwarddelete2commandLdelete</sysctl>
                  <only>FINDER</only>
                  <autogen>--KeyToKey-- FROMKEYCODE_FORWARD_DELETE, KeyCode::DELETE, ModifierFlag::COMMAND_L</autogen>
                </item>
                <item>
                  <name>Return Key Opens a file</name>
                  <appendix>(use F2 to rename but caution not to use Return when done typing name or file opens)</appendix>
                  <only>FINDER</only>
                  <sysctl>remap.KPReturn_to_Ctrl_O</sysctl>
                  <autogen>--KeyToKey-- KeyCode::RETURN, KeyCode::O, ModifierFlag::COMMAND_L</autogen>
                </item>
                <item>
                  <name>Use Return as Open</name>
                  <appendix>(+ Use FN+Return as Rename)</appendix>
                  <appendix>(Change Return to Command+O)</appendix>
                  <appendix>(Change FN+Return to Return)</appendix>
                  <sysctl>remap.app_finder_return2commandO</sysctl>
                  <only>FINDER</only>
                  <autogen>--KeyToKey-- KeyCode::RETURN, ModifierFlag::FN, KeyCode::RETURN</autogen>
                  <autogen>--KeyToKey-- KeyCode::RETURN, KeyCode::O, ModifierFlag::COMMAND_L</autogen>
                </item>
                <item>
                  <name>Use Enter as Open</name>
                  <appendix>(Change Enter to Command+O)</appendix>
                  <sysctl>remap.app_finder_enter2commandO</sysctl>
                  <only>FINDER</only>
                  <autogen>--KeyToKey-- KeyCode::ENTER, KeyCode::O, ModifierFlag::COMMAND_L</autogen>
                </item>
                <item>
                  <name>Use Quote (') to go UP a directory (' to Ctrl+Up)</name>
                  <only>FINDER</only>
                  <sysctl>remap.Quote_to_Ctrl_UpArrow</sysctl>
                  <autogen>--KeyToKey-- KeyCode::QUOTE, KeyCode::CURSOR_UP, ModifierFlag::COMMAND_L</autogen>
                </item>
                <item>
                  <name>Use Semicolon to go Back in history (; to Ctrl+[)</name>
                  <only>FINDER</only>
                  <sysctl>remap.Semicolon_to_Ctrl_LeftBrckt</sysctl>
                  <autogen>--KeyToKey-- KeyCode::SEMICOLON, KeyCode::BRACKET_LEFT, ModifierFlag::COMMAND_L</autogen>
                </item>
                <item>
                  <name>Use { to select next file (i.e. up arrow key) ({ to Up-Arrow)</name>
                  <only>FINDER</only>
                  <sysctl>remap.CurlyLBracket_to_UpArrow</sysctl>
                  <autogen>--KeyToKey-- KeyCode::BRACKET_LEFT, VK_SHIFT, KeyCode::CURSOR_UP</autogen>
                </item>
                <item>
                  <name>Use } to select previous file (i.e. down arrow key) (} to Down-Arrow)</name>
                  <only>FINDER</only>
                  <sysctl>remap.CurlyRBracket_to_DArrow</sysctl>
                  <autogen>--KeyToKey-- KeyCode::BRACKET_RIGHT, VK_SHIFT, KeyCode::CURSOR_DOWN</autogen>
                </item>
                <item>
                  <name>Use [ to collapse folder (i.e. left key) ([ to Left-Arrow)</name>
                  <only>FINDER</only>
                  <sysctl>remap.LBracket_to_LArrow</sysctl>
                  <autogen>--KeyToKey-- KeyCode::BRACKET_LEFT, KeyCode::CURSOR_LEFT</autogen>
                </item>
                <item>
                  <name>Use ] to expand folder (i.e. left key) (] to Left-Arrow)</name>
                  <only>FINDER</only>
                  <sysctl>remap.RBracket_to_RArrow</sysctl>
                  <autogen>--KeyToKey-- KeyCode::BRACKET_RIGHT, KeyCode::CURSOR_RIGHT</autogen>
                </item>
              </list>
            </item>
          </list>
        </item>
        <item>
          <name>Enable at only Terminal</name>
          <list>
            <item>
              <name>Change Command_L to Option_L</name>
              <sysctl>remap.app_term_commandL2optionL</sysctl>
              <only>TERMINAL</only>
              <autogen>--KeyToKey-- KeyCode::COMMAND_L, KeyCode::OPTION_L</autogen>
            </item>
            <item>
              <name>Change Command_L to Option_L</name>
              <appendix>(Pass-Through Tab and Backquote)</appendix>
              <sysctl>remap.app_term_commandL2optionL_except_tab</sysctl>
              <only>TERMINAL</only>
              <autogen>--KeyToKey-- KeyCode::TAB, ModifierFlag::OPTION_L, KeyCode::TAB, ModifierFlag::COMMAND_L</autogen>
              <autogen>--KeyToKey-- KeyCode::BACKQUOTE, ModifierFlag::OPTION_L, KeyCode::BACKQUOTE, ModifierFlag::COMMAND_L</autogen>
              <autogen>--KeyToKey-- KeyCode::COMMAND_L, KeyCode::OPTION_L</autogen>
            </item>
            <item>
              <name>Change Delete Key</name>
              <list>
                <item>
                  <name>Delete to Control_L+H</name>
                  <sysctl>remap.app_term_delete2controlLh</sysctl>
                  <only>TERMINAL</only>
                  <autogen>--KeyToKey-- KeyCode::DELETE, KeyCode::H, ModifierFlag::CONTROL_L</autogen>
                </item>
                <item>
                  <name>Control+Delete to Control_L+H</name>
                  <sysctl>remap.app_term_controldelete2controlLh</sysctl>
                  <only>TERMINAL</only>
                  <autogen>--KeyToKey-- KeyCode::DELETE, VK_CONTROL, KeyCode::H, ModifierFlag::CONTROL_L</autogen>
                </item>
                <item>
                  <name>Option+Delete to Control_L+H</name>
                  <sysctl>remap.app_term_optiondelete2controlLh</sysctl>
                  <only>TERMINAL</only>
                  <autogen>--KeyToKey-- KeyCode::DELETE, VK_OPTION, KeyCode::H, ModifierFlag::CONTROL_L</autogen>
                </item>
                <item>
                  <name>Shift+Delete to Control_L+H</name>
                  <sysctl>remap.app_term_shiftdelete2controlLh</sysctl>
                  <only>TERMINAL</only>
                  <autogen>--KeyToKey-- KeyCode::DELETE, VK_SHIFT, KeyCode::H, ModifierFlag::CONTROL_L</autogen>
                </item>
                <item>
                  <name>Control+Delete to Delete</name>
                  <sysctl>remap.app_term_controldelete2delete</sysctl>
                  <only>TERMINAL</only>
                  <autogen>--KeyToKey-- KeyCode::DELETE, VK_CONTROL, KeyCode::DELETE</autogen>
                </item>
                <item>
                  <name>Option+Delete to Delete</name>
                  <sysctl>remap.app_term_optiondelete2delete</sysctl>
                  <only>TERMINAL</only>
                  <autogen>--KeyToKey-- KeyCode::DELETE, VK_OPTION, KeyCode::DELETE</autogen>
                </item>
                <item>
                  <name>Shift+Delete to Delete</name>
                  <sysctl>remap.app_term_shiftdelete2delete</sysctl>
                  <only>TERMINAL</only>
                  <autogen>--KeyToKey-- KeyCode::DELETE, VK_SHIFT, KeyCode::DELETE</autogen>
                </item>
              </list>
            </item>
            <item>
              <name>Change Option_L to Command_L</name>
              <sysctl>remap.app_term_optionL2commandL</sysctl>
              <only>TERMINAL</only>
              <autogen>--KeyToKey-- KeyCode::OPTION_L, KeyCode::COMMAND_L</autogen>
            </item>
            <item>
              <name>Change Option_R to Control_R</name>
              <sysctl>remap.app_term_optionR2controlR</sysctl>
              <only>TERMINAL</only>
              <autogen>--KeyToKey-- KeyCode::OPTION_R, KeyCode::CONTROL_R</autogen>
            </item>
            <item>
              <name>Change Slash(/) Key</name>
              <list>
                <item>
                  <name>Control+Shift+Slash(/) to Delete</name>
                  <sysctl>remap.app_term_controlshiftslash2delete</sysctl>
                  <only>TERMINAL</only>
                  <autogen>--KeyToKey-- KeyCode::SLASH, VK_CONTROL | VK_SHIFT, KeyCode::DELETE</autogen>
                </item>
              </list>
            </item>
            <item>
              <name>Change Functional Keys to F1...F12</name>
              <appendix>(For keyboards of F10 == Volume Mute)</appendix>
              <sysctl>remap.app_term_functional2function</sysctl>
              <only>TERMINAL</only>
              <autogen>--ConsumerToKey-- ConsumerKeyCode::BRIGHTNESS_DOWN, KeyCode::F1</autogen>
              <autogen>--ConsumerToKey-- ConsumerKeyCode::BRIGHTNESS_UP, KeyCode::F2</autogen>
              <autogen>--KeyToKey-- KeyCode::BRIGHTNESS_DOWN, KeyCode::F1</autogen>
              <autogen>--KeyToKey-- KeyCode::BRIGHTNESS_UP, KeyCode::F2</autogen>
              <autogen>--KeyToKey-- KeyCode::EXPOSE_ALL, KeyCode::F3</autogen>
              <autogen>--KeyToKey-- KeyCode::DASHBOARD, KeyCode::F4</autogen>
              <autogen>--ConsumerToKey-- ConsumerKeyCode::MUSIC_PREV, KeyCode::F7</autogen>
              <autogen>--ConsumerToKey-- ConsumerKeyCode::MUSIC_PLAY, KeyCode::F8</autogen>
              <autogen>--ConsumerToKey-- ConsumerKeyCode::MUSIC_NEXT, KeyCode::F9</autogen>
              <autogen>--ConsumerToKey-- ConsumerKeyCode::VOLUME_MUTE, KeyCode::F10</autogen>
              <autogen>--ConsumerToKey-- ConsumerKeyCode::VOLUME_DOWN, KeyCode::F11</autogen>
              <autogen>--ConsumerToKey-- ConsumerKeyCode::VOLUME_UP, KeyCode::F12</autogen>
            </item>
            <item>
              <name>Change Option+y to F18</name>
              <only>TERMINAL</only>
              <sysctl>remap.app_term_optionY2f18</sysctl>
              <autogen>--KeyToKey-- KeyCode::Y, VK_OPTION, KeyCode::F18</autogen>
            </item>
          </list>
        </item>
        <item>
          <name>Enable at only Adobe Softwares</name>
          <list>
            <item>
              <name>Change Command+Tab to Control_L+Tab</name>
              <sysctl>remap.app_adobe_commandTab2controlLTab</sysctl>
              <only>ADOBE, PHOTOSHOP, ILLUSTRATOR</only>
              <autogen>--KeyToKey-- KeyCode::TAB, VK_COMMAND, KeyCode::TAB, ModifierFlag::CONTROL_L</autogen>
            </item>
          </list>
        </item>
        <item>
          <name>Enable at only Firefox/Thunderbird</name>
          <list>
            <item>
              <name>Fix Home/End</name>
              <appendix>(Home/End move to beg/end of line, Ctl/Cmd+Home/End move to beg/end of page)</appendix>
              <sysctl>remap.app_firefox_fix_home_end</sysctl>
              <only>FIREFOX, THUNDERBIRD</only>
              <autogen>--KeyToKey-- FROMKEYCODE_HOME, VK_COMMAND, KeyCode::CURSOR_UP,   ModifierFlag::COMMAND_L</autogen>
              <autogen>--KeyToKey-- FROMKEYCODE_HOME, VK_CONTROL, KeyCode::CURSOR_UP,   ModifierFlag::COMMAND_L</autogen>
              <autogen>--KeyToKey-- FROMKEYCODE_END,  VK_COMMAND, KeyCode::CURSOR_DOWN, ModifierFlag::COMMAND_L</autogen>
              <autogen>--KeyToKey-- FROMKEYCODE_END,  VK_CONTROL, KeyCode::CURSOR_DOWN, ModifierFlag::COMMAND_L</autogen>

              <autogen>--KeyToKey-- FROMKEYCODE_HOME, KeyCode::CURSOR_LEFT, ModifierFlag::COMMAND_L</autogen>
              <autogen>--KeyToKey-- FROMKEYCODE_END, KeyCode::CURSOR_RIGHT, ModifierFlag::COMMAND_L</autogen>
            </item>
          </list>
        </item>
        <item>
          <name>Enable at only Excel</name>
          <list>
            <item>
              <name>Change F2 to Ctrl+U</name>
              <sysctl>remap.app_excel_f2_to_ctrlu</sysctl>
              <only>EXCEL</only>
              <autogen>--KeyToKey-- KeyCode::F2, KeyCode::U, ModifierFlag::CONTROL_L</autogen>
            </item>
          </list>
        </item>
        <item>
          <name>Enable at only Entourage</name>
          <list>
            <item>
              <name>Change PageUp/PageDown to Option+Up/Down</name>
              <sysctl>remap.app_entourage_pageupdown_to_optionupdown</sysctl>
              <only>ENTOURAGE</only>
              <autogen>--KeyToKey-- FROMKEYCODE_PAGEUP, KeyCode::CURSOR_UP, ModifierFlag::OPTION_L</autogen>
              <autogen>--KeyToKey-- FROMKEYCODE_PAGEDOWN, KeyCode::CURSOR_DOWN, ModifierFlag::OPTION_L</autogen>
            </item>
          </list>
        </item>
        <item>
          <name>Enable at only MacSOUP</name>
          <list>
            <item>
              <name>Change Option_R to Enter</name>
              <sysctl>remap.app_macsoup_optionR2enter</sysctl>
              <only>MACSOUP</only>
              <autogen>--KeyToKey-- KeyCode::OPTION_R, KeyCode::ENTER</autogen>
            </item>
          </list>
        </item>
        <item>
          <name>Enable at only Vienna</name>
          <list>
            <item>
              <name>Change Option_R to Enter</name>
              <sysctl>remap.app_vienna_optionR2enter</sysctl>
              <only>VIENNA</only>
              <autogen>--KeyToKey-- KeyCode::OPTION_R, KeyCode::ENTER</autogen>
            </item>
          </list>
        </item>
        <item>
          <name>Enable at only Gruml</name>
          <list>
            <item>
              <name>Change Option_R to Return</name>
              <sysctl>remap.app_gruml_optionR2return</sysctl>
              <only>GRUML</only>
              <autogen>--KeyToKey-- KeyCode::OPTION_R, KeyCode::RETURN</autogen>
            </item>
          </list>
        </item>
        <item>
          <name>Enable at only Remote Desktop Connection Client</name>
          <list>
            <item>
              <name>Command+Tab to Option+Tab</name>
              <appendix>(only in RDC)</appendix>
              <sysctl>remap.app_rdc_commandTab2optionTab</sysctl>
              <only>REMOTEDESKTOPCONNECTION</only>
              <autogen>--KeyToKey-- KeyCode::TAB, VK_COMMAND, KeyCode::TAB, ModifierFlag::OPTION_L</autogen>
            </item>
            <item>
              <name>Command+XCVSZWF to Ctrl+XCVSZWF</name>
              <appendix>(only in RDC)</appendix>
              <sysctl>remap.app_rdc_commandXCVSZWF2controlXCVSZWF</sysctl>
              <only>REMOTEDESKTOPCONNECTION</only>
              <autogen>--KeyToKey-- KeyCode::X, VK_COMMAND, KeyCode::X, ModifierFlag::CONTROL_L</autogen>
              <autogen>--KeyToKey-- KeyCode::C, VK_COMMAND, KeyCode::C, ModifierFlag::CONTROL_L</autogen>
              <autogen>--KeyToKey-- KeyCode::V, VK_COMMAND, KeyCode::V, ModifierFlag::CONTROL_L</autogen>
              <autogen>--KeyToKey-- KeyCode::S, VK_COMMAND, KeyCode::S, ModifierFlag::CONTROL_L</autogen>
              <autogen>--KeyToKey-- KeyCode::Z, VK_COMMAND, KeyCode::Z, ModifierFlag::CONTROL_L</autogen>
              <autogen>--KeyToKey-- KeyCode::Y, VK_COMMAND, KeyCode::Y, ModifierFlag::CONTROL_L</autogen>
              <autogen>--KeyToKey-- KeyCode::W, VK_COMMAND, KeyCode::W, ModifierFlag::CONTROL_L</autogen>
              <autogen>--KeyToKey-- KeyCode::F, VK_COMMAND, KeyCode::F, ModifierFlag::CONTROL_L</autogen>
            </item>
            <item>
              <name>Command+SPACE to Ctrl+SPACE</name>
              <appendix>(only in RDC)</appendix>
              <sysctl>remap.app_rdc_commandSpace2controlSpace</sysctl>
              <only>REMOTEDESKTOPCONNECTION</only>
              <autogen>--KeyToKey-- KeyCode::SPACE, VK_COMMAND, KeyCode::SPACE, ModifierFlag::CONTROL_L</autogen>
            </item>
          </list>
        </item>
      </list>
    </item>

    <item>
      <name>Change Keyboard Layout</name>
      <list>
        <item>
          <name>Use Colemak Keyboard Layout</name>
          <sysctl>remap.qwerty2colemak</sysctl>
          <autogen>--KeyToKey-- KeyCode::E, KeyCode::F</autogen>
          <autogen>--KeyToKey-- KeyCode::R, KeyCode::P</autogen>
          <autogen>--KeyToKey-- KeyCode::T, KeyCode::G</autogen>
          <autogen>--KeyToKey-- KeyCode::Y, KeyCode::J</autogen>
          <autogen>--KeyToKey-- KeyCode::U, KeyCode::L</autogen>
          <autogen>--KeyToKey-- KeyCode::I, KeyCode::U</autogen>
          <autogen>--KeyToKey-- KeyCode::O, KeyCode::Y</autogen>
          <autogen>--KeyToKey-- KeyCode::P, KeyCode::SEMICOLON</autogen>
          <autogen>--KeyToKey-- KeyCode::S, KeyCode::R</autogen>
          <autogen>--KeyToKey-- KeyCode::D, KeyCode::S</autogen>
          <autogen>--KeyToKey-- KeyCode::F, KeyCode::T</autogen>
          <autogen>--KeyToKey-- KeyCode::G, KeyCode::D</autogen>
          <autogen>--KeyToKey-- KeyCode::J, KeyCode::N</autogen>
          <autogen>--KeyToKey-- KeyCode::K, KeyCode::E</autogen>
          <autogen>--KeyToKey-- KeyCode::L, KeyCode::I</autogen>
          <autogen>--KeyToKey-- KeyCode::SEMICOLON, KeyCode::O</autogen>
          <autogen>--KeyToKey-- KeyCode::N, KeyCode::K</autogen>
        </item>
        <item>
          <name>Use QWERF Keyboard Layout</name>
          <sysctl>remap.qwerty2qwerf</sysctl>
          <autogen>--KeyToKey-- KeyCode::T, KeyCode::F</autogen>
          <autogen>--KeyToKey-- KeyCode::Y, KeyCode::J</autogen>
          <autogen>--KeyToKey-- KeyCode::U, KeyCode::Y</autogen>
          <autogen>--KeyToKey-- KeyCode::I, KeyCode::K</autogen>
          <autogen>--KeyToKey-- KeyCode::O, KeyCode::L</autogen>
          <autogen>--KeyToKey-- KeyCode::P, KeyCode::SEMICOLON</autogen>
          <autogen>--KeyToKey-- KeyCode::F, KeyCode::T</autogen>
          <autogen>--KeyToKey-- KeyCode::J, KeyCode::U</autogen>
          <autogen>--KeyToKey-- KeyCode::K, KeyCode::I</autogen>
          <autogen>--KeyToKey-- KeyCode::L, KeyCode::O</autogen>
          <autogen>--KeyToKey-- KeyCode::SEMICOLON, KeyCode::P</autogen>
        </item>
        <item>
          <name>Use US Keyboard Layout</name>
          <sysctl>remap.layout2us</sysctl>
          <autogen>--SetKeyboardType-- KeyboardType::MACBOOK</autogen>
        </item>
      </list>
    </item>

    <item>
      <name>For PC Users</name>
      <list>
        <item>
          <name>Change PC Application Key</name>
          <list>
            <item>
              <name>Application Key to CapsLock</name>
              <sysctl>remap.pc_application2capslock</sysctl>
              <autogen>--KeyToKey-- KeyCode::PC_APPLICATION, KeyCode::CAPSLOCK</autogen>
            </item>
            <item>
              <name>Application Key to Command_L</name>
              <sysctl>remap.pc_application2commandL</sysctl>
              <autogen>--KeyToKey-- KeyCode::PC_APPLICATION, KeyCode::COMMAND_L</autogen>
            </item>
            <item>
              <name>Application Key to Command_R</name>
              <sysctl>remap.pc_application2commandR_comamndLspace</sysctl>
              <appendix>(+ When you type Application only, send Command_L+Space)</appendix>
              <autogen>--KeyOverlaidModifier-- KeyCode::PC_APPLICATION, KeyCode::COMMAND_R, KeyCode::SPACE, ModifierFlag::COMMAND_L</autogen>
            </item>
            <item>
              <name>Application Key to Control_L</name>
              <sysctl>remap.pc_application2controlL</sysctl>
              <autogen>--KeyToKey-- KeyCode::PC_APPLICATION, KeyCode::CONTROL_L</autogen>
            </item>
            <item>
              <name>Application Key to FN</name>
              <sysctl>remap.pc_application2fn</sysctl>
              <autogen>--KeyToKey-- KeyCode::PC_APPLICATION, KeyCode::FN</autogen>
            </item>
            <item>
              <name>Application Key to FN</name>
              <appendix>(+ When you type Application only, send FN_Lock)</appendix>
              <sysctl>remap.pc_application2fn_fnlock</sysctl>
              <autogen>--KeyOverlaidModifier-- KeyCode::PC_APPLICATION, KeyCode::FN, KeyCode::VK_LOCK_FN</autogen>
            </item>
            <item>
              <name>Application Key to Option_L</name>
              <sysctl>remap.pc_application2optionL</sysctl>
              <autogen>--KeyToKey-- KeyCode::PC_APPLICATION, KeyCode::OPTION_L</autogen>
            </item>
            <item>
              <name>Application Key to Shift_L</name>
              <sysctl>remap.pc_application2shiftL</sysctl>
              <autogen>--KeyToKey-- KeyCode::PC_APPLICATION, KeyCode::SHIFT_L</autogen>
            </item>
            <item>
              <name>Application Key to Delete</name>
              <appendix>(+ Command+Application Key to CapsLock)</appendix>
              <sysctl>remap.pc_application2delete_capslock</sysctl>
              <autogen>--KeyToKey-- KeyCode::PC_APPLICATION, VK_COMMAND, KeyCode::CAPSLOCK</autogen>
              <autogen>--KeyToKey-- KeyCode::PC_APPLICATION, KeyCode::DELETE</autogen>
            </item>
            <item>
              <name>Application Key to Escape</name>
              <sysctl>remap.pc_application2escape</sysctl>
              <autogen>--KeyToKey-- KeyCode::PC_APPLICATION, KeyCode::ESCAPE</autogen>
            </item>
            <item>
              <name>Application Key to Expose All</name>
              <sysctl>remap.pc_application2exposeALL</sysctl>
              <autogen>--KeyToKey-- KeyCode::PC_APPLICATION, KeyCode::EXPOSE_ALL</autogen>
            </item>
            <item>
              <name>Application Key to F9</name>
              <sysctl>remap.pc_application2f9</sysctl>
              <autogen>--KeyToKey-- KeyCode::PC_APPLICATION, KeyCode::F9</autogen>
            </item>
            <item>
              <name>Application Key to F11</name>
              <sysctl>remap.pc_application2f11</sysctl>
              <autogen>--KeyToKey-- KeyCode::PC_APPLICATION, KeyCode::F11</autogen>
            </item>
            <item>
              <name>Application Key to Command_L+Space</name>
              <sysctl>remap.pc_application2commandLspace</sysctl>
              <autogen>--KeyToKey-- KeyCode::PC_APPLICATION, KeyCode::SPACE, ModifierFlag::COMMAND_L</autogen>
            </item>
            <item>
              <name>Application Key to Underscore(Shift_L+Minus)</name>
              <sysctl>remap.pc_application2underscore</sysctl>
              <autogen>--KeyToKey-- KeyCode::PC_APPLICATION, KeyCode::MINUS, ModifierFlag::SHIFT_L</autogen>
            </item>
          </list>
        </item>
        <item>
          <name>Change PC Insert Key</name>
          <list>
            <item>
              <name>Insert Key to Control_R</name>
              <sysctl>remap.pc_insert2controlR</sysctl>
              <autogen>--KeyToKey-- KeyCode::PC_INSERT, KeyCode::CONTROL_R</autogen>
            </item>
            <item>
              <name>Insert Key to Option_L+Insert</name>
              <sysctl>remap.pc_insert2optionLinsert</sysctl>
              <autogen>--KeyToKey-- KeyCode::PC_INSERT, KeyCode::PC_INSERT, ModifierFlag::OPTION_L</autogen>
            </item>
            <item>
              <name>Insert Key to PageDown</name>
              <sysctl>remap.pc_insert2pagedown</sysctl>
              <autogen>--KeyToKey-- KeyCode::PC_INSERT, KeyCode::PAGEDOWN</autogen>
            </item>
            <item>
              <name>Insert Key to Tab</name>
              <sysctl>remap.pc_insert2tab</sysctl>
              <autogen>--KeyToKey-- KeyCode::PC_INSERT, KeyCode::TAB</autogen>
            </item>
          </list>
        </item>
        <item>
          <name>Change PC NumLock Key</name>
          <list>
            <item>
              <name>NumLock Key to F11</name>
              <sysctl>remap.pc_numlock2f11</sysctl>
              <autogen>--KeyToKey-- KeyCode::PC_KEYPAD_NUMLOCK, KeyCode::F11</autogen>
            </item>
            <item>
              <name>Drop NumLock Key</name>
              <sysctl>remap.drop_numlock</sysctl>
              <autogen>--KeyToKey-- KeyCode::PC_KEYPAD_NUMLOCK, KeyCode::VK_NONE</autogen>
            </item>
            <item>
              <name>Drop NumLock Key (except in TeamViewer.app)</name>
              <not>TEAMVIEWER</not>
              <sysctl>remap.drop_numlock_ex_teamviewer</sysctl>
              <autogen>--KeyToKey-- KeyCode::PC_KEYPAD_NUMLOCK, KeyCode::VK_NONE</autogen>
            </item>
          </list>
        </item>
        <item>
          <name>Change PC Pause/Break Key</name>
          <list>
            <item>
              <name>Pause/Break Key to Eject</name>
              <sysctl>remap.pc_pause2eject</sysctl>
              <autogen>--KeyToConsumer-- KeyCode::PC_PAUSE, ConsumerKeyCode::EJECT</autogen>
            </item>
            <item>
              <name>Pause/Break Key to Power</name>
              <sysctl>remap.pc_pause2power</sysctl>
              <autogen>--KeyToConsumer-- KeyCode::PC_PAUSE, ConsumerKeyCode::POWER</autogen>
            </item>
          </list>
        </item>
        <item>
          <name>Change PC PrintScreen Key</name>
          <list>
            <item>
              <name>PrintScreen Key to Eject</name>
              <sysctl>remap.pc_printscreen2eject</sysctl>
              <autogen>--KeyToConsumer-- KeyCode::PC_PRINTSCREEN, ConsumerKeyCode::EJECT</autogen>
            </item>
            <item>
              <name>PrintScreen Key to F12</name>
              <sysctl>remap.pc_printscreen2f12</sysctl>
              <autogen>--KeyToKey-- KeyCode::PC_PRINTSCREEN, KeyCode::F12</autogen>
            </item>
          </list>
        </item>
        <item>
          <name>Change PC ScrollLock Key</name>
          <list>
            <item>
              <name>ScrollLock Key to F13</name>
              <sysctl>remap.pc_scrolllock2f13</sysctl>
              <autogen>--KeyToKey-- KeyCode::PC_SCROLLLOCK, KeyCode::F13</autogen>
            </item>
          </list>
        </item>
        <item>
          <name>Use KeyPad as Arrow (PC Style NumLock)</name>
          <list>
            <item>
              <name>Enable KeyPad as Arrow</name>
              <appendix>(except virtual machine, RDC)</appendix>
              <sysctl>remap.keypadnumlock</sysctl>
              <not>VIRTUALMACHINE, REMOTEDESKTOPCONNECTION</not>
              <vk_config>true</vk_config>
              <autogen>--KeyToKey-- KeyCode::KEYPAD_0, KeyCode::VK_NONE</autogen>
              <autogen>--KeyToKey-- KeyCode::KEYPAD_5, KeyCode::VK_NONE</autogen>
              <autogen>--KeyToKey-- KeyCode::KEYPAD_COMMA, KeyCode::VK_NONE</autogen>
              <autogen>--KeyToKey-- KeyCode::KEYPAD_2, KeyCode::CURSOR_DOWN</autogen>
              <autogen>--KeyToKey-- KeyCode::KEYPAD_4, KeyCode::CURSOR_LEFT</autogen>
              <autogen>--KeyToKey-- KeyCode::KEYPAD_6, KeyCode::CURSOR_RIGHT</autogen>
              <autogen>--KeyToKey-- KeyCode::KEYPAD_8, KeyCode::CURSOR_UP</autogen>
              <autogen>--KeyToKey-- KeyCode::KEYPAD_1, KeyCode::END</autogen>
              <autogen>--KeyToKey-- KeyCode::KEYPAD_3, KeyCode::PAGEDOWN</autogen>
              <autogen>--KeyToKey-- KeyCode::KEYPAD_7, KeyCode::HOME</autogen>
              <autogen>--KeyToKey-- KeyCode::KEYPAD_9, KeyCode::PAGEUP</autogen>
              <autogen>--KeyToKey-- KeyCode::KEYPAD_DOT, KeyCode::FORWARD_DELETE</autogen>
            </item>
            <item>
              <name>Enable KeyPad as Arrow</name>
              <appendix>(With PC Style Home/End/PageUp/PageDown)</appendix>
              <appendix>(except virtual machine, RDC)</appendix>
              <sysctl>remap.keypadnumlock_pclikehomeend</sysctl>
              <not>VIRTUALMACHINE, REMOTEDESKTOPCONNECTION</not>
              <vk_config>true</vk_config>
              <autogen>--KeyToKey-- KeyCode::KEYPAD_0, KeyCode::VK_NONE</autogen>
              <autogen>--KeyToKey-- KeyCode::KEYPAD_5, KeyCode::VK_NONE</autogen>
              <autogen>--KeyToKey-- KeyCode::KEYPAD_COMMA, KeyCode::VK_NONE</autogen>
              <autogen>--KeyToKey-- KeyCode::KEYPAD_2, KeyCode::CURSOR_DOWN</autogen>
              <autogen>--KeyToKey-- KeyCode::KEYPAD_4, KeyCode::CURSOR_LEFT</autogen>
              <autogen>--KeyToKey-- KeyCode::KEYPAD_6, KeyCode::CURSOR_RIGHT</autogen>
              <autogen>--KeyToKey-- KeyCode::KEYPAD_8, KeyCode::CURSOR_UP</autogen>
              <autogen>--KeyToKey-- KeyCode::KEYPAD_1, KeyCode::CURSOR_RIGHT, ModifierFlag::COMMAND_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEYPAD_3, KeyCode::PAGEDOWN, ModifierFlag::OPTION_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEYPAD_7, KeyCode::CURSOR_LEFT, ModifierFlag::COMMAND_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEYPAD_9, KeyCode::PAGEUP, ModifierFlag::OPTION_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEYPAD_DOT, KeyCode::FORWARD_DELETE</autogen>
            </item>
            <item>
              <name>Use Clear Key to toggle "KeyPad as Arrow"</name>
              <appendix>(except virtual machine, RDC)</appendix>
              <sysctl>option.keypadnumlock_togglekey_clear</sysctl>
              <not>VIRTUALMACHINE, REMOTEDESKTOPCONNECTION</not>
              <autogen>--KeyToKey-- KeyCode::KEYPAD_CLEAR, KeyCode::VK_CONFIG_TOGGLE_remap_keypadnumlock</autogen>
            </item>
            <item>
              <name>Use Clear Key to toggle "KeyPad as Arrow (PC Style Home/End/PageUp/PageDown)"</name>
              <appendix>(except virtual machine, RDC)</appendix>
              <sysctl>option.keypadnumlock_pclikehomeend_togglekey_clear</sysctl>
              <not>VIRTUALMACHINE, REMOTEDESKTOPCONNECTION</not>
              <autogen>--KeyToKey-- KeyCode::KEYPAD_CLEAR, KeyCode::VK_CONFIG_TOGGLE_remap_keypadnumlock_pclikehomeend</autogen>
            </item>
          </list>
        </item>
        <item>
          <name>Use PC Style Home/End</name>
          <appendix>(behave like Control_L+A/E)</appendix>
          <sysctl>remap.pclikehomeend_emacs</sysctl>
          <not>VIRTUALMACHINE, REMOTEDESKTOPCONNECTION</not>
          <autogen>--KeyToKey-- FROMKEYCODE_HOME, VK_COMMAND, KeyCode::CURSOR_UP,    ModifierFlag::COMMAND_L</autogen>
          <autogen>--KeyToKey-- FROMKEYCODE_HOME, VK_CONTROL, KeyCode::CURSOR_UP,    ModifierFlag::COMMAND_L</autogen>
          <autogen>--KeyToKey-- FROMKEYCODE_END,  VK_COMMAND, KeyCode::CURSOR_DOWN,  ModifierFlag::COMMAND_L</autogen>
          <autogen>--KeyToKey-- FROMKEYCODE_END,  VK_CONTROL, KeyCode::CURSOR_DOWN,  ModifierFlag::COMMAND_L</autogen>
          <autogen>--KeyToKey-- FROMKEYCODE_HOME,             KeyCode::A, ModifierFlag::CONTROL_L</autogen>
          <autogen>--KeyToKey-- FROMKEYCODE_END,              KeyCode::E, ModifierFlag::CONTROL_L</autogen>
        </item>
        <item>
          <name>Use PC Style Home/End</name>
          <appendix>(behave like Command+Left/Right)</appendix>
          <sysctl>remap.pclikehomeend</sysctl>
          <block>
            <not>EMACS, TERMINAL, VIRTUALMACHINE, REMOTEDESKTOPCONNECTION, X11, ECLIPSE</not>
            <autogen>--KeyToKey-- FROMKEYCODE_HOME, VK_COMMAND, KeyCode::CURSOR_UP,    ModifierFlag::COMMAND_L</autogen>
            <autogen>--KeyToKey-- FROMKEYCODE_HOME, VK_CONTROL, KeyCode::CURSOR_UP,    ModifierFlag::COMMAND_L</autogen>
            <autogen>--KeyToKey-- FROMKEYCODE_END,  VK_COMMAND, KeyCode::CURSOR_DOWN,  ModifierFlag::COMMAND_L</autogen>
            <autogen>--KeyToKey-- FROMKEYCODE_END,  VK_CONTROL, KeyCode::CURSOR_DOWN,  ModifierFlag::COMMAND_L</autogen>
            <autogen>--KeyToKey-- FROMKEYCODE_HOME,             KeyCode::CURSOR_LEFT,  ModifierFlag::COMMAND_L</autogen>
            <autogen>--KeyToKey-- FROMKEYCODE_END,              KeyCode::CURSOR_RIGHT, ModifierFlag::COMMAND_L</autogen>
          </block>
          <block>
            <only>EMACS, TERMINAL, VIRTUALMACHINE, REMOTEDESKTOPCONNECTION, X11, ECLIPSE</only>
            <autogen>--KeyToKey-- FROMKEYCODE_HOME, KeyCode::A, ModifierFlag::CONTROL_L</autogen>
            <autogen>--KeyToKey-- FROMKEYCODE_END,  KeyCode::E, ModifierFlag::CONTROL_L</autogen>
          </block>
        </item>
        <item>
          <name>Use PC Style PageUp/PageDown</name>
          <appendix>(behave like Option+PageUp/PageDown)</appendix>
          <sysctl>remap.pclikepageupdown</sysctl>
          <not>VIRTUALMACHINE, REMOTEDESKTOPCONNECTION</not>
          <autogen>--KeyToKey-- FROMKEYCODE_PAGEUP, KeyCode::PAGEUP, ModifierFlag::OPTION_L</autogen>
          <autogen>--KeyToKey-- FROMKEYCODE_PAGEDOWN, KeyCode::PAGEDOWN, ModifierFlag::OPTION_L</autogen>
        </item>
        <item>
          <name>Use PC Style Copy/Paste</name>
          <appendix>(Control+C to Command_L+C)</appendix>
          <appendix>(Control+V to Command_L+V)</appendix>
          <appendix>(Control+X to Command_L+X)</appendix>
          <sysctl>remap.copy_paste_winstyle</sysctl>
          <autogen>--KeyToKey-- KeyCode::C, VK_CONTROL, KeyCode::C, ModifierFlag::COMMAND_L</autogen>
          <autogen>--KeyToKey-- KeyCode::V, VK_CONTROL, KeyCode::V, ModifierFlag::COMMAND_L</autogen>
          <autogen>--KeyToKey-- KeyCode::X, VK_CONTROL, KeyCode::X, ModifierFlag::COMMAND_L</autogen>
        </item>
        <item>
          <name>Use PC Style Copy/Paste</name>
          <appendix>(Swap Control+C and Command_L+C)</appendix>
          <appendix>(Control+V to Command_L+V)</appendix>
          <appendix>(Control+X to Command_L+X)</appendix>
          <sysctl>remap.copy_paste_winstyle2</sysctl>
          <autogen>--KeyToKey-- KeyCode::C, VK_CONTROL, KeyCode::C, ModifierFlag::COMMAND_L</autogen>
          <autogen>--KeyToKey-- KeyCode::V, VK_CONTROL, KeyCode::V, ModifierFlag::COMMAND_L</autogen>
          <autogen>--KeyToKey-- KeyCode::X, VK_CONTROL, KeyCode::X, ModifierFlag::COMMAND_L</autogen>
          <autogen>--KeyToKey-- KeyCode::C, ModifierFlag::COMMAND_L, KeyCode::C, ModifierFlag::CONTROL_L</autogen>
        </item>
      </list>
    </item>

    <item>
      <name>For Dvorak Users</name>
      <list>
        <item>
          <name>Dvorak's Control+PNBF to Up/Down/Left/Right</name>
          <appendix>(except Emacs, Terminal, Virtual, RDC, X11, Eclipse)</appendix>
          <sysctl>option.dvorak_emacsmode_controlPNBF</sysctl>
          <not>EMACS, TERMINAL, VIRTUALMACHINE, REMOTEDESKTOPCONNECTION, X11, ECLIPSE</not>
          <autogen>--KeyToKey-- KeyCode::R, VK_CONTROL, KeyCode::CURSOR_UP</autogen>
          <autogen>--KeyToKey-- KeyCode::Y, VK_CONTROL, KeyCode::CURSOR_RIGHT</autogen>
          <autogen>--KeyToKey-- KeyCode::L, VK_CONTROL, KeyCode::CURSOR_DOWN</autogen>
          <autogen>--KeyToKey-- KeyCode::N, VK_CONTROL, KeyCode::CURSOR_LEFT</autogen>
        </item>
        <item>
          <name>Dvorak's Control+H to Delete</name>
          <sysctl>remap.dvorak_controlJ</sysctl>
          <autogen>--KeyToKey-- KeyCode::J, ModifierFlag::CONTROL_L, KeyCode::DELETE</autogen>
        </item>
        <item>
          <name>Dvorak's Control+D to Forward Delete</name>
          <sysctl>remap.dvorak_controlH</sysctl>
          <autogen>--KeyToKey-- KeyCode::H, ModifierFlag::CONTROL_L, KeyCode::FORWARD_DELETE</autogen>
        </item>
        <item>
          <name>Dvorak's Control+W to Option+Delete</name>
          <appendix>(except Emacs, Terminal, X11, virtual machine, RDC, Eclipse)</appendix>
          <sysctl>option.dvorak_emacsmode_ex_controlW</sysctl>
          <not>EMACS, TERMINAL, VIRTUALMACHINE, REMOTEDESKTOPCONNECTION, X11, ECLIPSE</not>
          <autogen>--KeyToKey-- KeyCode::COMMA, VK_CONTROL, KeyCode::DELETE, ModifierFlag::OPTION_L</autogen>
        </item>

        <item>
          <name>Swap U and I (== Swap Qwerty::F and Qwerty::G)</name>
          <sysctl>remap.dvorak_u2i</sysctl>
          <!-- Dvorak:U == Qwerty:F, Dvorak:I == Qwerty:G -->
          <autogen>--KeyToKey-- KeyCode::F, KeyCode::G</autogen>
          <autogen>--KeyToKey-- KeyCode::G, KeyCode::F</autogen>
        </item>

        <!-- ============================================================ -->
        <!-- We must put "Use Dvorak Keyboard Layout" in the tail of Dvorak settings. -->
        <item>
          <name>Use Dvorak Keyboard Layout</name>
          <appendix>(QWERTY to Dvorak)</appendix>
          <sysctl>remap.qwerty2dvorak</sysctl>
          <!-- #include "include/dvorak.xml" -->
        </item>

        <item>
          <name>Use Dvorak Keyboard Layout</name>
          <appendix>(QWERTY to Dvorak, except in password dialogue boxes)</appendix>
          <sysctl>remap.qwerty2dvorak_ex_password</sysctl>
          <not>PASSWORD</not>
          <!-- #include "include/dvorak.xml" -->
        </item>

        <item>
          <name>Use Dvorak Keyboard Layout</name>
          <appendix>(QWERTY to Dvorak)</appendix>
          <appendix>(+ Swap U and I)</appendix>
          <sysctl>remap.qwerty2dvorak_swap_ui</sysctl>
          <autogen>--KeyToKey-- KeyCode::Q, KeyCode::QUOTE</autogen>
          <autogen>--KeyToKey-- KeyCode::W, KeyCode::COMMA</autogen>
          <autogen>--KeyToKey-- KeyCode::E, KeyCode::DOT</autogen>
          <autogen>--KeyToKey-- KeyCode::R, KeyCode::P</autogen>
          <autogen>--KeyToKey-- KeyCode::T, KeyCode::Y</autogen>
          <autogen>--KeyToKey-- KeyCode::Y, KeyCode::F</autogen>
          <autogen>--KeyToKey-- KeyCode::U, KeyCode::G</autogen>
          <autogen>--KeyToKey-- KeyCode::I, KeyCode::C</autogen>
          <autogen>--KeyToKey-- KeyCode::O, KeyCode::R</autogen>
          <autogen>--KeyToKey-- KeyCode::P, KeyCode::L</autogen>
          <autogen>--KeyToKey-- KeyCode::BRACKET_LEFT, KeyCode::SLASH</autogen>
          <autogen>--KeyToKey-- KeyCode::BRACKET_RIGHT, KeyCode::EQUAL</autogen>
          <autogen>--KeyToKey-- KeyCode::S, KeyCode::O</autogen>
          <autogen>--KeyToKey-- KeyCode::D, KeyCode::E</autogen>
          <autogen>--KeyToKey-- KeyCode::F, KeyCode::I</autogen>
          <autogen>--KeyToKey-- KeyCode::G, KeyCode::U</autogen>
          <autogen>--KeyToKey-- KeyCode::H, KeyCode::D</autogen>
          <autogen>--KeyToKey-- KeyCode::J, KeyCode::H</autogen>
          <autogen>--KeyToKey-- KeyCode::K, KeyCode::T</autogen>
          <autogen>--KeyToKey-- KeyCode::L, KeyCode::N</autogen>
          <autogen>--KeyToKey-- KeyCode::SEMICOLON, KeyCode::S</autogen>
          <autogen>--KeyToKey-- KeyCode::QUOTE, KeyCode::MINUS</autogen>
          <autogen>--KeyToKey-- KeyCode::Z, KeyCode::SEMICOLON</autogen>
          <autogen>--KeyToKey-- KeyCode::X, KeyCode::Q</autogen>
          <autogen>--KeyToKey-- KeyCode::C, KeyCode::J</autogen>
          <autogen>--KeyToKey-- KeyCode::V, KeyCode::K</autogen>
          <autogen>--KeyToKey-- KeyCode::B, KeyCode::X</autogen>
          <autogen>--KeyToKey-- KeyCode::N, KeyCode::B</autogen>
          <autogen>--KeyToKey-- KeyCode::COMMA, KeyCode::W</autogen>
          <autogen>--KeyToKey-- KeyCode::DOT, KeyCode::V</autogen>
          <autogen>--KeyToKey-- KeyCode::SLASH, KeyCode::Z</autogen>
          <autogen>--KeyToKey-- KeyCode::MINUS, KeyCode::BRACKET_LEFT</autogen>
          <autogen>--KeyToKey-- KeyCode::EQUAL, KeyCode::BRACKET_RIGHT</autogen>
        </item>
      </list>
    </item>

    <item>
      <name>For HHK (Happy Hacking Keyboard) Users</name>
      <list>
        <item>
          <name>Enable HHK compatible Arrow Key Mode</name>
          <sysctl>remap.hhkmode</sysctl>
          <autogen>--KeyToKey-- KeyCode::BRACKET_LEFT, ModifierFlag::FN, KeyCode::CURSOR_UP</autogen>
          <autogen>--KeyToKey-- KeyCode::SEMICOLON,    ModifierFlag::FN, KeyCode::CURSOR_LEFT</autogen>
          <autogen>--KeyToKey-- KeyCode::QUOTE,        ModifierFlag::FN, KeyCode::CURSOR_RIGHT</autogen>
          <autogen>--KeyToKey-- KeyCode::SLASH,        ModifierFlag::FN, KeyCode::CURSOR_DOWN</autogen>
          <autogen>--KeyToKey-- KeyCode::L,            ModifierFlag::FN, KeyCode::PAGEUP</autogen>
          <autogen>--KeyToKey-- KeyCode::DOT,          ModifierFlag::FN, KeyCode::PAGEDOWN</autogen>
          <autogen>--KeyToKey-- KeyCode::K,            ModifierFlag::FN, KeyCode::HOME</autogen>
          <autogen>--KeyToKey-- KeyCode::COMMA,        ModifierFlag::FN, KeyCode::END</autogen>
          <autogen>--KeyToKey-- KeyCode::KEY_1,        ModifierFlag::FN, KeyCode::F1</autogen>
          <autogen>--KeyToKey-- KeyCode::KEY_2,        ModifierFlag::FN, KeyCode::F2</autogen>
          <autogen>--KeyToKey-- KeyCode::KEY_3,        ModifierFlag::FN, KeyCode::F3</autogen>
          <autogen>--KeyToKey-- KeyCode::KEY_4,        ModifierFlag::FN, KeyCode::F4</autogen>
          <autogen>--KeyToKey-- KeyCode::KEY_5,        ModifierFlag::FN, KeyCode::F5</autogen>
          <autogen>--KeyToKey-- KeyCode::KEY_6,        ModifierFlag::FN, KeyCode::F6</autogen>
          <autogen>--KeyToKey-- KeyCode::KEY_7,        ModifierFlag::FN, KeyCode::F7</autogen>
          <autogen>--KeyToKey-- KeyCode::KEY_8,        ModifierFlag::FN, KeyCode::F8</autogen>
          <autogen>--KeyToKey-- KeyCode::KEY_9,        ModifierFlag::FN, KeyCode::F9</autogen>
          <autogen>--KeyToKey-- KeyCode::KEY_0,        ModifierFlag::FN, KeyCode::F10</autogen>
          <autogen>--KeyToKey-- KeyCode::MINUS,        ModifierFlag::FN, KeyCode::F11</autogen>
          <autogen>--KeyToKey-- KeyCode::EQUAL,        ModifierFlag::FN, KeyCode::F12</autogen>
        </item>
        <item>
          <name>Enable FN+hjkl at HHK to Left/Down/Up/Right</name>
          <sysctl>remap.hhkmode_vi_cursor</sysctl>
          <autogen>--KeyToKey-- KeyCode::KEYPAD_MULTIPLY, KeyCode::CURSOR_LEFT</autogen>
          <autogen>--KeyToKey-- KeyCode::KEYPAD_SLASH,    KeyCode::CURSOR_DOWN</autogen>
          <autogen>--KeyToKey-- KeyCode::HOME,            KeyCode::CURSOR_UP</autogen>
          <autogen>--KeyToKey-- KeyCode::PAGEUP,          KeyCode::CURSOR_RIGHT</autogen>
        </item>
      </list>
    </item>

    <item>
      <name>For IBM Model M Keyboard Users</name>
      <list>
        <item>
          <name>Change IBM Model M Keyboard</name>
          <appendix>(with PS2-to-USB adapters (Chesen Electronics Corp))</appendix>
          <appendix>Bottom row of Model M keyboard:</appendix>
          <appendix>   Original: Ctrl Alt [space bar] Alt Ctrl</appendix>
          <appendix>   Remapped: Ctrl Cmd [space bar] Cmd Alt</appendix>
          <sysctl>remap.modelMkeyboard</sysctl>
          <device_only>DeviceVendorID(0xa81),DeviceProductID(0x205)</device_only>
          <autogen>--KeyToKey-- KeyCode::OPTION_L, KeyCode::COMMAND_L</autogen>
          <autogen>--KeyToKey-- KeyCode::OPTION_R, KeyCode::COMMAND_R</autogen>
          <autogen>--KeyToKey-- KeyCode::CONTROL_R, KeyCode::OPTION_R</autogen>
        </item>
        <item>
          <name>Swap Start (aka Command) and Alt keys on Windows keyboard</name>
          <sysctl>remap.windows4mac</sysctl>
          <autogen>--KeyToKey-- KeyCode::OPTION_L, KeyCode::COMMAND_L</autogen>
          <autogen>--KeyToKey-- KeyCode::OPTION_R, KeyCode::COMMAND_R</autogen>
          <autogen>--KeyToKey-- KeyCode::COMMAND_L, KeyCode::OPTION_L</autogen>
          <autogen>--KeyToKey-- KeyCode::COMMAND_R, KeyCode::OPTION_R</autogen>
        </item>
      </list>
    </item>

    <item>
      <name>For Canadian</name>
      <list>
        <item>
          <name>Space to Option_L (when inputmode == canadian)</name>
          <sysctl>remap.canadian_space2optionL</sysctl>
          <inputmode_only>INPUTMODE_CANADIAN</inputmode_only>
          <autogen>--KeyToKey-- KeyCode::SPACE, KeyCode::OPTION_L</autogen>
        </item>
        <item>
          <name>Space to Option_L (when inputmode == canadian)</name>
          <appendix>(+ When you type Space only, send Space)</appendix>
          <sysctl>remap.canadian_space2optionL_space</sysctl>
          <inputmode_only>INPUTMODE_CANADIAN</inputmode_only>
          <autogen>--KeyOverlaidModifier-- KeyCode::SPACE, KeyCode::OPTION_L, KeyCode::SPACE</autogen>
        </item>
      </list>
    </item>
    <item>
      <name>For French</name>
      <list>
        <item>
          <name>Shift_L to Shift_L</name>
          <appendix>(+ When you type Shift_L only, send Backslash)</appendix>
          <sysctl>remap.french_shiftL2shiftL_backslash</sysctl>
          <autogen>--KeyOverlaidModifier-- KeyCode::SHIFT_L, KeyCode::SHIFT_L, KeyCode::DOT, ModifierFlag::OPTION_L | ModifierFlag::SHIFT_L</autogen>
        </item>
        <item>
          <name>Shift_R to Shift_R</name>
          <appendix>(+ When you type Shift_R only, send Backslash)</appendix>
          <sysctl>remap.french_shiftR2shiftR_backslash</sysctl>
          <autogen>--KeyOverlaidModifier-- KeyCode::SHIFT_R, KeyCode::SHIFT_R, KeyCode::DOT, ModifierFlag::OPTION_L | ModifierFlag::SHIFT_L</autogen>
        </item>
        <item>
          <name>Option+Shift+4 to Left Brace, Option+Shift+Minus to Right Brace</name>
          <appendix>Option+5 to Quote, Option+Right Paren to Minus</appendix>
          <sysctl>remap.french_swap_brackets_and_braces</sysctl>
          <autogen>--KeyToKey-- KeyCode::KEY_4,        VK_OPTION | VK_SHIFT | ModifierFlag::NONE, KeyCode::KEY_5, ModifierFlag::OPTION_L</autogen>
          <autogen>--KeyToKey-- KeyCode::FRENCH_MINUS, VK_OPTION | VK_SHIFT | ModifierFlag::NONE, KeyCode::FRENCH_RIGHT_PAREN, ModifierFlag::OPTION_L</autogen>

          <autogen>--KeyToKey-- KeyCode::KEY_5,              VK_OPTION | ModifierFlag::NONE, KeyCode::KEY_4, ModifierFlag::OPTION_L | ModifierFlag::SHIFT_L</autogen>
          <autogen>--KeyToKey-- KeyCode::FRENCH_RIGHT_PAREN, VK_OPTION | ModifierFlag::NONE, KeyCode::FRENCH_MINUS, ModifierFlag::OPTION_L | ModifierFlag::SHIFT_L</autogen>
        </item>
        <item>
          <name>Make MacBook AZERTY closer to the standard latin-9 mapping</name>
          <appendix>(For "French - Numerical" users)</appendix>
          <sysctl>remap.french_azerty_to_latin9</sysctl>
          <!-- - the key -/_ (where you put the brace), I would like to be =/+, that is, = on normal and + on SHIFT; -->
          <autogen>--KeyToKey-- KeyCode::FRENCH_MINUS, ModifierFlag::NONE, KeyCode::FRENCH_EQUAL</autogen>
          <autogen>--KeyToKey-- KeyCode::FRENCH_MINUS, VK_SHIFT | ModifierFlag::NONE, KeyCode::FRENCH_EQUAL, ModifierFlag::SHIFT_L</autogen>
          <!-- - the key 6, I would like to do -/6/|  (normal -, SHIFT 6, ALT+SHIFT |) -->
          <autogen>--KeyToKey-- KeyCode::KEY_6, ModifierFlag::NONE, KeyCode::FRENCH_MINUS</autogen>
          <autogen>--KeyToKey-- KeyCode::KEY_6, VK_OPTION | VK_SHIFT | ModifierFlag::NONE, KeyCode::L, ModifierFlag::OPTION_L | ModifierFlag::SHIFT_L</autogen>
          <!-- - the key =/+ I would like to be 則/! -->
          <autogen>--KeyToKey-- KeyCode::FRENCH_EQUAL, ModifierFlag::NONE, KeyCode::KEY_6</autogen>
          <autogen>--KeyToKey-- KeyCode::FRENCH_EQUAL, VK_SHIFT | ModifierFlag::NONE, KeyCode::KEY_8</autogen>
          <!-- - ALT+SHIFT+2 gives ~ -->
          <autogen>--KeyToKey-- KeyCode::KEY_2, VK_OPTION | VK_SHIFT | ModifierFlag::NONE, KeyCode::N, ModifierFlag::OPTION_L</autogen>
          <!-- - ALT+SHIFT+3 gives # -->
          <autogen>--KeyToKey-- KeyCode::KEY_3, VK_OPTION | VK_SHIFT | ModifierFlag::NONE, KeyCode::BACKSLASH, ModifierFlag::OPTION_L | ModifierFlag::SHIFT_L</autogen>
        </item>
        <item>
          <name>Forgiving open brackets binding.</name>
          <appendix>Command+4 to Left Brace, Command+5 to Left Bracket</appendix>
          <sysctl>remap.french_brackets_hack</sysctl>
          <!-- command+4 to { -->
          <autogen>--KeyToKey-- KeyCode::KEY_4, VK_COMMAND | ModifierFlag::NONE, KeyCode::KEY_5, ModifierFlag::OPTION_L</autogen>
          <!-- command+5 to [ -->
          <autogen>--KeyToKey-- KeyCode::KEY_5, VK_COMMAND | ModifierFlag::NONE, KeyCode::KEY_5, ModifierFlag::OPTION_L | ModifierFlag::SHIFT_L</autogen>
        </item>
      </list>
    </item>
    <item>
      <name>For German</name>
      <list>
        <item>
          <name>Quote(卒) to Forward Delete</name>
          <sysctl>remap.german_quote2forwarddelete</sysctl>
          <autogen>--KeyToKey-- KeyCode::GERMAN_QUOTE, KeyCode::FORWARD_DELETE</autogen>
        </item>
        <item>
          <name>Swap Circumflex(^) and Less-Than(&lt;)</name>
          <appendix>(only in virtual machine)</appendix>
          <sysctl>remap.german_swap_circumflex_lessthan_vm</sysctl>
          <only>VIRTUALMACHINE</only>
          <autogen>--KeyToKey-- KeyCode::GERMAN_CIRCUMFLEX, KeyCode::GERMAN_LESS_THAN</autogen>
          <autogen>--KeyToKey-- KeyCode::GERMAN_LESS_THAN, KeyCode::GERMAN_CIRCUMFLEX</autogen>
        </item>
      </list>
    </item>
    <item>
      <name>For Italian</name>
      <list>
        <item>
          <name>Option+AEIUO to àèìùò on "Italian Input Source"</name>
          <sysctl>remap.italian_optionAEIUO_grave_italian</sysctl>
          <autogen>--KeyToKey-- KeyCode::A, VK_OPTION, KeyCode::KEY_0, ModifierFlag::OPTION_L, KeyCode::A</autogen>
          <autogen>--KeyToKey-- KeyCode::E, VK_OPTION, KeyCode::KEY_0, ModifierFlag::OPTION_L, KeyCode::E</autogen>
          <autogen>--KeyToKey-- KeyCode::I, VK_OPTION, KeyCode::KEY_0, ModifierFlag::OPTION_L, KeyCode::I</autogen>
          <autogen>--KeyToKey-- KeyCode::U, VK_OPTION, KeyCode::KEY_0, ModifierFlag::OPTION_L, KeyCode::U</autogen>
          <autogen>--KeyToKey-- KeyCode::O, VK_OPTION, KeyCode::KEY_0, ModifierFlag::OPTION_L, KeyCode::O</autogen>
        </item>
        <item>
          <name>Option+AEIUO to àèìùò on "U.S. Input Source"</name>
          <sysctl>remap.italian_optionAEIUO_grave_us</sysctl>
          <autogen>--KeyToKey-- KeyCode::A, VK_OPTION, KeyCode::BACKQUOTE, ModifierFlag::OPTION_L, KeyCode::A</autogen>
          <autogen>--KeyToKey-- KeyCode::E, VK_OPTION, KeyCode::BACKQUOTE, ModifierFlag::OPTION_L, KeyCode::E</autogen>
          <autogen>--KeyToKey-- KeyCode::I, VK_OPTION, KeyCode::BACKQUOTE, ModifierFlag::OPTION_L, KeyCode::I</autogen>
          <autogen>--KeyToKey-- KeyCode::U, VK_OPTION, KeyCode::BACKQUOTE, ModifierFlag::OPTION_L, KeyCode::U</autogen>
          <autogen>--KeyToKey-- KeyCode::O, VK_OPTION, KeyCode::BACKQUOTE, ModifierFlag::OPTION_L, KeyCode::O</autogen>
        </item>
        <item>
          <name>KeyPad Comma(,) to Dot(.) on "Italian Pro Input Source"</name>
          <sysctl>remap.italian_keypadcomma2dot</sysctl>
          <!-- ITALIAN_KEYPAD_COMMA is 0x41 (== KEYPAD_DOT) -->
          <autogen>--KeyToKey-- KeyCode::KEYPAD_DOT, KeyCode::DOT</autogen>
        </item>
      </list>
    </item>
    <item>
      <name>For Japanese</name>
      <list>
        <item>
          <name>Change PC Application Key</name>
          <list>
            <item>
              <name>Application Key to Control_L</name>
              <appendix>(+ When you type Application Key only, send CapsLock)</appendix>
              <sysctl>remap.jis_pc_application2controlL_capslock</sysctl>
              <autogen>--KeyOverlaidModifier-- KeyCode::PC_APPLICATION, KeyCode::CONTROL_L, KeyCode::CAPSLOCK</autogen>
            </item>
          </list>
        </item>
        <item>
          <name>Change Backquote(`) Key</name>
          <list>
            <item>
              <name>Backquote(`) to KANA/EISUU (toggle)</name>
              <sysctl>remap.jis_backquote_kana_eisuu</sysctl>
              <autogen>--KeyToKey-- KeyCode::BACKQUOTE, KeyCode::VK_JIS_TOGGLE_EISUU_KANA</autogen>
            </item>
          </list>
        </item>
        <item>
          <name>Change Command_L Key</name>
          <list>
            <item>
              <name>Command_L to EISUU</name>
              <sysctl>remap.jis_commandL2eisuu</sysctl>
              <autogen>--KeyToKey-- KeyCode::COMMAND_L, KeyCode::JIS_EISUU</autogen>
            </item>
            <item>
              <name>Command_L to Command_L</name>
              <appendix>(+ When you type Command_L only, send EISUU)</appendix>
              <sysctl>remap.jis_commandL2commandL_eisuu</sysctl>
              <autogen>--KeyOverlaidModifier-- KeyCode::COMMAND_L, KeyCode::COMMAND_L, KeyCode::JIS_EISUU</autogen>
            </item>
            <item>
              <name>Command_L to Command_L</name>
              <appendix>(+ When you type Command_L only, send EISUU)</appendix>
              <appendix>(+ When you type Any modifiers+Command_L only, send EISUU)</appendix>
              <sysctl>remap.jis_commandL2commandL_eisuu_ex</sysctl>
              <autogen>--KeyOverlaidModifier-- KeyCode::COMMAND_L, VK_MOD_ANY, KeyCode::COMMAND_L, KeyCode::JIS_EISUU</autogen>
            </item>
            <item>
              <name>Command_L to Command_L</name>
              <appendix>(+ When you type Command_L only, send EISUU)</appendix>
              <appendix>(+ When you type Command_R+Command_L only, toggle Complete Vi Mode)</appendix>
              <sysctl>remap.jis_commandL2commandL_vimode_eisuu</sysctl>
              <autogen>--KeyOverlaidModifier-- KeyCode::COMMAND_L, ModifierFlag::COMMAND_R, KeyCode::COMMAND_L, ModifierFlag::COMMAND_R, KeyCode::VK_CONFIG_TOGGLE_notsave_complete_vimode</autogen>
              <autogen>--KeyOverlaidModifier-- KeyCode::COMMAND_L, KeyCode::COMMAND_L, KeyCode::JIS_EISUU</autogen>
            </item>
            <item>
              <name>Command_L to Command_L (except Terminal)</name>
              <appendix>(+ When you type Command_L only, send EISUU)</appendix>
              <sysctl>remap.jis_commandL2commandL_eisuu_ex_term</sysctl>
              <not>TERMINAL</not>
              <autogen>--KeyOverlaidModifier-- KeyCode::COMMAND_L, KeyCode::COMMAND_L, KeyCode::JIS_EISUU</autogen>
            </item>
            <item>
              <name>Command_L to Command_L</name>
              <appendix>(+ When you type Command_L only, send KANA/EISUU (toggle))</appendix>
              <sysctl>remap.jis_commandL2commandL_toggle_kana_eisuu</sysctl>
              <autogen>--KeyOverlaidModifier-- KeyCode::COMMAND_L, KeyCode::COMMAND_L, KeyCode::VK_JIS_TOGGLE_EISUU_KANA</autogen>
            </item>
            <item>
              <name>Command_L to Control_L</name>
              <appendix>(+ When you type Command_L only, send EISUU)</appendix>
              <sysctl>remap.jis_commandL2controlL_eisuu</sysctl>
              <autogen>--KeyOverlaidModifier-- KeyCode::COMMAND_L, KeyCode::CONTROL_L, KeyCode::JIS_EISUU</autogen>
            </item>
            <item>
              <name>Command_L to Control_L</name>
              <appendix>(+ When you type Command_L only, send EISUU)</appendix>
              <appendix>(+ When you type Shift+Command_L only, send ESCAPE)</appendix>
              <sysctl>remap.jis_commandL2controlL_eisuu_escape</sysctl>
              <autogen>--KeyOverlaidModifier-- KeyCode::COMMAND_L, VK_SHIFT, KeyCode::CONTROL_L, ModifierFlag::SHIFT_L, KeyCode::ESCAPE</autogen>
              <autogen>--KeyOverlaidModifier-- KeyCode::COMMAND_L, KeyCode::CONTROL_L, KeyCode::JIS_EISUU</autogen>
            </item>
            <item>
              <name>Command_L to Control_L</name>
              <appendix>(+ When you type Command_L only, send EISUU)</appendix>
              <appendix>(+ When you type Command_R+Command_L only, toggle Complete Vi Mode)</appendix>
              <appendix>(+ When you type Shift+Command_L only, send ESCAPE)</appendix>
              <sysctl>remap.jis_commandL2controlL_eisuu_vimode_escape</sysctl>
              <autogen>--KeyOverlaidModifier-- KeyCode::COMMAND_L, VK_SHIFT, KeyCode::CONTROL_L, ModifierFlag::SHIFT_L, KeyCode::ESCAPE</autogen>
              <autogen>--KeyOverlaidModifier-- KeyCode::COMMAND_L, ModifierFlag::COMMAND_R, KeyCode::CONTROL_L, ModifierFlag::COMMAND_R, KeyCode::VK_CONFIG_TOGGLE_notsave_complete_vimode</autogen>
              <autogen>--KeyOverlaidModifier-- KeyCode::COMMAND_L, KeyCode::CONTROL_L, KeyCode::JIS_EISUU</autogen>
            </item>
            <item>
              <name>Command_L to Option_L</name>
              <appendix>(+ When you type Command_L only, send EISUU)</appendix>
              <sysctl>remap.jis_commandL2optionL_eisuu</sysctl>
              <autogen>--KeyOverlaidModifier-- KeyCode::COMMAND_L, KeyCode::OPTION_L, KeyCode::JIS_EISUU</autogen>
            </item>
            <item>
              <name>Command_L x2 to EISUU</name>
              <sysctl>remap.jis_commandL_x2_to_eisuu</sysctl>
              <autogen>--DoublePressModifier-- KeyCode::COMMAND_L, KeyCode::COMMAND_L, KeyCode::JIS_EISUU</autogen>
            </item>
            <item>
              <name>Command_L x2 to EISUU x2 (for Kotoeri Users)</name>
              <sysctl>remap.jis_commandL_x2_to_eisuu_x2</sysctl>
              <autogen>--DoublePressModifier-- KeyCode::COMMAND_L, KeyCode::COMMAND_L, KeyCode::JIS_EISUU, KeyCode::JIS_EISUU</autogen>
            </item>
            <item>
              <name>Use Command_L as KANA/EISUU (toggle)</name>
              <sysctl>remap.jis_unify_kana_eisuu_to_commandL</sysctl>
              <autogen>--KeyToKey-- KeyCode::COMMAND_L, KeyCode::VK_JIS_TOGGLE_EISUU_KANA</autogen>
            </item>
          </list>
        </item>
        <item>
          <name>Change Command_R Key</name>
          <list>
            <item>
              <name>Command_R to EISUU</name>
              <sysctl>remap.jis_commandR2eisuu</sysctl>
              <autogen>--KeyToKey-- KeyCode::COMMAND_R, KeyCode::JIS_EISUU</autogen>
            </item>
            <item>
              <name>Command_R to KANA</name>
              <sysctl>remap.jis_commandR2kana</sysctl>
              <autogen>--KeyToKey-- KeyCode::COMMAND_R, KeyCode::JIS_KANA</autogen>
            </item>
            <item>
              <name>Command_R to KANA</name>
              <appendix>(+ Any modifiers+Command_R to KANA)</appendix>
              <sysctl>remap.jis_commandR2kana_ex</sysctl>
              <autogen>--KeyToKey-- KeyCode::COMMAND_R, VK_MOD_ANY, KeyCode::JIS_KANA</autogen>
            </item>
            <item>
              <name>Command_R to Shift_L+KANA</name>
              <sysctl>remap.jis_commandR2shiftLkana</sysctl>
              <autogen>--KeyToKey-- KeyCode::COMMAND_R, KeyCode::JIS_KANA, ModifierFlag::SHIFT_L</autogen>
            </item>
            <item>
              <name>Command_R to Command_R</name>
              <appendix>(+ When you type Command_R only, send KANA)</appendix>
              <sysctl>remap.jis_commandR2commandR_kana</sysctl>
              <autogen>--KeyOverlaidModifier-- KeyCode::COMMAND_R, KeyCode::COMMAND_R, KeyCode::JIS_KANA</autogen>
            </item>
            <item>
              <name>Command_R to Command_R</name>
              <appendix>(+ When you type Command_R only, send KANA)</appendix>
              <appendix>(+ When you type Command_L+Command_R only, toggle Complete Vi Mode)</appendix>
              <sysctl>remap.jis_commandR2commandR_vimode_kana</sysctl>
              <autogen>--KeyOverlaidModifier-- KeyCode::COMMAND_R, ModifierFlag::COMMAND_L, KeyCode::COMMAND_R, KeyCode::COMMAND_L, KeyCode::VK_CONFIG_TOGGLE_notsave_complete_vimode</autogen>
              <autogen>--KeyOverlaidModifier-- KeyCode::COMMAND_R, KeyCode::COMMAND_R, KeyCode::JIS_KANA</autogen>
            </item>
            <item>
              <name>Command_R to Command_R</name>
              <appendix>(+ When you type Command_R only, send KANA/EISUU (toggle))</appendix>
              <sysctl>remap.jis_commandR2commandR_toggle_kana_eisuu</sysctl>
              <autogen>--KeyOverlaidModifier-- KeyCode::COMMAND_R, KeyCode::COMMAND_R, KeyCode::VK_JIS_TOGGLE_EISUU_KANA</autogen>
            </item>
            <item>
              <name>Command_R to Command_R</name>
              <appendix>(+ When you type Command_R only, send KANA)</appendix>
              <appendix>(+ When you type Shift+Command_R only, send Return)</appendix>
              <sysctl>remap.jis_commandR2commandR_kana_return</sysctl>
              <autogen>--KeyOverlaidModifier-- KeyCode::COMMAND_R, VK_SHIFT, KeyCode::COMMAND_R, ModifierFlag::SHIFT_L, KeyCode::RETURN</autogen>
              <autogen>--KeyOverlaidModifier-- KeyCode::COMMAND_R, KeyCode::COMMAND_R, KeyCode::JIS_KANA</autogen>
            </item>
            <item>
              <name>Command_R to Command_R</name>
              <appendix>(+ When you type Command_R only, send KANA)</appendix>
              <appendix>(+ When you type Control+Command_R only, toggle Complete Vi Mode)</appendix>
              <appendix>(+ When you type Shift+Command_R only, send Return)</appendix>
              <sysctl>remap.jis_commandR2commandR_kana_vimode_return</sysctl>
              <autogen>--KeyOverlaidModifier-- KeyCode::COMMAND_R, VK_SHIFT, KeyCode::COMMAND_R, ModifierFlag::SHIFT_L, KeyCode::RETURN</autogen>
              <autogen>--KeyOverlaidModifier-- KeyCode::COMMAND_R, VK_CONTROL, KeyCode::COMMAND_R, ModifierFlag::CONTROL_L, KeyCode::VK_CONFIG_TOGGLE_notsave_complete_vimode</autogen>
              <autogen>--KeyOverlaidModifier-- KeyCode::COMMAND_R, KeyCode::COMMAND_R, KeyCode::JIS_KANA</autogen>
            </item>
            <item>
              <name>Command_R to Control_L</name>
              <appendix>(+ When you type Command_R only, send KANA)</appendix>
              <sysctl>remap.jis_commandR2controlL</sysctl>
              <autogen>--KeyOverlaidModifier-- KeyCode::COMMAND_R, KeyCode::CONTROL_L, KeyCode::JIS_KANA</autogen>
            </item>
            <item>
              <name>Command_R x2 to KANA</name>
              <sysctl>remap.jis_commandR_x2_to_kana</sysctl>
              <autogen>--DoublePressModifier-- KeyCode::COMMAND_R, KeyCode::COMMAND_R, KeyCode::JIS_KANA</autogen>
            </item>
            <item>
              <name>Command_R x2 to KANA x2 (for Kotoeri Users)</name>
              <sysctl>remap.jis_commandR_x2_to_kana_x2</sysctl>
              <autogen>--DoublePressModifier-- KeyCode::COMMAND_R, KeyCode::COMMAND_R, KeyCode::JIS_KANA, KeyCode::JIS_KANA</autogen>
            </item>
            <item>
              <name>Use Command_R as KANA/EISUU (toggle)</name>
              <sysctl>remap.jis_unify_kana_eisuu_to_commandR</sysctl>
              <autogen>--KeyToKey-- KeyCode::COMMAND_R, KeyCode::VK_JIS_TOGGLE_EISUU_KANA</autogen>
            </item>
          </list>
        </item>
        <item>
          <name>Change Delete Key</name>
          <list>
            <item>
              <name>Delete to KANA</name>
              <sysctl>remap.jis_delete2kana</sysctl>
              <autogen>--KeyToKey-- KeyCode::DELETE, KeyCode::JIS_KANA</autogen>
            </item>
          </list>
        </item>
        <item>
          <name>Change Escape Key</name>
          <list>
            <item>
              <name>Escape to EISUU+Escape</name>
              <sysctl>remap.jis_escape2eisuuAndEscape</sysctl>
              <autogen>--KeyOverlaidModifier-- KeyCode::ESCAPE, KeyCode::JIS_EISUU, KeyCode::ESCAPE</autogen>
            </item>
          </list>
        </item>
        <item>
          <name>Change Option_L Key</name>
          <list>
            <item>
              <name>Option_L to Option_L</name>
              <appendix>(+ When you type Option_L only, send EISUU)</appendix>
              <sysctl>remap.jis_optionL2optionL_eisuu</sysctl>
              <autogen>--KeyOverlaidModifier-- KeyCode::OPTION_L, KeyCode::OPTION_L, KeyCode::JIS_EISUU</autogen>
            </item>
          </list>
        </item>
        <item>
          <name>Change Option_R Key</name>
          <list>
            <item>
              <name>Option_R to Option_R</name>
              <appendix>(+ When you type Option_R only, send KANA)</appendix>
              <sysctl>remap.jis_optionR2optionR_kana</sysctl>
              <autogen>--KeyOverlaidModifier-- KeyCode::OPTION_R, KeyCode::OPTION_R, KeyCode::JIS_KANA</autogen>
            </item>
            <item>
              <name>Option_R to EISUU</name>
              <sysctl>remap.jis_optionR2eisuu</sysctl>
              <autogen>--KeyToKey-- KeyCode::OPTION_R, KeyCode::JIS_EISUU</autogen>
            </item>
            <item>
              <name>Option_R to KANA</name>
              <sysctl>remap.jis_optionR2kana</sysctl>
              <autogen>--KeyToKey-- KeyCode::OPTION_R, KeyCode::JIS_KANA</autogen>
            </item>
            <item>
              <name>Use Option_R as KANA/EISUU (toggle)</name>
              <sysctl>remap.jis_unify_kana_eisuu_to_optionR</sysctl>
              <autogen>--KeyToKey-- KeyCode::OPTION_R, KeyCode::VK_JIS_TOGGLE_EISUU_KANA</autogen>
            </item>
          </list>
        </item>
        <item>
          <name>Change Return Key</name>
          <list>
            <item>
              <name>Return to KANA</name>
              <sysctl>remap.jis_return2kana</sysctl>
              <autogen>--KeyToKey-- KeyCode::RETURN, KeyCode::JIS_KANA</autogen>
            </item>
          </list>
        </item>
        <item>
          <name>Change Right Bracket(]) Key</name>
          <list>
            <item>
              <name>Right Bracket(]) to Backquote(`)</name>
              <sysctl>remap.jis_rightbracket2backquote</sysctl>
              <autogen>--KeyToKey-- KeyCode::JIS_BRACKET_RIGHT, KeyCode::BACKQUOTE</autogen>
            </item>
          </list>
        </item>
        <item>
          <name>Change Space Key</name>
          <list>
            <item>
              <name>Command+Space to KANA/EISUU (toggle)</name>
              <sysctl>remap.jis_commandSpace2toggle_kana_eisuu</sysctl>
              <autogen>--KeyToKey-- KeyCode::SPACE, VK_COMMAND | ModifierFlag::NONE, KeyCode::VK_JIS_TOGGLE_EISUU_KANA</autogen>
            </item>
            <item>
              <name>Shift+Space to KANA/EISUU (toggle)</name>
              <sysctl>remap.jis_shiftSpace2toggle_kana_eisuu</sysctl>
              <autogen>--KeyToKey-- KeyCode::SPACE, VK_SHIFT, KeyCode::VK_JIS_TOGGLE_EISUU_KANA</autogen>
            </item>
            <item>
              <name>Shift+Space to KANA/EISUU (toggle) (except Emacs.app)</name>
              <sysctl>remap.jis_shiftSpace2toggle_kana_eisuu_ex_emacs</sysctl>
              <not>EMACS</not>
              <autogen>--KeyToKey-- KeyCode::SPACE, VK_SHIFT, KeyCode::VK_JIS_TOGGLE_EISUU_KANA</autogen>
            </item>
            <item>
              <name>Shift+Space to Equal</name>
              <appendix>(Disable when KANA mode)</appendix>
              <sysctl>remap.jis_shiftSpace2equal</sysctl>
              <inputmode_only>INPUTMODE_ROMAN</inputmode_only>
              <autogen>--KeyToKey-- KeyCode::SPACE, VK_SHIFT, KeyCode::EQUAL</autogen>
            </item>
          </list>
        </item>
        <item>
          <name>Change Tab Key</name>
          <list>
            <item>
              <name>Tab to EISUU</name>
              <sysctl>remap.jis_tab2eisuu</sysctl>
              <autogen>--KeyToKey-- KeyCode::TAB, KeyCode::JIS_EISUU</autogen>
            </item>
          </list>
        </item>
        <item>
          <name>Change EISUU Key</name>
          <list>
            <item>
              <name>EISUU to Command_L</name>
              <sysctl>remap.jis_eisuu2commandL</sysctl>
              <autogen>--KeyToKey-- KeyCode::JIS_EISUU, KeyCode::COMMAND_L</autogen>
            </item>
            <item>
              <name>EISUU to Command_L</name>
              <appendix>(+ When you type EISUU only, send EISUU)</appendix>
              <sysctl>remap.jis_eisuu2commandL_eisuu</sysctl>
              <autogen>--KeyOverlaidModifier-- KeyCode::JIS_EISUU, KeyCode::COMMAND_L, KeyCode::JIS_EISUU</autogen>
            </item>
            <item>
              <name>EISUU to Command_L (except Terminal)</name>
              <appendix>(+ When you type EISUU only, send EISUU)</appendix>
              <not>TERMINAL</not>
              <sysctl>remap.jis_eisuu2commandL_eisuu_ex_term</sysctl>
              <autogen>--KeyOverlaidModifier-- KeyCode::JIS_EISUU, KeyCode::COMMAND_L, KeyCode::JIS_EISUU</autogen>
            </item>
            <item>
              <name>EISUU to Control_L</name>
              <sysctl>remap.jis_eisuu2controlL</sysctl>
              <autogen>--KeyToKey-- KeyCode::JIS_EISUU, KeyCode::CONTROL_L</autogen>
            </item>
            <item>
              <name>EISUU to Control_L</name>
              <appendix>(+ When you type EISUU only, send EISUU)</appendix>
              <sysctl>remap.jis_eisuu2controlL_eisuu</sysctl>
              <autogen>--KeyOverlaidModifier-- KeyCode::JIS_EISUU, KeyCode::CONTROL_L, KeyCode::JIS_EISUU</autogen>
            </item>
            <item>
              <name>EISUU to Control_L</name>
              <appendix>(+ When you type Shift+EISUU only, send Escape)</appendix>
              <appendix>(+ When you type EISUU only, send EISUU)</appendix>
              <sysctl>remap.jis_eisuu2controlL_eisuu_escape</sysctl>
              <autogen>--KeyOverlaidModifier-- KeyCode::JIS_EISUU, VK_SHIFT, KeyCode::CONTROL_L, ModifierFlag::SHIFT_L, KeyCode::ESCAPE</autogen>
              <autogen>--KeyOverlaidModifier-- KeyCode::JIS_EISUU, KeyCode::CONTROL_L, KeyCode::JIS_EISUU</autogen>
            </item>
            <item>
              <name>EISUU to Control_L</name>
              <appendix>(+ When you type Shift+EISUU only, send Escape)</appendix>
              <appendix>(+ When you type Command_R+EISUU only, toggle Complete Vi Mode)</appendix>
              <appendix>(+ When you type EISUU only, send EISUU)</appendix>
              <sysctl>remap.jis_eisuu2controlL_eisuu_vimode_escape</sysctl>
              <autogen>--KeyOverlaidModifier-- KeyCode::JIS_EISUU, VK_SHIFT, KeyCode::CONTROL_L, ModifierFlag::SHIFT_L, KeyCode::ESCAPE</autogen>
              <autogen>--KeyOverlaidModifier-- KeyCode::JIS_EISUU, ModifierFlag::COMMAND_R, KeyCode::CONTROL_L, ModifierFlag::COMMAND_R, KeyCode::VK_CONFIG_TOGGLE_notsave_complete_vimode</autogen>
              <autogen>--KeyOverlaidModifier-- KeyCode::JIS_EISUU, KeyCode::CONTROL_L, KeyCode::JIS_EISUU</autogen>
            </item>
            <item>
              <name>EISUU to FN</name>
              <sysctl>remap.jis_eisuu2fn</sysctl>
              <autogen>--KeyToKey-- KeyCode::JIS_EISUU, KeyCode::FN</autogen>
            </item>
            <item>
              <name>EISUU to Option_L</name>
              <sysctl>remap.jis_eisuu2optionL</sysctl>
              <autogen>--KeyToKey-- KeyCode::JIS_EISUU, KeyCode::OPTION_L</autogen>
            </item>
            <item>
              <name>EISUU to Option_L (only in Terminal)</name>
              <appendix>(+ When you type EISUU only, send EISUU)</appendix>
              <only>TERMINAL</only>
              <sysctl>remap.jis_eisuu2optionL_eisuu_term</sysctl>
              <autogen>--KeyOverlaidModifier-- KeyCode::JIS_EISUU, KeyCode::OPTION_L, KeyCode::JIS_EISUU</autogen>
            </item>
            <item>
              <name>EISUU to Shift_L</name>
              <sysctl>remap.jis_eisuu2shiftL</sysctl>
              <autogen>--KeyToKey-- KeyCode::JIS_EISUU, KeyCode::SHIFT_L</autogen>
            </item>
            <item>
              <name>EISUU to ModifierFlag::EXTRA1</name>
              <sysctl>remap.jis_eisuu2modextra1</sysctl>
              <autogen>--KeyToKey-- KeyCode::JIS_EISUU, KeyCode::VK_MODIFIER_EXTRA1</autogen>
            </item>
            <item>
              <name>EISUU to Delete</name>
              <sysctl>remap.jis_eisuu2delete</sysctl>
              <autogen>--KeyToKey-- KeyCode::JIS_EISUU, KeyCode::DELETE</autogen>
            </item>
            <item>
              <name>Command+EISUU to EISUU</name>
              <sysctl>remap.jis_commandEisuu2eisuu</sysctl>
              <autogen>--KeyToKey-- KeyCode::JIS_EISUU, VK_COMMAND, KeyCode::JIS_EISUU</autogen>
            </item>
            <item>
              <name>EISUU to Escape</name>
              <sysctl>remap.jis_eisuu2escape</sysctl>
              <autogen>--KeyToKey-- KeyCode::JIS_EISUU, KeyCode::ESCAPE</autogen>
            </item>
            <item>
              <name>EISUU to Escape (only when inputmode == roman)</name>
              <sysctl>remap.jis_eisuu2escape_onlyroman</sysctl>
              <inputmode_only>INPUTMODE_ROMAN</inputmode_only>
              <autogen>--KeyToKey-- KeyCode::JIS_EISUU, KeyCode::ESCAPE</autogen>
            </item>
            <item>
              <name>EISUU to Control_L+F2 (= Move focus to the menu bar)</name>
              <sysctl>remap.jis_eisuu2controlLf2</sysctl>
              <autogen>--KeyToKey-- KeyCode::JIS_EISUU, KeyCode::F2, ModifierFlag::CONTROL_L</autogen>
            </item>
            <item>
              <name>EISUU to Tab</name>
              <sysctl>remap.jis_eisuu2tab</sysctl>
              <autogen>--KeyToKey-- KeyCode::JIS_EISUU, KeyCode::TAB</autogen>
            </item>
            <item>
              <name>EISUU to MiddleClick</name>
              <sysctl>remap.jis_eisuu2middleclick</sysctl>
              <autogen>--KeyToPointingButton-- KeyCode::JIS_EISUU, PointingButton::MIDDLE</autogen>
            </item>
            <item>
              <name>EISUU to RightClick</name>
              <sysctl>remap.jis_eisuu2rightclick</sysctl>
              <autogen>--KeyToPointingButton-- KeyCode::JIS_EISUU, PointingButton::RIGHT</autogen>
            </item>
            <item>
              <name>Use EISUU as KANA/EISUU (toggle)</name>
              <sysctl>remap.jis_unify_kana_to_eisuu</sysctl>
              <autogen>--KeyToKey-- KeyCode::JIS_EISUU, KeyCode::VK_JIS_TOGGLE_EISUU_KANA</autogen>
            </item>
            <item>
              <name>Ignore the multiple press of EISUU</name>
              <sysctl>remap.jis_ignore_multiple_eisuu</sysctl>
              <autogen>--IgnoreMultipleSameKeyPress-- KeyCode::JIS_EISUU</autogen>
            </item>
          </list>
        </item>
        <item>
          <name>Change KANA Key</name>
          <list>
            <item>
              <name>KANA to Command_L</name>
              <sysctl>remap.jis_kana2commandL</sysctl>
              <autogen>--KeyToKey-- KeyCode::JIS_KANA, KeyCode::COMMAND_L</autogen>
            </item>
            <item>
              <name>KANA to Command_R</name>
              <appendix>(+ When you type KANA only, send KANA)</appendix>
              <sysctl>remap.jis_kana2commandR_kana</sysctl>
              <autogen>--KeyOverlaidModifier-- KeyCode::JIS_KANA, KeyCode::COMMAND_R, KeyCode::JIS_KANA</autogen>
            </item>
            <item>
              <name>KANA to Command_R</name>
              <appendix>(+ When you type Shift+KANA only, send Return)</appendix>
              <appendix>(+ When you type KANA only, send KANA)</appendix>
              <sysctl>remap.jis_kana2commandR_kana_return</sysctl>
              <autogen>--KeyOverlaidModifier-- KeyCode::JIS_KANA, VK_SHIFT, KeyCode::COMMAND_R, ModifierFlag::SHIFT_L, KeyCode::RETURN</autogen>
              <autogen>--KeyOverlaidModifier-- KeyCode::JIS_KANA, KeyCode::COMMAND_R, KeyCode::JIS_KANA</autogen>
            </item>
            <item>
              <name>KANA to Command_R</name>
              <appendix>(+ When you type Shift+KANA only, send Return)</appendix>
              <appendix>(+ When you type Control+KANA only, toggle Complete Vi Mode)</appendix>
              <appendix>(+ When you type KANA only, send KANA)</appendix>
              <sysctl>remap.jis_kana2commandR_kana_vimode_return</sysctl>
              <autogen>--KeyOverlaidModifier-- KeyCode::JIS_KANA, VK_SHIFT, KeyCode::COMMAND_R, ModifierFlag::SHIFT_L, KeyCode::RETURN</autogen>
              <autogen>--KeyOverlaidModifier-- KeyCode::JIS_KANA, VK_CONTROL, KeyCode::COMMAND_R, ModifierFlag::CONTROL_L, KeyCode::VK_CONFIG_TOGGLE_notsave_complete_vimode</autogen>
              <autogen>--KeyOverlaidModifier-- KeyCode::JIS_KANA, KeyCode::COMMAND_R, KeyCode::JIS_KANA</autogen>
            </item>
            <item>
              <name>KANA to Control_L</name>
              <sysctl>remap.jis_kana2controlL</sysctl>
              <autogen>--KeyToKey-- KeyCode::JIS_KANA, KeyCode::CONTROL_L</autogen>
            </item>
            <item>
              <name>KANA to Control_L</name>
              <appendix>(+ When you type KANA only, send KANA)</appendix>
              <sysctl>remap.jis_kana2controlL_kana</sysctl>
              <autogen>--KeyOverlaidModifier-- KeyCode::JIS_KANA, KeyCode::CONTROL_L, KeyCode::JIS_KANA</autogen>
            </item>
            <item>
              <name>KANA to FN</name>
              <sysctl>remap.jis_kana2fn</sysctl>
              <autogen>--KeyToKey-- KeyCode::JIS_KANA, KeyCode::FN</autogen>
            </item>
            <item>
              <name>KANA to Option_L</name>
              <sysctl>remap.jis_kana2optionL</sysctl>
              <autogen>--KeyToKey-- KeyCode::JIS_KANA, KeyCode::OPTION_L</autogen>
            </item>
            <item>
              <name>KANA to Shift_L</name>
              <sysctl>remap.jis_kana2shiftL</sysctl>
              <autogen>--KeyToKey-- KeyCode::JIS_KANA, KeyCode::SHIFT_L</autogen>
            </item>
            <item>
              <name>KANA to Shift_L</name>
              <appendix>(+ When you type KANA only, send KANA)</appendix>
              <sysctl>remap.jis_kana2shiftL_kana</sysctl>
              <autogen>--KeyOverlaidModifier-- KeyCode::JIS_KANA, KeyCode::SHIFT_L, KeyCode::JIS_KANA</autogen>
            </item>
            <item>
              <name>KANA to Control_L+F2 (= Move focus to the menu bar)</name>
              <sysctl>remap.jis_kana2controlLf2</sysctl>
              <autogen>--KeyToKey-- KeyCode::JIS_KANA, KeyCode::F2, ModifierFlag::CONTROL_L</autogen>
            </item>
            <item>
              <name>Command+KANA to KANA</name>
              <sysctl>remap.jis_commandKana2kana</sysctl>
              <autogen>--KeyToKey-- KeyCode::JIS_KANA, VK_COMMAND, KeyCode::JIS_KANA</autogen>
            </item>
            <item>
              <name>KANA to Return</name>
              <sysctl>remap.jis_kana2return</sysctl>
              <autogen>--KeyToKey-- KeyCode::JIS_KANA, KeyCode::RETURN</autogen>
            </item>
            <item>
              <name>KANA to Space</name>
              <sysctl>remap.jis_kana2space</sysctl>
              <autogen>--KeyToKey-- KeyCode::JIS_KANA, KeyCode::SPACE</autogen>
            </item>
            <item>
              <name>KANA to MiddleClick</name>
              <sysctl>remap.jis_kana2middleclick</sysctl>
              <autogen>--KeyToPointingButton-- KeyCode::JIS_KANA, PointingButton::MIDDLE</autogen>
            </item>
            <item>
              <name>KANA to RightClick</name>
              <sysctl>remap.jis_kana2rightclick</sysctl>
              <autogen>--KeyToPointingButton-- KeyCode::JIS_KANA, PointingButton::RIGHT</autogen>
            </item>
            <item>
              <name>Shift+KANA to EISUU</name>
              <sysctl>remap.jis_shiftKana2eisuu</sysctl>
              <autogen>--KeyToKey-- KeyCode::JIS_KANA, VK_SHIFT, KeyCode::JIS_EISUU</autogen>
            </item>
            <item>
              <name>Use KANA as KANA/EISUU (toggle)</name>
              <sysctl>remap.jis_unify_eisuu_to_kana</sysctl>
              <autogen>--KeyToKey-- KeyCode::JIS_KANA, KeyCode::VK_JIS_TOGGLE_EISUU_KANA</autogen>
            </item>
            <item>
              <name>Ignore the multiple press of KANA</name>
              <sysctl>remap.jis_ignore_multiple_kana</sysctl>
              <autogen>--IgnoreMultipleSameKeyPress-- KeyCode::JIS_KANA</autogen>
            </item>
          </list>
        </item>
        <item>
          <name>Change Underscore(Ro) Key</name>
          <list>
            <item>
              <name>Underscore(Ro) to Shift_R</name>
              <sysctl>remap.jis_underscore2shiftR</sysctl>
              <autogen>--KeyToKey-- KeyCode::JIS_UNDERSCORE, KeyCode::SHIFT_R</autogen>
            </item>
            <item>
              <name>Underscore(Ro) to Backslash(\)</name>
              <sysctl>remap.jis_underscore2backslash</sysctl>
              <autogen>--KeyToKey-- KeyCode::JIS_UNDERSCORE, ModifierFlag::NONE, KeyCode::VK_JIS_BACKSLASH</autogen>
            </item>
            <item>
              <name>Underscore(Ro) to Delete</name>
              <sysctl>remap.jis_underscore2delete</sysctl>
              <autogen>--KeyToKey-- KeyCode::JIS_UNDERSCORE, KeyCode::DELETE</autogen>
            </item>
            <item>
              <name>Underscore(Ro) to JIS Yen(¥)</name>
              <sysctl>remap.jis_underscore2jis_yen</sysctl>
              <autogen>--KeyToKey-- KeyCode::JIS_UNDERSCORE, ModifierFlag::NONE, KeyCode::JIS_YEN</autogen>
            </item>
            <item>
              <name>Underscore(Ro) to JIS Yen(¥) (if no modifiers pressed)</name>
              <sysctl>remap.jis_underscore2jis_yen_nomods</sysctl>
              <autogen>--KeyToKey-- KeyCode::JIS_UNDERSCORE, ModifierFlag::NONE, KeyCode::JIS_YEN</autogen>
            </item>
          </list>
        </item>
        <item>
          <name>Change Yen(¥) Key</name>
          <list>
            <item>
              <name>JIS Yen(¥) to Backslash(\)</name>
              <appendix>(except virtual machine, X11)</appendix>
              <sysctl>remap.jis_yen2backslash</sysctl>
              <not>VIRTUALMACHINE, X11</not>
              <autogen>--KeyToKey-- KeyCode::JIS_YEN, KeyCode::VK_JIS_BACKSLASH</autogen>
            </item>
          </list>
        </item>
        <item>
          <name>Change Zero(0) Key</name>
          <list>
            <item>
              <name>Shift+0 to Backslash(\)</name>
              <sysctl>remap.jis_shift0_to_backslash</sysctl>
              <autogen>--KeyToKey-- KeyCode::KEY_0, VK_SHIFT, KeyCode::VK_JIS_BACKSLASH</autogen>
            </item>
            <item>
              <name>Shift+0 to JIS Yen(¥)</name>
              <sysctl>remap.jis_shift0_to_yen</sysctl>
              <autogen>--KeyToKey-- KeyCode::KEY_0, VK_SHIFT, KeyCode::JIS_YEN</autogen>
            </item>
            <item>
              <name>Shift+0 to Underscore(Ro)</name>
              <sysctl>remap.jis_shift0_to_underscore</sysctl>
              <autogen>--KeyToKey-- KeyCode::KEY_0, VK_SHIFT, KeyCode::JIS_UNDERSCORE</autogen>
            </item>
          </list>
        </item>
        <item>
          <name>Emacs Mode</name>
          <list>
            <item>
              <name>Control+[ to Escape at Japanese Keyboard</name>
              <sysctl>option.jis_emacsmode_controlLeftbracket</sysctl>
              <not>EMACS, TERMINAL, VIRTUALMACHINE, REMOTEDESKTOPCONNECTION, X11</not>
              <autogen>--KeyToKey-- KeyCode::JIS_BRACKET_LEFT, VK_CONTROL, KeyCode::ESCAPE</autogen>
            </item>
            <item>
              <name>Behavior in Emacs, Terminal, X11, VMware, Parallels, RDC</name>
              <list>
                <item>
                  <name>Force change C-[ to Escape</name>
                  <list>
                    <item>
                      <name>In Emacs, Terminal</name>
                      <sysctl>option.jis_emacsmode_force_controlLeftbracket_term</sysctl>
                      <only>EMACS, TERMINAL</only>
                      <autogen>--KeyToKey-- KeyCode::JIS_BRACKET_LEFT, VK_CONTROL, KeyCode::ESCAPE</autogen>
                    </item>
                    <item>
                      <name>In X11</name>
                      <sysctl>option.jis_emacsmode_force_controlLeftbracket_x11</sysctl>
                      <only>X11</only>
                      <autogen>--KeyToKey-- KeyCode::JIS_BRACKET_LEFT, VK_CONTROL, KeyCode::ESCAPE</autogen>
                    </item>
                    <item>
                      <name>In VMware Fusion, Parallels Desktop, Remote Desktop Connection</name>
                      <sysctl>option.jis_emacsmode_force_controlLeftbracket_vm</sysctl>
                      <only>VIRTUALMACHINE, REMOTEDESKTOPCONNECTION</only>
                      <autogen>--KeyToKey-- KeyCode::JIS_BRACKET_LEFT, VK_CONTROL, KeyCode::ESCAPE</autogen>
                    </item>
                  </list>
                </item>
              </list>
            </item>
          </list>
        </item>
        <item>
          <name>For Applications</name>
          <list>
            <item>
              <name>Enable at only Terminal</name>
              <list>
                <item>
                  <name>Command_L to Option_L</name>
                  <appendix>(+ When you type Command_L only, send EISUU)</appendix>
                  <only>TERMINAL</only>
                  <sysctl>remap.jis_app_commandL2optionL_eisuu</sysctl>
                  <autogen>--KeyOverlaidModifier-- KeyCode::COMMAND_L, KeyCode::OPTION_L, KeyCode::JIS_EISUU</autogen>
                </item>
                <item>
                  <name>Command_L to Option_L</name>
                  <appendix>(+ When you type Command_L only, send EISUU)</appendix>
                  <appendix>(Pass-Through Tab and Backquote)</appendix>
                  <only>TERMINAL</only>
                  <sysctl>remap.jis_app_commandL2optionL_eisuu_except_tab</sysctl>
                  <autogen>--KeyToKey-- KeyCode::TAB, ModifierFlag::OPTION_L, KeyCode::TAB, ModifierFlag::COMMAND_L</autogen>
                  <autogen>--KeyToKey-- KeyCode::BACKQUOTE, ModifierFlag::OPTION_L, KeyCode::BACKQUOTE, ModifierFlag::COMMAND_L</autogen>
                  <autogen>--KeyOverlaidModifier-- KeyCode::COMMAND_L, KeyCode::OPTION_L, KeyCode::JIS_EISUU</autogen>
                </item>
                <item>
                  <name>JIS Yen(¥) to F18 (if no modifiers pressed)</name>
                  <only>TERMINAL</only>
                  <sysctl>remap.jis_app_term_yen2f18</sysctl>
                  <autogen>--KeyToKey-- KeyCode::JIS_YEN, ModifierFlag::NONE, KeyCode::F18</autogen>
                </item>
                <item>
                  <name>Underscore(Ro) to F18</name>
                  <appendix>(+ Underscore to JIS Yen(¥) except Terminal)</appendix>
                  <sysctl>remap.jis_app_term_underscore2f18</sysctl>
                  <block>
                    <only>TERMINAL</only>
                    <autogen>--KeyToKey-- KeyCode::JIS_UNDERSCORE, ModifierFlag::NONE, KeyCode::F18</autogen>
                  </block>
                  <block>
                    <not>TERMINAL</not>
                    <autogen>--KeyToKey-- KeyCode::JIS_UNDERSCORE, ModifierFlag::NONE, KeyCode::JIS_YEN</autogen>
                  </block>
                </item>
                <item>
                  <name>Shift+0 to F18</name>
                  <appendix>(+ Shift+0 to JIS Yen(¥) except Terminal)</appendix>
                  <sysctl>remap.jis_app_term_shift0_to_f18</sysctl>
                  <block>
                    <only>TERMINAL</only>
                    <autogen>--KeyToKey-- KeyCode::KEY_0, VK_SHIFT, KeyCode::F18</autogen>
                  </block>
                  <block>
                    <not>TERMINAL</not>
                    <autogen>--KeyToKey-- KeyCode::KEY_0, VK_SHIFT, KeyCode::JIS_YEN</autogen>
                  </block>
                </item>
              </list>
            </item>
            <item>
              <name>Enable at only Vim</name>
              <list>
                <item>
                  <name>Change EISUU to EISUU &amp; Escape</name>
                  <only>VI</only>
                  <sysctl>remap.jis_app_vi_eisuu2eisuu_escape</sysctl>
                  <autogen>--KeyToKey-- KeyCode::JIS_EISUU, KeyCode::JIS_EISUU, KeyCode::ESCAPE</autogen>
                </item>
              </list>
            </item>
          </list>
        </item>
        <item>
          <name>Change Keyboard Layout</name>
          <list>
            <item>
              <name>Use Japanese Keyboard as ASCII Keyboard</name>
              <sysctl>remap.jis_jansi</sysctl>
              <autogen>--SetKeyboardType-- KeyboardType::MACBOOK</autogen>
              <autogen>--KeyToKey-- KeyCode::JIS_YEN, KeyCode::BACKQUOTE</autogen>
              <autogen>--KeyToKey-- KeyCode::JIS_UNDERSCORE, KeyCode::BACKQUOTE</autogen>
            </item>
            <item>
              <name>Use ASCII Keyboard as Japanese Keyboard</name>
              <list>
                <item>
                  <name>Use ASCII Keyboard as Japanese Keyboard</name>
                  <sysctl>remap.jis_layout_us2japanese</sysctl>
                  <autogen>--SetKeyboardType-- KeyboardType::JIS_MACBOOK_2008</autogen>
                </item>
                <item>
                  <name>Options</name>
                  <list>
                    <item>
                      <name>Backquote(`) to JIS Yen(¥)</name>
                      <sysctl>option.jis_layout_us2japanese_backquote2yen</sysctl>
                      <autogen>--KeyToKey-- KeyCode::BACKQUOTE, KeyCode::JIS_YEN</autogen>
                    </item>
                    <item>
                      <name>Backquote(`) to Backslash</name>
                      <sysctl>option.jis_layout_us2japanese_backquote2backslash</sysctl>
                      <autogen>--KeyToKey-- KeyCode::BACKQUOTE, KeyCode::VK_JIS_BACKSLASH</autogen>
                    </item>
                    <item>
                      <name>Shift_R to Shift_R</name>
                      <appendix>(+ When you type Shift_R only, send Underscore)</appendix>
                      <sysctl>option.jis_layout_us2japanese_shiftR2shiftR_underscore</sysctl>
                      <autogen>--KeyOverlaidModifier-- KeyCode::SHIFT_R, KeyCode::SHIFT_R, KeyCode::JIS_UNDERSCORE</autogen>
                    </item>
                    <item>
                      <name>(Shift_L+Shift_R to Underscore)</name>
                      <sysctl>option.jis_layout_us2japanese_shiftR2shiftR_shiftLshiftR2underscore</sysctl>
                      <autogen>--KeyToKey-- KeyCode::SHIFT_R, ModifierFlag::SHIFT_L, KeyCode::JIS_UNDERSCORE</autogen>
                    </item>
                  </list>
                </item>
              </list>
            </item>
            <item>
              <name>Use Japanese Keyboard as Semi-ASCII Keyboard</name>
              <appendix>Change Shift+semicolon(;) to colon(:)</appendix>
              <appendix>Change colon(:) to apostrophe(')</appendix>
              <appendix>Change Shift+colon(:) to double quote(")</appendix>
              <appendix>Change Shift+2 to plus(+)</appendix>
              <appendix>Change Shift+7 to asterisk(*)</appendix>
              <sysctl>remap.jis_layout_semiascii</sysctl>
              <autogen>--KeyToKey-- KeyCode::SEMICOLON, VK_SHIFT,           KeyCode::JIS_COLON</autogen>
              <!-- double quote(") == Shift+2 -->
              <autogen>--KeyToKey-- KeyCode::JIS_COLON, VK_SHIFT,           KeyCode::KEY_2, ModifierFlag::SHIFT_L</autogen>
              <!-- apostrophe(') == Shift+7 -->
              <autogen>--KeyToKey-- KeyCode::JIS_COLON,                     KeyCode::KEY_7, ModifierFlag::SHIFT_L</autogen>
              <!-- plus(+) == Shift+; -->
              <autogen>--KeyToKey-- KeyCode::KEY_2,     VK_SHIFT,           KeyCode::SEMICOLON, ModifierFlag::SHIFT_L</autogen>
              <!-- asterisk(*) == Shift+: -->
              <autogen>--KeyToKey-- KeyCode::KEY_7,     VK_SHIFT,           KeyCode::JIS_COLON, ModifierFlag::SHIFT_L</autogen>
            </item>
            <item>
              <name>Use JIS X 6004</name>
              <sysctl>remap.jis_layout_jisx6004</sysctl>
              <inputmodedetail_only>INPUTMODE_DETAIL_JAPANESE_HIRAGANA, INPUTMODE_DETAIL_JAPANESE, INPUTMODE_DETAIL_JAPANESE_KATAKANA, INPUTMODE_DETAIL_JAPANESE_HALFWIDTH_KANA</inputmodedetail_only>

              <!-- ====================================================================== -->
              <!-- Shift+Q -> small A (Shift+3) -->
              <autogen>--KeyToKey-- KeyCode::Q, VK_SHIFT | ModifierFlag::NONE, KeyCode::KEY_3, ModifierFlag::SHIFT_L</autogen>
              <!-- Shift+W -> p-sound ([) -->
              <autogen>--KeyToKey-- KeyCode::W, VK_SHIFT | ModifierFlag::NONE, KeyCode::JIS_BRACKET_LEFT</autogen>
              <!-- Shift+E -> HO (minus) -->
              <autogen>--KeyToKey-- KeyCode::E, VK_SHIFT | ModifierFlag::NONE, KeyCode::MINUS</autogen>
              <!-- Shift+R -> FU (2) -->
              <autogen>--KeyToKey-- KeyCode::R, VK_SHIFT | ModifierFlag::NONE, KeyCode::KEY_2</autogen>
              <!-- Shift+T -> ME (/) -->
              <autogen>--KeyToKey-- KeyCode::T, VK_SHIFT | ModifierFlag::NONE, KeyCode::SLASH</autogen>
              <!-- Shift+Y -> HI (V) -->
              <autogen>--KeyToKey-- KeyCode::Y, VK_SHIFT | ModifierFlag::NONE, KeyCode::V</autogen>
              <!-- Shift+U -> E (5) -->
              <autogen>--KeyToKey-- KeyCode::U, VK_SHIFT | ModifierFlag::NONE, KeyCode::KEY_5</autogen>
              <!-- Shift+I -> MI (N) -->
              <autogen>--KeyToKey-- KeyCode::I, VK_SHIFT | ModifierFlag::NONE, KeyCode::N</autogen>
              <!-- Shift+O -> YA (7) -->
              <autogen>--KeyToKey-- KeyCode::O, VK_SHIFT | ModifierFlag::NONE, KeyCode::KEY_7</autogen>
              <!-- Shift+P -> NU (1) -->
              <autogen>--KeyToKey-- KeyCode::P, VK_SHIFT | ModifierFlag::NONE, KeyCode::KEY_1</autogen>
              <!-- Shift+[ -> [ (Shift+[) -->
              <autogen>--KeyToKey-- KeyCode::JIS_ATMARK, VK_SHIFT | ModifierFlag::NONE, KeyCode::JIS_BRACKET_LEFT, ModifierFlag::SHIFT_L</autogen>

              <!-- Q -> SO (C) -->
              <autogen>--KeyToKey-- KeyCode::Q, ModifierFlag::NONE, KeyCode::C</autogen>
              <!-- W -> KE (:) -->
              <autogen>--KeyToKey-- KeyCode::W, ModifierFlag::NONE, KeyCode::JIS_COLON</autogen>
              <!-- E -> SE (P) -->
              <autogen>--KeyToKey-- KeyCode::E, ModifierFlag::NONE, KeyCode::P</autogen>
              <!-- R -> TE (W) -->
              <autogen>--KeyToKey-- KeyCode::R, ModifierFlag::NONE, KeyCode::W</autogen>
              <!-- T -> small YO (Shift+9) -->
              <autogen>--KeyToKey-- KeyCode::T, ModifierFlag::NONE, KeyCode::KEY_9, ModifierFlag::SHIFT_L</autogen>
              <!-- Y -> TU (Z) -->
              <autogen>--KeyToKey-- KeyCode::Y, ModifierFlag::NONE, KeyCode::Z</autogen>
              <!-- U -> NN (Y) -->
              <autogen>--KeyToKey-- KeyCode::U, ModifierFlag::NONE, KeyCode::Y</autogen>
              <!-- I -> NO (K) -->
              <autogen>--KeyToKey-- KeyCode::I, ModifierFlag::NONE, KeyCode::K</autogen>
              <!-- O -> WO (Shift+0) -->
              <autogen>--KeyToKey-- KeyCode::O, ModifierFlag::NONE, KeyCode::KEY_0, ModifierFlag::SHIFT_L</autogen>
              <!-- P -> RI (L) -->
              <autogen>--KeyToKey-- KeyCode::P, ModifierFlag::NONE, KeyCode::L</autogen>
              <!-- [ -> TI (A) -->
              <autogen>--KeyToKey-- KeyCode::JIS_ATMARK, ModifierFlag::NONE, KeyCode::A</autogen>

              <!-- ====================================================================== -->
              <!-- Shift+A -> small I (Shift+E) -->
              <autogen>--KeyToKey-- KeyCode::A, VK_SHIFT | ModifierFlag::NONE, KeyCode::E, ModifierFlag::SHIFT_L</autogen>
              <!-- Shift+S -> HE (^) -->
              <autogen>--KeyToKey-- KeyCode::S, VK_SHIFT | ModifierFlag::NONE, KeyCode::JIS_HAT</autogen>
              <!-- Shift+D -> RA (O) -->
              <autogen>--KeyToKey-- KeyCode::D, VK_SHIFT | ModifierFlag::NONE, KeyCode::O</autogen>
              <!-- Shift+F -> small YU (Shift+8) -->
              <autogen>--KeyToKey-- KeyCode::F, VK_SHIFT | ModifierFlag::NONE, KeyCode::KEY_8, ModifierFlag::SHIFT_L</autogen>
              <!-- Shift+G -> YO (9) -->
              <autogen>--KeyToKey-- KeyCode::G, VK_SHIFT | ModifierFlag::NONE, KeyCode::KEY_9</autogen>
              <!-- Shift+H -> MA (J) -->
              <autogen>--KeyToKey-- KeyCode::H, VK_SHIFT | ModifierFlag::NONE, KeyCode::J</autogen>
              <!-- Shift+J -> O (6) -->
              <autogen>--KeyToKey-- KeyCode::J, VK_SHIFT | ModifierFlag::NONE, KeyCode::KEY_6</autogen>
              <!-- Shift+K -> MO (M) -->
              <autogen>--KeyToKey-- KeyCode::K, VK_SHIFT | ModifierFlag::NONE, KeyCode::M</autogen>
              <!-- Shift+L -> WA (0) -->
              <autogen>--KeyToKey-- KeyCode::L, VK_SHIFT | ModifierFlag::NONE, KeyCode::KEY_0</autogen>
              <!-- Shift+; -> YU (8) -->
              <autogen>--KeyToKey-- KeyCode::SEMICOLON, VK_SHIFT | ModifierFlag::NONE, KeyCode::KEY_8</autogen>
              <!-- Shift+: -> ] (Shift+]) -->
              <autogen>--KeyToKey-- KeyCode::JIS_COLON, VK_SHIFT | ModifierFlag::NONE, KeyCode::JIS_BRACKET_RIGHT, ModifierFlag::SHIFT_L</autogen>

              <!-- A -> HA (F) -->
              <autogen>--KeyToKey-- KeyCode::A, ModifierFlag::NONE, KeyCode::F</autogen>
              <!-- S -> KA (T) -->
              <autogen>--KeyToKey-- KeyCode::S, ModifierFlag::NONE, KeyCode::T</autogen>
              <!-- D -> SI (D) -->
              <!-- don't change D -->
              <!-- F -> TO (S) -->
              <autogen>--KeyToKey-- KeyCode::F, ModifierFlag::NONE, KeyCode::S</autogen>
              <!-- G -> TA (Q) -->
              <autogen>--KeyToKey-- KeyCode::G, ModifierFlag::NONE, KeyCode::Q</autogen>
              <!-- H -> KU (H) -->
              <!-- don't change H -->
              <!-- J -> U (4) -->
              <autogen>--KeyToKey-- KeyCode::J, ModifierFlag::NONE, KeyCode::KEY_4</autogen>
              <!-- K -> I (E) -->
              <autogen>--KeyToKey-- KeyCode::K, ModifierFlag::NONE, KeyCode::E</autogen>
              <!-- L -> voiced-sound (@) -->
              <autogen>--KeyToKey-- KeyCode::L, ModifierFlag::NONE, KeyCode::JIS_ATMARK</autogen>
              <!-- ; -> KI (G) -->
              <autogen>--KeyToKey-- KeyCode::SEMICOLON, ModifierFlag::NONE, KeyCode::G</autogen>
              <!-- : -> NA (U) -->
              <autogen>--KeyToKey-- KeyCode::JIS_COLON, ModifierFlag::NONE, KeyCode::U</autogen>

              <!-- ====================================================================== -->
              <!-- Shift+Z -> small U (Shift+4) -->
              <autogen>--KeyToKey-- KeyCode::Z, VK_SHIFT | ModifierFlag::NONE, KeyCode::KEY_4, ModifierFlag::SHIFT_L</autogen>
              <!-- Shift+X -> small E (Shift+5) -->
              <autogen>--KeyToKey-- KeyCode::X, VK_SHIFT | ModifierFlag::NONE, KeyCode::KEY_5, ModifierFlag::SHIFT_L</autogen>
              <!-- Shift+C -> small O (Shift+6) -->
              <autogen>--KeyToKey-- KeyCode::C, VK_SHIFT | ModifierFlag::NONE, KeyCode::KEY_6, ModifierFlag::SHIFT_L</autogen>
              <!-- Shift+V -> NE (,) -->
              <autogen>--KeyToKey-- KeyCode::V, VK_SHIFT | ModifierFlag::NONE, KeyCode::COMMA</autogen>
              <!-- Shift+B -> small YA (Shift+7) -->
              <autogen>--KeyToKey-- KeyCode::B, VK_SHIFT | ModifierFlag::NONE, KeyCode::KEY_7, ModifierFlag::SHIFT_L</autogen>
              <!-- Shift+N -> MU (]) -->
              <autogen>--KeyToKey-- KeyCode::N, VK_SHIFT | ModifierFlag::NONE, KeyCode::JIS_BRACKET_RIGHT</autogen>
              <!-- Shift+M -> RO (Underscore) -->
              <autogen>--KeyToKey-- KeyCode::M, VK_SHIFT | ModifierFlag::NONE, KeyCode::JIS_UNDERSCORE</autogen>
              <!-- Shift+, -> dot (Shift+slash) -->
              <autogen>--KeyToKey-- KeyCode::COMMA, VK_SHIFT | ModifierFlag::NONE, KeyCode::SLASH, ModifierFlag::SHIFT_L</autogen>
              <!-- Shift+. -> minus (JIS_YEN) -->
              <autogen>--KeyToKey-- KeyCode::DOT, VK_SHIFT | ModifierFlag::NONE, KeyCode::JIS_YEN</autogen>

              <!-- Z -> SU (R) -->
              <autogen>--KeyToKey-- KeyCode::Z, ModifierFlag::NONE, KeyCode::R</autogen>
              <!-- X -> KO (B) -->
              <autogen>--KeyToKey-- KeyCode::X, ModifierFlag::NONE, KeyCode::B</autogen>
              <!-- C -> NI (I) -->
              <autogen>--KeyToKey-- KeyCode::C, ModifierFlag::NONE, KeyCode::I</autogen>
              <!-- V -> SA (X) -->
              <autogen>--KeyToKey-- KeyCode::V, ModifierFlag::NONE, KeyCode::X</autogen>
              <!-- B -> A (3) -->
              <autogen>--KeyToKey-- KeyCode::B, ModifierFlag::NONE, KeyCode::KEY_3</autogen>
              <!-- N -> small TU (Shift+Z) -->
              <autogen>--KeyToKey-- KeyCode::N, ModifierFlag::NONE, KeyCode::Z, ModifierFlag::SHIFT_L</autogen>
              <!-- M -> RU (dot) -->
              <autogen>--KeyToKey-- KeyCode::M, ModifierFlag::NONE, KeyCode::DOT</autogen>
              <!-- , -> , (Shift+,) -->
              <autogen>--KeyToKey-- KeyCode::COMMA, ModifierFlag::NONE, KeyCode::COMMA, ModifierFlag::SHIFT_L</autogen>
              <!-- . -> . (Shift+.) -->
              <autogen>--KeyToKey-- KeyCode::DOT, ModifierFlag::NONE, KeyCode::DOT, ModifierFlag::SHIFT_L</autogen>
              <!-- / -> RE (;) -->
              <autogen>--KeyToKey-- KeyCode::SLASH, ModifierFlag::NONE, KeyCode::SEMICOLON</autogen>

              <!-- ====================================================================== -->
              <!-- An upper step -->
              <autogen>--KeyToKey-- KeyCode::KEY_1,     VK_SHIFT | ModifierFlag::NONE, KeyCode::KEY_1,     ModifierFlag::OPTION_L | ModifierFlag::SHIFT_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEY_2,     VK_SHIFT | ModifierFlag::NONE, KeyCode::KEY_2,     ModifierFlag::OPTION_L | ModifierFlag::SHIFT_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEY_3,     VK_SHIFT | ModifierFlag::NONE, KeyCode::KEY_3,     ModifierFlag::OPTION_L | ModifierFlag::SHIFT_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEY_4,     VK_SHIFT | ModifierFlag::NONE, KeyCode::KEY_4,     ModifierFlag::OPTION_L | ModifierFlag::SHIFT_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEY_5,     VK_SHIFT | ModifierFlag::NONE, KeyCode::KEY_5,     ModifierFlag::OPTION_L | ModifierFlag::SHIFT_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEY_6,     VK_SHIFT | ModifierFlag::NONE, KeyCode::KEY_6,     ModifierFlag::OPTION_L | ModifierFlag::SHIFT_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEY_7,     VK_SHIFT | ModifierFlag::NONE, KeyCode::KEY_7,     ModifierFlag::OPTION_L | ModifierFlag::SHIFT_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEY_8,     VK_SHIFT | ModifierFlag::NONE, KeyCode::KEY_8,     ModifierFlag::OPTION_L | ModifierFlag::SHIFT_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEY_9,     VK_SHIFT | ModifierFlag::NONE, KeyCode::KEY_9,     ModifierFlag::OPTION_L | ModifierFlag::SHIFT_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEY_0,     VK_SHIFT | ModifierFlag::NONE, KeyCode::KEY_0,     ModifierFlag::OPTION_L | ModifierFlag::SHIFT_L</autogen>
              <autogen>--KeyToKey-- KeyCode::MINUS,     VK_SHIFT | ModifierFlag::NONE, KeyCode::MINUS,     ModifierFlag::OPTION_L | ModifierFlag::SHIFT_L</autogen>
              <autogen>--KeyToKey-- KeyCode::JIS_HAT,   VK_SHIFT | ModifierFlag::NONE, KeyCode::JIS_HAT,   ModifierFlag::OPTION_L | ModifierFlag::SHIFT_L</autogen>
              <autogen>--KeyToKey-- KeyCode::JIS_YEN,   VK_SHIFT | ModifierFlag::NONE, KeyCode::JIS_YEN,   ModifierFlag::OPTION_L | ModifierFlag::SHIFT_L</autogen>

              <autogen>--KeyToKey-- KeyCode::KEY_1,     ModifierFlag::NONE, KeyCode::KEY_1,     ModifierFlag::OPTION_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEY_2,     ModifierFlag::NONE, KeyCode::KEY_2,     ModifierFlag::OPTION_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEY_3,     ModifierFlag::NONE, KeyCode::KEY_3,     ModifierFlag::OPTION_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEY_4,     ModifierFlag::NONE, KeyCode::KEY_4,     ModifierFlag::OPTION_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEY_5,     ModifierFlag::NONE, KeyCode::KEY_5,     ModifierFlag::OPTION_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEY_6,     ModifierFlag::NONE, KeyCode::KEY_6,     ModifierFlag::OPTION_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEY_7,     ModifierFlag::NONE, KeyCode::KEY_7,     ModifierFlag::OPTION_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEY_8,     ModifierFlag::NONE, KeyCode::KEY_8,     ModifierFlag::OPTION_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEY_9,     ModifierFlag::NONE, KeyCode::KEY_9,     ModifierFlag::OPTION_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEY_0,     ModifierFlag::NONE, KeyCode::KEY_0,     ModifierFlag::OPTION_L</autogen>
              <autogen>--KeyToKey-- KeyCode::MINUS,     ModifierFlag::NONE, KeyCode::MINUS,     ModifierFlag::OPTION_L</autogen>
              <autogen>--KeyToKey-- KeyCode::JIS_HAT,   ModifierFlag::NONE, KeyCode::JIS_HAT,   ModifierFlag::OPTION_L</autogen>
              <autogen>--KeyToKey-- KeyCode::JIS_YEN,   ModifierFlag::NONE, KeyCode::JIS_YEN,   ModifierFlag::OPTION_L</autogen>
            </item>
            <item>
              <name>Use JIS X 6004 for US Keyboard</name>
              <sysctl>remap.jis_layout_jisx6004_us</sysctl>
              <inputmodedetail_only>INPUTMODE_DETAIL_JAPANESE_HIRAGANA, INPUTMODE_DETAIL_JAPANESE, INPUTMODE_DETAIL_JAPANESE_KATAKANA, INPUTMODE_DETAIL_JAPANESE_HALFWIDTH_KANA</inputmodedetail_only>

              <!-- ====================================================================== -->
              <!-- Shift+Q -> small A (Shift+3) -->
              <autogen>--KeyToKey-- KeyCode::Q, VK_SHIFT | ModifierFlag::NONE, KeyCode::KEY_3, ModifierFlag::SHIFT_L</autogen>
              <!-- Shift+W -> p-sound (=) -->
              <autogen>--KeyToKey-- KeyCode::W, VK_SHIFT | ModifierFlag::NONE, KeyCode::EQUAL</autogen>
              <!-- Shift+E -> HO (minus) -->
              <autogen>--KeyToKey-- KeyCode::E, VK_SHIFT | ModifierFlag::NONE, KeyCode::MINUS</autogen>
              <!-- Shift+R -> FU (2) -->
              <autogen>--KeyToKey-- KeyCode::R, VK_SHIFT | ModifierFlag::NONE, KeyCode::KEY_2</autogen>
              <!-- Shift+T -> ME (/) -->
              <autogen>--KeyToKey-- KeyCode::T, VK_SHIFT | ModifierFlag::NONE, KeyCode::SLASH</autogen>
              <!-- Shift+Y -> HI (V) -->
              <autogen>--KeyToKey-- KeyCode::Y, VK_SHIFT | ModifierFlag::NONE, KeyCode::V</autogen>
              <!-- Shift+U -> E (5) -->
              <autogen>--KeyToKey-- KeyCode::U, VK_SHIFT | ModifierFlag::NONE, KeyCode::KEY_5</autogen>
              <!-- Shift+I -> MI (N) -->
              <autogen>--KeyToKey-- KeyCode::I, VK_SHIFT | ModifierFlag::NONE, KeyCode::N</autogen>
              <!-- Shift+O -> YA (7) -->
              <autogen>--KeyToKey-- KeyCode::O, VK_SHIFT | ModifierFlag::NONE, KeyCode::KEY_7</autogen>
              <!-- Shift+P -> NU (1) -->
              <autogen>--KeyToKey-- KeyCode::P, VK_SHIFT | ModifierFlag::NONE, KeyCode::KEY_1</autogen>
              <!-- Shift+[ -> [ (Shift+=) -->
              <autogen>--KeyToKey-- KeyCode::BRACKET_LEFT, VK_SHIFT | ModifierFlag::NONE, KeyCode::EQUAL, ModifierFlag::SHIFT_L</autogen>

              <!-- Q -> SO (C) -->
              <autogen>--KeyToKey-- KeyCode::Q, ModifierFlag::NONE, KeyCode::C</autogen>
              <!-- W -> KE (') -->
              <autogen>--KeyToKey-- KeyCode::W, ModifierFlag::NONE, KeyCode::QUOTE</autogen>
              <!-- E -> SE (P) -->
              <autogen>--KeyToKey-- KeyCode::E, ModifierFlag::NONE, KeyCode::P</autogen>
              <!-- R -> TE (W) -->
              <autogen>--KeyToKey-- KeyCode::R, ModifierFlag::NONE, KeyCode::W</autogen>
              <!-- T -> small YO (Shift+9) -->
              <autogen>--KeyToKey-- KeyCode::T, ModifierFlag::NONE, KeyCode::KEY_9, ModifierFlag::SHIFT_L</autogen>
              <!-- Y -> TU (Z) -->
              <autogen>--KeyToKey-- KeyCode::Y, ModifierFlag::NONE, KeyCode::Z</autogen>
              <!-- U -> NN (Y) -->
              <autogen>--KeyToKey-- KeyCode::U, ModifierFlag::NONE, KeyCode::Y</autogen>
              <!-- I -> NO (K) -->
              <autogen>--KeyToKey-- KeyCode::I, ModifierFlag::NONE, KeyCode::K</autogen>
              <!-- O -> WO (Shift+0) -->
              <autogen>--KeyToKey-- KeyCode::O, ModifierFlag::NONE, KeyCode::KEY_0, ModifierFlag::SHIFT_L</autogen>
              <!-- P -> RI (L) -->
              <autogen>--KeyToKey-- KeyCode::P, ModifierFlag::NONE, KeyCode::L</autogen>
              <!-- [ -> TI (A) -->
              <autogen>--KeyToKey-- KeyCode::BRACKET_LEFT, ModifierFlag::NONE, KeyCode::A</autogen>

              <!-- ====================================================================== -->
              <!-- Shift+A -> small I (Shift+E) -->
              <autogen>--KeyToKey-- KeyCode::A, VK_SHIFT | ModifierFlag::NONE, KeyCode::E, ModifierFlag::SHIFT_L</autogen>
              <!-- Shift+S -> HE (\) -->
              <autogen>--KeyToKey-- KeyCode::S, VK_SHIFT | ModifierFlag::NONE, KeyCode::BACKSLASH</autogen>
              <!-- Shift+D -> RA (O) -->
              <autogen>--KeyToKey-- KeyCode::D, VK_SHIFT | ModifierFlag::NONE, KeyCode::O</autogen>
              <!-- Shift+F -> small YU (Shift+8) -->
              <autogen>--KeyToKey-- KeyCode::F, VK_SHIFT | ModifierFlag::NONE, KeyCode::KEY_8, ModifierFlag::SHIFT_L</autogen>
              <!-- Shift+G -> YO (9) -->
              <autogen>--KeyToKey-- KeyCode::G, VK_SHIFT | ModifierFlag::NONE, KeyCode::KEY_9</autogen>
              <!-- Shift+H -> MA (J) -->
              <autogen>--KeyToKey-- KeyCode::H, VK_SHIFT | ModifierFlag::NONE, KeyCode::J</autogen>
              <!-- Shift+J -> O (6) -->
              <autogen>--KeyToKey-- KeyCode::J, VK_SHIFT | ModifierFlag::NONE, KeyCode::KEY_6</autogen>
              <!-- Shift+K -> MO (M) -->
              <autogen>--KeyToKey-- KeyCode::K, VK_SHIFT | ModifierFlag::NONE, KeyCode::M</autogen>
              <!-- Shift+L -> WA (0) -->
              <autogen>--KeyToKey-- KeyCode::L, VK_SHIFT | ModifierFlag::NONE, KeyCode::KEY_0</autogen>
              <!-- Shift+; -> YU (8) -->
              <autogen>--KeyToKey-- KeyCode::SEMICOLON, VK_SHIFT | ModifierFlag::NONE, KeyCode::KEY_8</autogen>
              <!-- Shift+' -> ] (Shift+[) -->
              <autogen>--KeyToKey-- KeyCode::QUOTE, VK_SHIFT | ModifierFlag::NONE, KeyCode::BRACKET_LEFT, ModifierFlag::SHIFT_L</autogen>

              <!-- A -> HA (F) -->
              <autogen>--KeyToKey-- KeyCode::A, ModifierFlag::NONE, KeyCode::F</autogen>
              <!-- S -> KA (T) -->
              <autogen>--KeyToKey-- KeyCode::S, ModifierFlag::NONE, KeyCode::T</autogen>
              <!-- D -> SI (D) -->
              <!-- don't change D -->
              <!-- F -> TO (S) -->
              <autogen>--KeyToKey-- KeyCode::F, ModifierFlag::NONE, KeyCode::S</autogen>
              <!-- G -> TA (Q) -->
              <autogen>--KeyToKey-- KeyCode::G, ModifierFlag::NONE, KeyCode::Q</autogen>
              <!-- H -> KU (H) -->
              <!-- don't change H -->
              <!-- J -> U (4) -->
              <autogen>--KeyToKey-- KeyCode::J, ModifierFlag::NONE, KeyCode::KEY_4</autogen>
              <!-- K -> I (E) -->
              <autogen>--KeyToKey-- KeyCode::K, ModifierFlag::NONE, KeyCode::E</autogen>
              <!-- L -> voiced-sound ([) -->
              <autogen>--KeyToKey-- KeyCode::L, ModifierFlag::NONE, KeyCode::BRACKET_LEFT</autogen>
              <!-- ; -> KI (G) -->
              <autogen>--KeyToKey-- KeyCode::SEMICOLON, ModifierFlag::NONE, KeyCode::G</autogen>
              <!-- ' -> NA (U) -->
              <autogen>--KeyToKey-- KeyCode::QUOTE, ModifierFlag::NONE, KeyCode::U</autogen>

              <!-- ====================================================================== -->
              <!-- Shift+Z -> small U (Shift+4) -->
              <autogen>--KeyToKey-- KeyCode::Z, VK_SHIFT | ModifierFlag::NONE, KeyCode::KEY_4, ModifierFlag::SHIFT_L</autogen>
              <!-- Shift+X -> small E (Shift+5) -->
              <autogen>--KeyToKey-- KeyCode::X, VK_SHIFT | ModifierFlag::NONE, KeyCode::KEY_5, ModifierFlag::SHIFT_L</autogen>
              <!-- Shift+C -> small O (Shift+6) -->
              <autogen>--KeyToKey-- KeyCode::C, VK_SHIFT | ModifierFlag::NONE, KeyCode::KEY_6, ModifierFlag::SHIFT_L</autogen>
              <!-- Shift+V -> NE (,) -->
              <autogen>--KeyToKey-- KeyCode::V, VK_SHIFT | ModifierFlag::NONE, KeyCode::COMMA</autogen>
              <!-- Shift+B -> small YA (Shift+7) -->
              <autogen>--KeyToKey-- KeyCode::B, VK_SHIFT | ModifierFlag::NONE, KeyCode::KEY_7, ModifierFlag::SHIFT_L</autogen>
              <!-- Shift+N -> MU (]) -->
              <autogen>--KeyToKey-- KeyCode::N, VK_SHIFT | ModifierFlag::NONE, KeyCode::BRACKET_RIGHT</autogen>
              <!-- Shift+M -> RO (Shift+') -->
              <autogen>--KeyToKey-- KeyCode::M, VK_SHIFT | ModifierFlag::NONE, KeyCode::QUOTE, ModifierFlag::SHIFT_L</autogen>
              <!-- Shift+, -> dot (Shift+slash) -->
              <autogen>--KeyToKey-- KeyCode::COMMA, VK_SHIFT | ModifierFlag::NONE, KeyCode::SLASH, ModifierFlag::SHIFT_L</autogen>
              <!-- Shift+. -> minus (JIS_YEN) -->
              <autogen>--KeyToKey-- KeyCode::DOT, VK_SHIFT | ModifierFlag::NONE, KeyCode::VK_JIS_YEN</autogen>

              <!-- Z -> SU (R) -->
              <autogen>--KeyToKey-- KeyCode::Z, ModifierFlag::NONE, KeyCode::R</autogen>
              <!-- X -> KO (B) -->
              <autogen>--KeyToKey-- KeyCode::X, ModifierFlag::NONE, KeyCode::B</autogen>
              <!-- C -> NI (I) -->
              <autogen>--KeyToKey-- KeyCode::C, ModifierFlag::NONE, KeyCode::I</autogen>
              <!-- V -> SA (X) -->
              <autogen>--KeyToKey-- KeyCode::V, ModifierFlag::NONE, KeyCode::X</autogen>
              <!-- B -> A (3) -->
              <autogen>--KeyToKey-- KeyCode::B, ModifierFlag::NONE, KeyCode::KEY_3</autogen>
              <!-- N -> small TU (Shift+Z) -->
              <autogen>--KeyToKey-- KeyCode::N, ModifierFlag::NONE, KeyCode::Z, ModifierFlag::SHIFT_L</autogen>
              <!-- M -> RU (dot) -->
              <autogen>--KeyToKey-- KeyCode::M, ModifierFlag::NONE, KeyCode::DOT</autogen>
              <!-- , -> , (Shift+,) -->
              <autogen>--KeyToKey-- KeyCode::COMMA, ModifierFlag::NONE, KeyCode::COMMA, ModifierFlag::SHIFT_L</autogen>
              <!-- . -> . (Shift+.) -->
              <autogen>--KeyToKey-- KeyCode::DOT, ModifierFlag::NONE, KeyCode::DOT, ModifierFlag::SHIFT_L</autogen>
              <!-- / -> RE (;) -->
              <autogen>--KeyToKey-- KeyCode::SLASH, ModifierFlag::NONE, KeyCode::SEMICOLON</autogen>

              <!-- ====================================================================== -->
              <!-- An upper step -->
              <autogen>--KeyToKey-- KeyCode::BACKQUOTE, VK_SHIFT | ModifierFlag::NONE, KeyCode::BACKQUOTE, ModifierFlag::OPTION_L | ModifierFlag::SHIFT_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEY_1,     VK_SHIFT | ModifierFlag::NONE, KeyCode::KEY_1,     ModifierFlag::OPTION_L | ModifierFlag::SHIFT_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEY_2,     VK_SHIFT | ModifierFlag::NONE, KeyCode::KEY_2,     ModifierFlag::OPTION_L | ModifierFlag::SHIFT_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEY_3,     VK_SHIFT | ModifierFlag::NONE, KeyCode::KEY_3,     ModifierFlag::OPTION_L | ModifierFlag::SHIFT_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEY_4,     VK_SHIFT | ModifierFlag::NONE, KeyCode::KEY_4,     ModifierFlag::OPTION_L | ModifierFlag::SHIFT_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEY_5,     VK_SHIFT | ModifierFlag::NONE, KeyCode::KEY_5,     ModifierFlag::OPTION_L | ModifierFlag::SHIFT_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEY_6,     VK_SHIFT | ModifierFlag::NONE, KeyCode::KEY_6,     ModifierFlag::OPTION_L | ModifierFlag::SHIFT_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEY_7,     VK_SHIFT | ModifierFlag::NONE, KeyCode::KEY_7,     ModifierFlag::OPTION_L | ModifierFlag::SHIFT_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEY_8,     VK_SHIFT | ModifierFlag::NONE, KeyCode::KEY_8,     ModifierFlag::OPTION_L | ModifierFlag::SHIFT_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEY_9,     VK_SHIFT | ModifierFlag::NONE, KeyCode::KEY_9,     ModifierFlag::OPTION_L | ModifierFlag::SHIFT_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEY_0,     VK_SHIFT | ModifierFlag::NONE, KeyCode::KEY_0,     ModifierFlag::OPTION_L | ModifierFlag::SHIFT_L</autogen>
              <autogen>--KeyToKey-- KeyCode::MINUS,     VK_SHIFT | ModifierFlag::NONE, KeyCode::MINUS,     ModifierFlag::OPTION_L | ModifierFlag::SHIFT_L</autogen>
              <autogen>--KeyToKey-- KeyCode::EQUAL,     VK_SHIFT | ModifierFlag::NONE, KeyCode::EQUAL,     ModifierFlag::OPTION_L | ModifierFlag::SHIFT_L</autogen>

              <autogen>--KeyToKey-- KeyCode::BACKQUOTE, ModifierFlag::NONE, KeyCode::BACKQUOTE, ModifierFlag::OPTION_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEY_1,     ModifierFlag::NONE, KeyCode::KEY_1,     ModifierFlag::OPTION_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEY_2,     ModifierFlag::NONE, KeyCode::KEY_2,     ModifierFlag::OPTION_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEY_3,     ModifierFlag::NONE, KeyCode::KEY_3,     ModifierFlag::OPTION_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEY_4,     ModifierFlag::NONE, KeyCode::KEY_4,     ModifierFlag::OPTION_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEY_5,     ModifierFlag::NONE, KeyCode::KEY_5,     ModifierFlag::OPTION_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEY_6,     ModifierFlag::NONE, KeyCode::KEY_6,     ModifierFlag::OPTION_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEY_7,     ModifierFlag::NONE, KeyCode::KEY_7,     ModifierFlag::OPTION_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEY_8,     ModifierFlag::NONE, KeyCode::KEY_8,     ModifierFlag::OPTION_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEY_9,     ModifierFlag::NONE, KeyCode::KEY_9,     ModifierFlag::OPTION_L</autogen>
              <autogen>--KeyToKey-- KeyCode::KEY_0,     ModifierFlag::NONE, KeyCode::KEY_0,     ModifierFlag::OPTION_L</autogen>
              <autogen>--KeyToKey-- KeyCode::MINUS,     ModifierFlag::NONE, KeyCode::MINUS,     ModifierFlag::OPTION_L</autogen>
              <autogen>--KeyToKey-- KeyCode::EQUAL,     ModifierFlag::NONE, KeyCode::EQUAL,     ModifierFlag::OPTION_L</autogen>

              <!-- ====================================================================== -->
              <!-- Extra -->

              <!-- \ -> JIS_BACKSLASH -->
              <autogen>--KeyToKey-- KeyCode::BACKSLASH, ModifierFlag::NONE, KeyCode::VK_JIS_BACKSLASH, ModifierFlag::OPTION_L</autogen>

              <!-- \ -> vertical_line (JIS_VERTICAL_LINE) -->
              <autogen>--KeyToKey-- KeyCode::BACKSLASH, VK_SHIFT | ModifierFlag::NONE, KeyCode::VK_JIS_YEN, ModifierFlag::OPTION_L | ModifierFlag::SHIFT_L</autogen>

              <!-- ] -> NONE -->
              <autogen>--KeyToKey-- KeyCode::BRACKET_RIGHT, ModifierFlag::NONE, KeyCode::VK_NONE</autogen>

              <!-- Shift+] -> NONE -->
              <autogen>--KeyToKey-- KeyCode::BRACKET_RIGHT,VK_SHIFT | ModifierFlag::NONE, KeyCode::VK_NONE</autogen>

              <!-- Shift+/ -> question (JIS_QUESION) -->
              <autogen>--KeyToKey-- KeyCode::SLASH, VK_SHIFT | ModifierFlag::NONE, KeyCode::SLASH, ModifierFlag::OPTION_L | ModifierFlag::SHIFT_L</autogen>
            </item>
            <item>
              <name>Use KAWASHIMA Special Keyboard Layout</name>
              <sysctl>remap.jis_layout_kawashima</sysctl>
              <inputmodedetail_only>INPUTMODE_DETAIL_JAPANESE_HIRAGANA, INPUTMODE_DETAIL_JAPANESE</inputmodedetail_only>
              <!-- A -> Q, A+Shift_L -> 1, A+Shift_R -> Q[ -->
              <autogen>--KeyToKey-- KeyCode::A, ModifierFlag::SHIFT_L, KeyCode::KEY_1</autogen>
              <autogen>--KeyToKey-- KeyCode::A, ModifierFlag::SHIFT_R, KeyCode::Q, KeyCode::BRACKET_LEFT</autogen>
              <autogen>--KeyToKey-- KeyCode::A, ModifierFlag::NONE, KeyCode::Q</autogen>
              <!-- J -> E, J+Shift_L -> A[, J+Shift_R -> A -->
              <autogen>--KeyToKey-- KeyCode::J, ModifierFlag::SHIFT_L, KeyCode::A, KeyCode::BRACKET_LEFT</autogen>
              <autogen>--KeyToKey-- KeyCode::J, ModifierFlag::SHIFT_R, KeyCode::A</autogen>
              <autogen>--KeyToKey-- KeyCode::J, ModifierFlag::NONE, KeyCode::E</autogen>
            </item>
            <item>
              <name>Use Windows Kana-Input Layout on ASCII Keyboard</name>
              <inputmode_not>INPUTMODE_ROMAN</inputmode_not>
              <autogen>--KeyToKey-- KeyCode::MINUS, VK_SHIFT, KeyCode::BRACKET_RIGHT, ModifierFlag::SHIFT_L</autogen>
              <autogen>--KeyToKey-- KeyCode::BRACKET_RIGHT, VK_SHIFT, KeyCode::BRACKET_LEFT, ModifierFlag::SHIFT_L</autogen>
              <autogen>--KeyToKey-- KeyCode::BRACKET_LEFT, VK_SHIFT, KeyCode::EQUAL, ModifierFlag::SHIFT_L</autogen>
              <autogen>--KeyToKey-- KeyCode::EQUAL, VK_SHIFT, KeyCode::MINUS, ModifierFlag::SHIFT_L</autogen>

              <autogen>--KeyToKey-- KeyCode::BRACKET_RIGHT, ModifierFlag::NONE, KeyCode::EQUAL</autogen>
              <autogen>--KeyToKey-- KeyCode::EQUAL, ModifierFlag::NONE, KeyCode::BACKSLASH</autogen>
              <autogen>--KeyToKey-- KeyCode::BACKSLASH, ModifierFlag::NONE, KeyCode::BRACKET_RIGHT</autogen>
              <sysctl>remap.jis_layout_windowskanainput</sysctl>
            </item>
          </list>
        </item>
        <item>
          <name>Simultaneous Key Presses</name>
          <list>
            <item>
              <name>Simultaneous Key Presses [EISUU+KANA] to toggle Vi Mode</name>
              <sysctl>remap.vimode_toggle_eisuukana</sysctl>
              <autogen>--SimultaneousKeyPresses-- KeyCode::JIS_EISUU, KeyCode::JIS_KANA, KeyCode::VK_CONFIG_TOGGLE_notsave_complete_vimode</autogen>
            </item>
          </list>
        </item>
        <item>
          <name>Hack for the bug of Mac OS X</name>
          <list>
            <item>
              <name>Drop Command/Control/Option/Shift+EISUU, Command/Control/Option/Shift+KANA</name>
              <appendix>(to prevent the system hangup at Snow Leopard)</appendix>
              <sysctl>option.jis_drop_eisuukana_with_modifiers</sysctl>
              <autogen>--DropKeyAfterRemap-- KeyCode::JIS_EISUU, VK_COMMAND</autogen>
              <autogen>--DropKeyAfterRemap-- KeyCode::JIS_KANA,  VK_COMMAND</autogen>
              <autogen>--DropKeyAfterRemap-- KeyCode::JIS_EISUU, VK_CONTROL</autogen>
              <autogen>--DropKeyAfterRemap-- KeyCode::JIS_KANA,  VK_CONTROL</autogen>
              <autogen>--DropKeyAfterRemap-- KeyCode::JIS_EISUU, VK_OPTION</autogen>
              <autogen>--DropKeyAfterRemap-- KeyCode::JIS_KANA,  VK_OPTION</autogen>
              <autogen>--DropKeyAfterRemap-- KeyCode::JIS_EISUU, VK_SHIFT</autogen>
              <autogen>--DropKeyAfterRemap-- KeyCode::JIS_KANA,  VK_SHIFT</autogen>
            </item>
          </list>
        </item>
      </list>
    </item>
    <item>
      <name>For Russian</name>
      <list>
        <item>
          <name>Change Backquote(`) Key</name>
          <list>
            <item>
              <name>Backquote(`) to Paragraph(§)</name>
              <sysctl>remap.russian_backquote2paragraph</sysctl>
              <autogen>--KeyToKey-- KeyCode::BACKQUOTE, KeyCode::RUSSIAN_PARAGRAPH</autogen>
            </item>
          </list>
        </item>
        <item>
          <name>Change Command_L Key</name>
          <list>
            <item>
              <name>Command_L to Command_L</name>
              <appendix>(+ When you type Command_L only, change inputmode to english)</appendix>
              <sysctl>remap.russian_commandL2commandL_english</sysctl>
              <autogen>--KeyOverlaidModifier-- KeyCode::COMMAND_L, KeyCode::COMMAND_L, KeyCode::VK_CHANGE_INPUTMODE_ENGLISH</autogen>
            </item>
          </list>
        </item>
        <item>
          <name>Change Command_R Key</name>
          <list>
            <item>
              <name>Command_R to Command_R</name>
              <appendix>(+ When you type Command_R only, change inputmode to russian)</appendix>
              <sysctl>remap.russian_commandR2commandR_russian</sysctl>
              <autogen>--KeyOverlaidModifier-- KeyCode::COMMAND_R, KeyCode::COMMAND_R, KeyCode::VK_CHANGE_INPUTMODE_RUSSIAN</autogen>
            </item>
          </list>
        </item>
        <item>
          <name>Change Paragraph(§) Key</name>
          <list>
            <item>
              <name>Paragraph(§) to Backquote(`)</name>
              <sysctl>remap.russian_paragraph2backquote</sysctl>
              <autogen>--KeyToKey-- KeyCode::RUSSIAN_PARAGRAPH, KeyCode::BACKQUOTE</autogen>
            </item>
            <item>
              <name>Paragraph(§) to Escape</name>
              <sysctl>remap.russian_paragraph2escape</sysctl>
              <autogen>--KeyToKey-- KeyCode::RUSSIAN_PARAGRAPH, KeyCode::ESCAPE</autogen>
            </item>
            <item>
              <name>Paragraph(§) to Forward Delete</name>
              <sysctl>remap.russian_paragraph2forwarddelete</sysctl>
              <autogen>--KeyToKey-- KeyCode::RUSSIAN_PARAGRAPH, KeyCode::FORWARD_DELETE</autogen>
            </item>
          </list>
        </item>
        <item>
          <name>Change Tilda(~) Key</name>
          <list>
            <item>
              <name>Tilda(~) to Shift_L</name>
              <sysctl>remap.russian_tilda2shiftL</sysctl>
              <autogen>--KeyToKey-- KeyCode::RUSSIAN_TILDA, KeyCode::SHIFT_L</autogen>
            </item>
          </list>
        </item>
      </list>
    </item>
    <item>
      <name>For Swedish</name>
      <list>
        <item>
          <name>Space to Option_L (when inputmode == swedish)</name>
          <sysctl>remap.swedish_space2optionL_swedish</sysctl>
          <inputmode_only>INPUTMODE_SWEDISH</inputmode_only>
          <autogen>--KeyToKey-- KeyCode::SPACE, KeyCode::OPTION_L</autogen>
        </item>
        <item>
          <name>Command_L to Command_L</name>
          <appendix>(+ When you type Command_L only, change inputmode to english)</appendix>
          <sysctl>remap.swedish_commandL2commandL_english</sysctl>
          <autogen>--KeyOverlaidModifier-- KeyCode::COMMAND_L, KeyCode::COMMAND_L, KeyCode::VK_CHANGE_INPUTMODE_ENGLISH</autogen>
        </item>
        <item>
          <name>Command_R to Command_R</name>
          <appendix>(+ When you type Command_R only, change inputmode to swedish)</appendix>
          <sysctl>remap.swedish_commandR2commandR_swedish</sysctl>
          <autogen>--KeyOverlaidModifier-- KeyCode::COMMAND_R, KeyCode::COMMAND_R, KeyCode::VK_CHANGE_INPUTMODE_SWEDISH</autogen>
        </item>
        <item>
          <name>Swap Section(§) and Less-Than(&lt;)</name>
          <appendix>(only in virtual machine)</appendix>
          <sysctl>remap.swedish_swap_section_lessthan_vm</sysctl>
          <only>VIRTUALMACHINE</only>
          <autogen>--KeyToKey-- KeyCode::SWEDISH_SECTION, KeyCode::SWEDISH_LESS_THAN</autogen>
          <autogen>--KeyToKey-- KeyCode::SWEDISH_LESS_THAN, KeyCode::SWEDISH_SECTION</autogen>
        </item>
      </list>
    </item>
    <item>
      <name>For Swiss</name>
      <list>
        <item>
          <name>Swap Y and Z</name>
          <sysctl>remap.swiss_swap_y_z</sysctl>
          <autogen>--KeyToKey-- KeyCode::Y, KeyCode::Z</autogen>
          <autogen>--KeyToKey-- KeyCode::Z, KeyCode::Y</autogen>
        </item>
        <item>
          <name>Swap Section(§) and Less-Than(&lt;)</name>
          <appendix>(only in virtual machine)</appendix>
          <sysctl>remap.swiss_swap_section_lessthan_vm</sysctl>
          <only>VIRTUALMACHINE</only>
          <autogen>--KeyToKey-- KeyCode::SWISS_SECTION, KeyCode::SWISS_LESS_THAN</autogen>
          <autogen>--KeyToKey-- KeyCode::SWISS_LESS_THAN, KeyCode::SWISS_SECTION</autogen>
        </item>
      </list>
    </item>
    <item>
      <name>For UK Keyboard users</name>
      <list>
        <item>
          <name>Improve UK Keyboard Layout</name>
          <appendix>( '\' to additional Enter, '§' to '`' and '`' to '\' )</appendix>
          <sysctl>remap.uk_saneuklayout</sysctl>
          <autogen>--KeyToKey-- KeyCode::UK_SECTION, KeyCode::BACKQUOTE</autogen>
          <autogen>--KeyToKey-- KeyCode::BACKQUOTE, KeyCode::BACKSLASH</autogen>
          <autogen>--KeyToKey-- KeyCode::BACKSLASH, KeyCode::ENTER</autogen>
        </item>
        <item>
          <name>Improve UK Keyboard Layout (Option 2)</name>
          <appendix>( '§' to '`' and '`' to '\' )</appendix>
          <sysctl>remap.uk_saneuklayout2</sysctl>
          <autogen>--KeyToKey-- KeyCode::UK_SECTION, KeyCode::BACKQUOTE</autogen>
          <autogen>--KeyToKey-- KeyCode::BACKQUOTE, KeyCode::BACKSLASH</autogen>
        </item>
        <item>
          <name>Swap @ and double-quote(")</name>
          <sysctl>remap.uk_swap_at_doublequote</sysctl>
          <autogen>--KeyToKey-- KeyCode::KEY_2, VK_SHIFT, KeyCode::QUOTE, ModifierFlag::SHIFT_L</autogen>
          <autogen>--KeyToKey-- KeyCode::QUOTE, VK_SHIFT, KeyCode::KEY_2, ModifierFlag::SHIFT_L</autogen>
        </item>
        <item>
          <name>Section(§) to Option_L+3 (#), Shift+Section(§) to Tilde(~)</name>
          <sysctl>remap.uk_section2hash</sysctl>
          <autogen>--KeyToKey-- KeyCode::UK_SECTION, VK_SHIFT, KeyCode::BACKQUOTE, ModifierFlag::SHIFT_L</autogen>
          <autogen>--KeyToKey-- KeyCode::UK_SECTION, KeyCode::KEY_3, ModifierFlag::OPTION_L</autogen>
        </item>
        <item>
          <name>Backquote(`) to Backslash(\)</name>
          <sysctl>remap.uk_backquote2backslash</sysctl>
          <autogen>--KeyToKey-- KeyCode::BACKQUOTE, KeyCode::BACKSLASH</autogen>
        </item>
        <item>
          <name>Backquote(`) to Section(§)</name>
          <sysctl>remap.uk_backquote2section</sysctl>
          <autogen>--KeyToKey-- KeyCode::BACKQUOTE, KeyCode::UK_SECTION</autogen>
        </item>
        <item>
          <name>Backquote(`) to Shift_L</name>
          <sysctl>remap.uk_backquote2shiftL</sysctl>
          <autogen>--KeyToKey-- KeyCode::BACKQUOTE, KeyCode::SHIFT_L</autogen>
        </item>
        <item>
          <name>Backslash(\) to Option_L+3 (#), Shift+Backslash(\) to Tilde(~)</name>
          <sysctl>remap.uk_backslash2hash</sysctl>
          <autogen>--KeyToKey-- KeyCode::BACKSLASH, VK_SHIFT, KeyCode::BACKQUOTE, ModifierFlag::SHIFT_L</autogen>
          <autogen>--KeyToKey-- KeyCode::BACKSLASH, KeyCode::KEY_3, ModifierFlag::OPTION_L</autogen>
        </item>
        <item>
          <name>Section(§) to Backquote(`)</name>
          <sysctl>remap.uk_section2backquote</sysctl>
          <autogen>--KeyToKey-- KeyCode::UK_SECTION, KeyCode::BACKQUOTE</autogen>
        </item>
        <item>
          <name>Section(§) to Backquote(`)</name>
          <appendix>(except virtual machine)</appendix>
          <sysctl>remap.uk_section2backquote_ex_vm</sysctl>
          <not>VIRTUALMACHINE</not>
          <autogen>--KeyToKey-- KeyCode::UK_SECTION, KeyCode::BACKQUOTE</autogen>
        </item>
        <item>
          <name>Section(§) to Backslash(\)</name>
          <sysctl>remap.uk_section2backslash</sysctl>
          <autogen>--KeyToKey-- KeyCode::UK_SECTION, KeyCode::BACKSLASH</autogen>
        </item>
      </list>
    </item>
    <!-- #include "include/samples.xml" -->
    <!-- #include "include/local.bottom.xml" -->
  </list>
</root>
