diff --git a/lib/src/api/Constructors.gf b/lib/src/api/Constructors.gf
index f9170fe0e..fba8df3d6 100644
--- a/lib/src/api/Constructors.gf
+++ b/lib/src/api/Constructors.gf
@@ -195,7 +195,7 @@ incomplete resource Constructors = open Grammar in {  --%
     mkUtt = overload { 
       mkUtt : S -> Utt                     -- she slept   --:  
       = UttS ; --%  
-      mkUtt : Cl -> Utt                     -- she sleeps  
+      mkUtt : Cl -> Utt                    -- she sleeps  
       = \c -> UttS (TUseCl TPres ASimul PPos c) ; --%  
       mkUtt : QS -> Utt                    -- who didn't sleep   --:
       = UttQS   ; --%  
@@ -330,7 +330,7 @@ incomplete resource Constructors = open Grammar in {  --%
 
       mkS : Conj -> S -> S -> S   -- she sleeps and I run    
       = \c,x,y -> ConjS c (BaseS x y) ; --% 
-      mkS : Conj -> ListS  -> S   -- she sleeps, I run and you sleep  --:
+      mkS : Conj -> ListS  -> S   -- she sleeps, I run and you walk  --:
       = \c,xy -> ConjS c xy ; --% 
 
 -- A sentence can be prefixed by an adverb.
@@ -353,22 +353,25 @@ incomplete resource Constructors = open Grammar in {  --%
       = \s,v,o -> PredVP s (ComplV2 v o); --%   
       mkCl : NP -> V3 -> NP -> NP -> Cl   -- she sends it to him
       = \s,v,o,i -> PredVP s (ComplV3 v o i); --%   
-
       mkCl : NP  -> VV -> VP -> Cl        -- she wants to sleep
         = \s,v,vp -> PredVP s (ComplVV v vp) ; --% 
       mkCl : NP  -> VS -> S  -> Cl        -- she says that she sleeps
         = \s,v,p -> PredVP s (ComplVS v p) ; --% 
       mkCl : NP  -> VQ -> QS -> Cl        -- she wonders who sleeps
         = \s,v,q -> PredVP s (ComplVQ v q) ; --% 
-      mkCl : NP  -> VA -> AP -> Cl        -- she becomes old
+      mkCl : NP  -> VA -> A -> Cl         -- she becomes old
+        = \s,v,q -> PredVP s (ComplVA v (PositA q)) ; --% 
+      mkCl : NP  -> VA -> AP -> Cl        -- she becomes very old
         = \s,v,q -> PredVP s (ComplVA v q) ; --% 
-      mkCl : NP  -> V2A -> NP -> AP -> Cl -- she paints it red
+      mkCl : NP  -> V2A -> NP -> A -> Cl  -- she paints it red
+        = \s,v,n,q -> PredVP s (ComplV2A v n (PositA q)) ; --% 
+      mkCl : NP  -> V2A -> NP -> AP -> Cl -- she paints it very red
         = \s,v,n,q -> PredVP s (ComplV2A v n q) ; --% 
-      mkCl : NP  -> V2S -> NP -> S -> Cl          -- she tells him that we sleep
+      mkCl : NP  -> V2S -> NP -> S -> Cl          -- she answers to him that we sleep
         = \s,v,n,q -> PredVP s (ComplSlash (SlashV2S v q) n) ; --% 
       mkCl : NP  -> V2Q -> NP -> QS -> Cl         -- she asks him who sleeps 
         = \s,v,n,q -> PredVP s (ComplSlash (SlashV2Q v q) n) ; --% 
-      mkCl : NP  -> V2V -> NP -> VP -> Cl         -- she forces him to sleep
+      mkCl : NP  -> V2V -> NP -> VP -> Cl         -- she begs him to sleep
         = \s,v,n,q -> PredVP s (ComplSlash (SlashV2V v q) n) ; --% 
       mkCl : NP -> A  -> Cl    -- she is old
         = \x,y -> PredVP x (UseComp (CompAP (PositA y))) ; --%   
@@ -378,11 +381,11 @@ incomplete resource Constructors = open Grammar in {  --%
 	= \x,y,z -> PredVP x (UseComp (CompAP (ComplA2 y z))) ; --% 
       mkCl : NP -> AP -> Cl    -- she is very old 
 	= \x,y -> PredVP x (UseComp (CompAP y)) ; --% 
-      mkCl : NP -> NP -> Cl    -- she is the man   
+      mkCl : NP -> NP -> Cl    -- she is the woman   
         = \x,y -> PredVP x (UseComp (CompNP y)) ; --%   
-      mkCl : NP -> N -> Cl    -- she is a man   
+      mkCl : NP -> N -> Cl    -- she is a woman   
         = \x,y -> PredVP x (UseComp (CompCN (UseN y))) ; --% 
-      mkCl : NP -> CN -> Cl    -- she is an old man   
+      mkCl : NP -> CN -> Cl    -- she is an old woman   
 	= \x,y -> PredVP x (UseComp (CompCN y)) ; --%   
       mkCl : NP -> Adv -> Cl   -- she is here   
 	= \x,y -> PredVP x (UseComp (CompAdv y)) ; --%   
@@ -390,7 +393,7 @@ incomplete resource Constructors = open Grammar in {  --%
 -- As the general rule, a clause can be built from a subject noun phrase and 
 -- a verb phrase.
 
-      mkCl : NP -> VP -> Cl   -- she always sleeps here   --:
+      mkCl : NP -> VP -> Cl   -- she always sleeps   --:
       = PredVP  ; --%
 
 -- Existentials are a special form of clauses.
@@ -399,7 +402,7 @@ incomplete resource Constructors = open Grammar in {  --%
       = \y -> ExistNP (DetArtSg IndefArt (UseN y)) ; --% 
       mkCl : CN -> Cl          -- there is an old house 
       = \y -> ExistNP (DetArtSg IndefArt y) ; --% 
-      mkCl : NP -> Cl          -- there are five houses   --:
+      mkCl : NP -> Cl          -- there are many houses   --:
       = ExistNP ; --% 
 
 -- There are also special forms in which a noun phrase or an adverb is
@@ -407,7 +410,7 @@ incomplete resource Constructors = open Grammar in {  --%
 
       mkCl : NP  -> RS -> Cl   -- it is she who sleeps   --: 
       = CleftNP    ; --% 
-      mkCl : Adv -> S  -> Cl   -- it is here he sleeps    --:
+      mkCl : Adv -> S  -> Cl   -- it is here that she sleeps    --:
       = CleftAdv   ; --% 
 
 -- Subjectless verb phrases are used for impersonal actions.
@@ -416,7 +419,7 @@ incomplete resource Constructors = open Grammar in {  --%
       = \v -> ImpersCl (UseV v) ; --%
       mkCl : VP -> Cl  -- it is raining    --:
       = ImpersCl   ;  --%
-      mkCl : SC -> VP -> Cl  --:
+      mkCl : SC -> VP -> Cl  -- that she sleeps is good --:
       = PredSCVP ; --%
 
       } ; 
@@ -435,25 +438,25 @@ incomplete resource Constructors = open Grammar in {  --%
     mkVP = overload { 
       mkVP : V   -> VP                -- sleep --:
       = UseV      ; --% 
-      mkVP : V2  -> NP -> VP          -- love it 
+      mkVP : V2  -> NP -> VP          -- love him 
       = ComplV2   ; --% 
       mkVP : V3  -> NP -> NP -> VP    -- send a message to him 
       = ComplV3   ; --% 
-      mkVP : VV  -> VP -> VP          -- want to run  --:
+      mkVP : VV  -> VP -> VP          -- want to sleep  --:
       = ComplVV   ; --% 
-      mkVP : VS  -> S  -> VP          -- know that she runs  --: 
+      mkVP : VS  -> S  -> VP          -- know that she sleeps  --: 
       = ComplVS   ; --% 
-      mkVP : VQ  -> QS -> VP          -- wonder if she runs  --:
+      mkVP : VQ  -> QS -> VP          -- wonder if she sleeps  --:
       = ComplVQ   ; --% 
       mkVP : VA  -> AP -> VP          -- become red  --:
       = ComplVA   ; --% 
       mkVP : V2A -> NP -> AP -> VP    -- paint it red 
       = ComplV2A  ; --% 
-      mkVP : V2S -> NP -> S  -> VP          -- tell him that we sleep 
+      mkVP : V2S -> NP -> S  -> VP         -- answer to him that we sleep 
         = \v,n,q -> (ComplSlash (SlashV2S v q) n) ; --% 
       mkVP : V2Q -> NP -> QS -> VP         -- ask him who sleeps
         = \v,n,q -> (ComplSlash (SlashV2Q v q) n) ; --% 
-      mkVP : V2V -> NP -> VP -> VP         -- force him to sleep
+      mkVP : V2V -> NP -> VP -> VP         -- beg him to sleep
         = \v,n,q -> (ComplSlash (SlashV2V v q) n) ; --% 
 
 -- The verb can also be a copula ("be"), and the relevant argument is
@@ -471,7 +474,7 @@ incomplete resource Constructors = open Grammar in {  --%
       = \y -> UseComp (CompCN (UseN y)) ; --% 
       mkVP : CN -> VP              -- be an old man 
       = \y -> UseComp (CompCN y) ; --% 
-      mkVP : NP -> VP              -- be this man 
+      mkVP : NP -> VP              -- be the man 
       = \a -> UseComp (CompNP a)   ; --% 
       mkVP : Adv -> VP             -- be here 
       = \a -> UseComp (CompAdv a)   ; --% 
@@ -489,15 +492,19 @@ incomplete resource Constructors = open Grammar in {  --%
       = ComplSlash ; --% 
       mkVP : VPSlash -> VP            -- paint itself black --:
         = ReflVP ; --%
+
       mkVP : Comp -> VP               -- be warm --:
         = UseComp ; --%
 
       } ; --% 
 
--- Two-place verbs can be used reflexively.
-
+-- Two-place verbs can be used reflexively, and VPSlash more generally.
+    reflexiveVP = overload { --%
       reflexiveVP : V2 -> VP        -- love itself 
       = \v -> ReflVP (SlashV2a v) ; --% 
+      reflexiveVP : VPSlash -> VP   -- paint itself black
+        = ReflVP ; --%
+      } ; --%
 
 
 -- Two-place verbs can also be used in the passive, with or without an agent.
@@ -648,6 +655,27 @@ incomplete resource Constructors = open Grammar in {  --%
 
       } ; --% 
 
+-- Pronouns can be used as noun phrases.
+
+      i_NP : NP          -- I
+      = mkNP i_Pron ;
+      you_NP : NP        -- you (singular)
+      = mkNP youSg_Pron ;
+      youPol_NP : NP     -- you (polite singular)
+      = mkNP youPol_Pron ;
+      he_NP : NP         -- he
+      = mkNP he_Pron ;
+      she_NP : NP        -- she
+      = mkNP she_Pron ;
+      it_NP : NP         -- it
+      = mkNP it_Pron ;
+      we_NP : NP         -- we
+      = mkNP we_Pron ;
+      youPl_NP : NP      -- you (plural)
+      = mkNP she_Pron ;
+      they_NP : NP       -- they
+      = mkNP they_Pron ;
+
 
 --3 Det, determiners 
 
@@ -793,8 +821,12 @@ incomplete resource Constructors = open Grammar in {  --%
 
 -- Number words up to 999,999 can be built as follows.
 
-      mkNumeral : Sub1000 -> Numeral -- coerce 1..999 --: 
-      = \n -> num (pot3 n) ; --%
+      mkNumeral : Unit -> Numeral -- eight (coerce 1..9) --: 
+      = \n -> num (pot2as3 (pot1as2 (pot0as1 n.n))) ; --%
+      mkNumeral : Sub100 -> Numeral -- twenty-five (coerce 1..99) --: 
+      = \n -> num (pot2as3 (pot1as2 n)) ; --%
+      mkNumeral : Sub1000 -> Numeral -- six hundred (coerce 1..999) --: 
+      = \n -> num (pot2as3 n) ; --%
       mkNumeral : Sub1000 -> Sub1000 -> Numeral -- 1000m + n --: 
       = \m,n -> num (pot3plus m n) ; --%
 
@@ -810,10 +842,10 @@ incomplete resource Constructors = open Grammar in {  --%
     mkSub1000 = overload {  --% 
       mkSub1000 : Sub100 -> Sub1000 -- coerce 1..99  --:
       = pot1as2 ; --% 
-      mkSub1000 : Sub10 -> Sub1000 -- 100n  --:
-      = pot2 ; --% 
-      mkSub1000 : Sub10 -> Sub100 -> Sub1000 -- 100m + n  --:
-      = pot2plus ; --% 
+      mkSub1000 : Unit -> Sub1000 -- 100n  --:
+      = \n -> pot2 n.n ; --% 
+      mkSub1000 : Unit -> Sub100 -> Sub1000 -- 100m + n  --:
+      = \m,n -> pot2plus m.n n ; --% 
       } ; --%
 
     mkSub100 = overload {  --% 
@@ -1495,7 +1527,7 @@ incomplete resource Constructors = open Grammar in {  --%
 
   ComplV2 : V2 -> NP -> VP = \v,np -> ComplSlash (SlashV2a v) np ;
   ComplV2A : V2A -> NP -> AP -> VP = \v,np,ap -> ComplSlash (SlashV2A v ap) np ; 
-  ComplV3 : V3 -> NP -> NP -> VP = \v,o,d -> ComplSlash (Slash3V3 v o) d ; 
+  ComplV3 : V3 -> NP -> NP -> VP = \v,o,d -> ComplSlash (Slash3V3 v d) o ; 
 
     that_NP : NP = DetNP (DetQuant that_Quant sgNum) ; 
     this_NP : NP = DetNP (DetQuant this_Quant sgNum) ; 
@@ -1687,8 +1719,5 @@ oper
     n1000_Numeral : Numeral 
     = num (pot3 (pot1as2 (pot0as1 pot01))) ; --%  
 
--- for testing
-
-  she_NP : NP = mkNP she_Pron ;
 
 }  
diff --git a/lib/src/dutch/ParadigmsDut.gf b/lib/src/dutch/ParadigmsDut.gf
index 7bc2fcebb..001621bc2 100644
--- a/lib/src/dutch/ParadigmsDut.gf
+++ b/lib/src/dutch/ParadigmsDut.gf
@@ -39,10 +39,6 @@ oper
 
   de,het : Gender ;
 
-  masculine = Utr ;
-  feminine  = Utr ;
-  het,neuter = Neutr ;
-  de,utrum = Utr ;
 
   
 --2 Nouns
@@ -52,11 +48,6 @@ oper
     mkN : (bit : Str) -> Gender -> N ;
     mkN : (gat,gaten : Str) -> Gender -> N ;
   } ;
-  mkN = overload {
-    mkN : (muis : Str) -> N = \a -> lin N (regNoun a) ;
-    mkN : (bit : Str) -> Gender -> N = \a,b -> lin N (regNounG a b) ;
-    mkN : (gat,gaten : Str) -> Gender -> N = \a,b,c -> lin N (mkNoun a b c) ;
-  } ;
 
 -- Relational nouns need a preposition. The most common is "van".
 
@@ -65,10 +56,6 @@ oper
     mkN2 : N -> Prep -> N2
     } ;   
 
-  mkN2 = overload {
-    mkN2 : N -> N2 = \n -> lin N2 (n ** {c2 = "van"}) ; 
-    mkN2 : N -> Prep -> N2 = \n,p -> lin N2 (n ** {c2 = p.s}) ; 
-    } ;   
 
 ---- Use the function $mkPrep$ or see the section on prepositions below to  
 ---- form other prepositions.
@@ -77,7 +64,6 @@ oper
 ---- Three-place relational nouns ("die Verbindung von x nach y") need two prepositions.
 --
   mkN3 : N -> Prep -> Prep -> N3 ;
-  mkN3 n p q = lin N3 (n ** {c2 = p.s ; c3 = q.s}) ; 
 
 --3 Proper names and noun phrases
 
@@ -85,10 +71,6 @@ oper
     mkPN : Str -> PN ;
     } ;
 
-  mkPN = overload {
-    mkPN : Str -> PN = \s -> lin PN {s = \\_ => s} ;
-    } ;
-
 
 --2 Adjectives
 
@@ -97,10 +79,6 @@ oper
     mkA : (goed,goede,goeds,beter,best : Str) -> A ;
     } ;
 
-  mkA = overload {
-    mkA : (vers : Str) -> A = \a -> lin A (regAdjective a) ;
-    mkA : (goed,goede,goeds,beter,best : Str) -> A = \a,b,c,d,e -> lin A (mkAdjective a b c d e) ;
-    } ;
 
 -- Invariable adjective are a special case. 
 
@@ -124,14 +102,14 @@ oper
 -- A preposition is formed from a string.
 
   mkPrep : Str -> Prep ;
-  mkPrep s = lin Prep (ss s) ;
+
   
 ---- A couple of common prepositions (always with the dative).
 --
   van_Prep : Prep ;
-  van_Prep = mkPrep "van" ;
   te_Prep  : Prep ;
-  te_Prep = mkPrep "te" ;
+
+
 --
 --2 Verbs
 
@@ -146,40 +124,9 @@ oper
     mkV : Str -> V -> V
     } ;
 
-  mkV = overload {
-    mkV : (aaien : Str) -> V = 
-      \s -> lin V (v2vv (regVerb s)) ;
-    mkV : (breken,brak,gebroken : Str) -> V = 
-      \a,b,c -> lin V (v2vv (irregVerb a b c)) ;
-    mkV : (breken,brak,braken,gebroken : Str) -> V = 
-      \a,b,c,d -> lin V (v2vv (irregVerb2 a b c d)) ;
-    mkV : (aai,aait,aaien,aaide,aaiden,geaaid : Str) -> V =
-      \a,b,c,d,f,g -> lin V (v2vv (mkVerb a b c d d f g)) ;
-    mkV : Str -> V -> V = \v,s ->lin V (prefixV v s) ;
-    } ;
-
   zijnV  : V -> V ;
-  zijnV v = lin V (v2vvAux v VZijn) ;
 
   reflV  : V -> V ;
-  reflV v = lin V {s = v.s ; aux = v.aux ; prefix = v.prefix ; vtype = VRefl} ;
-
-  zijn_V : V = lin V ResDut.zijn_V ;
-  hebben_V : V = lin V ResDut.hebben_V ;
-
---3 Two-place verbs
-
-  mkV2 : overload {
-    mkV2 : Str -> V2 ;
-    mkV2 : V -> V2 ;
-    mkV2 : V -> Prep -> V2 ;
-    } ;
-
-  mkV2 = overload {
-    mkV2 : Str -> V2 = \s -> lin V2 (v2vv (regVerb s) ** {c2 = []}) ;
-    mkV2 : V -> V2 = \s -> lin V2 (s ** {c2 = []}) ;
-    mkV2 : V -> Prep -> V2  = \s,p -> lin V2 (s ** {c2 = p.s}) ;
-    } ;
 
 
 --
@@ -195,12 +142,6 @@ oper
     mkV3 : V -> Prep -> Prep -> V3 ;  -- sprechen, mit, über
     } ;
 
-  mkV3 = overload {
-    mkV3 : V -> Prep -> Prep -> V3 = mkmaxV3 ;
-    mkV3 : V -> Prep -> V3 = \v,p -> mkmaxV3 v (mkPrep []) p ; 
-    mkV3 : V -> V3 = \v -> mkmaxV3 v (mkPrep []) (mkPrep []) ; 
-    } ;
-  mkmaxV3 : V -> Prep -> Prep -> V3 = \v,c,d -> lin V3 (v ** {c2 = c.s ; c3 = d.s}) ;
 
 ----3 Other complement patterns
 ----
@@ -231,9 +172,88 @@ oper
 --
 --
 
+
+--.
+
   mkOrd : A -> Ord = \a -> lin Ord {s = a.s ! Posit} ;
 
-----.
+  mkN = overload {
+    mkN : (muis : Str) -> N 
+    = \a -> lin N (regNoun a) ;
+    mkN : (bit : Str) -> Gender -> N 
+    = \a,b -> lin N (regNounG a b) ;
+    mkN : (gat,gaten : Str) -> Gender -> N 
+    = \a,b,c -> lin N (mkNoun a b c) ;
+  } ;
+
+  mkN2 = overload {
+    mkN2 : N -> N2 
+    = \n -> lin N2 (n ** {c2 = "van"}) ; 
+    mkN2 : N -> Prep -> N2 
+    = \n,p -> lin N2 (n ** {c2 = p.s}) ; 
+    } ;   
+  mkN3 n p q = lin N3 (n ** {c2 = p.s ; c3 = q.s}) ; 
+
+  mkPN = overload {
+    mkPN : Str -> PN = \s -> lin PN {s = \\_ => s} ;
+    } ;
+
+  masculine = Utr ;
+  feminine  = Utr ;
+  het,neuter = Neutr ;
+  de,utrum = Utr ;
+
+  mkA = overload {
+    mkA : (vers : Str) -> A = \a -> lin A (regAdjective a) ;
+    mkA : (goed,goede,goeds,beter,best : Str) -> A = \a,b,c,d,e -> lin A (mkAdjective a b c d e) ;
+    } ;
+
+  mkPrep s = lin Prep (ss s) ;
+  van_Prep = mkPrep "van" ;
+  te_Prep = mkPrep "te" ;
+
+  mkV = overload {
+    mkV : (aaien : Str) -> V = 
+      \s -> lin V (v2vv (regVerb s)) ;
+    mkV : (breken,brak,gebroken : Str) -> V = 
+      \a,b,c -> lin V (v2vv (irregVerb a b c)) ;
+    mkV : (breken,brak,braken,gebroken : Str) -> V = 
+      \a,b,c,d -> lin V (v2vv (irregVerb2 a b c d)) ;
+    mkV : (aai,aait,aaien,aaide,aaiden,geaaid : Str) -> V =
+      \a,b,c,d,f,g -> lin V (v2vv (mkVerb a b c d d f g)) ;
+    mkV : Str -> V -> V = \v,s ->lin V (prefixV v s) ;
+    } ;
+  zijnV v = lin V (v2vvAux v VZijn) ;
+  reflV v = lin V {s = v.s ; aux = v.aux ; prefix = v.prefix ; vtype = VRefl} ;
+
+  zijn_V : V = lin V ResDut.zijn_V ;
+  hebben_V : V = lin V ResDut.hebben_V ;
+
+  mkV2 = overload {
+    mkV2 : Str -> V2 = \s -> lin V2 (v2vv (regVerb s) ** {c2 = []}) ;
+    mkV2 : V -> V2 = \s -> lin V2 (s ** {c2 = []}) ;
+    mkV2 : V -> Prep -> V2  = \s,p -> lin V2 (s ** {c2 = p.s}) ;
+    } ;
+
+
+--3 Two-place verbs
+
+  mkV2 : overload {
+    mkV2 : Str -> V2 ;
+    mkV2 : V -> V2 ;
+    mkV2 : V -> Prep -> V2 ;
+    } ;
+  mkV3 = overload {
+    mkV3 : V -> Prep -> Prep -> V3 = mkmaxV3 ;
+    mkV3 : V -> Prep -> V3 = \v,p -> mkmaxV3 v (mkPrep []) p ; 
+    mkV3 : V -> V3 = \v -> mkmaxV3 v (mkPrep []) (mkPrep []) ; 
+    } ;
+  mkmaxV3 : V -> Prep -> Prep -> V3 = \v,c,d -> lin V3 (v ** {c2 = c.s ; c3 = d.s}) ;
+
+
+
+
+
 ----2 Definitions of paradigms
 ----
 ---- The definitions should not bother the user of the API. So they are
diff --git a/lib/src/french/ParadigmsFre.gf b/lib/src/french/ParadigmsFre.gf
index 1009de8d9..0ad090398 100644
--- a/lib/src/french/ParadigmsFre.gf
+++ b/lib/src/french/ParadigmsFre.gf
@@ -235,9 +235,12 @@ oper
 -- (transitive verbs). 
 
   mkV2 = overload {
-    mkV2 : Str -> V2 = \s -> dirV2 (regV s) ;
-    mkV2 : V -> V2 = dirV2 ;  
-    mkV2 : V -> Prep -> V2 = mmkV2
+    mkV2 : Str -> V2 
+    = \s -> dirV2 (regV s) ;
+    mkV2 : V -> V2 
+    = dirV2 ;  
+    mkV2 : V -> Prep -> V2 
+    = mmkV2
   } ;
 
 
diff --git a/lib/src/italian/StructuralIta.gf b/lib/src/italian/StructuralIta.gf
index 078fcd919..08e6ca2e3 100644
--- a/lib/src/italian/StructuralIta.gf
+++ b/lib/src/italian/StructuralIta.gf
@@ -42,9 +42,9 @@ lin
     mkPronoun
       "lui" "lo" "gli" "glie" "lui" "suo" "sua" "suoi" "sue"
       Masc Sg P3 ;
-  here7from_Adv = ss ["da quì"] ;
-  here7to_Adv = ss "quì" ;
-  here_Adv = ss "quì" ;
+  here7from_Adv = ss ["da quà"] ;
+  here7to_Adv = ss "quà" ;
+  here_Adv = ss "quà" ;
   how_IAdv = ss "come" ;
   how8much_IAdv = ss "quanto" ;
   how8many_IDet = {s = \\g,c => prepCase c ++ genForms "quanti" "quante" ! g ; n = Pl} ;
diff --git a/lib/src/romanian/ParadigmsRon.gf b/lib/src/romanian/ParadigmsRon.gf
index 528f36fcb..907f73678 100644
--- a/lib/src/romanian/ParadigmsRon.gf
+++ b/lib/src/romanian/ParadigmsRon.gf
@@ -86,13 +86,18 @@ mkN3 n p q = n ** {lock_N3 = <> ; c2 = p ; c3 = q };
 -- feminine is used for strings ending with "e", the masculine for other strings.
 
   mkPN  = overload {
-    mkPN : Str -> PN = mkPropN ;
-    mkPN : Str -> Str -> Gender -> Number -> PN = mkPropNI ;
-    mkPN : Str -> Gender -> PN = mkPropNoun ;
-    mkPN : Str -> Gender -> Number -> PN = mkProperNoun;  
+    mkPN : Str -> PN 
+    = mkPropN ;
+    mkPN : Str -> Str -> Gender -> Number -> PN 
+    = mkPropNI ;
+    mkPN : Str -> Gender -> PN 
+    = mkPropNoun ;
+    mkPN : Str -> Gender -> Number -> PN 
+    = mkProperNoun;  
    } ;
 
-mkInAn : PN -> PN = \romania ->
+mkInAn : PN -> PN
+   = \romania ->
    {s = table {No | Ac | Vo => romania.s ! No ;
                _ => case romania.g of
                        { Fem => romania.s ! Ge ;
@@ -103,24 +108,27 @@ mkInAn : PN -> PN = \romania ->
     lock_PN = <>
     };
 
-mkPropNI : Str -> Str -> Gender -> Number -> PN =
-\romania, romaniei,g,n ->
+mkPropNI : Str -> Str -> Gender -> Number -> PN --% 
+ = \romania, romaniei,g,n ->
 {s = table {Ge | Da => romaniei;
             _       => romania  };
 g = g; n = n;
 a = Inanimate;
 lock_PN = <>
 };
-mkPropN : Str -> PN = \Ion ->
+mkPropN : Str -> PN --%
+ = \Ion ->
 case last Ion of
 { "a" => mkPropNoun Ion Feminine ;
    _  => mkPropNoun Ion Masculine
 };
 
-mkPropNoun : Str -> Gender -> PN = \Ion, gen ->
+mkPropNoun : Str -> Gender -> PN 
+= \Ion, gen ->
  mkProperNoun Ion gen singular ;
 
-mkProperNoun : Str -> Gender -> Number -> PN = \Ion, gen, num ->
+mkProperNoun : Str -> Gender -> Number -> PN --%
+= \Ion, gen, num ->
 {s = table {No => Ion;
             Ac => Ion;
             Ge => case <last Ion,gen> of
@@ -148,6 +156,26 @@ lock_PN = <>
  mkA2 : A -> Prep -> A2 ;
  mkA2 a p = a ** {c2 = p ; lock_A2 = <>} ;
 
+ mkV : Str -> V 
+ = \s -> mkNV (regV s) ; 
+
+
+
+  mkV2S : V -> Prep -> V2S ;  
+  mkV2V : V -> Prep -> Prep -> V2V ;
+  mkVA  : V -> VA ;
+  mkV2A : V -> Prep -> Prep -> V2A ;
+  mkVQ  : V -> VQ ;
+  mkV2Q : V -> Prep -> V2Q ;
+
+  mkAS  : A -> AS ;
+  mkA2S : A -> Prep -> A2S ;
+  mkAV  : A -> Prep -> AV ;
+  mkA2V : A -> Prep -> Prep -> A2V ;
+
+
+
+
 --.
 --2 Definitions of the paradigms
 
@@ -208,7 +236,7 @@ regN : Str -> NGender -> N ;
 regN s g = mkInanimate (mkNomReg s g) ** {lock_N = <>};
              
 
-mkVI : Str -> Str -> Str -> N;
+mkVI : Str -> Str -> Str -> N ;
 mkVI s ss sss = mkInanimate (mkNomVIrreg s ss sss) ** {lock_N = <>};
 
 mkIn : N -> N ;
@@ -343,23 +371,7 @@ case s of
   x + "î"   => mkV141 s
 };
 
-oper mkV : Str -> V = \s -> mkNV (regV s) ; 
-
-
-
-  mkV2S : V -> Prep -> V2S ;  
-  mkV2V : V -> Prep -> Prep -> V2V ;
-  mkVA  : V -> VA ;
-  mkV2A : V -> Prep -> Prep -> V2A ;
-  mkVQ  : V -> VQ ;
-  mkV2Q : V -> Prep -> V2Q ;
-
-  mkAS  : A -> AS ;
-  mkA2S : A -> Prep -> A2S ;
-  mkAV  : A -> Prep -> AV ;
-  mkA2V : A -> Prep -> Prep -> A2V ;
-
-
+oper 
   mmkV3 : V -> Prep -> Prep -> V3;
   mmkV3 v p q = v ** {c2 = p ; c3 = q ; lock_V3 = <>} ;
   
diff --git a/lib/src/urdu/ParadigmsUrd.gf b/lib/src/urdu/ParadigmsUrd.gf
index 8a34fb844..4fe80dcad 100644
--- a/lib/src/urdu/ParadigmsUrd.gf
+++ b/lib/src/urdu/ParadigmsUrd.gf
@@ -47,14 +47,20 @@ oper
  
 
 -- Proper names     
-  mkPN : Str -> PN = \s -> let n = regNoun s in {s = n.s ! Sg ; g = n.g ; lock_PN = <>} ;
-  personalPN : Str -> Str -> Str -> Str -> Number -> Gender -> UPerson -> Pron = \s1,s2,s3,sp,nn,g,p -> let n = mkPron s1 s2 s3 in {s = n.s ; a = toAgr nn p g ; ps = sp ; lock_Pron = <>};
-  demoPN : Str -> Str -> Str -> Quant = \s1,s2,s3 -> let n = makeDemonPronForm s1 s2 s3 in {s = n.s ; a = defaultAgr ; lock_Quant = <>};
-  mkDet : Str -> Str -> Str -> Str -> Number -> Det = \s1,s2,s3,s4,nb -> let dt = makeDet s1 s2 s3 s4 nb in {s = dt.s ; n = nb ; lock_Det = <>};
-  mkIP : (x1,x2,x3:Str) -> Number -> Gender -> IP = \s1,s2,s3,n,g -> let p = mkIntPronForm s1 s2 s3 in { s = p.s ; n = n ; g = g ;  lock_IP = <>}; 
+  mkPN : Str -> PN 
+  = \s -> let n = regNoun s in {s = n.s ! Sg ; g = n.g ; lock_PN = <>} ;
+  personalPN : Str -> Str -> Str -> Str -> Number -> Gender -> UPerson -> Pron --% 
+  = \s1,s2,s3,sp,nn,g,p -> let n = mkPron s1 s2 s3 in {s = n.s ; a = toAgr nn p g ; ps = sp ; lock_Pron = <>};
+  demoPN : Str -> Str -> Str -> Quant --%
+  = \s1,s2,s3 -> let n = makeDemonPronForm s1 s2 s3 in {s = n.s ; a = defaultAgr ; lock_Quant = <>};
+  mkDet : Str -> Str -> Str -> Str -> Number -> Det --% 
+  = \s1,s2,s3,s4,nb -> let dt = makeDet s1 s2 s3 s4 nb in {s = dt.s ; n = nb ; lock_Det = <>};
+  mkIP : (x1,x2,x3:Str) -> Number -> Gender -> IP --% 
+  = \s1,s2,s3,n,g -> let p = mkIntPronForm s1 s2 s3 in { s = p.s ; n = n ; g = g ;  lock_IP = <>}; 
 
 -- AdN
-  mkAdN : Str -> AdN = \s -> {s = s ; p = False ; lock_AdN = <>} ; 
+  mkAdN : Str -> AdN  --%
+  = \s -> {s = s ; p = False ; lock_AdN = <>} ; 
 --2 Adjectives
 
   mkA = overload {
@@ -79,7 +85,7 @@ oper
     mkV2 : V -> Str -> V2 
       = \v,p -> v ** {c2 = {s = p ; c = VTrans} ; lock_V2 = <>} ;
     } ;
-  dirV2 : V -> V2 = \v -> v ** {c2 = {s = [] ; c = VTrans} ; lock_V2 = <>} ;
+  dirV2 : V -> V2 = \v -> v ** {c2 = {s = [] ; c = VTrans} ; lock_V2 = <>} ; --%
   
   mkV3 : V -> Str -> Str -> V3;
     mkV3 v p q = v ** { c2 = p ; c3 = q ; lock_V3 = <>} ;
@@ -90,13 +96,16 @@ oper
   
 -- compund verbs
    compoundV = overload {
-   compoundV : Str -> V -> V = \s,v -> {s = \\vf => s ++ v.s ! vf ; lock_V = <>} ;     
-   compoundV : Str -> V2 -> V = \s,v -> {s = \\vf => s ++ v.s ! vf ; lock_V = <>} ;
+   compoundV : Str -> V -> V 
+   = \s,v -> {s = \\vf => s ++ v.s ! vf ; lock_V = <>} ;     
+   compoundV : Str -> V2 -> V 
+   = \s,v -> {s = \\vf => s ++ v.s ! vf ; lock_V = <>} ;
    };
  
 
 ----2 Adverbs
-  mkAdv : Str -> Adv = \str -> {s = \\_ => str ; lock_Adv = <>};
+  mkAdv : Str -> Adv 
+  = \str -> {s = \\_ => str ; lock_Adv = <>};
 
 ----2 Prepositions
 
@@ -122,21 +131,13 @@ oper
     mkConj : Str -> Str -> Conj ;           -- both ... and (plural)
     mkConj : Str -> Str -> Number -> Conj ; -- either ... or (agrement number given as argument)
   } ;
- mkConj = overload {
-    mkConj : Str -> Conj = \y -> mk2Conj [] y plural ;
-    mkConj : Str -> Number -> Conj = \y,n -> mk2Conj [] y n ;
-    mkConj : Str -> Str -> Conj = \x,y -> mk2Conj x y plural ;
-    mkConj : Str -> Str -> Number -> Conj = mk2Conj ;
-  } ;
-
-  mk2Conj : Str -> Str -> Number -> Conj = \x,y,n -> 
-    lin Conj (sd2 x y ** {n = n}) ;  
 
 --  mkV0  : V -> V0 ;
   mkVS  : V -> VS;
   mkVS v = v ;
 --  mkV2S : V -> Prep -> V2S ;
-  mkVV  : V -> VV = \v ->  lin VV (v ** {isAux = False});
+  mkVV  : V -> VV 
+  = \v ->  lin VV (v ** {isAux = False});
     
   mkAdA : Str -> AdA ;
 --  mkAdv x = lin Adv (ss x) ;
@@ -180,4 +181,18 @@ oper
 --  nominative = Nom ;
 --  genitive = Gen ;
   
+ mkConj = overload {
+    mkConj : Str -> Conj 
+    = \y -> mk2Conj [] y plural ;
+    mkConj : Str -> Number -> Conj 
+    = \y,n -> mk2Conj [] y n ;
+    mkConj : Str -> Str -> Conj 
+    = \x,y -> mk2Conj x y plural ;
+    mkConj : Str -> Str -> Number -> Conj 
+    = mk2Conj ;
+  } ;
+
+  mk2Conj : Str -> Str -> Number -> Conj = \x,y,n -> 
+    lin Conj (sd2 x y ** {n = n}) ;  
+
 }