#
# basic.txt describes the expected output of running kmc against basic.xml. It is used in
# the end-to-end test test-compiler-e2e.ts.
#
# Any changes to the compiler or basic.xml will likely result in changes to the compiled file.
# While structural differences should be updated manually in this file to ensure that we are
# getting the expected result for the e2e test, the checksum can be safely retrieved from the
# updated compilation result. The following may be helpful for working with this file when
# updating the binary format:
#
#    cd developer/src/kmc
#    ./build.sh configure build # if needed
#    ./build.sh build-fixtures
#
#  This will compile both the .xml and the .txt to build/test/fixtures and also emit the
#  checksum for basic-xml.kmx so you can patch that into this file.
#

block(kmxheader)  #  struct COMP_KEYBOARD {
  4b 58 54 53      #    KMX_DWORD dwIdentifier;   // 0000 Keyman compiled keyboard id

  00 10 00 00      #    KMX_DWORD dwFileVersion;  // 0004 Version of the file - Keyman 4.0 is 0x0400

  00 00 00 00      #    KMX_DWORD dwCheckSum;     // 0008 deprecated in 16.0, always 0
  00 00 00 00      #    KMX_DWORD KeyboardID;     // 000C as stored in HKEY_LOCAL_MACHINE//system//currentcontrolset//control//keyboard layouts
  01 00 00 00      #    KMX_DWORD IsRegistered;   // 0010
  00 00 00 00      #    KMX_DWORD version;        // 0014 keyboard version

  sizeof(stores,12) #    KMX_DWORD cxStoreArray;   // 0018 in array entries
  00 00 00 00       #    KMX_DWORD cxGroupArray;   // 001C in array entries

  offset(stores)   #    KMX_DWORD dpStoreArray;   // 0020 [LPSTORE] address of first item in store array
  00 00 00 00      #    KMX_DWORD dpGroupArray;   // 0024 [LPGROUP] address of first item in group array

  ff ff ff ff      #    KMX_DWORD StartGroup[2];  // 0028 index of starting groups [2 of them]
  ff ff ff ff      #

  20 00 00 00      #    KMX_DWORD dwFlags;        // 0030 Flags for the keyboard file

  00 00 00 00      #    KMX_DWORD dwHotKey;       // 0034 standard windows hotkey (hiword=shift/ctrl/alt stuff, loword=vkey)

  00 00 00 00      #    KMX_DWORD dpBitmapOffset; // 0038 offset of the bitmaps in the file
  00 00 00 00      #    KMX_DWORD dwBitmapSize;   // 003C size in bytes of the bitmaps
                   #  };

block(kmxplusinfo)                  #  struct COMP_KEYBOARD_KMXPLUSINFO {
  offset(sect)                      #    KMX_DWORD dpKMXPlus;      // 0040 offset of KMXPlus data from BOF, <sect> header is first
  diff(sect,eof)                    #    KMX_DWORD dwKMXPlusSize;  // 0044 size in bytes of entire KMXPlus data
                                    #  };

block(stores)                          #  struct COMP_STORE {
  07 00 00 00                          #  KMX_DWORD dwSystemID; - TSS_NAME
  offset(store_name_name)              #  KMX_DWORD dpName;
  offset(store_name_string)            #  KMX_DWORD dpString;
                                       #  };
  # excluding this so we don't have compiled version changes
  # 14 00 00 00                          #  KMX_DWORD dwSystemID; - TSS_COMPILEDVERSION
  # offset(store_compiledversion_name)   #  KMX_DWORD dpName;
  # offset(store_compiledversion_string) #  KMX_DWORD dpString;
                                       #  };
  24 00 00 00                          #  KMX_DWORD dwSystemID; - TSS_KEYBOARDVERSION
  offset(store_keyboardversion_name)   #  KMX_DWORD dpName;
  offset(store_keyboardversion_string) #  KMX_DWORD dpString;
                                       #  };
  26 00 00 00                          #  KMX_DWORD dwSystemID; - TSS_TARGETS
  offset(store_targets_name)           #  KMX_DWORD dpName;
  offset(store_targets_string)         #  KMX_DWORD dpString;
                                       #  };

block(store_name_name)
  26 00 4e 00 41 00 4d 00 45 00 00 00  # '&NAME'
block(store_name_string)
  54 00 65 00 73 00 74 00 4b 00 62 00 64 00 00 00 # 'TestKbd'

block(store_keyboardversion_name)
  26 00 4b 00 45 00 59 00 42 00 4f 00 41 00 52 00
  44 00 56 00 45 00 52 00 53 00 49 00 4f 00 4e 00
  00 00                                # '&KEYBOARDVERSION'
block(store_keyboardversion_string)
  31 00 2e 00 30 00 2e 00 30 00 00 00  # '1.0.0'

block(store_targets_name)
  26 00 54 00 41 00 52 00 47 00 45 00 54 00 53 00 00 00 # '&TARGETS'
block(store_targets_string)
  64 00 65 00 73 00 6b 00 74 00 6f 00 70 00 00 00 # 'desktop'

block(sect)                         #  struct COMP_KMXPLUS_SECT {
  73 65 63 74                       #    KMX_DWORD header.ident;   // 0000 Section name
  diff(sect,endsect)                #    KMX_DWORD header.size;    // 0004 Section length
  diff(sect,eof)                    #    KMX_DWORD total;          // 0008 KMXPlus entire length
  sizeof(sectitems,8)               #    KMX_DWORD count;          // 000C number of section headers
                                    #  };
  # Next sections are sect entries
  #    KMX_DWORD sect;           // 0010+ Section identity
  #    KMX_DWORD offset;         // 0014+ Section offset relative to dpKMXPlus of section

block(sectitems)
  # 62 6b 73 70
  # diff(sect,bksp)

  64 69 73 70
  diff(sect,disp)

  65 6c 65 6d
  diff(sect,elem)

  # 66 69 6e 6c
  # diff(sect,finl)

  6b 65 79 73
  diff(sect,keys)

  6c 61 79 72
  diff(sect,layr)

  6c 69 73 74
  diff(sect,list)

  6c 6f 63 61
  diff(sect,loca)

  6d 65 74 61
  diff(sect,meta)

  6e 61 6d 65
  diff(sect,name)

  # 6f 72 64 72
  # diff(sect,ordr)

  73 74 72 73
  diff(sect,strs)

  # 74 72 61 6e
  # diff(sect,tran)

  76 6b 65 79
  diff(sect,vkey)

block(endsect)

# ----------------------------------------------------------------------------------------------------
# bksp
# ----------------------------------------------------------------------------------------------------

# block(bksp)
#   62 6b 73 70
#   sizeof(bksp)
#   01 00 00 00                       #   KMX_DWORD count;          // 0008 number of entries
#                                     # };

#                                     # struct COMP_KMXPLUS_TRAN_ENTRY {
#   index(elemNull,elemBkspFrom)      #    KMXPLUS_ELEM from;
#   00 00 00 00                       #    KMXPLUS_STR to;
#   00 00 00 00                       #    KMXPLUS_ELEM before;
#   00 00 00 00                       #    KMX_DWORD flags;
#                                     # };


# ----------------------------------------------------------------------------------------------------
# disp
# ----------------------------------------------------------------------------------------------------

block(disp)                         # struct COMP_KMXPLUS_DISP {
  64 69 73 70                       #   KMX_DWORD header.ident;   // 0000 Section name - disp
  sizeof(disp)                      #   KMX_DWORD header.size;    // 0004 Section length
  01 00 00 00                       #   KMX_DWORD count;          // 0008 number of entries
  index(strNull,strElemBkspFrom2,2) #   KMX_DWORD baseCharacter   // 000C baseCharacter = 'e'
                                    # };

                                    # only entry:
  index(strNull,strElemTranFrom2,2) #   KMX_DWORD to       // 000C baseCharacter = 'a'
  index(strNull,strElemTranFrom1,2) #   KMX_DWORD display   // 000C baseCharacter = '^'



# ----------------------------------------------------------------------------------------------------
# elem
# ----------------------------------------------------------------------------------------------------

block(elem)                         # struct COMP_KMXPLUS_ELEM {
  65 6c 65 6d                       #   KMX_DWORD header.ident;   // 0000 Section name - elem
  diff(elem,endelem)                #   KMX_DWORD header.size;    // 0004 Section length
  index(elemNull,endelem)           #   KMX_DWORD count;          // 0008 number of entries
                                    # };

  00 00 00 00                       #    KMX_DWORD offset;                 // 0010+ offset from this blob
  sizeof(elemNull,8)                #    KMX_DWORD length;                 // 0014+ str length (ELEMENT units)

  # diff(elem,elemFinlFrom)           #    KMX_DWORD offset;                 // 0010+ offset from this blob
  # sizeof(elemFinlFrom,8)            #    KMX_DWORD length;                 // 0014+ str length (ELEMENT units)

  # diff(elem,elemTranFrom)           #    KMX_DWORD offset;                 // 0010+ offset from this blob
  # sizeof(elemTranFrom,8)            #    KMX_DWORD length;                 // 0014+ str length (ELEMENT units)

  # diff(elem,elemBkspFrom)           #    KMX_DWORD offset;                 // 0010+ offset from this blob
  # sizeof(elemBkspFrom,8)            #    KMX_DWORD length;                 // 0014+ str length (ELEMENT units)

  # diff(elem,elemOrdrFrom)           #    KMX_DWORD offset;                 // 0010+ offset from this blob
  # sizeof(elemOrdrFrom,8)            #    KMX_DWORD length;                 // 0014+ str length (ELEMENT units)

  # diff(elem,elemOrdrBefore)         #    KMX_DWORD offset;                 // 0010+ offset from this blob
  # sizeof(elemOrdrBefore,8)          #    KMX_DWORD length;                 // 0014+ str length (ELEMENT units)


block(elemNull)

# block(elemFinlFrom)
#   index(strNull,strElemTranFrom1,2)  #    KMX_DWORD element;                // str: output string or UTF-32LE codepoint
#   01 00 00 00                        #    KMX_DWORD flags;                  // flag and order values - unicodeset
#   index(strNull,strElemTranFrom1,2)  #    KMX_DWORD element;                // str: output string or UTF-32LE codepoint
#   01 00 00 00                        #    KMX_DWORD flags;                  // flag and order values - unicodeset

# block(elemTranFrom)
#   index(strNull,strElemTranFrom1,2)  #    KMX_DWORD element;                // str: output string or UTF-32LE codepoint
#   01 00 00 00                        #    KMX_DWORD flags;                  // flag and order values - unicodeset
#   index(strNull,strElemTranFrom2,2)  #    KMX_DWORD element;                // str: output string or UTF-32LE codepoint
#   01 00 00 00                        #    KMX_DWORD flags;                  // flag and order values - unicodeset

# block(elemBkspFrom)
#   index(strNull,strElemTranFrom1,2)  #    KMX_DWORD element;                // str: output string or UTF-32LE codepoint
#   01 00 00 00                        #    KMX_DWORD flags;                  // flag and order values - unicodeset
#   index(strNull,strElemBkspFrom2,2)  #    KMX_DWORD element;                // str: output string or UTF-32LE codepoint
#   01 00 00 00                        #    KMX_DWORD flags;                  // flag and order values - unicodeset

# block(elemOrdrFrom)
#   # <reorder before="ᩫ" from="᩠᩵ᩅ" order="10 55 10" />
#   index(strNull,strElemOrdrFrom1,2)  #    KMX_DWORD element;                // str: output string or UTF-32LE codepoint
#   01 00 0A 00                        #    KMX_DWORD flags;                  // flag and order values - unicodeset
#   index(strNull,strElemOrdrFrom2,2)  #    KMX_DWORD element;                // str: output string or UTF-32LE codepoint
#   01 00 37 00                        #    KMX_DWORD flags;                  // flag and order values - unicodeset
#   index(strNull,strElemOrdrFrom3,2)  #    KMX_DWORD element;                // str: output string or UTF-32LE codepoint
#   01 00 0A 00                        #    KMX_DWORD flags;                  // flag and order values - unicodeset

# block(elemOrdrBefore)
#   index(strNull,strElemOrdrBefore,2) #    KMX_DWORD element;                // str: output string or UTF-32LE codepoint
#   01 00 00 00                        #    KMX_DWORD flags;                  // flag and order values - unicodeset

block(endelem)

# ----------------------------------------------------------------------------------------------------
# finl
# ----------------------------------------------------------------------------------------------------

# block(finl)
#   66 69 6e 6c
#   sizeof(finl)
#   01 00 00 00                       #   KMX_DWORD count;          // 0008 number of entries
#                                     # };

#                                     # struct COMP_KMXPLUS_TRAN_ENTRY {
#   index(elemNull,elemFinlFrom)      #    KMXPLUS_ELEM from;
#   index(strNull,strElemTranFrom1,2) #    KMXPLUS_STR to;
#   00 00 00 00                       #    KMXPLUS_ELEM before;
#   01 00 00 00                       #    KMX_DWORD flags;
#                                     # };
# ----------------------------------------------------------------------------------------------------
# keys
# ----------------------------------------------------------------------------------------------------

block(keys)                         # struct COMP_KMXPLUS_KEYS {
  6b 65 79 73                       #   KMX_DWORD header.ident;   // 0000 Section name - keys
  sizeof(keys)                      #   KMX_DWORD header.size;    // 0004 Section length
  02 00 00 00                       #   KMX_DWORD keyCount
  01 00 00 00                       #   KMX_DWORD flicksCount
  00 00 00 00                       #   KMX_DWORD flickCount
  02 00 00 00                       #   KMX_DWORD kmapCount;          // 0008 number of kmap
  # keys
  # (#0000) hmaqtugha
  index(strNull,strKey1,2)          #   KMXPLUS_STR 'U+0127'
  01 00 00 00                       #   KMX_DWORD (flags: extend)
  index(strNull,strHmaqtugha,2)     #   KMXPLUS_STR 'hmaqtugha'
  00 00 00 00                       #   KMXPLUS_STR switch
  0A 00 00 00                       #   KMX_DWORD width*10
  01 00 00 00 # TODO: index(listNull,indexAe,4)         #   LIST longPress 'a e'
  00 00 00 00                       #   STR longPressDefault
  00 00 00 00 # TODO: index(listNull,listNull,4)        #   LIST multiTap
  00 00 00 00                       #   flicks 0
  # (#0001) that
  index(strNull,strKeys,2)          #   KMXPLUS_STR 'U+0127'
  01 00 00 00                       #   KMX_DWORD flags = extend
  index(strNull,strThat,2)          #   KMXPLUS_STR 'hmaqtugha'
  00 00 00 00                       #   KMXPLUS_STR switch
  0A 00 00 00                       #   KMX_DWORD width*10
  00 00 00 00 # TODO: index(listNull,listNull,4)        #   LIST longPress
  00 00 00 00                       #   STR longPressDefault
  00 00 00 00 # TODO: index(listNull,listNull,4)        #   LIST multiTap
  00 00 00 00                       #   flicks 0
  # flicks
  #  flicks 0 - null
  00 00 00 00                       #   KMX_DWORD count
  00 00 00 00                       #   KMX_DWORD flick
  00 00 00 00                       #   KMX_STR id
  # flick
  # Right now there aren't any flick elements.
  #00 00 00 00                       #   LIST directions
  #00 00 00 01                       #   flags
  #00 00 00 00                       #   str: to
  # kmapdata:

  31 00 00 00  00 00 00 00  01 00 00 00  # KMX_DWORD vkey, mod, key;
  c0 00 00 00  00 00 00 00  00 00 00 00  # KMX_DWORD vkey, mod, key;


# ----------------------------------------------------------------------------------------------------
# layr
# ----------------------------------------------------------------------------------------------------

block(layr)                         # struct COMP_KMXPLUS_LAYR {
  6c 61 79 72                       #   KMX_DWORD header.ident;   // 0000 Section name - layr
  sizeof(layr)                      #   KMX_DWORD header.size;    // 0004 Section length
  01 00 00 00                       #   KMX_DWORD listCount
  01 00 00 00                       #   KMX_DWORD layerCount
  01 00 00 00                       #   KMX_DWORD rowCount
  02 00 00 00                       #   KMX_DWORD keyCount
  # list 0
  04 00 00 00                       #   KMX_DWORD hardware = 'us'
  00 00 00 00                       #   KMX_DWORD layer;
  01 00 00 00 # count
  7B 00 00 00                       #   KMX_DWORD minDeviceWidth; // 123
  # layers 0
  index(strNull,strBase,2)          #   KMXPLUS_STR id;
  00 00 00 00                       #   KMX_DWORD mod
  00 00 00 00                       #   KMX_DWORD row index
  01 00 00 00                       #   KMX_DWORD  count
  # rows 0
  00 00 00 00                       #   KMX_DWORD key index
  02 00 00 00                       #   KMX_DWORD count
  # keys
  index(strNull,strHmaqtugha,2)     #   KMXPLUS_STR locale;       // 'hmaqtugha'
  index(strNull,strThat,2)          #   KMXPLUS_STR locale;       // 'that'

# ----------------------------------------------------------------------------------------------------
# list
# ----------------------------------------------------------------------------------------------------

# TODO-LDML: lots of comment-out ahead. Need to revisit.

block(list)                         # struct COMP_KMXPLUS_LAYR_LIST {
  6c 69 73 74                       #   KMX_DWORD header.ident;   // 0000 Section name - list
  diff(list,endList)                #   KMX_DWORD header.size;    // 0004 Section length
  02 00 00 00                       #   KMX_DWORD listCount (should be 2)
  02 00 00 00                       #   KMX_DWORD indexCount (should be 2)
  # list #0 the null list
  block(listNull)
  00 00 00 00 #index(indexNull,indexNull,2)      #   KMX_DWORD list index (0)
  00 00 00 00                       #   KMX_DWORD lists[0].count
  # list #1 the ae list
  block(listAe)
  00 00 00 00 # index(indexAe,indexNull,2)        #   KMX_DWORD list index (also 0)
  02 00 00 00                       #   KMX_DWORD count
  block(endLists)
  # indices
  #block(indexNull)
  # No null index
  # index(strNull,strNull,2)         #   KMXPLUS_STR string index
  block(indexAe)
  index(strNull,strElemTranFrom2,2) #   KMXPLUS_STR a
  index(strNull,strElemBkspFrom2,2) #   KMXPLUS_STR e
  block(endIndices)
  block(endList)

# ----------------------------------------------------------------------------------------------------
# loca
# ----------------------------------------------------------------------------------------------------

block(loca)                         # struct COMP_KMXPLUS_LOCA {
  6c 6f 63 61                       #   KMX_DWORD header.ident;   // 0000 Section name - loca
  sizeof(loca)                      #   KMX_DWORD header.size;    // 0004 Section length
  01 00 00 00                       #   KMX_DWORD count;          // 0008 number of locales
  index(strNull,strLocale,2)        #   KMXPLUS_STR locale;       // 000C+ locale string entry = 'mt'
                                    # };
# ----------------------------------------------------------------------------------------------------
# meta
# ----------------------------------------------------------------------------------------------------

block(meta)                         # struct COMP_KMXPLUS_META {
  6d 65 74 61                       #   KMX_DWORD header.ident;   // 0000 Section name - meta
  sizeof(meta)                      #   KMX_DWORD header.size;    // 0004 Section length
  index(strNull,strAuthor,2)        #   KMXPLUS_STR author;
  index(strNull,strConformsTo,2)    #   KMXPLUS_STR conform;
  index(strNull,strLayout,2)        #   KMXPLUS_STR layout;
  index(strNull,strNorm,2)          #   KMXPLUS_STR normalization;
  index(strNull,strIndicator,2)     #   KMXPLUS_STR indicator;
  index(strNull,strVersion,2)       #   KMXPLUS_STR version;
  00 00 00 00                       #   KMX_DWORD settings;
                                    # };
# ----------------------------------------------------------------------------------------------------
# store_targets_name
# ----------------------------------------------------------------------------------------------------

block(name)                         # struct COMP_KMXPLUS_META {
  6e 61 6d 65                       #   KMX_DWORD header.ident;   // 0000 Section name - name
  sizeof(name)                      #   KMX_DWORD header.size;    // 0004 Section length
  01 00 00 00                       #   KMX_DWORD count;          // 0008 number of names
  index(strNull,strName,2)          #   KMXPLUS_STR name;         // 000C+ name string entry = 'TestKbd'
                                    # };

# ----------------------------------------------------------------------------------------------------
# ordr
# ----------------------------------------------------------------------------------------------------

# block(ordr)
#   6f 72 64 72                       #    KMX_DWORD header.ident;   // 0000 Section name - ordr
#   sizeof(ordr)                      #    KMX_DWORD header.size;    // 0004 Section length
#   01 00 00 00                       #    KMX_DWORD count;          // 0008 count of str entries
#                                     # };

#   index(elemNull,elemOrdrFrom)      #    KMXPLUS_ELEM elements;
#   index(elemNull,elemOrdrBefore)    #    KMXPLUS_ELEM before;

# ----------------------------------------------------------------------------------------------------
# strs
# ----------------------------------------------------------------------------------------------------

block(strs)                         #  struct COMP_KMXPLUS_STRS {
  73 74 72 73                       #    KMX_DWORD header.ident;   // 0000 Section name - strs
  diff(strs,endstrs)                #    KMX_DWORD header.size;    // 0004 Section length
  index(strNull,endstrs,2)          #    KMX_DWORD count;          // 0008 count of str entries
                                    # };

  # Next sections are string entries
  #    KMX_DWORD offset;         // 0010+ offset from this blob
  #    KMX_DWORD length;         // 0014+ str length (UTF-16LE units)

  diff(strs,strNull)       sizeof(strNull,2)
  diff(strs,strVersion)    sizeof(strVersion,2)
  diff(strs,strNorm)       sizeof(strNorm,2)
  diff(strs,strName)       sizeof(strName,2)
  diff(strs,strElemTranFrom1) sizeof(strElemTranFrom1,2)
  diff(strs,strElemTranFrom2)   sizeof(strElemTranFrom2,2)
  diff(strs,strBase)   sizeof(strBase,2)
  diff(strs,strElemBkspFrom2) sizeof(strElemBkspFrom2,2)
  diff(strs,strHmaqtugha) sizeof(strHmaqtugha,2)
  diff(strs,strLocale)     sizeof(strLocale,2)
  diff(strs,strLayout)     sizeof(strLayout,2)
  diff(strs,strAuthor)     sizeof(strAuthor,2)
  diff(strs,strConformsTo) sizeof(strConformsTo,2)
  diff(strs,strThat)   sizeof(strThat,2)
  # diff(strs,strTranTo)          sizeof(strTranTo,2)
  diff(strs,strKey1)       sizeof(strKey1,2)
  diff(strs,strKeys)       sizeof(strKeys,2)
  # diff(strs,strElemOrdrFrom3)   sizeof(strElemOrdrFrom3,2)
  # diff(strs,strElemOrdrFrom1)   sizeof(strElemOrdrFrom1,2)
  # diff(strs,strElemOrdrBefore)  sizeof(strElemOrdrBefore,2)
  # diff(strs,strElemOrdrFrom2)   sizeof(strElemOrdrFrom2,2)
  diff(strs,strIndicator)  sizeof(strIndicator,2)


  # String table -- block(x) is used to store the null u16char at end of each string
  #                 without interfering with sizeof() calculation above

  block(strNull)             block(x) 00 00                                             # the zero-length string
  block(strVersion)          31 00 2e 00 30 00 2e 00 30 00   block(x) 00 00             # '1.0.0'
  block(strNorm)             4e 00 46 00 43 00   block(x) 00 00                         # 'NFC'
  block(strName)             54 00 65 00 73 00 74 00 4b 00 62 00 64 00   block(x) 00 00 # 'TestKbd'
  block(strElemTranFrom1)    5E 00 block(x) 00 00                                       # '^'
  block(strElemTranFrom2)    61 00 block(x) 00 00                                       # 'a'
  block(strBase)             62 00 61 00 73 00 65 00 block(x) 00 00                     # 'base'
  block(strElemBkspFrom2)    65 00 block(x) 00 00                                       # 'e'
  block(strHmaqtugha)        68 00 6d 00 61 00 71 00 74 00 75 00 67 00 68 00 61 00 block(x) 00 00   # 'hmaqtugha'
  block(strLocale)           6d 00 74 00   block(x) 00 00                               # 'mt'
  block(strLayout)           71 00 77 00 65 00 72 00 74 00 79 00   block(x) 00 00       # 'qwerty'
  block(strAuthor)           73 00 72 00 6c 00 32 00 39 00 35 00   block(x) 00 00       # 'srl295'
  block(strConformsTo)       74 00 65 00 63 00 68 00 70 00 72 00 65 00 76 00
                             69 00 65 00 77 00 block(x) 00 00                         # 'techpreview'
  block(strThat)             74 00 68 00 61 00 74 00 block(x) 00 00                     # 'that'
  # block(strTranTo)           E2 00 block(x) 00 00                                       # 'â'
  block(strKey1)             27 01 block(x) 00 00                                     # 'ħ'
  block(strKeys)             90 17 b6 17 block(x) 00 00                               # 'ថា'
  # <reorder before="ᩫ" from="᩠᩵ᩅ" order="10 55 10" />
  # block(strElemOrdrFrom3)    45 1a block(x) 00 00                                       # 'ᩅ'
  # block(strElemOrdrFrom1)    60 1a block(x) 00 00                                       # '᩠'
  # block(strElemOrdrBefore)   6b 1a block(x) 00 00                                       # 'ᩫ'
  # block(strElemOrdrFrom2)    75 1a block(x) 00 00                                       # '᩵'
  block(strIndicator)        3d d8 40 de block(x) 00 00                               # '🙀'




block(endstrs)                      # end of strs block

# ----------------------------------------------------------------------------------------------------
# tran
# ----------------------------------------------------------------------------------------------------

# block(tran)                         # struct COMP_KMXPLUS_TRAN {
#   74 72 61 6e                       #   KMX_DWORD header.ident;   // 0000 Section name - tran
#   sizeof(tran)                      #   KMX_DWORD header.size;    // 0004 Section length
#   01 00 00 00                       #   KMX_DWORD count;          // 0008 number of entries
#                                     # };

#                                     # struct COMP_KMXPLUS_TRAN_ENTRY {
#   index(elemNull,elemTranFrom)      #    KMXPLUS_ELEM from;
#   index(strNull,strTranTo,2)        #    KMXPLUS_STR to;
#   00 00 00 00                       #    KMXPLUS_ELEM before;
#   00 00 00 00                       #    KMX_DWORD flags;
#                                     # };

block(vkey)                         # struct COMP_KMXPLUS_VKEY {
  76 6b 65 79                       #   KMX_DWORD header.ident;   // 0000 Section name - vkey
  sizeof(vkey)                      #   KMX_DWORD header.size;    // 0004 Section length
  02 00 00 00                       #   KMX_DWORD count;          // 0008 Number of vkey maps

  41 00 00 00    51 00 00 00        #   KMX_DWORD vkey;  KMX_DWORD target; // K_A => K_Q
  51 00 00 00    41 00 00 00        #   KMX_DWORD vkey;  KMX_DWORD target; // K_Q => K_A
                                    # };

block(eof)   # end of file
