table:
- tables/en-ueb-g2.ctb
tests:

  # 10.1.1 page 103

- - When will Will meet us?
  - ',:5 w ,w meet u8'
- - Every child from here knows Mr More.
  - ',e * f "h "ks ,mr ,m4'
- - '"do re mi fa so"'
  - 8d re mi fa s0
- - That is quite fair and very just.
  - ',t is q fair & v j4'
- - '"People, people who need people"'
  - 8,p1 p :o ne$ p0
- - I do not like that watering-can!
  - ',i d n l t wat}+-c6'
- - But, would the people rather do the can-can for us?
  - ',b1 wd ! p r d ! c-c = u8'
- - '"You so-and-so–go away!"'
  - 8,y s-&-s,-g away60
- - '"I do have some–but I would like more!"'
  - 8,i d h "s,-b ,i wd l m60
- - You can go–but not yet–just wait!
  - ',y c g,-b n yet,-~1j ~1wait6'
  - typeform:
      bold: '                       ++++++++++'
- - last will and testament
  - la/ w & te/a;t
- - a child-like manner
  - a *-l mann}
- - will-o'-the-wisp
  - w-o'-!-wisp
- - '"Do-It-Yourself"'
  - 8,d-,x-,yrf0
- - come from–not go to
  - come f,-n g to
- - (just say so)
  - '"<j say s">'
- - As You Like It
  - ',z ,y ,l ,x'
- - Knowledge is power.
  - .7,k is p{}4.'
  - typeform:
      italic: +++++++++++++++++++
- - likes and dislikes
  - likes & 4likes
- - childlike and likeness
  - '*ildlike & like;s'
- - moreover and evermore
  - moreov} & "emore
- - haves or have-nots?
  - .1haves or h-.1nots8
  - typeform:
      italic: +++++         +++++
- - '"must have"s'
  - 8m/ have0s
  - xfail: true
- - www.doityourself.com
  - www4doity|rself4com
  - xfail: true
- - '"but, no buts"'
  - 8b1 no buts0
- - peoples
  - peoples
- - everyday
  - .1"ey.'"d
  - typeform:
      italic: '+++++   '
- - quite/very
  - quite_/v}y
- - d'you
  - d'y|
- - t'do
  - t'do
- - t'have
  - t'have

  # 10.1.2 page 105

- - it'd
  - x'd
- - you'd
  - y'd
- - it'll
  - x'll
- - that'll
  - t'll
- - you'll
  - y'll
- - you're
  - y're
- - people's
  - p's
- - so's
  - s's
- - you's
  - y's
- - can't
  - c't
- - you've
  - y've
- - It's not "its"
  - .7,x's n 8xs0.'
  - typeform:
      italic: ++++++++++++++
- - Thomas More's life
  - ',?omas ,m''s life'
- - Mr Just's house
  - ',mr ,j''s h|se'
- - I can–you can't!
  - ',i c,-y c''t6'
- - '"You''ve done it!"'
  - 8,y've d"o x60
- - more'n
  - more'n
- - you'm
  - y|'m

  # 10.1.3 page 106

  # [United States]
- - US
  - ',,us'
  - xfail: true

  # [Information Technology]  
- - IT
  - ',,it'
  - xfail: true

- - CAN Network
  - ',,c ,net"w'

  # [Government of Ontario, pronounced "go"]
- - GO Train
  - ',,g ,tra9'

  # 10.1.4 page 106

- - but-ton
  - but-ton
  - xfail: true
- - be–have
  - be,-have
  - xfail: true
- - dis as ter
  - dis as t}
  - xfail: true

  # 10.2.1 page 106

- - I shall still find out which child did this!
  - ',i % / f9d | : ~1* did ?6'
  - typeform:
      bold: '                             +++++          '
- - Which CHILD-PROOF lock?
  - ',: ,,*-,,pro( lock8'
- - still-life and whiskey-still
  - /-life & :iskey-/
- - Out-of-the-way
  - .1,|-(-!-way
  - typeform:
      italic: ++++++++++++++
- - (This way out!)
  - '"<,? way |6">'
- - '"Which way out?"'
  - '8,: way |80'
- - childish
  - '*ildi%'
- - grandchild
  - gr&*ild
- - outcome
  - '|tcome'
- - without
  - )|t
- - shallot
  - '%allot'
- - shallow
  - '%all{'
- - shilly-shally
  - '%illy-%ally'
- - standstill
  - /&/ill
- - thistle
  - ?i/le
- - whichever
  - :i*"e
- - this/that
  - ?is_/?at
- - Stillson wrench
  - ',/illson wr5*'
- - www.universalchildcare.ca
  - www4univ}sal*ildc>e4ca

  # 10.2.2 page 107

- - this'd
  - ?'d
- - which'll
  - :'ll
- - still's
  - /'s
- - which've
  - :'ve
- - Julia Child's recipe
  - ',julia ,*''s recipe'
- - this'n
  - ?is'n

  # 10.3.1 page 108

- - andante
  - '&ante'
- - England
  - ',5gl&'
- - grandad
  - gr&ad
- - grandmother
  - gr&"m
- - meander
  - me&}
- - merchandise
  - m}*&ise
- - pandemic
  - p&emic
- - pandowdy
  - p&{dy
- - afford
  - af=d
- - comfort
  - com=t
- - forgo
  - =go
- - Fortran
  - ',=tran'
- - Pforzheimer
  - ',p=zheim}'
- - pianoforte
  - piano=te
- - coffee
  - c(fee
- - Geoffrey
  - ',ge(frey'
- - lofty
  - l(ty
- - often
  - (t5
- - profane
  - pr(ane
- - roof
  - ro(
- - sofa
  - s(a
- - tofu
  - t(u
- - whereof
  - '":('
- - Athens
  - ',a!ns'
- - bathed
  - ba!d
- - bother
  - bo!r
- - Esther
  - ',es!r'
- - furthest
  - fur!/
- - nevertheless
  - n"e!.s
- - scythe
  - scy!
- - thee
  - '!e'
- - Matthew
  - ',mat!w'
- - Parthenon
  - ',p>!non'
- - theatre
  - '!atre'
- - Theresa
  - ',!resa'
- - forthwith
  - =?)
- - withe
  - )e
- - Swithin
  - ',s)9'
- - without
  - )|t
- - with a knowledge of and respect for the rules
  - ) a k ( & respect = ! rules
- - Thelma's roof will withstand the force of the wind and/or the rain.
  - ',!lma''s ro( w )/& ! =ce ( ! w9d &_/or ! ra94'
- - Andy Vandyke proofread the profile.
  - ',&y ,v&yke pro(r1d ! pr(ile4'
- - out-of-the-way
  - '|-(-!-way'
- - chifforobe
  - '*i6orobe'
- - twofold
  - twofold
- - insofar
  - 9sof>
- - biofeedback
  - biofe$back
- - microfilm
  - microfilm
- - apartheid
  - a"pheid
- - northeast
  - nor?1/
- - thence
  - ?;e
- - sweetheart
  - sweethe>t
- - Sontheimer
  - ',sontheim}'
  - xfail: true

  # 10.4.1 page 110

- - aerial
  - a}ial
- - aghast
  - a<a/
- - anteroom
  - ant}oom
- - argh!
  - '><6'
- - bear
  - be>
- - boredom
  - bor$om
- - brougham
  - br|<am
- - cheddar
  - '*$d>'
- - cherished
  - '*}i%$'
- - cough
  - c|<
- - coupon
  - c|pon
- - cringed
  - cr+$
- - derailed
  - d}ail$
- - dingy
  - d+y
- - dough
  - d|<
- - ed.
  - $4
- - Edith
  - ',$i?'
- - e'er
  - e'}
- - er–
  - '},-'
- - erase
  - '}ase'
- - Erie
  - ',}ie'
- - error
  - '}ror'
- - freedom
  - fre$om
- - ginger
  - g+}
- - gingham
  - g+ham
- - Goering
  - ',go}+'
- - hierarchy
  - hi}>*y
- - laugh
  - lau<
- - lingerie
  - l+}ie
- - lowdown
  - l{d{n
- - malediction
  - mal$ic;n
- - meningitis
  - m5+itis
- - merchandising
  - m}*&is+
- - meringue
  - m}+ue
- - mistake
  - mi/ake
- - monowheel
  - mono:eel
- - nightingale
  - ni<t+ale
- - nth
  - n?
- - oedema
  - o$ema
- - '''ounds'
  - '''|nds'
- - '"Ow!"'
  - 8,{60
- - (par)
  - '"<p>">'
- - predated
  - pr$at$
- - psst
  - ps/
- - redistribute
  - r$i/ribute
- - reroute
  - r}|te
- - riflery
  - rifl}y
- - sheer
  - '%e}'
- - Singh
  - ',s+h'
- - sou'east
  - s|'ea/
- - '''struth'
  - '''/ru?'
- - Thomas
  - ',?omas'
- - thorough
  - ?or|<
- - thou
  - ?|
- - toward
  - t{>d
- - trebled
  - trebl$
- - wharf
  - :>f
- - whistle
  - :i/le
- - Xth
  - ',x?'
- - xxist
  - xxi/
- - ædile
  - a~6edile
- - anthill
  - anthill
- - blessèd
  - b.s~*ed
- - deshabille
  - deshabille
  - xfail: true
- - foghorn
  - foghorn
- - kilowatt
  - kilowatt
- - noway
  - noway
- - painstaking
  - pa9stak+
- - parenthood
  - p>5thood
- - rawhide
  - rawhide
- - shanghai
  - '%anghai'
- - Stalingrad
  - ',/al9grad'
- - viceregal
  - viceregal

  # 10.4.2 page 111

- - Sh!
  - ',sh6'
- - th'
  - th'
- - St.
  - ',st4'
- - Wh–?
  - ',wh,-;8'
  - xfail: true
- - St Stephen
  - ',st ,/eph5'
- - ch-ch-chilly
  - ch-ch-*illy
- - Shhh!
  - ',%hh6'
- - th'n
  - ?'n
- - Ste Anne
  - ',/e ,anne'

  # 10.4.3 page 112

- - finger
  - f+}
- - ginger
  - g+}
- - singe
  - s+e
- - singeing
  - s+e+
- - sting
  - /+
- - stinging
  - /++
- - brown(ing)
  - br{n"<+">
- - browning
  - br{n.2+
  - typeform:
      italic: '     +  '
- - SmithInge
  - ',smi?,+e'
- - Ch'ing Dynasty
  - ',*''+ ,dyna/y'
- - ingot
  - 9got
- - Ingoldsby
  - ',9goldsby'
- - ingredients
  - 9gr$i5ts
- - ingrown
  - 9gr{n
- - to-ing and fro-ing
  - to-9g & fro-9g
- - brown-ing
  - br{n-.19g
  - typeform:
      italic: '      +++'
- - Smith–Inge
  - ',smi?,-,9ge'

  # 10.5.1 page 113

- - to be
  - to 2
- - his car
  - 8 c>
- - Be good.
  - ',2 gd4'
- - HIS DOG
  - ',,8 ,,dog'
- - That was right!
  - ',t .10 "r6'
  - typeform:
      italic: '     +++       '
- - BE ALL THAT YOU CAN BE
  - ',,,2 all t y c 2,'''
- - Be happy.
  - .1,2 .1happy4
  - typeform:
      italic: +++++++++
- - to be or not to be
  - .7to 2 or n to 2.'
  - typeform:
      italic: ++++++++++++++++++
- - his hers its
  - ~78 h}s xs~'
  - typeform:
      bold: ++++++++++++
- - '"Was that his car?"'
  - 8_1,0 t _18 c>80
  - typeform:
      underline: ' +++      +++      '
    xfail: true
- - at my (not his) house
  - at my "<n 8"> h|se
- - He is [was]; they are [were].
  - ',he is .<0.>2 !y >e .<7.>4'
- - (Were there many?)
  - '"<,7 "! _m8">'
- - his/her
  - his_/h}
- - What will you be?
  - ',:at w y be8'
- - would-be actor
  - wd-be actor
- - his-and-hers towels
  - his-&-h}s t{els
- - That were–I mean was–mine.
  - ',t w}e,-,i m1n was,-m9e4'
- - '"Be safe."'
  - 8,be safe40
- - '"Was that his?"'
  - 8,was t .1his80
  - typeform:
      italic: '          +++  '
    xfail: true
- - ‘His mother owns “his” car.’
  - 8,his "m {ns ~8his~0 c>40
  - xfail: true

  # 10.5.2 page 114

- - it was enough
  - x 0 5
- - GIVE MORE THAN ENOUGH
  - ',,,give m ?an 5,'''
- - Buy meat (enough for 2).
  - ',buy m1t "<5 = #b">4'
- - (Did you have enough help? Just enough.)
  - '"<,did y h .15 help8 ,j 54">'
  - typeform:
      italic: '              ++++++                    '
- - Enough's happened.
  - ',5''s happ5$4'
- - Mum's had-enough mood
  - ',mum''s _h-5 mood'
- - www.enoughforall.org
  - www45|<=all4org
- - enough/sufficient
  - 5|<_/su6ici5t

  # 10.5.3 page 114
  
- - not in here
  - n 9 "h
- - In or out?
  - ',9 or |8'
- - GO ALL IN
  - ',,,g all 9,'''
- - in't
  - 9't
- - mother-in-law
  - '"m-9-law'
- - listen-in
  - li/5-9
- - Listen!–In this case …
  - ',li/56,-,9 ? case 444'
- - '"teach-in"'
  - 8t1*-90
- - IN-DEPTH
  - ',,9-,,dep?'
- - ("In no way.")
  - '"<8,9 no way40">'
- - fade in
  - .1fade .19
  - typeform:
      italic: +++++++
- - -in
  - '-.19'
  - typeform:
      italic: ' ++'
- - In the box
  - .7,9 ! box.'
  - typeform:
      italic: ++++++++++
- - after before between in
  - ~7af 2f 2t 9~'
  - typeform:
      bold: +++++++++++++++++++++++
- - In the table …
  - '`.<,9 ! table 444`.>'
  - typeform:
      transnote: ++++++++++++++
- - <in file>
  - '`<9 file`>'
- - in/out
  - 9_/|t
- - Come in, stay in.
  - ',come in1 /ay in4'
- - '"In any case"'
  - 8,in any case0
- - ‘Is that “in”?’
  - 8,is t ~8in~080
  - xfail: true

  #  10.5.4 page 116

- - It was enough–more than enough.
  - ',x 0 5,-m ?an 5|<4'
- - We had enough–5.
  - ',we _h 5,-#e4'
- - '"That''s enough!"–in a firm voice'
  - 8,t's 560,-in a firm voice
  - xfail: true
- - Take enough.
  - ',take 5|<4'
- - ‘Is that “in”?–in style, I mean.’
  - 8,is t ~89~08,-in /yle1 ,i m1n40
  - xfail: true

  # 10.6.1 page 116

- - beatitude
  - 2atitude
- - Beatrice
  - ',2atrice'
- - become
  - 2come
- - begonia
  - 2gonia
- - behemoth
  - 2hemo?
- - being
  - 2+
- - beneficent
  - 2nefic5t
- - beta
  - 2ta
- - first-begotten
  - f/-2gott5
- - air-conditioned
  - air-3di;n$
- - concept
  - 3cept
- - congress
  - 3gress
- - control
  - 3trol
- - re-connect
  - re-3nect
- - disaster
  - 4a/}
- - disco
  - 4co
- - dishonest
  - 4h"o/
- - dislike
  - 4like
- - dissect
  - 4sect
- - distance
  - 4t.e
- - self-discipline
  - self-4cipl9e
- - beckon
  - beckon
- - been
  - be5
- - belligerent
  - bellig}5t
- - benefit
  - b5efit
- - best
  - be/
- - bethel
  - be!l
- - better
  - bett}
- - unbecoming
  - unbecom+
- - con
  - con
- - conch
  - con*
- - cone
  - c"o
- - coneys
  - c"oys
- - inconvenient
  - 9conv5i5t
- - disc
  - disc
- - dish
  - di%
- - dishevel
  - di%evel
- - dispirited
  - di_s$
- - disulphide
  - disulphide
  - xfail: true
- - indistinct
  - 9di/9ct

  # 10.6.2 page 117

- - '"Belinda!"'
  - 8,2l9da60
- - (Contact the districts)
  - '"<,3tact ! .14tricts">'
  - typeform:
      italic: '             ++++++++++'
- - '''display will minimise'''
  - '''4play w m9imise'''
- - concave/convex
  - 3cave_/convex
- - McConnell
  - ',mc,connell'
- - O'Connor
  - ',o'',connor'
- - MetroDisco
  - ',metro,disco'
- - be'ave
  - be'ave
- - be-stow
  - be-/{
- - '[be]hold'
  - .<be.>hold
- - con(vey)
  - con"<vey">
- - dis'armony
  - dis'>mony
- - disturb
  - dis.1turb
  - typeform:
      italic: '   ++++'

  # 10.6.3  page 118

- - BeLinda
  - ',be,l9da'
- - conCUR
  - con,,cur
- - DisCORD
  - ',dis,,cord'
- - DISlike
  - ',,dis,''like'

  # 10.6.4 page 118
  
- - Conn.
  - ',3n4'
- - cont
  - 3t
- - dist.
  - 4t4
- - mod cons
  - mod 3s
  - xfail: true
- - BEd
  - ',b,$'
  - xfail: true
- - Belg
  - ',belg'
- - bet
  - bet
- - Bev
  - ',bev'
- - Con.
  - ',con4'

  # 10.6.5 page 119
  
- - abbé
  - a2~/e
- - accept
  - a3ept
- - account
  - a3.t
- - acreage
  - acr1ge
- - affirm
  - a6irm
- - aggressive
  - a7ressive
- - agreeable
  - agre1ble
- - areas
  - '>1s'
- - arpeggio
  - '>pe7io'
- - baccalaureate
  - ba3alaur1te
- - beat
  - b1t
- - begging
  - be7+
- - borealis
  - bor1lis
- - bubble
  - bu2le
- - bureau
  - bur1u
- - Caribbean
  - ',c>i21n'
- - caveat
  - cav1t
- - create
  - cr1te
- - creation
  - cr1;n
- - disease
  - 41se
- - doggone
  - do7"o
- - eggnog
  - e7nog
- - epicurean
  - epicur1n
- - flaccid
  - fla3id
- - genealogy
  - g51logy
- - Hanseatic
  - ',hans1tic'
- - head
  - h1d
- - Judaean
  - ',juda1n'
- - likeable
  - lik1ble
- - Liliaceae
  - ',liliac1e'
- - lineage
  - l91ge
- - mecca
  - me3a
- - Minneapolis
  - ',m9n1polis'
- - Montreal
  - ',montr1l'
- - motheaten
  - mo?1t5
- - muffin
  - mu69
- - Neapolitan
  - ',n1politan'
- - northeast
  - nor?1/
- - occupy
  - o3upy
- - oceanic
  - oc1nic
- - oleaginous
  - ol1g9|s
- - orgeat
  - org1t
- - paean
  - pa1n
- - pancreas
  - pancr1s
- - peaceable
  - p1c1ble
- - peanut
  - p1nut
- - rabbi
  - ra2i
- - really
  - r1lly
- - réchauffé
  - r~/e*au6~/e
- - Seamus
  - ',s1mus'
- - Sean
  - ',s1n'
- - seashore
  - s1%ore
- - Seattle
  - ',s1ttle'
- - Sheffield
  - ',%e6ield'
- - sheriffs
  - '%}i6s'
- - speakeasy
  - sp1k1sy
- - tableau
  - tabl1u
- - tobacco
  - toba3o
- - toreador
  - tor1dor
- - Yeats
  - ',y1ts'
- - afford
  - af=d
- - appear
  - appe>
- - arccosine
  - '>ccos9e'
- - bacchanal
  - bac*anal
- - bear
  - be>
- - beatitude
  - 2atitude
- - Beatrice
  - ',2atrice'
- - cinéaste
  - c9~/ea/e
- - coffee
  - c(fee
- - dumbbell
  - dumbbell
- - '''ead'
  - '''ead'
- - east
  - ea/
- - ebb
  - ebb
- - ebb-tide
  - ebb-tide
- - hideaway
  - hideaway
- - idea(s)
  - idea"<s">
- - Leander
  - ',le&}'
- - limeade
  - limeade
- - mah-jongg
  - mah-j;gg
- - man-eater
  - man-eat}
- - pineapple
  - p9eapple
- - robb'd
  - robb'd
- - saccharine
  - sac*>9e
- - sea-green
  - sea-gre5
- - sheriff's
  - '%}iff''s'
- - snuff
  - snuff
- - sou'east
  - s|'ea/
- - stiffly
  - /iff.1ly
  - typeform:
      italic: '     ++'
- - subbasement
  - subbase;t
- - tea
  - tea
- - theatre
  - '!atre'

#   10.6.6 page 121

- - CliffSide
  - ',cliff,side'
- - EggHead
  - ',egg,h1d'
- - MacEACHEN
  - ',mac,,ea*5'
- - SeaWorld
  - ',sea,_w'
- - TEAspoon
  - ',,tea,''spoon'

  # 10.6.7 page 121

- - deactivate
  - deactivate
- - geanticline
  - geanticl9e
- - preamble
  - preamble
- - reaction
  - reac;n

  # 10.6.8 page 122

- - antinode
  - ant9ode
- - arena
  - '>5a'
- - been
  - be5
- - begin
  - 2g9
- - be'ind
  - be'9d
- - benefit
  - b5efit
- - binary
  - b9>y
- - binomial
  - b9omial
- - Blakeney
  - ',blak5ey'
- - Caen
  - ',ca5'
- - casino
  - cas9o
- - china
  - '*9a'
- - Chopin
  - ',*op9'
- - citizeness
  - citiz5ess
- - deafen
  - d1f5
- - denote
  - d5ote
- - deny
  - d5y
- - disingenuous
  - 49g5u|s
- - double-entendre
  - d|ble-5t5dre
- - e'en
  - e'5
- - Einstein
  - ',e9/e9'
- - enceinte
  - 5ce9te
- - engine
  - 5g9e
- - Enid
  - ',5id'
- - enormous
  - 5orm|s
- - equinox
  - equ9ox
- - faint
  - fa9t
- - feminine
  - fem99e
- - goin'
  - go9'
- - haven't
  - hav5't
- - henna
  - h5na
- - Inc.
  - ',9c4'
- - incline
  - 9cl9e
- - ingot
  - 9got
- - in's
  - 9's
- - into
  - 9to
- - maenad
  - ma5ad
- - Montenegro
  - ',mont5egro'
- - phoenix
  - pho5ix
- - p(en)
  - p"<5">
- - p(in)
  - p"<9">
- - prenatal
  - pr5atal
- - queen
  - que5
- - renew
  - r5ew
- - self-induced
  - self-9duc$
- - shut-ins
  - '%ut-9s'
- - within
  - )9
- - to-ing
  - to-9g
- - Athens
  - ',a!ns'
- - benign
  - 2nign
- - business
  - busi;s
- - cringed
  - cr+$
- - fenced
  - f;ed
- - filename
  - file"n
- - forenoon
  - =enoon
- - Francene
  - ',fr.ene'
- - lament
  - la;t
- - ménage
  - m~/enage
- - señor
  - se~}nor
- - toenail
  - toenail

  # 10.6.9 page 123

- - Aix-en-Provence
  - ',aix-en-,prov;e'
- - Chou En-lai
  - ',*| ,en-lai'
- - en route
  - en r|te

  # 10.6.10 page 123
  
- - '"Sudden!"'
  - 8,sudd560
- - '"Comin''?"'
  - 8,com9'80
- - linen…
  - l95444
- - bein'
  - .129'
  - xfail: true
- - (bein')
  - '"<29''">'
- - bein'
  - 2in'
  - xfail: true
- - “bein'”
  - ~82in'~0
  - xfail: true

  # 10.7.1 page 125
  
- - foreword
  - =e~w
- - misworded
  - mis~w$
- - sword
  - s~w
- - word-for-word
  - ~w-=-~w
- - Wordsworth
  - ',~wswor?'
- - cannot
  - _c
- - Germany
  - ',g}_m'
- - many-sided
  - _m-sid$
- - dispirited
  - di_s$
- - spirits
  - _ss
- - spiritual
  - _sual
- - theirs
  - _!s
- - SeaWorld
  - ',sea,_w'
- - underworld
  - '"u_w'
- - world-wide
  - _w-wide
- - worldly
  - _wly
- - day-by-day
  - '"d-by-"d'
- - Dayton
  - ',"dton'
- - Friday
  - ',fri"d'
- - G'day
  - ',g''"d'
- - father-in-law
  - '"f-9-law'
- - fatherless
  - '"f.s'
- - grandfather
  - gr&"f
- - acknowledge
  - ac"kl$ge
- - knowing
  - '"k+'
- - Knowles
  - ',"kles'
- - well-known
  - well-"kn
- - Gaylord
  - ',gay"l'
- - lordosis
  - '"losis'
- - lordship
  - '"l%ip'
- - m'lord
  - m'"l
- - godmother
  - god"m
- - mother-of-pearl
  - '"m-(-pe>l'
- - motherly
  - '"mly'
- - smother
  - s"m
- - apartheid
  - a"pheid
- - Bonaparte
  - ',bona"pe'
- - impartial
  - im"pial
- - part-time
  - '"p-"t'
- - partake
  - '"pake'
- - parterre
  - '"p}re'
- - party
  - '"py'
- - passe-partout
  - passe-"p|t
- - Spartan
  - ',s"pan'
- - questionnaire
  - '"qnaire'
- - unquestionable
  - un"qable
- - affrighted
  - a6"r$
- - aright
  - a"r
- - brighten
  - b"r5
- - millwright
  - millw"r
- - right-handed
  - '"r-h&$'
- - righteous
  - '"re|s'
- - youngest
  - '"ye/'
- - Youngstown
  - ',"yst{n'
- - characteristic
  - '"*i/ic'
- - characterise
  - '"*ise'
- - throughout
  - '"?|t'
- - elsewhere
  - 'else":'
- - somewhere
  - '"s":'
- - whereby
  - '":by'
- - wherein
  - '":9'
- - drought
  - dr"|
- - fought
  - f"|
- - Houghton
  - ',h"|on'
- - oughtn't
  - '"|n''t'
- - thoughtful
  - ?"|;l
- - coworker
  - co"w}
- - fireworks
  - fire"ws
- - stonework
  - /"o"w
- - unworkable
  - un"wable
- - workday
  - '"w"d'
- - working
  - '"w+'
- - Dayan
  - ',dayan'
  - xfail: true
- - Sanday
  - ',s&ay'
- - today
  - td
- - Lucknow
  - ',luckn{'
- - chlordane
  - '*lordane'
- - chemotherapy
  - '*emo!rapy'
- - Parthenon
  - ',p>!non'
- - where'er
  - :}e'}
- - wherever
  - :}"e
- - Dworkin
  - ',dwork9'
  - xfail: true

  # 10.7.2 page 127
  
- - upon these shores
  - ~u ~! %ores
- - Whose are those?
  - ',~: >e ~?8'
- - hereupon
  - '"h~u'
- - whereupon
  - '":~u'
- - whosesoever
  - ~:so"e
- - thereby
  - '"!by'
- - therefore
  - '"!=e'
- - therein
  - '"!9'
- - thereupon
  - '"!~u'
- - coupon
  - c|pon
- - Dupont
  - ',dupont'
- - hypotheses
  - hypo!ses
- - Theseus
  - ',!seus'
- - spathose
  - spa?ose
- - Thoseby
  - ',?oseby'
- - bothered
  - bo!r$
- - ethereal
  - e!r1l
- - isothere
  - iso!re
- - smithereens
  - smi!re5s
- - Theresa
  - ',!resa'
- - withered
  - )}$

  # 10.7.3 page 128

- - Galahad
  - ',gala_h'
- - haddock
  - _hdock
- - Haddon
  - ',_hdon'
- - hadji
  - _hji
- - Hadley
  - ',_hley'
- - hadn't
  - _hn't
- - Chad
  - ',*ad'
- - Hades
  - ',hades'
- - Hadrian
  - ',hadrian'
- - menhaden
  - m5had5
- - shadow
  - '%ad{'
- - Thaddeus
  - ',?addeus'

  # 10.7.4 page 128

- - asseverate
  - ass"eate
- - beverage
  - b"eage
- - Everest
  - ',"ee/'
- - everything
  - '"ey?+'
- - fever
  - f"e
- - irreverence
  - irr"e;e
- - nevertheless
  - n"e!.s
- - reverend
  - r"e5d
- - several
  - s"eal
- - Severn
  - ',s"en'
- - Unilever
  - ',unil"e'
- - believer
  - 2liev}
- - eversion
  - ev}.n
- - Guinevere
  - ',gu9ev}e'
- - McKeever
  - ',mc,keev}'
  - xfail: true
- - Monteverdi
  - ',montev}di'
- - persevere
  - p}sev}e
- - reverberate
  - rev}b}ate
- - revere
  - rev}e
- - reverify
  - rev}ify
- - severity
  - sev};y
- - thievery
  - ?iev}y

  # 10.7.5 page 129

- - adhere
  - ad"h
- - atmosphere
  - atmosp"h
- - cohere
  - co"h
- - hereabout
  - '"hab'
- - herewith
  - '"h)'
- - sphere
  - sp"h
- - filename
  - file"n
- - nameable
  - '"nable'
- - renamed
  - re"nd
- - surname
  - sur"n
- - adhered
  - adh}$
- - bothered
  - bo!r$
- - coherence
  - coh};e
- - elsewhere
  - 'else":'
- - ethereal
  - e!r1l
- - heredity
  - h}$;y
- - Hereford (City)
  - ',h}e=d "<,c;y">'
- - enamel
  - 5amel
- - ornament
  - orna;t
- - unamended
  - unam5d$
- - Vietnamese
  - ',vietnamese'

  # 10.7.6 page 130

- - acetone
  - acet"o
- - atonement
  - at"o;t
- - baloney
  - bal"oy
- - bygone
  - byg"o
- - cone
  - c"o
- - demonetise
  - dem"otise
- - dishonesty
  - 4h"o/y
- - done
  - d"o
- - everyone
  - '"ey"o'
- - honey
  - h"oy
- - Jones
  - ',j"os'
- - lonesome
  - l"o"s
- - Mulroney
  - ',mulr"oy'
- - one-sided
  - '"o-sid$'
- - oneness
  - '"o;s'
- - phone
  - ph"o
- - scone
  - sc"o
- - stonework
  - /"o"w
- - stoney
  - /"oy
- - anemone
  - anemone
- - baroness
  - b>o;s
- - baronet
  - b>onet
- - Boone
  - ',boone'
- - Cantonese
  - ',cantonese'
- - colonel
  - colonel
- - Conestoga
  - ',3e/oga'
- - crooner
  - croon}
- - cushioned
  - cu%ion$
- - Donegal
  - ',donegal'
- - erroneous
  - '}rone|s'
- - Hermione
  - ',h}mione'
- - Indonesia
  - ',9donesia'
- - krone
  - krone
- - Monet
  - ',monet'
- - onerous
  - on}|s
- - phonetic
  - phonetic
- - pioneer
  - pione}
- - poisoned
  - poison$
- - Rhône
  - ',rh~%one'
- - Rooney
  - ',rooney'
- - sooner
  - soon}
- - stoned
  - /on$

  # 10.7.7 page 131

- - blithesome
  - bli!"s
- - chromosome
  - '*romo"s'
- - fearsome
  - fe>"s
- - handsome
  - h&"s
- - handsomer
  - h&"sr
- - lonesomest
  - l"o"s/
- - somebody
  - '"sbody'
- - somesuch
  - '"ss*'
- - somewhere
  - '"s":'
- - twosome
  - two"s
- - blossomed (blossom)
  - blossom$ "<blossom">
- - gasometer
  - gasomet}
- - isometric
  - isometric
- - ransomed (ransom)
  - ransom$ "<ransom">
- - somersault
  - som}sault
- - Somerset
  - ',som}set'

  # 10.7.8 page 131
  
- - daytime
  - '"d"t'
- - maritime
  - m>i"t
- - mistimed
  - mis"td
- - pastime
  - pas"t
- - sometimes
  - '"s"ts'
- - springtime
  - spr+"t
- - timeously
  - '"t|sly'
- - Timex
  - ',"tx'
- - untimely
  - un"tly
- - altimeter
  - altimet}
- - centime
  - c5time
- - centimeter
  - c5timet}
- - Mortimer
  - ',mortim}'
- - multimedia
  - multim$ia
- - sentiment
  - s5ti;t

  # 10.7.9 page 132

- - blunder
  - bl"u
- - misunderstand
  - mis"u/&
- - thundered
  - ?"u$
- - undergo
  - '"ugo'
- - underpaid
  - '"upd'
- - Wunderhorn
  - ',w"uhorn'
- - flounder
  - fl.d}
- - laundering
  - laund}+
- - Saunders
  - ',saund}s'
- - underived
  - und}iv$
- - underogatory
  - und}ogatory
