#   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

~bold
                       ++++++++++
You can go–but not yet–just wait!
,y c g,-b n yet,-~1j ~1wait6

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

~italic
+++++++++++++++++++
Knowledge is power.
.7,k is p{}4.'

likes and dislikes
likes & 4likes

childlike and likeness
*ildlike & like;s

moreover and evermore
moreov} & "emore

~italic
+++++         +++++
haves or have-nots?
.1haves or h-.1nots8

"must have"s
8m/ have0s

www.doityourself.com
www4doity|rself4com

"but, no buts"
8b1 no buts0

peoples
peoples

~italic
+++++
everyday
.1"ey.'"d

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

~italic
++++++++++++++
It's not "its"
.7,x's n 8xs0.'

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

#   [Information Technology]  
IT
,,it

CAN Network
,,c ,net"w

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

#   10.1.4 page 106

but-ton
but-ton

be–have
be,-have

dis as ter
dis as t}

#   10.2.1 page 106

~bold
                             +++++
I shall still find out which child did this!
,i % / f9d | : ~1* did ?6

Which CHILD-PROOF lock?
,: ,,*-,,pro( lock8

still-life and whiskey-still
/-life & :iskey-/

~italic
++++++++++++++
Out-of-the-way
.1,|-(-!-way

(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}

#   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

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

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"<+">

~italic
     +
browning
br{n.2+

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

~italics
      +++
brown-ing
br{n-.19g

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

~italic
     +++
That was right!
,t .10 "r6

BE ALL THAT YOU CAN BE
,,,2 all t y c 2,'

~italic
+++++++++
Be happy.
.1,2 .1happy4

~italic
++++++++++++++++++
to be or not to be
.7to 2 or n to 2.'

~bold
++++++++++++
his hers its
~78 h}s xs~'

~under
 +++      +++
"Was that his car?"
8_1,0 t _18 c>80

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

~italic
          +++
"Was that his?"
8,was t .1his80

‘His mother owns “his” car.’
8,his "m {ns ~8his~0 c>40

#   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

~italic
              ++++++
(Did you have enough help? Just enough.)
"<,did y h .15 help8 ,j 54">

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">

~italic
+++++++
fade in
.1fade .19

~italic
 ++
-in
-.19

~italic
++++++++++
In the box
.7,9 ! box.'

~bold
+++++++++++++++++++++++
after before between in
~7af 2f 2t 9~'

~trans_note
++++++++++++++
In the table …
`.<,9 ! table 444`.>

<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

#   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

Take enough.
,take 5|<4

‘Is that “in”?–in style, I mean.’
8,is t ~89~08,-in /yle1 ,i m1n40

#   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

indistinct
9di/9ct

#   10.6.2 page 117

"Belinda!"
8,2l9da60

~italic
             ++++++++++
(Contact the districts)
"<,3tact ! .14tricts">

'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

~italic
   ++++
disturb
dis.1turb

#   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

BEd
,b,$

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/

~italic
     ++
stiffly
/iff.1ly

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'

(bein')
"<29'">

bein'
2in'

“bein'”
~82in'~0

#   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

Sanday
,s&ay

today
td

Lucknow
,luckn{

chlordane
*lordane

chemotherapy
*emo!rapy

Parthenon
,p>!non

where'er
:}e'}

wherever
:}"e

Dworkin
,dwork9

#   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}

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

