diff --git a/Duckling/Numeral/EN/Rules.hs b/Duckling/Numeral/EN/Rules.hs
--- a/Duckling/Numeral/EN/Rules.hs
+++ b/Duckling/Numeral/EN/Rules.hs
@@ -13,20 +13,21 @@
 module Duckling.Numeral.EN.Rules
   ( rules ) where
 
+import Control.Applicative ((<|>))
 import Data.HashMap.Strict (HashMap)
-import qualified Data.HashMap.Strict as HashMap
 import Data.Maybe
+import Data.String
 import Data.Text (Text)
-import qualified Data.Text as Text
 import Prelude
-import Data.String
+import qualified Data.HashMap.Strict as HashMap
+import qualified Data.Text as Text
 
 import Duckling.Dimensions.Types
 import Duckling.Numeral.Helpers
 import Duckling.Numeral.Types (NumeralData (..))
-import qualified Duckling.Numeral.Types as TNumeral
 import Duckling.Regex.Types
 import Duckling.Types
+import qualified Duckling.Numeral.Types as TNumeral
 
 ruleIntegers :: Rule
 ruleIntegers = Rule
@@ -46,7 +47,7 @@
   , pattern =
     [ regex "(a )?dozens?( of)?"
     ]
-  , prod = \_ -> integer 12 >>= withMultipliable
+  , prod = \_ -> integer 12 >>= withMultipliable >>= notOkForAnyTime
   }
 
 zeroNineteenMap :: HashMap Text Integer
@@ -58,23 +59,8 @@
   , ( "zero"  , 0 )
   , ( "zilch" , 0 )
   , ( "one"   , 1 )
-  , ( "single", 1 )
   , ( "two", 2 )
-  , ( "a couple", 2 )
-  , ( "a couple of", 2 )
-  , ( "couple", 2 )
-  , ( "couples", 2 )
-  , ( "couple of", 2 )
-  , ( "couples of", 2 )
-  , ( "a pair", 2 )
-  , ( "a pair of", 2 )
-  , ( "pair", 2 )
-  , ( "pairs", 2 )
-  , ( "pair of", 2 )
-  , ( "pairs of", 2 )
   , ( "three", 3 )
-  , ( "a few", 3 )
-  , ( "few", 3 )
   , ( "four", 4 )
   , ( "five", 5 )
   , ( "six", 6 )
@@ -93,14 +79,37 @@
   , ( "nineteen", 19 )
   ]
 
+informalMap :: HashMap Text Integer
+informalMap = HashMap.fromList
+  [ ( "single", 1 )
+  , ( "a couple", 2 )
+  , ( "a couple of", 2 )
+  , ( "couple", 2 )
+  , ( "couples", 2 )
+  , ( "couple of", 2 )
+  , ( "couples of", 2 )
+  , ( "a pair", 2 )
+  , ( "a pair of", 2 )
+  , ( "pair", 2 )
+  , ( "pairs", 2 )
+  , ( "pair of", 2 )
+  , ( "pairs of", 2 )
+  , ( "a few", 3 )
+  , ( "few", 3 )
+  ]
+
 ruleToNineteen :: Rule
 ruleToNineteen = Rule
   { name = "integer (0..19)"
   -- e.g. fourteen must be before four, otherwise four will always shadow fourteen
-  , pattern = [regex "(none|zilch|naught|nought|nil|zero|one|single|two|(a )?(pair|couple)s?( of)?|three|(a )?few|fourteen|four|fifteen|five|sixteen|six|seventeen|seven|eighteen|eight|nineteen|nine|ten|eleven|twelve|thirteen)"]
+  , pattern =
+    [ regex "(none|zilch|naught|nought|nil|zero|one|single|two|(a )?(pair|couple)s?( of)?|three|(a )?few|fourteen|four|fifteen|five|sixteen|six|seventeen|seven|eighteen|eight|nineteen|nine|ten|eleven|twelve|thirteen)"
+    ]
   , prod = \tokens -> case tokens of
       (Token RegexMatch (GroupMatch (match:_)):_) ->
-        HashMap.lookup (Text.toLower match) zeroNineteenMap >>= integer
+        let x = Text.toLower match in
+        (HashMap.lookup x zeroNineteenMap >>= integer) <|>
+        (HashMap.lookup x informalMap >>= integer >>= notOkForAnyTime)
       _ -> Nothing
   }
 
@@ -110,7 +119,7 @@
   , pattern = [regex "(twenty|thirty|fou?rty|fifty|sixty|seventy|eighty|ninety)"]
   , prod = \tokens ->
       case tokens of
-        (Token RegexMatch (GroupMatch (match : _)) : _) ->
+        (Token RegexMatch (GroupMatch (match:_)):_) ->
           case Text.toLower match of
             "twenty"  -> integer 20
             "thirty"  -> integer 30
diff --git a/Duckling/Numeral/Helpers.hs b/Duckling/Numeral/Helpers.hs
--- a/Duckling/Numeral/Helpers.hs
+++ b/Duckling/Numeral/Helpers.hs
@@ -15,6 +15,7 @@
   , integer
   , multiply
   , divide
+  , notOkForAnyTime
   , numberBetween
   , numberWith
   , oneOf
@@ -23,18 +24,18 @@
   , parseInteger
   , withGrain
   , withMultipliable
-  , parseDecimal,
+  , parseDecimal
   ) where
 
-import qualified Data.Attoparsec.Text as Atto
 import Data.Maybe
 import Data.Text (Text)
-import qualified Data.Text as Text
 import Prelude
+import qualified Data.Attoparsec.Text as Atto
+import qualified Data.Text as Text
 
 import Duckling.Dimensions.Types
 import Duckling.Numeral.Types
-import Duckling.Types hiding (value)
+import Duckling.Types hiding (Entity(value))
 
 zeroT :: Text
 zeroT = Text.singleton '0'
@@ -106,11 +107,17 @@
   Just . Token Numeral $ x {grain = Just g}
 withGrain _ _ = Nothing
 
+notOkForAnyTime :: Token -> Maybe Token
+notOkForAnyTime (Token Numeral x) =
+  Just . Token Numeral $ x {okForAnyTime = False}
+notOkForAnyTime _ = Nothing
+
 double :: Double -> Maybe Token
 double x = Just . Token Numeral $ NumeralData
   { value = x
   , grain = Nothing
   , multipliable = False
+  , okForAnyTime = True
   }
 
 integer :: Integer -> Maybe Token
diff --git a/Duckling/Numeral/PT/Corpus.hs b/Duckling/Numeral/PT/Corpus.hs
--- a/Duckling/Numeral/PT/Corpus.hs
+++ b/Duckling/Numeral/PT/Corpus.hs
@@ -131,11 +131,24 @@
              [ "100"
              , "Cem"
              ]
+  , examples (NumeralValue 104)
+             [ "104"
+             , "cento e quatro"
+             ]
   , examples (NumeralValue 243)
              [ "243"
+             ,"duzentos e quarenta e tres"
              ]
   , examples (NumeralValue 300)
              [ "trezentos"
+             ]
+  , examples (NumeralValue 343)
+             [ "trezentos e quarenta e tres"
+             , "343"
+             ]
+  , examples (NumeralValue 891)
+             [ "oitocentos e noventa e um"
+             , "891"
              ]
   , examples (NumeralValue 3000000)
              [ "3M"
diff --git a/Duckling/Numeral/PT/Rules.hs b/Duckling/Numeral/PT/Rules.hs
--- a/Duckling/Numeral/PT/Rules.hs
+++ b/Duckling/Numeral/PT/Rules.hs
@@ -184,7 +184,8 @@
 ruleNumeral6 = Rule
   { name = "number 100..1000 "
   , pattern =
-    [ regex "(ce(m|to)|duzentos|trezentos|quatrocentos|quinhentos|seiscentos|setecentos|oitocentos|novecentos|mil)"
+    [
+      regex "(cem|cento|duzentos|trezentos|quatrocentos|quinhentos|seiscentos|setecentos|oitocentos|novecentos|mil)"
     ]
   , prod = \tokens -> case tokens of
       (Token RegexMatch (GroupMatch (match:_)):_) -> case Text.toLower match of
@@ -244,17 +245,17 @@
 
 ruleNumerals :: Rule
 ruleNumerals = Rule
-  { name = "numbers 200..999"
+  { name = "numbers (100..999)"
   , pattern =
-    [ numberBetween 2 10
-    , numberWith TNumeral.value (== 100)
+    [ numberBetween 100 1000
+    , regex "e"
     , numberBetween 0 100
     ]
   , prod = \tokens -> case tokens of
       (Token Numeral (NumeralData {TNumeral.value = v1}):
        _:
        Token Numeral (NumeralData {TNumeral.value = v2}):
-       _) -> double $ v1 * 100 + v2
+       _) -> double $ v1 + v2
       _ -> Nothing
   }
 
diff --git a/Duckling/Numeral/Types.hs b/Duckling/Numeral/Types.hs
--- a/Duckling/Numeral/Types.hs
+++ b/Duckling/Numeral/Types.hs
@@ -29,6 +29,11 @@
   { value        :: Double
   , grain        :: Maybe Int
   , multipliable :: Bool
+  -- Hack until other use cases pop up,
+  -- at which point we'll craft a generic solution.
+  -- This allows to explicitly flag Numerals that don't work well with Time.
+  -- See `ruleTODLatent`. Prevents things like "at single", "dozens o'clock".
+  , okForAnyTime :: Bool
   }
   deriving (Eq, Generic, Hashable, Ord, Show, NFData)
 
diff --git a/Duckling/Numeral/VI/Corpus.hs b/Duckling/Numeral/VI/Corpus.hs
--- a/Duckling/Numeral/VI/Corpus.hs
+++ b/Duckling/Numeral/VI/Corpus.hs
@@ -56,6 +56,10 @@
              [ "18"
              , "mười tám"
              ]
+  , examples (NumeralValue 100)
+            [ "100"
+            , "tră"
+            ]
   , examples (NumeralValue 1.1)
              [ "1.1"
              , "1.10"
diff --git a/Duckling/Numeral/VI/Rules.hs b/Duckling/Numeral/VI/Rules.hs
--- a/Duckling/Numeral/VI/Rules.hs
+++ b/Duckling/Numeral/VI/Rules.hs
@@ -12,6 +12,7 @@
 module Duckling.Numeral.VI.Rules
   ( rules ) where
 
+import qualified Data.HashMap.Strict as HashMap
 import Data.Maybe
 import qualified Data.Text as Text
 import Prelude
@@ -24,6 +25,18 @@
 import Duckling.Regex.Types
 import Duckling.Types
 
+powersOfTenMap :: HashMap.HashMap Text.Text (Double, Int)
+powersOfTenMap = HashMap.fromList
+  [ ( "tr\x0103",   (1e2, 2) )
+  , ( "tr\x0103m",  (1e2, 2) )
+  , ( "ngh\x00ec",  (1e3, 3) )
+  , ( "ngh\x00ecn", (1e3, 3) )
+  , ( "tri\x1ec7",  (1e6, 6) )
+  , ( "tri\x1ec7u", (1e6, 6) )
+  , ( "t",          (1e9, 9) )
+  , ( "t\x1ef7",    (1e9, 9) )
+  ]
+
 rulePowersOfTen :: Rule
 rulePowersOfTen = Rule
   { name = "powers of tens"
@@ -31,16 +44,10 @@
     [ regex "(tr\x0103m?|ngh\x00ecn?|tri\x1ec7u?|t\x1ef7?)"
     ]
   , prod = \tokens -> case tokens of
-      (Token RegexMatch (GroupMatch (match:_)):_) -> case Text.toLower match of
-        "tr\x0103"   -> double 1e2 >>= withGrain 2 >>= withMultipliable
-        "tr\x0103m"  -> double 1e2 >>= withGrain 2 >>= withMultipliable
-        "ngh\x00ec"  -> double 1e3 >>= withGrain 3 >>= withMultipliable
-        "ngh\x00ecn" -> double 1e3 >>= withGrain 3 >>= withMultipliable
-        "tri\x1ec7"  -> double 1e6 >>= withGrain 6 >>= withMultipliable
-        "tri\x1ec7u" -> double 1e6 >>= withGrain 6 >>= withMultipliable
-        "t"          -> double 1e9 >>= withGrain 9 >>= withMultipliable
-        "t\x1ef7"    -> double 1e9 >>= withGrain 9 >>= withMultipliable
-        _            -> Nothing
+      (Token RegexMatch (GroupMatch (match:_)):_) ->
+        do
+          (value, grain) <- HashMap.lookup (Text.toLower match) powersOfTenMap
+          double value >>= withGrain grain >>= withMultipliable
       _ -> Nothing
   }
 
@@ -206,6 +213,50 @@
       _ -> Nothing
   }
 
+integerMap :: HashMap.HashMap Text.Text Integer
+integerMap = HashMap.fromList
+  [ ("kh\x00f4ng",               0)
+  , ("m\x1ed9t",                 1)
+  , ("linh m\x1ed9t",            1)
+  , ("l\x1ebb m\x1ed9t",         1)
+  , ("hai",                      2)
+  , ("l\x1ebb hai",              2)
+  , ("linh hai",                 2)
+  , ("ba",                       3)
+  , ("l\x1ebb",                  3)
+  , ("linh ba",                  3)
+  , ("l\x1ebb b\x1ed1n",         4)
+  , ("linh b\x1ed1n",            4)
+  , ("b\x1ed1n",                 4)
+  , ("n\x0103m",                 5)
+  , ("l\x1ebb n\x0103m",         5)
+  , ("linh n\x0103m",            5)
+  , ("linh s\x00e1u",            6)
+  , ("s\x00e1u",                 6)
+  , ("l\x1ebb s\x00e1u",         6)
+  , ("linh b\x1ea3y",            7)
+  , ("l\x1ebb b\x1ea3y",         7)
+  , ("b\x1ea3y",                 7)
+  , ("l\x1ebb t\x00e1m",         8)
+  , ("linh t\x00e1m",            8)
+  , ("t\x00e1m",                 8)
+  , ("l\x1ebb ch\x00edn",        9)
+  , ("ch\x00edn",                9)
+  , ("linh ch\x00edn",           9)
+  , ("linh m\x01b0\x1eddi",      10)
+  , ("m\x01b0\x1eddi",           10)
+  , ("l\x1ebb m\x01b0\x1eddi",   10)
+  , ("m\x01b0\x1eddi m\x1ed9t",  11)
+  , ("m\x01b0\x1eddi hai",       12)
+  , ("m\x01b0\x1eddi ba",        13)
+  , ("m\x01b0\x1eddi b\x1ed1n",  14)
+  , ("m\x01b0\x1eddi l\x0103m",  15)
+  , ("m\x01b0\x1eddi s\x00e1u",  16)
+  , ("m\x01b0\x1eddi b\x1ea3y",  17)
+  , ("m\x01b0\x1eddi t\x00e1m",  18)
+  , ("m\x01b0\x1eddi ch\x00edn", 19)
+  ]
+
 ruleInteger :: Rule
 ruleInteger = Rule
   { name = "integer (0..19)"
@@ -213,51 +264,23 @@
     [ regex "(kh\x00f4ng|m\x1ed9t|linh m\x1ed9t|l\x1ebb m\x1ed9t|hai|linh hai|l\x1ebb hai|ba|linh ba|l\x1ebb ba|b\x1ed1n|linh b\x1ed1n|l\x1ebb b\x1ed1n|n\x0103m|linh n\x0103m|l\x1ebb n\x0103m|s\x00e1u|l\x1ebb s\x00e1u|linh s\x00e1u|b\x1ea3y|l\x1ebb b\x1ea3y|linh b\x1ea3y|t\x00e1m|linh t\x00e1m|l\x1ebb t\x00e1m|ch\x00edn|linh ch\x00edn|l\x1ebb ch\x00edn|m\x01b0\x1eddi m\x1ed9t|m\x01b0\x1eddi hai|m\x01b0\x1eddi ba|m\x01b0\x1eddi b\x1ed1n|m\x01b0\x1eddi l\x0103m|m\x01b0\x1eddi s\x00e1u|m\x01b0\x1eddi b\x1ea3y|m\x01b0\x1eddi t\x00e1m|m\x01b0\x1eddi ch\x00edn|m\x01b0\x1eddi|linh m\x01b0\x1eddi)"
     ]
   , prod = \tokens -> case tokens of
-      (Token RegexMatch (GroupMatch (match:_)):_) -> case match of
-        "kh\x00f4ng" -> integer 0
-        "m\x1ed9t" -> integer 1
-        "linh m\x1ed9t" -> integer 1
-        "l\x1ebb m\x1ed9t" -> integer 1
-        "hai" -> integer 2
-        "l\x1ebb hai" -> integer 2
-        "linh hai" -> integer 2
-        "ba" -> integer 3
-        "l\x1ebb" -> integer 3
-        "linh ba" -> integer 3
-        "l\x1ebb b\x1ed1n" -> integer 4
-        "linh b\x1ed1n" -> integer 4
-        "b\x1ed1n" -> integer 4
-        "n\x0103m" -> integer 5
-        "l\x1ebb n\x0103m" -> integer 5
-        "linh n\x0103m" -> integer 5
-        "linh s\x00e1u" -> integer 6
-        "s\x00e1u" -> integer 6
-        "l\x1ebb s\x00e1u" -> integer 6
-        "linh b\x1ea3y" -> integer 7
-        "l\x1ebb b\x1ea3y" -> integer 7
-        "b\x1ea3y" -> integer 7
-        "l\x1ebb t\x00e1m" -> integer 8
-        "linh t\x00e1m" -> integer 8
-        "t\x00e1m" -> integer 8
-        "l\x1ebb ch\x00edn" -> integer 9
-        "ch\x00edn" -> integer 9
-        "linh ch\x00edn" -> integer 9
-        "linh m\x01b0\x1eddi" -> integer 10
-        "m\x01b0\x1eddi" -> integer 10
-        "l\x1ebb m\x01b0\x1eddi" -> integer 10
-        "m\x01b0\x1eddi m\x1ed9t" -> integer 11
-        "m\x01b0\x1eddi hai" -> integer 12
-        "m\x01b0\x1eddi ba" -> integer 13
-        "m\x01b0\x1eddi b\x1ed1n" -> integer 14
-        "m\x01b0\x1eddi l\x0103m" -> integer 15
-        "m\x01b0\x1eddi s\x00e1u" -> integer 16
-        "m\x01b0\x1eddi b\x1ea3y" -> integer 17
-        "m\x01b0\x1eddi t\x00e1m" -> integer 18
-        "m\x01b0\x1eddi ch\x00edn" -> integer 19
-        _ -> Nothing
+      (Token RegexMatch (GroupMatch (match:_)):_) ->
+        HashMap.lookup (Text.toLower match) integerMap >>= integer
       _ -> Nothing
   }
 
+tensMap :: HashMap.HashMap Text.Text Integer
+tensMap = HashMap.fromList
+  [ ("hai m\x01b0\x01a1i",       20)
+  , ("ba m\x01b0\x01a1i",        30)
+  , ("b\x1ed1n m\x01b0\x01a1i",  40)
+  , ("n\x0103m m\x01b0\x01a1i",  50)
+  , ("s\x00e1u m\x01b0\x01a1i",  60)
+  , ("b\x1ea3y m\x01b0\x01a1i",  70)
+  , ("t\x00e1m m\x01b0\x01a1i",  80)
+  , ("ch\x00edn m\x01b0\x01a1i", 90)
+  ]
+
 ruleInteger2 :: Rule
 ruleInteger2 = Rule
   { name = "integer (20..90)"
@@ -265,16 +288,8 @@
     [ regex "(hai m\x01b0\x01a1i|ba m\x01b0\x01a1i|b\x1ed1n m\x01b0\x01a1i|n\x0103m m\x01b0\x01a1i|s\x00e1u m\x01b0\x01a1i|b\x1ea3y m\x01b0\x01a1i|t\x00e1m m\x01b0\x01a1i|ch\x00edn m\x01b0\x01a1i)"
     ]
   , prod = \tokens -> case tokens of
-      (Token RegexMatch (GroupMatch (match:_)):_) -> case match of
-        "hai m\x01b0\x01a1i" -> integer 20
-        "ba m\x01b0\x01a1i" -> integer 30
-        "b\x1ed1n m\x01b0\x01a1i" -> integer 40
-        "n\x0103m m\x01b0\x01a1i" -> integer 50
-        "s\x00e1u m\x01b0\x01a1i" -> integer 60
-        "b\x1ea3y m\x01b0\x01a1i" -> integer 70
-        "t\x00e1m m\x01b0\x01a1i" -> integer 80
-        "ch\x00edn m\x01b0\x01a1i" -> integer 90
-        _ -> Nothing
+      (Token RegexMatch (GroupMatch (match:_)):_) ->
+        HashMap.lookup (Text.toLower match) tensMap >>= integer
       _ -> Nothing
   }
 
diff --git a/Duckling/Ordinal/GA/Corpus.hs b/Duckling/Ordinal/GA/Corpus.hs
--- a/Duckling/Ordinal/GA/Corpus.hs
+++ b/Duckling/Ordinal/GA/Corpus.hs
@@ -26,6 +26,11 @@
 allExamples = concat
   [ examples (OrdinalData 6)
              [ "séu"
+             , "6a"
+             , "6d"
+             , "06u"
+             , "6 ú"
+             , "0006 adh"
              ]
   , examples (OrdinalData 1)
              [ "chead"
diff --git a/Duckling/Ordinal/GA/Rules.hs b/Duckling/Ordinal/GA/Rules.hs
--- a/Duckling/Ordinal/GA/Rules.hs
+++ b/Duckling/Ordinal/GA/Rules.hs
@@ -107,7 +107,7 @@
 ruleOrdinalDigits = Rule
   { name = "ordinal (digits)"
   , pattern =
-    [ regex "0*(\\d+) ?(a|d|(\x00fa|u))"
+    [ regex "0*(\\d+) ?(adh|a|d|\x00fa|u)"
     ]
   , prod = \tokens -> case tokens of
       (Token RegexMatch (GroupMatch (match:_)):_) -> ordinal <$> parseInt match
diff --git a/Duckling/Ranking/Classifiers/DE.hs b/Duckling/Ranking/Classifiers/DE.hs
--- a/Duckling/Ranking/Classifiers/DE.hs
+++ b/Duckling/Ranking/Classifiers/DE.hs
@@ -35,11 +35,11 @@
                                likelihoods = HashMap.fromList [], n = 0}}),
        ("integer (numeric)",
         Classifier{okData =
-                     ClassData{prior = -0.6616839111041602, unseen = -4.74493212836325,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 113},
+                     ClassData{prior = -0.9179699933938751, unseen = -4.795790545596741,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 119},
                    koData =
-                     ClassData{prior = -0.7256326357044337, unseen = -4.68213122712422,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 106}}),
+                     ClassData{prior = -0.5097076806646496, unseen = -5.198497031265826,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 179}}),
        ("exactly <time-of-day>",
         Classifier{okData =
                      ClassData{prior = 0.0, unseen = -2.3025850929940455,
@@ -175,41 +175,39 @@
                                likelihoods = HashMap.fromList [], n = 0}}),
        ("mm/dd",
         Classifier{okData =
-                     ClassData{prior = -0.13353139262452263,
-                               unseen = -2.1972245773362196,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 7},
+                     ClassData{prior = -0.40546510810816444,
+                               unseen = -3.258096538021482,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 24},
                    koData =
-                     ClassData{prior = -2.0794415416798357,
-                               unseen = -1.0986122886681098,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 1}}),
+                     ClassData{prior = -1.0986122886681098, unseen = -2.639057329615259,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 12}}),
        ("at <time-of-day>",
         Classifier{okData =
-                     ClassData{prior = -0.19237189264745613,
-                               unseen = -4.356708826689592,
+                     ClassData{prior = -0.2113090936672069, unseen = -4.382026634673881,
                                likelihoods =
                                  HashMap.fromList
-                                   [("<time-of-day>  o'clock", -2.0412203288596382),
+                                   [("<time-of-day>  o'clock", -2.0668627594729756),
                                     ("half <integer> (german style hour-of-day)",
-                                     -3.6506582412937383),
-                                    ("about <time-of-day>", -2.7343675094195836),
-                                    ("time-of-day (latent)", -1.7047480922384253),
+                                     -3.676300671907076),
+                                    ("about <time-of-day>", -2.760009940032921),
+                                    ("time-of-day (latent)", -1.7303905228517629),
                                     ("relative minutes after|past <integer> (hour-of-day)",
-                                     -3.6506582412937383),
-                                    ("hh:mm", -2.9575110607337933),
+                                     -3.676300671907076),
+                                    ("hh:mm", -2.760009940032921),
                                     ("quarter after|past <integer> (hour-of-day)",
-                                     -3.6506582412937383),
-                                    ("hour", -1.0479685558493548), ("minute", -2.264363880173848),
+                                     -3.676300671907076),
+                                    ("hour", -1.0736109864626924), ("minute", -2.172223275130802),
                                     ("<hour-of-day> <integer> (as relative minutes)",
-                                     -3.6506582412937383)],
-                               n = 33},
+                                     -3.676300671907076)],
+                               n = 34},
                    koData =
-                     ClassData{prior = -1.742969305058623, unseen = -3.258096538021482,
+                     ClassData{prior = -1.6582280766035324, unseen = -3.332204510175204,
                                likelihoods =
                                  HashMap.fromList
-                                   [("time-of-day (latent)", -1.6094379124341003),
-                                    ("<time-of-day> am|pm", -1.8325814637483102),
-                                    ("hour", -1.4271163556401458), ("minute", -2.120263536200091)],
-                               n = 7}}),
+                                   [("time-of-day (latent)", -1.5040773967762742),
+                                    ("<time-of-day> am|pm", -1.9095425048844386),
+                                    ("hour", -1.349926716949016), ("minute", -2.1972245773362196)],
+                               n = 8}}),
        ("absorption of , after named day",
         Classifier{okData =
                      ClassData{prior = -7.410797215372185e-2,
@@ -227,36 +225,36 @@
                                n = 1}}),
        ("on <date>",
         Classifier{okData =
-                     ClassData{prior = -0.2076393647782445, unseen = -4.804021044733257,
+                     ClassData{prior = -0.24256163717131135,
+                               unseen = -4.787491742782046,
                                likelihoods =
                                  HashMap.fromList
-                                   [("mm/dd", -4.102643365036796),
-                                    ("absorption of , after named day", -3.6971782569286313),
-                                    ("intersect", -1.8513515664303006),
-                                    ("after lunch", -2.849880396541428),
-                                    ("day", -1.499953679592412), ("afternoon", -2.849880396541428),
-                                    ("named-day", -2.849880396541428),
-                                    ("intersect by ','", -2.849880396541428),
-                                    ("intersect by 'of', 'from', 's", -3.4094961844768505),
-                                    ("<day-of-month> (ordinal)", -4.102643365036796),
-                                    ("hour", -1.9054187877005764), ("evening", -4.102643365036796),
-                                    ("<datetime> - <datetime> (interval)", -4.102643365036796),
-                                    ("minute", -2.4932054526026954),
-                                    ("morning", -4.102643365036796)],
-                               n = 52},
+                                   [("absorption of , after named day", -3.6805112044434196),
+                                    ("intersect", -1.834684513945089),
+                                    ("after lunch", -2.833213344056216),
+                                    ("day", -1.5210269550900473), ("afternoon", -2.833213344056216),
+                                    ("named-day", -2.833213344056216),
+                                    ("intersect by ','", -2.833213344056216),
+                                    ("intersect by 'of', 'from', 's", -3.392829131991639),
+                                    ("<day-of-month> (ordinal)", -4.085976312551584),
+                                    ("hour", -1.8887517352153647), ("evening", -4.085976312551584),
+                                    ("<datetime> - <datetime> (interval)", -4.085976312551584),
+                                    ("minute", -2.4765384001174837),
+                                    ("morning", -4.085976312551584)],
+                               n = 51},
                    koData =
-                     ClassData{prior = -1.6739764335716716,
-                               unseen = -3.7376696182833684,
+                     ClassData{prior = -1.5353299402803784, unseen = -3.828641396489095,
                                likelihoods =
                                  HashMap.fromList
-                                   [("intersect", -1.6341305250244718),
-                                    ("after lunch", -3.0204248861443626),
-                                    ("<day-of-month>(ordinal) <named-month>", -3.0204248861443626),
-                                    ("tomorrow", -3.0204248861443626), ("day", -2.1041341542702074),
-                                    ("intersect by 'of', 'from', 's", -3.0204248861443626),
-                                    ("<day-of-month> (ordinal)", -3.0204248861443626),
-                                    ("hour", -3.0204248861443626), ("minute", -1.6341305250244718)],
-                               n = 12}}),
+                                   [("intersect", -1.7272209480904839),
+                                    ("after lunch", -3.1135153092103742),
+                                    ("<day-of-month>(ordinal) <named-month>", -3.1135153092103742),
+                                    ("tomorrow", -3.1135153092103742), ("day", -2.1972245773362196),
+                                    ("hh:mm", -2.70805020110221),
+                                    ("intersect by 'of', 'from', 's", -3.1135153092103742),
+                                    ("<day-of-month> (ordinal)", -3.1135153092103742),
+                                    ("hour", -3.1135153092103742), ("minute", -1.5040773967762742)],
+                               n = 14}}),
        ("integer (0..19)",
         Classifier{okData =
                      ClassData{prior = -0.10536051565782628,
@@ -308,7 +306,7 @@
                                likelihoods = HashMap.fromList [], n = 0}}),
        ("<time-of-day>  o'clock",
         Classifier{okData =
-                     ClassData{prior = -3.077165866675366e-2,
+                     ClassData{prior = -4.580953603129422e-2,
                                unseen = -4.9344739331306915,
                                likelihoods =
                                  HashMap.fromList
@@ -325,13 +323,13 @@
                                     ("after <time-of-day>", -3.1354942159291497)],
                                n = 64},
                    koData =
-                     ClassData{prior = -3.4965075614664802, unseen = -2.70805020110221,
+                     ClassData{prior = -3.1060803307228566, unseen = -2.833213344056216,
                                likelihoods =
                                  HashMap.fromList
-                                   [("time-of-day (latent)", -1.9459101490553135),
-                                    ("hour", -1.540445040947149),
-                                    ("after <time-of-day>", -1.9459101490553135)],
-                               n = 2}}),
+                                   [("time-of-day (latent)", -1.6739764335716716),
+                                    ("hour", -1.3862943611198906),
+                                    ("after <time-of-day>", -2.0794415416798357)],
+                               n = 3}}),
        ("hour (grain)",
         Classifier{okData =
                      ClassData{prior = -0.15415067982725836,
@@ -358,264 +356,274 @@
                                n = 1}}),
        ("intersect",
         Classifier{okData =
-                     ClassData{prior = -0.23031204079282233,
-                               unseen = -6.885509670034817,
+                     ClassData{prior = -0.26452876747706405, unseen = -6.90975328164481,
                                likelihoods =
                                  HashMap.fromList
-                                   [("intersect by ','named-month", -4.399580002254782),
-                                    ("hourday", -4.93857650298747), ("dayhour", -2.527777825353191),
-                                    ("daymonth", -3.1232865363492204),
+                                   [("intersect by ','named-month", -4.4238481295272205),
+                                    ("hourday", -4.962844630259907),
+                                    ("<datetime> - <datetime> (interval)year", -4.962844630259907),
+                                    ("dayhour", -2.5520459526256287),
+                                    ("daymonth", -3.147554663621658),
                                     ("<day-of-month>(ordinal) <named-month> year<time-of-day>  o'clock",
-                                     -6.191339471482838),
-                                    ("monthyear", -4.4865913792444125),
-                                    ("yearhour", -6.191339471482838),
-                                    ("intersect<time-of-day>  o'clock", -4.051273307986567),
-                                    ("christmasyear", -6.191339471482838),
-                                    ("after lunchat <time-of-day>", -6.191339471482838),
+                                     -6.215607598755275),
+                                    ("monthyear", -4.51085950651685),
+                                    ("yearhour", -6.215607598755275),
+                                    ("intersect<time-of-day>  o'clock", -4.075541435259004),
+                                    ("christmasyear", -6.215607598755275),
+                                    ("after lunchat <time-of-day>", -6.215607598755275),
                                     ("absorption of , after named daymm/dd/yyyy",
-                                     -6.191339471482838),
-                                    ("named-daylast <cycle>", -6.191339471482838),
-                                    ("intersect by 'of', 'from', 'syear", -5.785874363374673),
-                                    ("<time-of-day> am|pmintersect", -5.092727182814728),
-                                    ("intersect<time> <part-of-day>", -4.111897929803002),
-                                    ("the <day-of-month> (ordinal)named-month", -6.191339471482838),
-                                    ("<time-of-day>  o'clockafter lunch", -5.498192290922892),
+                                     -6.215607598755275),
+                                    ("named-daylast <cycle>", -6.215607598755275),
+                                    ("intersect by 'of', 'from', 'syear", -5.810142490647111),
+                                    ("<time-of-day> am|pmintersect", -5.116995310087166),
+                                    ("intersect<time> <part-of-day>", -4.13616605707544),
+                                    ("the <day-of-month> (ordinal)named-month", -6.215607598755275),
+                                    ("<time-of-day>  o'clockafter lunch", -5.52246041819533),
                                     ("<time> <part-of-day><time-of-day>  o'clock",
-                                     -6.191339471482838),
-                                    ("today<time-of-day>  o'clock", -6.191339471482838),
-                                    ("<time-of-day>  o'clockon <date>", -5.785874363374673),
-                                    ("<time-of-day> am|pmintersect by ','", -5.498192290922892),
-                                    ("intersect by ','year", -5.092727182814728),
-                                    ("on <date><time-of-day>  o'clock", -6.191339471482838),
-                                    ("exactly <time-of-day>tomorrow", -5.785874363374673),
-                                    ("mm/dd<time-of-day>  o'clock", -6.191339471482838),
-                                    ("monthhour", -5.785874363374673),
+                                     -6.215607598755275),
+                                    ("today<time-of-day>  o'clock", -6.215607598755275),
+                                    ("<time-of-day>  o'clockon <date>", -5.810142490647111),
+                                    ("<time-of-day> am|pmintersect by ','", -5.52246041819533),
+                                    ("intersect by ','year", -5.116995310087166),
+                                    ("on <date><time-of-day>  o'clock", -6.215607598755275),
+                                    ("exactly <time-of-day>tomorrow", -5.810142490647111),
+                                    ("mm/dd<time-of-day>  o'clock", -6.215607598755275),
+                                    ("monthhour", -5.810142490647111),
                                     ("on <date>between <datetime> and <datetime> (interval)",
-                                     -6.191339471482838),
-                                    ("last <day-of-week> of <time>year", -6.191339471482838),
-                                    ("hourmonth", -5.785874363374673),
-                                    ("todayat <time-of-day>", -5.498192290922892),
-                                    ("mm/ddabout <time-of-day>", -5.785874363374673),
+                                     -6.215607598755275),
+                                    ("last <day-of-week> of <time>year", -6.215607598755275),
+                                    ("hourmonth", -5.810142490647111),
+                                    ("todayat <time-of-day>", -5.52246041819533),
+                                    ("mm/ddabout <time-of-day>", -5.810142490647111),
                                     ("on <date>between <time-of-day> and <time-of-day> (interval)",
-                                     -6.191339471482838),
-                                    ("on <date>at <time-of-day>", -5.785874363374673),
-                                    ("named-dayhh:mm", -6.191339471482838),
-                                    ("dayday", -3.013285641134892),
-                                    ("<time> <part-of-day>at <time-of-day>", -5.785874363374673),
+                                     -6.215607598755275),
+                                    ("on <date>at <time-of-day>", -5.810142490647111),
+                                    ("named-dayhh:mm", -6.215607598755275),
+                                    ("dayday", -3.0375537684073297),
+                                    ("<time> <part-of-day>at <time-of-day>", -5.810142490647111),
                                     ("<time-of-day> am|pmabsorption of , after named day",
-                                     -6.191339471482838),
-                                    ("about <time-of-day>on <date>", -6.191339471482838),
+                                     -6.215607598755275),
+                                    ("about <time-of-day>on <date>", -6.215607598755275),
                                     ("<hour-of-day> <integer> (as relative minutes)in|during the <part-of-day>",
-                                     -5.785874363374673),
-                                    ("<day-of-month> (ordinal)intersect", -5.092727182814728),
-                                    ("hourhour", -3.6656108271745818),
-                                    ("<part-of-day> of <time>named-month", -5.785874363374673),
-                                    ("hh:mmintersect by ','", -4.93857650298747),
-                                    ("intersectnamed-month", -3.358126127426621),
-                                    ("dayyear", -3.552282141867579),
+                                     -5.810142490647111),
+                                    ("<day-of-month> (ordinal)intersect", -5.116995310087166),
+                                    ("hourhour", -3.68987895444702),
+                                    ("<part-of-day> of <time>named-month", -5.810142490647111),
+                                    ("hh:mmintersect by ','", -4.962844630259907),
+                                    ("intersectnamed-month", -3.3823942546990593),
+                                    ("dayyear", -3.297836866670996),
                                     ("<time-of-day>  o'clockin|during the <part-of-day>",
-                                     -5.092727182814728),
-                                    ("tomorrow<time-of-day>  o'clock", -6.191339471482838),
-                                    ("<time-of-day>  o'clocktomorrow", -5.498192290922892),
+                                     -5.116995310087166),
+                                    ("tomorrow<time-of-day>  o'clock", -6.215607598755275),
+                                    ("<time-of-day>  o'clocktomorrow", -5.52246041819533),
                                     ("<day-of-month>(ordinal) <named-month>year",
-                                     -5.785874363374673),
+                                     -5.810142490647111),
                                     ("half <integer> (german style hour-of-day)after lunch",
-                                     -6.191339471482838),
+                                     -6.215607598755275),
                                     ("absorption of , after named day<day-of-month>(ordinal) <named-month>",
-                                     -4.93857650298747),
-                                    ("hourminute", -5.498192290922892),
+                                     -4.962844630259907),
+                                    ("hourminute", -5.52246041819533),
                                     ("on <date><day-of-month>(ordinal) <named-month>",
-                                     -5.785874363374673),
-                                    ("minutemonth", -3.5171908220563086),
-                                    ("minutehour", -3.9400476728763425),
-                                    ("named-day<time> timezone", -6.191339471482838),
+                                     -5.810142490647111),
+                                    ("minutemonth", -3.5414589493287467),
+                                    ("minutehour", -3.96431580014878),
+                                    ("named-day<time> timezone", -6.215607598755275),
                                     ("at <time-of-day>in|during the <part-of-day>",
-                                     -5.275048739608683),
-                                    ("named-monthyear", -4.4865913792444125),
+                                     -5.29931686688112),
+                                    ("named-monthyear", -4.51085950651685),
                                     ("absorption of , after named day<day-of-month>(ordinal) <named-month> year",
-                                     -5.785874363374673),
+                                     -5.810142490647111),
                                     ("absorption of , after named day<named-month> <day-of-month> (non ordinal)",
-                                     -5.092727182814728),
+                                     -5.116995310087166),
                                     ("named-day<time-of-day> - <time-of-day> (interval)",
-                                     -6.191339471482838),
+                                     -6.215607598755275),
                                     ("<day-of-month>(ordinal) <named-month> year<time> <part-of-day>",
-                                     -6.191339471482838),
+                                     -6.215607598755275),
                                     ("<hour-of-day> <integer> (as relative minutes)after lunch",
-                                     -6.191339471482838),
+                                     -6.215607598755275),
                                     ("named-day<datetime> - <datetime> (interval)",
-                                     -6.191339471482838),
-                                    ("on <date>named-month", -5.275048739608683),
+                                     -6.215607598755275),
+                                    ("on <date>named-month", -5.29931686688112),
                                     ("intersect<day-of-month>(ordinal) <named-month>",
-                                     -4.805045110362947),
+                                     -4.829313237635384),
                                     ("this <part-of-day><time-of-day>  o'clock",
-                                     -6.191339471482838),
+                                     -6.215607598755275),
                                     ("<day-of-month>(ordinal) <named-month>intersect",
-                                     -6.191339471482838),
-                                    ("hh:mmintersect", -3.748992436113633),
+                                     -6.215607598755275),
+                                    ("hh:mmintersect", -3.7732605633860707),
                                     ("named-dayfrom <datetime> - <datetime> (interval)",
-                                     -5.785874363374673),
-                                    ("named-daynext <cycle>", -6.191339471482838),
+                                     -5.810142490647111),
+                                    ("named-daynext <cycle>", -6.215607598755275),
                                     ("named-dayfrom <time-of-day> - <time-of-day> (interval)",
-                                     -5.498192290922892),
-                                    ("<day-of-month> (ordinal)named-day", -5.785874363374673),
-                                    ("intersect by ','intersect", -4.93857650298747),
+                                     -5.52246041819533),
+                                    ("<day-of-month> (ordinal)named-day", -5.810142490647111),
+                                    ("intersect by ','intersect", -4.962844630259907),
                                     ("half <integer> (german style hour-of-day)in|during the <part-of-day>",
-                                     -5.785874363374673),
-                                    ("at <time-of-day>intersect", -4.399580002254782),
+                                     -5.810142490647111),
+                                    ("from <datetime> - <datetime> (interval)year",
+                                     -5.52246041819533),
+                                    ("at <time-of-day>intersect", -4.4238481295272205),
                                     ("on <date>from <time-of-day> - <time-of-day> (interval)",
-                                     -5.785874363374673),
+                                     -5.810142490647111),
                                     ("<time> <part-of-day>from <time-of-day> - <time-of-day> (interval)",
-                                     -6.191339471482838),
+                                     -6.215607598755275),
                                     ("absorption of , after named day<day-of-month> (ordinal)",
-                                     -4.93857650298747),
-                                    ("dayminute", -3.9941148941466182),
+                                     -4.962844630259907),
+                                    ("dayminute", -4.018383021419056),
                                     ("on <date>from <datetime> - <datetime> (interval)",
-                                     -6.191339471482838),
+                                     -6.215607598755275),
                                     ("<time> <part-of-day>from <datetime> - <datetime> (interval)",
-                                     -6.191339471482838),
-                                    ("intersectyear", -4.399580002254782),
-                                    ("on <date>intersect", -5.785874363374673),
-                                    ("on <date><day-of-month> (ordinal)", -5.785874363374673),
-                                    ("<ordinal> <cycle> of <time>year", -6.191339471482838),
-                                    ("minuteday", -2.2116578175808765),
+                                     -6.215607598755275),
+                                    ("intersectyear", -4.4238481295272205),
+                                    ("on <date>intersect", -5.810142490647111),
+                                    ("on <date><day-of-month> (ordinal)", -5.810142490647111),
+                                    ("<ordinal> <cycle> of <time>year", -6.215607598755275),
+                                    ("minuteday", -2.235925944853314),
                                     ("absorption of , after named dayintersect",
-                                     -3.7934441986844667),
+                                     -3.817712325956905),
                                     ("named-daybetween <time-of-day> and <time-of-day> (interval)",
-                                     -6.191339471482838),
+                                     -6.215607598755275),
                                     ("<datetime> - <datetime> (interval)named-month",
-                                     -5.785874363374673),
-                                    ("year<time-of-day>  o'clock", -6.191339471482838),
-                                    ("at <time-of-day>intersect by ','", -5.498192290922892),
-                                    ("named-dayat <time-of-day>", -5.785874363374673),
-                                    ("hh:mmabsorption of , after named day", -5.785874363374673),
-                                    ("<time-of-day> am|pmnamed-day", -6.191339471482838),
-                                    ("intersect by ','<time> <part-of-day>", -5.275048739608683),
-                                    ("hh:mmon <date>", -3.748992436113633),
+                                     -5.810142490647111),
+                                    ("year<time-of-day>  o'clock", -6.215607598755275),
+                                    ("at <time-of-day>intersect by ','", -5.52246041819533),
+                                    ("named-dayat <time-of-day>", -5.810142490647111),
+                                    ("hh:mmabsorption of , after named day", -5.810142490647111),
+                                    ("<time-of-day> am|pmnamed-day", -6.215607598755275),
+                                    ("intersect by ','<time> <part-of-day>", -5.29931686688112),
+                                    ("hh:mmon <date>", -3.7732605633860707),
                                     ("named-daybetween <datetime> and <datetime> (interval)",
-                                     -6.191339471482838),
+                                     -6.215607598755275),
                                     ("at <time-of-day>absorption of , after named day",
-                                     -6.191339471482838),
-                                    ("until <time-of-day>after lunch", -6.191339471482838),
-                                    ("mm/ddyear", -5.785874363374673),
-                                    ("intersect by ','<time-of-day>  o'clock", -5.275048739608683),
-                                    ("intersect<day-of-month> (ordinal)", -4.805045110362947),
-                                    ("absorption of , after named daymm/dd", -6.191339471482838),
-                                    ("named-day<time-of-day>  o'clock", -6.191339471482838),
+                                     -6.215607598755275),
+                                    ("until <time-of-day>after lunch", -6.215607598755275),
+                                    ("mm/ddyear", -5.810142490647111),
+                                    ("intersect by ','<time-of-day>  o'clock", -5.29931686688112),
+                                    ("intersect<day-of-month> (ordinal)", -4.829313237635384),
+                                    ("absorption of , after named daymm/dd", -6.215607598755275),
+                                    ("named-day<time-of-day>  o'clock", -6.215607598755275),
                                     ("<day-of-month> (ordinal)intersect by 'of', 'from', 's",
-                                     -5.498192290922892),
-                                    ("at <time-of-day>on <date>", -4.319537294581246),
-                                    ("intersectintersect", -4.051273307986567),
-                                    ("dayweek", -5.092727182814728),
+                                     -5.52246041819533),
+                                    ("at <time-of-day>on <date>", -4.343805421853684),
+                                    ("intersectintersect", -4.075541435259004),
+                                    ("dayweek", -5.116995310087166),
                                     ("absorption of , after named daythe <day-of-month> (ordinal)",
-                                     -6.191339471482838),
-                                    ("weekyear", -5.785874363374673),
-                                    ("hh:mmin|during the <part-of-day>", -5.275048739608683),
+                                     -6.215607598755275),
+                                    ("weekyear", -5.810142490647111),
+                                    ("hh:mmin|during the <part-of-day>", -5.29931686688112),
                                     ("intersect by 'of', 'from', 'snamed-month",
-                                     -6.191339471482838),
-                                    ("named-monthintersect", -6.191339471482838),
-                                    ("<day-of-month> (ordinal)named-month", -4.319537294581246),
-                                    ("tomorrowat <time-of-day>", -5.785874363374673),
+                                     -6.215607598755275),
+                                    ("named-monthintersect", -6.215607598755275),
+                                    ("<day-of-month> (ordinal)named-month", -4.343805421853684),
+                                    ("tomorrowat <time-of-day>", -5.810142490647111),
                                     ("<hour-of-day> <integer> (as relative minutes)on <date>",
-                                     -6.191339471482838),
-                                    ("named-daythis <cycle>", -5.498192290922892),
-                                    ("at <time-of-day>tomorrow", -6.191339471482838),
+                                     -6.215607598755275),
+                                    ("named-daythis <cycle>", -5.52246041819533),
+                                    ("at <time-of-day>tomorrow", -6.215607598755275),
                                     ("about <time-of-day>in|during the <part-of-day>",
-                                     -5.785874363374673),
+                                     -5.810142490647111),
                                     ("half <integer> (german style hour-of-day)on <date>",
-                                     -6.191339471482838),
-                                    ("this <part-of-day>at <time-of-day>", -5.785874363374673),
+                                     -6.215607598755275),
+                                    ("this <part-of-day>at <time-of-day>", -5.810142490647111),
                                     ("after lunch<hour-of-day> <integer> (as relative minutes)",
-                                     -5.785874363374673),
-                                    ("last <cycle> of <time>year", -5.785874363374673),
+                                     -5.810142490647111),
+                                    ("last <cycle> of <time>year", -5.810142490647111),
                                     ("<named-month> <day-of-month> (non ordinal)year",
-                                     -6.191339471482838),
+                                     -6.215607598755275),
                                     ("<day-of-month> (non ordinal) <named-month>year",
-                                     -6.191339471482838)],
-                               n = 417},
+                                     -6.215607598755275)],
+                               n = 426},
                    koData =
-                     ClassData{prior = -1.581267035467404, unseen = -5.886104031450156,
+                     ClassData{prior = -1.4591557093847622,
+                               unseen = -6.0112671744041615,
                                likelihoods =
                                  HashMap.fromList
-                                   [("intersect by ','named-month", -4.497028027368389),
-                                    ("named-day<part-of-day> of <time>", -5.190175207928333),
+                                   [("intersect by ','named-month", -4.622518824322705),
+                                    ("named-day<part-of-day> of <time>", -5.31566600488265),
                                     ("absorption of , after named daythe <day-of-month> (non ordinal)",
-                                     -5.190175207928333),
-                                    ("dayhour", -4.497028027368389),
-                                    ("daymonth", -3.3183730310267423),
-                                    ("monthday", -4.7847100998201695),
-                                    ("monthyear", -5.190175207928333),
-                                    ("yearhour", -5.190175207928333),
-                                    ("after lunchat <time-of-day>", -4.7847100998201695),
-                                    ("intersect by 'of', 'from', 'syear", -4.497028027368389),
-                                    ("<time-of-day> am|pmintersect", -3.4854271156899084),
-                                    ("intersect<time> <part-of-day>", -5.190175207928333),
-                                    ("<time-of-day>  o'clockafter lunch", -5.190175207928333),
-                                    ("after lunch<time-of-day>  o'clock", -5.190175207928333),
-                                    ("at <time-of-day>named-day", -5.190175207928333),
-                                    ("absorption of , after named dayhh:mm", -5.190175207928333),
-                                    ("<time-of-day> am|pmintersect by ','", -3.9374122394329656),
+                                     -5.31566600488265),
+                                    ("<datetime> - <datetime> (interval)year", -5.31566600488265),
+                                    ("dayhour", -4.622518824322705),
+                                    ("daymonth", -3.4438638279810583),
+                                    ("monthday", -4.9102008967744855),
+                                    ("monthyear", -5.31566600488265),
+                                    ("yearhour", -5.31566600488265),
+                                    ("after lunchat <time-of-day>", -4.9102008967744855),
+                                    ("mm/dduntil <time-of-day>", -4.9102008967744855),
+                                    ("until <time-of-day>year", -4.9102008967744855),
+                                    ("intersect by 'of', 'from', 'syear", -4.622518824322705),
+                                    ("<time-of-day> am|pmintersect", -3.6109179126442243),
+                                    ("intersect<time> <part-of-day>", -5.31566600488265),
+                                    ("<time-of-day>  o'clockafter lunch", -5.31566600488265),
+                                    ("after lunch<time-of-day>  o'clock", -5.31566600488265),
+                                    ("at <time-of-day>named-day", -5.31566600488265),
+                                    ("absorption of , after named dayhh:mm", -5.31566600488265),
+                                    ("<time-of-day> am|pmintersect by ','", -4.062903036387282),
                                     ("<time-of-day>  o'clock<time> <part-of-day>",
-                                     -4.273884476054178),
-                                    ("monthhour", -5.190175207928333),
+                                     -4.399375273008495),
+                                    ("mm/ddhh:mm", -4.399375273008495),
+                                    ("monthhour", -5.31566600488265),
                                     ("on <date>between <datetime> and <datetime> (interval)",
-                                     -5.190175207928333),
-                                    ("todayat <time-of-day>", -5.190175207928333),
+                                     -5.31566600488265),
+                                    ("todayat <time-of-day>", -5.31566600488265),
                                     ("on <date>between <time-of-day> and <time-of-day> (interval)",
-                                     -5.190175207928333),
-                                    ("named-dayhh:mm", -5.190175207928333),
-                                    ("dayday", -3.803880846808443),
+                                     -5.31566600488265),
+                                    ("named-dayhh:mm", -5.31566600488265),
+                                    ("dayday", -3.9293716437627593),
                                     ("<time-of-day> am|pmabsorption of , after named day",
-                                     -4.7847100998201695),
-                                    ("hourhour", -3.6860978111520595),
-                                    ("intersectnamed-month", -3.580737295494233),
-                                    ("dayyear", -4.273884476054178),
-                                    ("minutemonth", -3.24426505887302),
-                                    ("named-monthyear", -5.190175207928333),
+                                     -4.9102008967744855),
+                                    ("hourhour", -3.8115886081063755),
+                                    ("intersectnamed-month", -3.7062280924485496),
+                                    ("dayyear", -3.236224463202814),
+                                    ("minutemonth", -3.369755855827336),
+                                    ("named-monthyear", -5.31566600488265),
                                     ("named-day<time-of-day> - <time-of-day> (interval)",
-                                     -5.190175207928333),
-                                    ("on <date>named-month", -5.190175207928333),
+                                     -5.31566600488265),
+                                    ("on <date>named-month", -5.31566600488265),
                                     ("absorption of , after named daynamed-month",
-                                     -4.091562919260224),
+                                     -4.21705371621454),
                                     ("intersect<day-of-month>(ordinal) <named-month>",
-                                     -4.497028027368389),
-                                    ("named-dayafter <time-of-day>", -4.7847100998201695),
+                                     -4.622518824322705),
+                                    ("named-dayafter <time-of-day>", -4.9102008967744855),
                                     ("named-dayfrom <datetime> - <datetime> (interval)",
-                                     -4.7847100998201695),
+                                     -4.9102008967744855),
                                     ("<hour-of-day> <integer> (as relative minutes)named-month",
-                                     -5.190175207928333),
+                                     -5.31566600488265),
                                     ("named-dayfrom <time-of-day> - <time-of-day> (interval)",
-                                     -4.497028027368389),
-                                    ("<day-of-month> (ordinal)named-day", -4.497028027368389),
-                                    ("at <time-of-day>intersect", -4.091562919260224),
+                                     -4.622518824322705),
+                                    ("<day-of-month> (ordinal)named-day", -4.622518824322705),
+                                    ("<day-of-month> (ordinal)hh:mm", -4.399375273008495),
+                                    ("at <time-of-day>intersect", -4.21705371621454),
                                     ("on <date>from <time-of-day> - <time-of-day> (interval)",
-                                     -4.7847100998201695),
-                                    ("dayminute", -2.992950630592114),
+                                     -4.9102008967744855),
+                                    ("dayminute", -2.676608675267391),
                                     ("on <date>from <datetime> - <datetime> (interval)",
-                                     -5.190175207928333),
-                                    ("minuteday", -2.194442934374343),
+                                     -5.31566600488265),
+                                    ("minuteday", -2.3199337313286588),
                                     ("named-daybetween <time-of-day> and <time-of-day> (interval)",
-                                     -5.190175207928333),
-                                    ("at <time-of-day>intersect by ','", -4.497028027368389),
-                                    ("<time-of-day> am|pmnamed-day", -4.7847100998201695),
+                                     -5.31566600488265),
+                                    ("at <time-of-day>intersect by ','", -4.622518824322705),
+                                    ("<time-of-day> am|pmnamed-day", -4.9102008967744855),
                                     ("named-daybetween <datetime> and <datetime> (interval)",
-                                     -5.190175207928333),
+                                     -5.31566600488265),
                                     ("at <time-of-day>absorption of , after named day",
-                                     -5.190175207928333),
+                                     -5.31566600488265),
                                     ("named-month<day-of-month> (non ordinal) <named-month>",
-                                     -4.7847100998201695),
-                                    ("year<time> <part-of-day>", -5.190175207928333),
-                                    ("intersect<day-of-month> (ordinal)", -4.497028027368389),
+                                     -4.9102008967744855),
+                                    ("year<time> <part-of-day>", -5.31566600488265),
+                                    ("mm/ddyear", -3.8115886081063755),
+                                    ("intersect<day-of-month> (ordinal)", -4.622518824322705),
                                     ("<day-of-month> (ordinal)intersect by 'of', 'from', 's",
-                                     -4.7847100998201695),
+                                     -4.9102008967744855),
                                     ("<named-month> <day-of-month> (non ordinal)named-month",
-                                     -4.7847100998201695),
-                                    ("intersectintersect", -4.497028027368389),
-                                    ("<day-of-month> (ordinal)named-month", -4.497028027368389),
-                                    ("until <time-of-day>named-month", -5.190175207928333),
-                                    ("after <time-of-day>year", -5.190175207928333),
-                                    ("on <date>after <time-of-day>", -5.190175207928333),
-                                    ("tomorrownoon", -5.190175207928333)],
-                               n = 108}}),
+                                     -4.9102008967744855),
+                                    ("intersectintersect", -4.622518824322705),
+                                    ("<day-of-month> (ordinal)named-month", -4.622518824322705),
+                                    ("until <time-of-day>named-month", -5.31566600488265),
+                                    ("after <time-of-day>year", -5.31566600488265),
+                                    ("on <date>after <time-of-day>", -5.31566600488265),
+                                    ("tomorrownoon", -5.31566600488265)],
+                               n = 129}}),
        ("<ordinal> <cycle> of <time>",
         Classifier{okData =
                      ClassData{prior = 0.0, unseen = -2.4849066497880004,
@@ -649,23 +657,32 @@
                                likelihoods = HashMap.fromList [], n = 0}}),
        ("from <datetime> - <datetime> (interval)",
         Classifier{okData =
-                     ClassData{prior = -0.5108256237659907,
-                               unseen = -2.5649493574615367,
+                     ClassData{prior = -1.2039728043259361, unseen = -3.295836866004329,
                                likelihoods =
                                  HashMap.fromList
-                                   [("minuteminute", -1.3862943611198906),
+                                   [("minuteminute", -2.159484249353372),
                                     ("time-of-day (latent)time-of-day (latent)",
-                                     -1.791759469228055),
-                                    ("hh:mmhh:mm", -1.3862943611198906),
-                                    ("hourhour", -1.791759469228055)],
-                               n = 3},
+                                     -2.5649493574615367),
+                                    ("hh:mmhh:mm", -2.159484249353372),
+                                    ("dayday", -1.8718021769015913),
+                                    ("hourhour", -2.5649493574615367),
+                                    ("mm/ddmm/dd", -1.8718021769015913)],
+                               n = 6},
                    koData =
-                     ClassData{prior = -0.916290731874155, unseen = -2.3978952727983707,
+                     ClassData{prior = -0.35667494393873245,
+                               unseen = -3.7612001156935624,
                                likelihoods =
                                  HashMap.fromList
-                                   [("hh:mmtime-of-day (latent)", -1.2039728043259361),
-                                    ("minutehour", -1.2039728043259361)],
-                               n = 2}}),
+                                   [("dayhour", -2.3513752571634776),
+                                    ("mm/ddmm/dd/yyyy", -2.3513752571634776),
+                                    ("hh:mmtime-of-day (latent)", -2.639057329615259),
+                                    ("mm/ddhh:mm", -2.3513752571634776),
+                                    ("dayday", -1.791759469228055),
+                                    ("minutehour", -2.639057329615259),
+                                    ("mm/ddintersect", -2.3513752571634776),
+                                    ("dayminute", -2.3513752571634776),
+                                    ("mm/ddtime-of-day (latent)", -2.3513752571634776)],
+                               n = 14}}),
        ("after tomorrow",
         Classifier{okData =
                      ClassData{prior = 0.0, unseen = -1.0986122886681098,
@@ -731,11 +748,12 @@
                                n = 1}}),
        ("mm/dd/yyyy",
         Classifier{okData =
-                     ClassData{prior = 0.0, unseen = -1.791759469228055,
+                     ClassData{prior = -1.252762968495368, unseen = -1.791759469228055,
                                likelihoods = HashMap.fromList [("", 0.0)], n = 4},
                    koData =
-                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
-                               likelihoods = HashMap.fromList [], n = 0}}),
+                     ClassData{prior = -0.3364722366212129,
+                               unseen = -2.4849066497880004,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 10}}),
        ("couple",
         Classifier{okData =
                      ClassData{prior = 0.0, unseen = -1.6094379124341003,
@@ -910,9 +928,9 @@
                      ClassData{prior = -infinity, unseen = -0.6931471805599453,
                                likelihoods = HashMap.fromList [], n = 0},
                    koData =
-                     ClassData{prior = 0.0, unseen = -2.1972245773362196,
+                     ClassData{prior = 0.0, unseen = -2.995732273553991,
                                likelihoods = HashMap.fromList [("integer (numeric)", 0.0)],
-                               n = 7}}),
+                               n = 18}}),
        ("in|during the <part-of-day>",
         Classifier{okData =
                      ClassData{prior = -6.0624621816434854e-2,
@@ -1041,28 +1059,31 @@
                                n = 2}}),
        ("time-of-day (latent)",
         Classifier{okData =
-                     ClassData{prior = -0.6931471805599453, unseen = -4.007333185232471,
+                     ClassData{prior = -0.7686547330680905, unseen = -4.007333185232471,
                                likelihoods =
                                  HashMap.fromList
                                    [("integer (numeric)", -0.11778303565638351),
                                     ("integer (0..19)", -2.379546134130174)],
                                n = 51},
                    koData =
-                     ClassData{prior = -0.6931471805599453, unseen = -4.007333185232471,
+                     ClassData{prior = -0.6229429218866968, unseen = -4.143134726391533,
                                likelihoods =
                                  HashMap.fromList
-                                   [("integer (numeric)", -0.587786664902119),
-                                    ("integer (0..19)", -0.9444616088408514),
-                                    ("couple", -2.890371757896165)],
-                               n = 51}}),
+                                   [("integer (numeric)", -0.4895482253187058),
+                                    ("integer (0..19)", -1.0826119473216687),
+                                    ("couple", -3.028522096376982)],
+                               n = 59}}),
        ("year",
         Classifier{okData =
-                     ClassData{prior = 0.0, unseen = -2.9444389791664407,
+                     ClassData{prior = -8.338160893905101e-2,
+                               unseen = -3.2188758248682006,
                                likelihoods = HashMap.fromList [("integer (numeric)", 0.0)],
-                               n = 17},
+                               n = 23},
                    koData =
-                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
-                               likelihoods = HashMap.fromList [], n = 0}}),
+                     ClassData{prior = -2.5257286443082556,
+                               unseen = -1.3862943611198906,
+                               likelihoods = HashMap.fromList [("integer (numeric)", 0.0)],
+                               n = 2}}),
        ("last <day-of-week> of <time>",
         Classifier{okData =
                      ClassData{prior = 0.0, unseen = -2.3025850929940455,
@@ -1198,14 +1219,22 @@
                    koData =
                      ClassData{prior = -infinity, unseen = -2.3978952727983707,
                                likelihoods = HashMap.fromList [], n = 0}}),
+       ("dd.(mm.)? - dd.mm.(yy[yy]?)? (interval)",
+        Classifier{okData =
+                     ClassData{prior = 0.0, unseen = -2.890371757896165,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 16},
+                   koData =
+                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
+                               likelihoods = HashMap.fromList [], n = 0}}),
        ("hh:mm",
         Classifier{okData =
-                     ClassData{prior = -0.12136085700426748,
-                               unseen = -3.4965075614664802,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 31},
+                     ClassData{prior = -0.6190392084062235,
+                               unseen = -3.6109179126442243,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 35},
                    koData =
-                     ClassData{prior = -2.169053700369523, unseen = -1.791759469228055,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 4}}),
+                     ClassData{prior = -0.7731898882334817,
+                               unseen = -3.4657359027997265,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 30}}),
        ("quarter after|past <integer> (hour-of-day)",
         Classifier{okData =
                      ClassData{prior = 0.0, unseen = -2.3025850929940455,
@@ -1382,7 +1411,7 @@
                                likelihoods = HashMap.fromList [], n = 0}}),
        ("<day-of-month> (ordinal)",
         Classifier{okData =
-                     ClassData{prior = -0.3513978868378886,
+                     ClassData{prior = -0.5520685823000397,
                                unseen = -3.0910424533583156,
                                likelihoods =
                                  HashMap.fromList
@@ -1390,13 +1419,12 @@
                                     ("ordinal (digits)", -0.2113090936672069)],
                                n = 19},
                    koData =
-                     ClassData{prior = -1.2163953243244932,
-                               unseen = -2.3978952727983707,
+                     ClassData{prior = -0.8574502318512216, unseen = -2.833213344056216,
                                likelihoods =
                                  HashMap.fromList
-                                   [("ordinals (first..19th)", -0.35667494393873245),
-                                    ("ordinal (digits)", -1.2039728043259361)],
-                               n = 8}}),
+                                   [("ordinals (first..19th)", -0.8266785731844679),
+                                    ("ordinal (digits)", -0.5753641449035618)],
+                               n = 14}}),
        ("noon",
         Classifier{okData =
                      ClassData{prior = -infinity, unseen = -0.6931471805599453,
@@ -1406,31 +1434,32 @@
                                likelihoods = HashMap.fromList [("", 0.0)], n = 2}}),
        ("until <time-of-day>",
         Classifier{okData =
-                     ClassData{prior = -0.25131442828090605,
-                               unseen = -4.060443010546419,
+                     ClassData{prior = -0.5108256237659907, unseen = -4.0943445622221,
                                likelihoods =
                                  HashMap.fromList
-                                   [("<time> <part-of-day>", -2.097141118779237),
-                                    ("<time-of-day>  o'clock", -2.2512917986064953),
-                                    ("intersect", -3.349904087274605),
-                                    ("time-of-day (latent)", -2.097141118779237),
-                                    ("<time-of-day> am|pm", -3.349904087274605),
-                                    ("EOM|End of month", -3.349904087274605),
-                                    ("hour", -0.9985288301111273), ("month", -3.349904087274605),
-                                    ("midnight|EOD|end of day", -3.349904087274605)],
+                                   [("<time> <part-of-day>", -2.1316272948504063),
+                                    ("<time-of-day>  o'clock", -2.2857779746776643),
+                                    ("intersect", -3.3843902633457743),
+                                    ("time-of-day (latent)", -2.1316272948504063),
+                                    ("<time-of-day> am|pm", -3.3843902633457743),
+                                    ("EOM|End of month", -3.3843902633457743),
+                                    ("hour", -1.0330150061822965), ("month", -3.3843902633457743),
+                                    ("midnight|EOD|end of day", -3.3843902633457743)],
                                n = 21},
                    koData =
-                     ClassData{prior = -1.5040773967762742, unseen = -3.332204510175204,
+                     ClassData{prior = -0.916290731874155, unseen = -3.828641396489095,
                                likelihoods =
                                  HashMap.fromList
-                                   [("intersect", -2.6026896854443837),
-                                    ("<day-of-month>(ordinal) <named-month>", -2.6026896854443837),
-                                    ("day", -1.6863989535702288), ("hh:mm", -2.1972245773362196),
-                                    ("<day-of-month> (ordinal)", -2.6026896854443837),
+                                   [("mm/dd", -2.70805020110221),
+                                    ("intersect", -2.4203681286504293),
+                                    ("mm/dd/yyyy", -2.70805020110221),
+                                    ("<day-of-month>(ordinal) <named-month>", -3.1135153092103742),
+                                    ("day", -1.4087672169719492), ("hh:mm", -2.1972245773362196),
+                                    ("<day-of-month> (ordinal)", -3.1135153092103742),
                                     ("<day-of-month> (non ordinal) <named-month>",
-                                     -2.6026896854443837),
+                                     -3.1135153092103742),
                                     ("minute", -2.1972245773362196)],
-                               n = 6}}),
+                               n = 14}}),
        ("<integer> and an half hours",
         Classifier{okData =
                      ClassData{prior = 0.0, unseen = -1.0986122886681098,
@@ -1598,48 +1627,58 @@
                                likelihoods = HashMap.fromList [], n = 0}}),
        ("<datetime> - <datetime> (interval)",
         Classifier{okData =
-                     ClassData{prior = -0.3364722366212129,
-                               unseen = -3.7612001156935624,
+                     ClassData{prior = -0.9694005571881036, unseen = -4.174387269895637,
                                likelihoods =
                                  HashMap.fromList
-                                   [("intersecthh:mm", -3.044522437723423),
-                                    ("on <date>hh:mm", -3.044522437723423),
-                                    ("minuteminute", -1.252762968495368),
+                                   [("intersecthh:mm", -3.4657359027997265),
+                                    ("on <date>hh:mm", -3.4657359027997265),
+                                    ("minuteminute", -1.6739764335716716),
                                     ("<day-of-month> (ordinal)<day-of-month> (ordinal)",
-                                     -2.639057329615259),
-                                    ("hh:mmhh:mm", -1.791759469228055),
-                                    ("dayday", -2.128231705849268),
+                                     -3.0602707946915624),
+                                    ("hh:mmhh:mm", -2.2129729343043585),
+                                    ("dayday", -1.6739764335716716),
                                     ("<named-month> <day-of-month> (non ordinal)<named-month> <day-of-month> (non ordinal)",
-                                     -2.639057329615259),
-                                    ("intersect by 'of', 'from', 'shh:mm", -2.3513752571634776)],
-                               n = 15},
+                                     -3.0602707946915624),
+                                    ("intersect by 'of', 'from', 'shh:mm", -2.772588722239781),
+                                    ("mm/ddmm/dd", -2.0794415416798357)],
+                               n = 22},
                    koData =
-                     ClassData{prior = -1.252762968495368, unseen = -3.2188758248682006,
+                     ClassData{prior = -0.4769240720903093, unseen = -4.532599493153256,
                                likelihoods =
                                  HashMap.fromList
                                    [("<day-of-month> (ordinal)<day-of-month>(ordinal) <named-month>",
-                                     -2.0794415416798357),
-                                    ("daymonth", -2.0794415416798357),
-                                    ("dayday", -1.5686159179138452),
-                                    ("<day-of-month> (ordinal)intersect", -2.0794415416798357),
+                                     -3.4231762883809305),
+                                    ("daymonth", -3.4231762883809305),
+                                    ("mm/ddmm/dd/yyyy", -2.575878427993727),
+                                    ("<day-of-month> (ordinal)mm/dd", -2.91235066461494),
+                                    ("mm/ddhh:mm", -2.4423470353692043),
+                                    ("dayday", -1.3437347467010947),
+                                    ("<day-of-month> (ordinal)intersect", -3.1354942159291497),
+                                    ("<day-of-month> (ordinal)hh:mm", -2.91235066461494),
+                                    ("mm/ddintersect", -2.575878427993727),
+                                    ("dayminute", -2.03688192726104),
+                                    ("<day-of-month> (ordinal)mm/dd/yyyy", -3.4231762883809305),
                                     ("<named-month> <day-of-month> (non ordinal)named-month",
-                                     -2.0794415416798357)],
-                               n = 6}}),
+                                     -3.4231762883809305)],
+                               n = 36}}),
        ("<time-of-day> - <time-of-day> (interval)",
         Classifier{okData =
-                     ClassData{prior = -0.6931471805599453, unseen = -2.833213344056216,
+                     ClassData{prior = -0.8266785731844679, unseen = -3.044522437723423,
                                likelihoods =
                                  HashMap.fromList
-                                   [("minuteminute", -0.8266785731844679),
-                                    ("hh:mmhh:mm", -0.8266785731844679)],
-                               n = 6},
+                                   [("minuteminute", -0.916290731874155),
+                                    ("hh:mmhh:mm", -0.916290731874155)],
+                               n = 7},
                    koData =
-                     ClassData{prior = -0.6931471805599453, unseen = -2.833213344056216,
+                     ClassData{prior = -0.5753641449035618,
+                               unseen = -3.2188758248682006,
                                likelihoods =
                                  HashMap.fromList
-                                   [("hh:mmtime-of-day (latent)", -0.8266785731844679),
-                                    ("minutehour", -0.8266785731844679)],
-                               n = 6}}),
+                                   [("hh:mmtime-of-day (latent)", -1.2321436812926323),
+                                    ("hourminute", -1.791759469228055),
+                                    ("minutehour", -1.2321436812926323),
+                                    ("time-of-day (latent)hh:mm", -1.791759469228055)],
+                               n = 9}}),
        ("last n <cycle>",
         Classifier{okData =
                      ClassData{prior = 0.0, unseen = -3.9318256327243257,
@@ -1741,11 +1780,12 @@
                                likelihoods = HashMap.fromList [], n = 0}}),
        ("ordinal (digits)",
         Classifier{okData =
-                     ClassData{prior = 0.0, unseen = -2.995732273553991,
+                     ClassData{prior = -0.2876820724517809, unseen = -2.995732273553991,
                                likelihoods = HashMap.fromList [("", 0.0)], n = 18},
                    koData =
-                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
-                               likelihoods = HashMap.fromList [], n = 0}}),
+                     ClassData{prior = -1.3862943611198906,
+                               unseen = -2.0794415416798357,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 6}}),
        ("quarter (grain)",
         Classifier{okData =
                      ClassData{prior = 0.0, unseen = -1.791759469228055,
@@ -1845,7 +1885,7 @@
                                likelihoods = HashMap.fromList [], n = 0}}),
        ("<hour-of-day> <integer> (as relative minutes)",
         Classifier{okData =
-                     ClassData{prior = -0.3364722366212129, unseen = -2.772588722239781,
+                     ClassData{prior = -0.6931471805599453, unseen = -2.772588722239781,
                                likelihoods =
                                  HashMap.fromList
                                    [("hour", -0.916290731874155),
@@ -1854,13 +1894,13 @@
                                      -1.0986122886681098)],
                                n = 5},
                    koData =
-                     ClassData{prior = -1.252762968495368, unseen = -2.3025850929940455,
+                     ClassData{prior = -0.6931471805599453, unseen = -2.772588722239781,
                                likelihoods =
                                  HashMap.fromList
-                                   [("time-of-day (latent)integer (0..19)", -1.5040773967762742),
-                                    ("time-of-day (latent)integer (numeric)", -1.5040773967762742),
-                                    ("hour", -1.0986122886681098)],
-                               n = 2}}),
+                                   [("time-of-day (latent)integer (0..19)", -2.0149030205422647),
+                                    ("time-of-day (latent)integer (numeric)", -1.0986122886681098),
+                                    ("hour", -0.916290731874155)],
+                               n = 5}}),
        ("this <time>",
         Classifier{okData =
                      ClassData{prior = 0.0, unseen = -2.639057329615259,
diff --git a/Duckling/Ranking/Classifiers/EN.hs b/Duckling/Ranking/Classifiers/EN.hs
--- a/Duckling/Ranking/Classifiers/EN.hs
+++ b/Duckling/Ranking/Classifiers/EN.hs
@@ -59,11 +59,12 @@
                                likelihoods = HashMap.fromList [], n = 0}}),
        ("integer (numeric)",
         Classifier{okData =
-                     ClassData{prior = -0.8463513387831728, unseen = -5.030437921392435,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 151},
+                     ClassData{prior = -0.8649974374866046,
+                               unseen = -5.0369526024136295,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 152},
                    koData =
-                     ClassData{prior = -0.5603262675390213, unseen = -5.313205979041787,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 201}}),
+                     ClassData{prior = -0.5465437063680699, unseen = -5.351858133476067,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 209}}),
        ("<duration> hence|ago",
         Classifier{okData =
                      ClassData{prior = 0.0, unseen = -3.784189633918261,
@@ -136,6 +137,15 @@
                    koData =
                      ClassData{prior = -infinity, unseen = -0.6931471805599453,
                                likelihoods = HashMap.fromList [], n = 0}}),
+       ("mm/yyyy",
+        Classifier{okData =
+                     ClassData{prior = -0.6931471805599453,
+                               unseen = -1.0986122886681098,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 1},
+                   koData =
+                     ClassData{prior = -0.6931471805599453,
+                               unseen = -1.0986122886681098,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 1}}),
        ("integer after|past <hour-of-day>",
         Classifier{okData =
                      ClassData{prior = 0.0, unseen = -2.3025850929940455,
@@ -224,11 +234,12 @@
                                likelihoods = HashMap.fromList [], n = 0}}),
        ("mm/dd",
         Classifier{okData =
-                     ClassData{prior = -1.4469189829363254, unseen = -1.791759469228055,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 4},
+                     ClassData{prior = -1.3862943611198906,
+                               unseen = -2.0794415416798357,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 6},
                    koData =
-                     ClassData{prior = -0.2682639865946794, unseen = -2.70805020110221,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 13}}),
+                     ClassData{prior = -0.2876820724517809, unseen = -2.995732273553991,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 18}}),
        ("at <time-of-day>",
         Classifier{okData =
                      ClassData{prior = -0.10919929196499197,
@@ -319,12 +330,11 @@
                                n = 4}}),
        ("integer (0..19)",
         Classifier{okData =
-                     ClassData{prior = -2.7398974188114388e-2,
-                               unseen = -3.6375861597263857,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 36},
+                     ClassData{prior = -2.469261259037152e-2,
+                               unseen = -3.7376696182833684,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 40},
                    koData =
-                     ClassData{prior = -3.6109179126442243,
-                               unseen = -1.0986122886681098,
+                     ClassData{prior = -3.713572066704308, unseen = -1.0986122886681098,
                                likelihoods = HashMap.fromList [("", 0.0)], n = 1}}),
        ("between <time-of-day> and <time-of-day> (interval)",
         Classifier{okData =
@@ -350,10 +360,20 @@
                    koData =
                      ClassData{prior = -infinity, unseen = -0.6931471805599453,
                                likelihoods = HashMap.fromList [], n = 0}}),
+       ("from <month> dd-dd (interval)",
+        Classifier{okData =
+                     ClassData{prior = 0.0, unseen = -1.6094379124341003,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("July", -0.6931471805599453), ("month", -0.6931471805599453)],
+                               n = 1},
+                   koData =
+                     ClassData{prior = -infinity, unseen = -1.0986122886681098,
+                               likelihoods = HashMap.fromList [], n = 0}}),
        ("October",
         Classifier{okData =
-                     ClassData{prior = 0.0, unseen = -2.5649493574615367,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 11},
+                     ClassData{prior = 0.0, unseen = -2.833213344056216,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 15},
                    koData =
                      ClassData{prior = -infinity, unseen = -0.6931471805599453,
                                likelihoods = HashMap.fromList [], n = 0}}),
@@ -388,27 +408,27 @@
                                likelihoods = HashMap.fromList [], n = 0}}),
        ("in|within|after <duration>",
         Classifier{okData =
-                     ClassData{prior = -5.129329438755058e-2,
-                               unseen = -4.532599493153256,
+                     ClassData{prior = -4.652001563489282e-2,
+                               unseen = -4.61512051684126,
                                likelihoods =
                                  HashMap.fromList
-                                   [("week", -3.1354942159291497),
-                                    ("<integer> more <unit-of-duration>", -3.828641396489095),
-                                    ("three-quarters of an hour", -2.91235066461494),
-                                    ("<integer> + '\"", -3.1354942159291497),
-                                    ("number.number hours", -3.828641396489095),
-                                    ("second", -3.4231762883809305), ("day", -3.1354942159291497),
-                                    ("half an hour", -2.91235066461494),
-                                    ("<integer> <unit-of-duration>", -1.749199854809259),
-                                    ("a <unit-of-duration>", -2.91235066461494),
-                                    ("quarter of an hour", -2.91235066461494),
-                                    ("hour", -2.4423470353692043),
-                                    ("about|exactly <duration>", -3.828641396489095),
-                                    ("<integer> and an half hour", -3.828641396489095),
-                                    ("minute", -1.3437347467010947)],
-                               n = 38},
+                                   [("week", -3.2188758248682006),
+                                    ("<integer> more <unit-of-duration>", -3.912023005428146),
+                                    ("three-quarters of an hour", -2.995732273553991),
+                                    ("<integer> + '\"", -3.2188758248682006),
+                                    ("number.number hours", -3.912023005428146),
+                                    ("second", -3.506557897319982), ("day", -3.2188758248682006),
+                                    ("half an hour", -2.995732273553991),
+                                    ("<integer> <unit-of-duration>", -1.6094379124341003),
+                                    ("a <unit-of-duration>", -2.995732273553991),
+                                    ("quarter of an hour", -2.995732273553991),
+                                    ("hour", -2.5257286443082556),
+                                    ("about|exactly <duration>", -3.912023005428146),
+                                    ("<integer> and an half hour", -3.912023005428146),
+                                    ("minute", -1.2729656758128873)],
+                               n = 42},
                    koData =
-                     ClassData{prior = -2.995732273553991, unseen = -3.044522437723423,
+                     ClassData{prior = -3.0910424533583156, unseen = -3.044522437723423,
                                likelihoods =
                                  HashMap.fromList
                                    [("quarter", -1.8971199848858813),
@@ -461,8 +481,8 @@
                                likelihoods = HashMap.fromList [], n = 0}}),
        ("July",
         Classifier{okData =
-                     ClassData{prior = 0.0, unseen = -2.5649493574615367,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 11},
+                     ClassData{prior = 0.0, unseen = -2.70805020110221,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 13},
                    koData =
                      ClassData{prior = -infinity, unseen = -0.6931471805599453,
                                likelihoods = HashMap.fromList [], n = 0}}),
@@ -497,219 +517,225 @@
                      ClassData{prior = -infinity, unseen = -0.6931471805599453,
                                likelihoods = HashMap.fromList [], n = 0},
                    koData =
-                     ClassData{prior = 0.0, unseen = -1.0986122886681098,
+                     ClassData{prior = 0.0, unseen = -1.6094379124341003,
                                likelihoods =
                                  HashMap.fromList [("integer (numeric)integer (numeric)", 0.0)],
-                               n = 1}}),
+                               n = 3}}),
        ("intersect",
         Classifier{okData =
-                     ClassData{prior = -0.44313061099463913,
-                               unseen = -6.1092475827643655,
+                     ClassData{prior = -0.4563567154045537, unseen = -6.124683390894205,
                                likelihoods =
                                  HashMap.fromList
                                    [("<datetime> - <datetime> (interval)on <date>",
-                                     -4.497584975308154),
+                                     -4.513054897080286),
                                     ("<time-of-day> - <time-of-day> (interval)on <date>",
-                                     -4.497584975308154),
-                                    ("hourday", -3.709127614943884),
-                                    ("dayhour", -3.162583908575814),
-                                    ("daymonth", -5.413875707182309),
-                                    ("monthday", -5.0084105990741445),
-                                    ("monthyear", -3.8044377947482086),
-                                    ("Tuesdaythe <day-of-month> (ordinal)", -5.413875707182309),
-                                    ("Christmasyear", -5.413875707182309),
+                                     -4.513054897080286),
+                                    ("hourday", -3.724597536716016),
+                                    ("dayhour", -3.1780538303479458),
+                                    ("daymonth", -5.429345628954441),
+                                    ("monthday", -5.0238805208462765),
+                                    ("monthyear", -3.8199077165203406),
+                                    ("Tuesdaythe <day-of-month> (ordinal)", -5.429345628954441),
+                                    ("Christmasyear", -5.429345628954441),
+                                    ("houryear", -5.429345628954441),
                                     ("this|next <day-of-week>hh(:mm) - <time-of-day> am|pm",
-                                     -5.413875707182309),
+                                     -5.429345628954441),
                                     ("<time-of-day> am|pmintersect by \",\", \"of\", \"from\", \"'s\"",
-                                     -4.720728526622364),
-                                    ("<time-of-day> am|pmintersect", -4.161112738686941),
+                                     -4.736198448394496),
+                                    ("<time-of-day> am|pmintersect", -4.176582660459073),
                                     ("intersect by \",\", \"of\", \"from\", \"'s\"year",
-                                     -5.413875707182309),
-                                    ("Marchyear", -5.413875707182309),
+                                     -5.429345628954441),
+                                    ("Marchyear", -5.429345628954441),
                                     ("<named-month>|<named-day> <day-of-month> (ordinal)year",
-                                     -5.0084105990741445),
-                                    ("intersect<time-of-day> am|pm", -5.413875707182309),
-                                    ("Thursdayhh(:mm) - <time-of-day> am|pm", -5.413875707182309),
-                                    ("monthhour", -5.0084105990741445),
-                                    ("last <day-of-week> of <time>year", -5.413875707182309),
-                                    ("todayat <time-of-day>", -5.413875707182309),
-                                    ("Thursday<time> timezone", -5.0084105990741445),
+                                     -5.0238805208462765),
+                                    ("intersect<time-of-day> am|pm", -5.429345628954441),
+                                    ("Thursdayhh(:mm) - <time-of-day> am|pm", -5.429345628954441),
+                                    ("monthhour", -5.0238805208462765),
+                                    ("last <day-of-week> of <time>year", -5.429345628954441),
+                                    ("todayat <time-of-day>", -5.429345628954441),
+                                    ("Thursday<time> timezone", -5.0238805208462765),
                                     ("this <time>hh(:mm) - <time-of-day> am|pm",
-                                     -5.413875707182309),
-                                    ("dayday", -3.398972686640044),
-                                    ("Thanksgiving Dayyear", -5.0084105990741445),
-                                    ("<time> <part-of-day>at <time-of-day>", -5.413875707182309),
-                                    ("Tuesdayin <named-month>", -5.413875707182309),
-                                    ("mm/ddat <time-of-day>", -5.413875707182309),
-                                    ("tonightat <time-of-day>", -5.413875707182309),
+                                     -5.429345628954441),
+                                    ("dayday", -3.414442608412176),
+                                    ("Thanksgiving Dayyear", -5.0238805208462765),
+                                    ("<time> <part-of-day>at <time-of-day>", -5.429345628954441),
+                                    ("Tuesdayin <named-month>", -5.429345628954441),
+                                    ("mm/ddat <time-of-day>", -5.429345628954441),
+                                    ("tonightat <time-of-day>", -5.429345628954441),
                                     ("<time-of-day> am|pmabsorption of , after named day",
-                                     -4.720728526622364),
-                                    ("today<time-of-day> am|pm", -5.413875707182309),
-                                    ("Februarythe <day-of-month> (ordinal)", -5.0084105990741445),
-                                    ("at <time-of-day><time> <part-of-day>", -5.413875707182309),
-                                    ("mm/dd<time-of-day> am|pm", -5.413875707182309),
-                                    ("hourhour", -4.161112738686941),
-                                    ("<time-of-day> am|pmon <date>", -3.398972686640044),
-                                    ("Wednesdaythis|last|next <cycle>", -5.413875707182309),
+                                     -4.736198448394496),
+                                    ("today<time-of-day> am|pm", -5.429345628954441),
+                                    ("Februarythe <day-of-month> (ordinal)", -5.0238805208462765),
+                                    ("at <time-of-day><time> <part-of-day>", -5.429345628954441),
+                                    ("mm/dd<time-of-day> am|pm", -5.429345628954441),
+                                    ("hourhour", -4.176582660459073),
+                                    ("<time-of-day> am|pmon <date>", -3.414442608412176),
+                                    ("Wednesdaythis|last|next <cycle>", -5.429345628954441),
                                     ("intersect<named-month> <day-of-month> (non ordinal)",
-                                     -3.909798310406035),
-                                    ("dayyear", -3.2166511298460896),
+                                     -3.925268232178167),
+                                    ("dayyear", -3.2321210516182215),
+                                    ("last weekend of <named-month>year", -5.429345628954441),
                                     ("<time-of-day> o'clockin|during the <part-of-day>",
-                                     -5.413875707182309),
-                                    ("<time-of-day> am|pmtomorrow", -4.720728526622364),
-                                    ("minutehour", -4.497584975308154),
-                                    ("Mother's Dayyear", -5.413875707182309),
+                                     -5.429345628954441),
+                                    ("<time-of-day> am|pmtomorrow", -4.736198448394496),
+                                    ("minutehour", -4.513054897080286),
+                                    ("Mother's Dayyear", -5.429345628954441),
                                     ("at <time-of-day>in|during the <part-of-day>",
-                                     -5.0084105990741445),
+                                     -5.0238805208462765),
                                     ("absorption of , after named day<named-month> <day-of-month> (non ordinal)",
-                                     -3.709127614943884),
-                                    ("tomorrow<time-of-day> sharp|exactly", -5.413875707182309),
+                                     -3.724597536716016),
+                                    ("tomorrow<time-of-day> sharp|exactly", -5.429345628954441),
                                     ("Thursdayfrom <datetime> - <datetime> (interval)",
-                                     -4.497584975308154),
+                                     -4.513054897080286),
                                     ("on <date><named-month> <day-of-month> (non ordinal)",
-                                     -5.0084105990741445),
+                                     -5.0238805208462765),
                                     ("Thursdayfrom <time-of-day> - <time-of-day> (interval)",
-                                     -4.497584975308154),
-                                    ("Mondayin|during the <part-of-day>", -5.413875707182309),
+                                     -4.513054897080286),
+                                    ("Mondayin|during the <part-of-day>", -5.429345628954441),
                                     ("tomorrowfrom <time-of-day> - <time-of-day> (interval)",
-                                     -5.0084105990741445),
-                                    ("intersectin|during the <part-of-day>", -5.413875707182309),
+                                     -5.0238805208462765),
+                                    ("intersectin|during the <part-of-day>", -5.429345628954441),
                                     ("<day-of-month> (ordinal or number) of <named-month>in|during the <part-of-day>",
-                                     -5.413875707182309),
+                                     -5.429345628954441),
                                     ("from <time-of-day> - <time-of-day> (interval)on <date>",
-                                     -4.720728526622364),
+                                     -4.736198448394496),
                                     ("intersect by \",\", \"of\", \"from\", \"'s\"<time-of-day> am|pm",
-                                     -4.497584975308154),
-                                    ("at <time-of-day>intersect", -5.0084105990741445),
+                                     -4.513054897080286),
+                                    ("at <time-of-day>intersect", -5.0238805208462765),
                                     ("<time-of-day> - <time-of-day> (interval)tomorrow",
-                                     -5.413875707182309),
+                                     -5.429345628954441),
                                     ("at <time-of-day>intersect by \",\", \"of\", \"from\", \"'s\"",
-                                     -5.413875707182309),
-                                    ("dayminute", -3.1112906141882632),
+                                     -5.429345628954441),
+                                    ("dayminute", -3.126760535960395),
                                     ("from <datetime> - <datetime> (interval)on <date>",
-                                     -5.0084105990741445),
+                                     -5.0238805208462765),
                                     ("<datetime> - <datetime> (interval)tomorrow",
-                                     -5.413875707182309),
+                                     -5.429345628954441),
                                     ("absorption of , after named dayintersect by \",\", \"of\", \"from\", \"'s\"",
-                                     -5.0084105990741445),
-                                    ("<ordinal> <cycle> of <time>year", -5.413875707182309),
-                                    ("minuteday", -2.0126783255201537),
+                                     -5.0238805208462765),
+                                    ("<ordinal> <cycle> of <time>year", -5.429345628954441),
+                                    ("minuteday", -2.0281482472922856),
                                     ("absorption of , after named dayintersect",
-                                     -5.413875707182309),
-                                    ("Octoberyear", -4.161112738686941),
+                                     -5.429345628954441),
+                                    ("Octoberyear", -4.176582660459073),
                                     ("the <day-of-month> (ordinal)in|during the <part-of-day>",
-                                     -5.413875707182309),
+                                     -5.429345628954441),
                                     ("at <time-of-day>absorption of , after named day",
-                                     -5.413875707182309),
+                                     -5.429345628954441),
                                     ("<day-of-month> (ordinal or number) <named-month>year",
-                                     -5.413875707182309),
-                                    ("year<time-of-day> am|pm", -5.413875707182309),
-                                    ("Septemberyear", -5.0084105990741445),
-                                    ("at <time-of-day>on <date>", -4.315263418514199),
+                                     -5.429345628954441),
+                                    ("year<time-of-day> am|pm", -5.429345628954441),
+                                    ("Septemberyear", -5.0238805208462765),
+                                    ("at <time-of-day>on <date>", -4.330733340286331),
                                     ("between <time-of-day> and <time-of-day> (interval)on <date>",
-                                     -4.720728526622364),
-                                    ("Halloweenyear", -5.413875707182309),
-                                    ("dayweek", -5.413875707182309),
-                                    ("weekyear", -5.0084105990741445),
-                                    ("hh:mmin|during the <part-of-day>", -4.720728526622364),
-                                    ("Father's Dayyear", -5.413875707182309),
+                                     -4.736198448394496),
+                                    ("Halloweenyear", -5.429345628954441),
+                                    ("dayweek", -5.429345628954441),
+                                    ("weekyear", -5.0238805208462765),
+                                    ("hh:mmin|during the <part-of-day>", -4.736198448394496),
+                                    ("Father's Dayyear", -5.429345628954441),
                                     ("<cycle> after|before <time><time-of-day> am|pm",
-                                     -5.0084105990741445),
-                                    ("February<time> <part-of-day>", -5.413875707182309),
-                                    ("Martin Luther King's Dayyear", -5.0084105990741445),
-                                    ("tomorrowat <time-of-day>", -4.720728526622364),
-                                    ("between <time> and <time>on <date>", -4.720728526622364),
-                                    ("at <time-of-day>tomorrow", -5.0084105990741445),
-                                    ("tomorrow<time-of-day> am|pm", -5.413875707182309),
+                                     -5.0238805208462765),
+                                    ("February<time> <part-of-day>", -5.429345628954441),
+                                    ("Martin Luther King's Dayyear", -5.0238805208462765),
+                                    ("tomorrowat <time-of-day>", -4.736198448394496),
+                                    ("between <time> and <time>on <date>", -4.736198448394496),
+                                    ("at <time-of-day>tomorrow", -5.0238805208462765),
+                                    ("tomorrow<time-of-day> am|pm", -5.429345628954441),
                                     ("in|during the <part-of-day>at <time-of-day>",
-                                     -5.413875707182309),
-                                    ("Labor Dayyear", -5.413875707182309),
-                                    ("Februaryintersect", -5.413875707182309),
-                                    ("last <cycle> of <time>year", -4.720728526622364),
+                                     -5.429345628954441),
+                                    ("Labor Dayyear", -5.429345628954441),
+                                    ("Februaryintersect", -5.429345628954441),
+                                    ("last <cycle> of <time>year", -4.736198448394496),
                                     ("<named-month> <day-of-month> (non ordinal)year",
-                                     -5.413875707182309),
-                                    ("yearminute", -5.413875707182309)],
-                               n = 165},
+                                     -5.429345628954441),
+                                    ("yearminute", -5.429345628954441)],
+                               n = 166},
                    koData =
-                     ClassData{prior = -1.0272875078461794, unseen = -5.717027701406222,
+                     ClassData{prior = -1.0039963122932607, unseen = -5.75890177387728,
                                likelihoods =
                                  HashMap.fromList
-                                   [("in <named-month>year", -5.020585624949423),
+                                   [("in <named-month>year", -5.062595033026967),
                                     ("<time-of-day> - <time-of-day> (interval)on <date>",
-                                     -5.020585624949423),
-                                    ("hourday", -5.020585624949423),
+                                     -5.062595033026967),
+                                    ("hourday", -5.062595033026967),
                                     ("<named-month> <day-of-month> (non ordinal)July",
-                                     -5.020585624949423),
-                                    ("dayhour", -3.228826155721369),
-                                    ("daymonth", -3.005682604407159),
-                                    ("monthday", -4.61512051684126),
-                                    ("monthyear", -4.61512051684126),
-                                    ("intersecthh:mm", -5.020585624949423),
-                                    ("until <time-of-day><time-of-day> am|pm", -5.020585624949423),
+                                     -5.062595033026967),
+                                    ("dayhour", -3.270835563798912),
+                                    ("daymonth", -3.047692012484702),
+                                    ("monthday", -4.657129924918802),
+                                    ("monthyear", -4.3694478524670215),
+                                    ("intersecthh:mm", -5.062595033026967),
+                                    ("houryear", -5.062595033026967),
+                                    ("until <time-of-day><time-of-day> am|pm", -5.062595033026967),
                                     ("<time-of-day> am|pmintersect by \",\", \"of\", \"from\", \"'s\"",
-                                     -4.327438444389479),
-                                    ("<time-of-day> am|pmintersect", -3.767822656454056),
+                                     -4.3694478524670215),
+                                    ("<time-of-day> am|pmintersect", -3.809832064531599),
                                     ("intersect by \",\", \"of\", \"from\", \"'s\"year",
-                                     -4.327438444389479),
-                                    ("Tuesdayafter <time-of-day>", -5.020585624949423),
+                                     -4.146304301152812),
+                                    ("Tuesdayafter <time-of-day>", -5.062595033026967),
                                     ("July<day-of-month> (ordinal or number) <named-month>",
-                                     -5.020585624949423),
-                                    ("absorption of , after named dayJuly", -4.61512051684126),
-                                    ("monthhour", -4.61512051684126),
-                                    ("todayat <time-of-day>", -5.020585624949423),
-                                    ("dayday", -5.020585624949423),
-                                    ("mm/ddat <time-of-day>", -4.61512051684126),
-                                    ("<time-of-day> am|pmon <date>", -3.767822656454056),
-                                    ("dayyear", -4.104294893075269),
-                                    ("Thursdayat <time-of-day>", -5.020585624949423),
-                                    ("August<time-of-day> am|pm", -5.020585624949423),
-                                    ("monthminute", -5.020585624949423),
-                                    ("<time-of-day> am|pmtomorrow", -5.020585624949423),
-                                    ("Thursdayhh:mm", -5.020585624949423),
+                                     -5.062595033026967),
+                                    ("absorption of , after named dayJuly", -4.657129924918802),
+                                    ("monthhour", -4.657129924918802),
+                                    ("hourmonth", -5.062595033026967),
+                                    ("todayat <time-of-day>", -5.062595033026967),
+                                    ("dayday", -4.657129924918802),
+                                    ("mm/ddat <time-of-day>", -4.657129924918802),
+                                    ("<time-of-day> am|pmon <date>", -3.809832064531599),
+                                    ("dayyear", -4.146304301152812),
+                                    ("Thursdaymm/dd", -5.062595033026967),
+                                    ("Thursdayat <time-of-day>", -5.062595033026967),
+                                    ("August<time-of-day> am|pm", -5.062595033026967),
+                                    ("monthminute", -5.062595033026967),
+                                    ("<time-of-day> am|pmtomorrow", -5.062595033026967),
+                                    ("Thursdayhh:mm", -5.062595033026967),
                                     ("August<day-of-month> (ordinal or number) <named-month>",
-                                     -5.020585624949423),
-                                    ("minutemonth", -3.5165082281731497),
+                                     -5.062595033026967),
+                                    ("minutemonth", -3.5585176362506927),
                                     ("Thursdayfrom <datetime> - <datetime> (interval)",
-                                     -4.61512051684126),
+                                     -4.657129924918802),
                                     ("Thursdayfrom <time-of-day> - <time-of-day> (interval)",
-                                     -4.61512051684126),
-                                    ("Aprilyear", -5.020585624949423),
+                                     -4.657129924918802),
+                                    ("Aprilyear", -5.062595033026967),
                                     ("mm/dd<time-of-day> - <time-of-day> (interval)",
-                                     -4.61512051684126),
+                                     -4.657129924918802),
                                     ("tomorrowfrom <time-of-day> - <time-of-day> (interval)",
-                                     -5.020585624949423),
-                                    ("yesterday<time-of-day> am|pm", -5.020585624949423),
+                                     -5.062595033026967),
+                                    ("yesterday<time-of-day> am|pm", -5.062595033026967),
                                     ("intersect by \",\", \"of\", \"from\", \"'s\"hh:mm",
-                                     -4.104294893075269),
+                                     -4.146304301152812),
                                     ("<named-month> <day-of-month> (non ordinal)August",
-                                     -5.020585624949423),
-                                    ("until <time-of-day>on <date>", -4.327438444389479),
-                                    ("at <time-of-day>intersect", -4.61512051684126),
+                                     -5.062595033026967),
+                                    ("until <time-of-day>on <date>", -4.3694478524670215),
+                                    ("at <time-of-day>intersect", -4.657129924918802),
                                     ("at <time-of-day>intersect by \",\", \"of\", \"from\", \"'s\"",
-                                     -5.020585624949423),
-                                    ("dayminute", -3.0746754758941104),
-                                    ("intersectSeptember", -3.5165082281731497),
+                                     -5.062595033026967),
+                                    ("dayminute", -3.1166848839716534),
+                                    ("intersectSeptember", -3.5585176362506927),
                                     ("absorption of , after named dayintersect by \",\", \"of\", \"from\", \"'s\"",
-                                     -5.020585624949423),
-                                    ("minuteday", -2.217225244042889),
+                                     -5.062595033026967),
+                                    ("minuteday", -2.259234652120432),
                                     ("absorption of , after named dayintersect",
-                                     -5.020585624949423),
-                                    ("Februaryin|during the <part-of-day>", -5.020585624949423),
-                                    ("yearhh:mm", -5.020585624949423),
-                                    ("hh:mmon <date>", -3.5165082281731497),
+                                     -5.062595033026967),
+                                    ("Februaryin|during the <part-of-day>", -5.062595033026967),
+                                    ("week-endin <named-month>", -5.062595033026967),
+                                    ("Octoberyear", -5.062595033026967),
+                                    ("yearhh:mm", -5.062595033026967),
+                                    ("hh:mmon <date>", -3.5585176362506927),
                                     ("absorption of , after named daySeptember",
-                                     -4.104294893075269),
-                                    ("on <date>September", -4.61512051684126),
-                                    ("at <time-of-day>on <date>", -4.61512051684126),
-                                    ("absorption of , after named dayFebruary", -4.104294893075269),
+                                     -4.146304301152812),
+                                    ("on <date>September", -4.657129924918802),
+                                    ("at <time-of-day>on <date>", -4.657129924918802),
+                                    ("absorption of , after named dayFebruary", -4.146304301152812),
                                     ("July<integer> to|till|before <hour-of-day>",
-                                     -5.020585624949423),
-                                    ("tomorrowat <time-of-day>", -5.020585624949423),
-                                    ("tomorrow<time-of-day> am|pm", -5.020585624949423),
-                                    ("after <time-of-day><time-of-day> am|pm", -5.020585624949423),
-                                    ("after <time-of-day>year", -5.020585624949423),
-                                    ("yearminute", -5.020585624949423)],
-                               n = 92}}),
+                                     -5.062595033026967),
+                                    ("tomorrowat <time-of-day>", -5.062595033026967),
+                                    ("tomorrow<time-of-day> am|pm", -5.062595033026967),
+                                    ("after <time-of-day><time-of-day> am|pm", -5.062595033026967),
+                                    ("after <time-of-day>year", -5.062595033026967),
+                                    ("yearminute", -5.062595033026967)],
+                               n = 96}}),
        ("after lunch/work/school",
         Classifier{okData =
                      ClassData{prior = 0.0, unseen = -1.3862943611198906,
@@ -726,15 +752,14 @@
                                likelihoods = HashMap.fromList [], n = 0}}),
        ("in <number> (implicit minutes)",
         Classifier{okData =
-                     ClassData{prior = -1.3217558399823195,
-                               unseen = -2.3978952727983707,
+                     ClassData{prior = -1.041453874828161, unseen = -2.70805020110221,
                                likelihoods =
                                  HashMap.fromList
-                                   [("integer (numeric)", -0.2231435513142097),
-                                    ("integer (0..19)", -1.6094379124341003)],
-                               n = 8},
+                                   [("integer (numeric)", -0.5596157879354228),
+                                    ("integer (0..19)", -0.8472978603872037)],
+                               n = 12},
                    koData =
-                     ClassData{prior = -0.3101549283038396,
+                     ClassData{prior = -0.4353180712578455,
                                unseen = -3.2188758248682006,
                                likelihoods =
                                  HashMap.fromList
@@ -769,32 +794,33 @@
                                likelihoods = HashMap.fromList [], n = 0}}),
        ("from <datetime> - <datetime> (interval)",
         Classifier{okData =
-                     ClassData{prior = -0.8472978603872037,
-                               unseen = -3.1354942159291497,
+                     ClassData{prior = -0.916290731874155, unseen = -3.2188758248682006,
                                likelihoods =
                                  HashMap.fromList
-                                   [("minuteminute", -1.4816045409242156),
-                                    ("hh:mmhh:mm", -1.4816045409242156),
+                                   [("minuteminute", -1.5686159179138452),
+                                    ("hh:mmhh:mm", -1.5686159179138452),
                                     ("<time-of-day> am|pmtime-of-day (latent)",
-                                     -2.3978952727983707),
-                                    ("hourhour", -1.9924301646902063),
+                                     -2.4849066497880004),
+                                    ("hourhour", -2.0794415416798357),
                                     ("<time-of-day> am|pm<time-of-day> am|pm",
-                                     -2.3978952727983707)],
+                                     -2.4849066497880004)],
                                n = 6},
                    koData =
-                     ClassData{prior = -0.5596157879354228, unseen = -3.295836866004329,
+                     ClassData{prior = -0.5108256237659907,
+                               unseen = -3.4339872044851463,
                                likelihoods =
                                  HashMap.fromList
-                                   [("hh:mmtime-of-day (latent)", -1.6486586255873816),
-                                    ("minuteminute", -2.159484249353372),
-                                    ("time-of-day (latent)time-of-day (latent)",
-                                     -2.5649493574615367),
-                                    ("hourhour", -2.159484249353372),
-                                    ("minutehour", -1.6486586255873816),
-                                    ("hh:mmintersect", -2.159484249353372),
-                                    ("time-of-day (latent)<time-of-day> am|pm",
-                                     -2.5649493574615367)],
-                               n = 8}}),
+                                   [("dayhour", -2.70805020110221),
+                                    ("hh:mmtime-of-day (latent)", -1.791759469228055),
+                                    ("minuteminute", -2.3025850929940455),
+                                    ("time-of-day (latent)time-of-day (latent)", -2.70805020110221),
+                                    ("hourhour", -2.3025850929940455),
+                                    ("minutehour", -1.791759469228055),
+                                    ("hh:mmintersect", -2.3025850929940455),
+                                    ("time-of-day (latent)<time-of-day> am|pm", -2.70805020110221),
+                                    ("<named-month> <day-of-month> (non ordinal)time-of-day (latent)",
+                                     -2.70805020110221)],
+                               n = 9}}),
        ("Saturday",
         Classifier{okData =
                      ClassData{prior = 0.0, unseen = -2.0794415416798357,
@@ -1003,13 +1029,13 @@
                                likelihoods = HashMap.fromList [], n = 0}}),
        ("week (grain)",
         Classifier{okData =
-                     ClassData{prior = -2.7398974188114388e-2,
+                     ClassData{prior = -8.004270767353637e-2,
                                unseen = -3.6375861597263857,
                                likelihoods = HashMap.fromList [("", 0.0)], n = 36},
                    koData =
-                     ClassData{prior = -3.6109179126442243,
-                               unseen = -1.0986122886681098,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 1}}),
+                     ClassData{prior = -2.5649493574615367,
+                               unseen = -1.6094379124341003,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 3}}),
        ("<part-of-day> of <time>",
         Classifier{okData =
                      ClassData{prior = 0.0, unseen = -2.3978952727983707,
@@ -1119,7 +1145,7 @@
                                likelihoods = HashMap.fromList [], n = 0}}),
        ("this|last|next <cycle>",
         Classifier{okData =
-                     ClassData{prior = -0.11122563511022437,
+                     ClassData{prior = -0.16251892949777494,
                                unseen = -4.3694478524670215,
                                likelihoods =
                                  HashMap.fromList
@@ -1132,15 +1158,15 @@
                                     ("quarter (grain)", -2.7472709142554916)],
                                n = 34},
                    koData =
-                     ClassData{prior = -2.2512917986064953,
-                               unseen = -2.9444389791664407,
+                     ClassData{prior = -1.8971199848858813,
+                               unseen = -3.1354942159291497,
                                likelihoods =
                                  HashMap.fromList
-                                   [("week", -1.791759469228055),
-                                    ("week (grain)", -1.791759469228055),
-                                    ("day", -1.791759469228055),
-                                    ("day (grain)", -1.791759469228055)],
-                               n = 4}}),
+                                   [("week", -1.4816045409242156),
+                                    ("week (grain)", -1.4816045409242156),
+                                    ("day", -1.9924301646902063),
+                                    ("day (grain)", -1.9924301646902063)],
+                               n = 6}}),
        ("Mother's Day",
         Classifier{okData =
                      ClassData{prior = 0.0, unseen = -1.791759469228055,
@@ -1204,6 +1230,17 @@
                                likelihoods =
                                  HashMap.fromList [("ordinal (digits)", -0.2876820724517809)],
                                n = 2}}),
+       ("last weekend of <named-month>",
+        Classifier{okData =
+                     ClassData{prior = 0.0, unseen = -2.639057329615259,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("October", -0.9555114450274363), ("July", -1.8718021769015913),
+                                    ("month", -0.7731898882334817)],
+                               n = 5},
+                   koData =
+                     ClassData{prior = -infinity, unseen = -1.3862943611198906,
+                               likelihoods = HashMap.fromList [], n = 0}}),
        ("the <day-of-month> (number)",
         Classifier{okData =
                      ClassData{prior = 0.0, unseen = -1.0986122886681098,
@@ -1217,8 +1254,8 @@
                      ClassData{prior = -infinity, unseen = -0.6931471805599453,
                                likelihoods = HashMap.fromList [], n = 0},
                    koData =
-                     ClassData{prior = 0.0, unseen = -2.890371757896165,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 16}}),
+                     ClassData{prior = 0.0, unseen = -2.9444389791664407,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 17}}),
        ("Sunday",
         Classifier{okData =
                      ClassData{prior = 0.0, unseen = -2.3025850929940455,
@@ -1235,8 +1272,8 @@
                                likelihoods = HashMap.fromList [], n = 0}}),
        ("minute (grain)",
         Classifier{okData =
-                     ClassData{prior = 0.0, unseen = -2.5649493574615367,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 11},
+                     ClassData{prior = 0.0, unseen = -2.833213344056216,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 15},
                    koData =
                      ClassData{prior = -infinity, unseen = -0.6931471805599453,
                                likelihoods = HashMap.fromList [], n = 0}}),
@@ -1259,30 +1296,28 @@
                                n = 1}}),
        ("time-of-day (latent)",
         Classifier{okData =
-                     ClassData{prior = -0.6330432564902398, unseen = -4.143134726391533,
+                     ClassData{prior = -0.5108256237659907, unseen = -4.143134726391533,
                                likelihoods =
                                  HashMap.fromList
                                    [("integer (numeric)", -0.10178269430994236),
                                     ("integer (0..19)", -2.3353749158170367)],
                                n = 60},
                    koData =
-                     ClassData{prior = -0.7570959051602187, unseen = -4.02535169073515,
+                     ClassData{prior = -0.916290731874155, unseen = -3.7612001156935624,
                                likelihoods =
-                                 HashMap.fromList
-                                   [("integer (numeric)", -0.15718558352241238),
-                                    ("integer (0..19)", -1.927891643552635)],
-                               n = 53}}),
+                                 HashMap.fromList [("integer (numeric)", -2.409755157906053e-2)],
+                               n = 40}}),
        ("year",
         Classifier{okData =
-                     ClassData{prior = -0.2231435513142097,
-                               unseen = -3.4011973816621555,
+                     ClassData{prior = -0.24362208265775043,
+                               unseen = -3.4339872044851463,
                                likelihoods = HashMap.fromList [("integer (numeric)", 0.0)],
-                               n = 28},
+                               n = 29},
                    koData =
-                     ClassData{prior = -1.6094379124341003,
-                               unseen = -2.1972245773362196,
+                     ClassData{prior = -1.5314763709643884,
+                               unseen = -2.3025850929940455,
                                likelihoods = HashMap.fromList [("integer (numeric)", 0.0)],
-                               n = 7}}),
+                               n = 8}}),
        ("last <day-of-week> of <time>",
         Classifier{okData =
                      ClassData{prior = 0.0, unseen = -2.3978952727983707,
@@ -1298,28 +1333,28 @@
                                likelihoods = HashMap.fromList [], n = 0}}),
        ("<integer> <unit-of-duration>",
         Classifier{okData =
-                     ClassData{prior = -0.8209805520698302, unseen = -4.499809670330265,
+                     ClassData{prior = -0.758529939822797, unseen = -4.584967478670572,
                                likelihoods =
                                  HashMap.fromList
-                                   [("week", -2.2914117923959205),
-                                    ("integer (0..19)year (grain)", -3.1023420086122493),
-                                    ("integer (numeric)day (grain)", -2.5427262206768266),
-                                    ("integer (0..19)second (grain) ", -3.7954891891721947),
-                                    ("integer (0..19)hour (grain)", -2.6968769005040847),
-                                    ("second", -3.7954891891721947),
-                                    ("integer (numeric)year (grain)", -3.7954891891721947),
-                                    ("day", -2.5427262206768266), ("year", -2.8791984572980396),
-                                    ("integer (numeric)week (grain)", -2.8791984572980396),
-                                    ("integer (0..19)month (grain)", -3.39002408106403),
-                                    ("hour", -2.409194828052304), ("month", -3.39002408106403),
-                                    ("integer (numeric)minute (grain)", -2.8791984572980396),
-                                    ("integer (0..19)minute (grain)", -3.7954891891721947),
-                                    ("minute", -2.6968769005040847),
-                                    ("integer (numeric)hour (grain)", -3.39002408106403),
-                                    ("integer (0..19)week (grain)", -2.8791984572980396)],
-                               n = 33},
+                                   [("week", -2.3774864011671633),
+                                    ("integer (0..19)year (grain)", -3.188416617383492),
+                                    ("integer (numeric)day (grain)", -2.62880082944807),
+                                    ("integer (0..19)second (grain) ", -3.8815637979434374),
+                                    ("integer (0..19)hour (grain)", -2.782951509275328),
+                                    ("second", -3.8815637979434374),
+                                    ("integer (numeric)year (grain)", -3.8815637979434374),
+                                    ("day", -2.62880082944807), ("year", -2.9652730660692823),
+                                    ("integer (numeric)week (grain)", -2.9652730660692823),
+                                    ("integer (0..19)month (grain)", -3.4760986898352733),
+                                    ("hour", -2.495269436823547), ("month", -3.4760986898352733),
+                                    ("integer (numeric)minute (grain)", -2.9652730660692823),
+                                    ("integer (0..19)minute (grain)", -2.782951509275328),
+                                    ("minute", -2.2721258855093374),
+                                    ("integer (numeric)hour (grain)", -3.4760986898352733),
+                                    ("integer (0..19)week (grain)", -2.9652730660692823)],
+                               n = 37},
                    koData =
-                     ClassData{prior = -0.579818495252942, unseen = -4.68213122712422,
+                     ClassData{prior = -0.6317782341836533, unseen = -4.68213122712422,
                                likelihoods =
                                  HashMap.fromList
                                    [("week", -2.8810693652338513),
@@ -1480,134 +1515,137 @@
                                likelihoods = HashMap.fromList [], n = 0}}),
        ("about|exactly <time-of-day>",
         Classifier{okData =
-                     ClassData{prior = -0.11778303565638351,
-                               unseen = -3.332204510175204,
+                     ClassData{prior = -0.2231435513142097, unseen = -3.367295829986474,
                                likelihoods =
                                  HashMap.fromList
-                                   [("week", -2.6026896854443837),
-                                    ("hh(:mm) - <time-of-day> am|pm", -2.6026896854443837),
-                                    ("this|last|next <cycle>", -2.6026896854443837),
-                                    ("day", -2.1972245773362196),
-                                    ("time-of-day (latent)", -2.6026896854443837),
-                                    ("hhmm (latent)", -2.1972245773362196),
-                                    ("<time-of-day> am|pm", -2.6026896854443837),
-                                    ("hour", -1.9095425048844386),
-                                    ("next <time>", -2.6026896854443837),
-                                    ("this|next <day-of-week>", -2.6026896854443837),
-                                    ("minute", -2.1972245773362196)],
+                                   [("week", -2.639057329615259),
+                                    ("hh(:mm) - <time-of-day> am|pm", -2.639057329615259),
+                                    ("this|last|next <cycle>", -2.639057329615259),
+                                    ("day", -2.2335922215070942),
+                                    ("time-of-day (latent)", -2.639057329615259),
+                                    ("hhmm (latent)", -2.2335922215070942),
+                                    ("<time-of-day> am|pm", -2.639057329615259),
+                                    ("hour", -1.9459101490553135),
+                                    ("next <time>", -2.639057329615259),
+                                    ("this|next <day-of-week>", -2.639057329615259),
+                                    ("minute", -2.2335922215070942)],
                                n = 8},
                    koData =
-                     ClassData{prior = -2.1972245773362196, unseen = -2.639057329615259,
+                     ClassData{prior = -1.6094379124341003, unseen = -2.833213344056216,
                                likelihoods =
                                  HashMap.fromList
-                                   [("time-of-day (latent)", -1.8718021769015913),
-                                    ("hour", -1.8718021769015913)],
-                               n = 1}}),
+                                   [("mm/dd", -2.0794415416798357), ("day", -2.0794415416798357),
+                                    ("time-of-day (latent)", -2.0794415416798357),
+                                    ("hour", -2.0794415416798357)],
+                               n = 2}}),
        ("intersect by \",\", \"of\", \"from\", \"'s\"",
         Classifier{okData =
-                     ClassData{prior = -0.41773520069997866,
-                               unseen = -5.1298987149230735,
+                     ClassData{prior = -0.4769240720903093, unseen = -5.147494476813453,
                                likelihoods =
                                  HashMap.fromList
                                    [("Wednesday<named-month> <day-of-month> (non ordinal)",
-                                     -4.430816798843313),
-                                    ("dayhour", -3.1780538303479458),
-                                    ("daymonth", -3.1780538303479458),
+                                     -4.448516375942715),
+                                    ("dayhour", -3.1957534074473464),
+                                    ("daymonth", -3.1957534074473464),
                                     ("<named-month> <day-of-month> (non ordinal)Friday",
-                                     -4.430816798843313),
+                                     -4.448516375942715),
                                     ("Friday<named-month> <day-of-month> (non ordinal)",
-                                     -3.7376696182833684),
-                                    ("Wednesdayintersect", -4.430816798843313),
-                                    ("Labor Daythis|last|next <cycle>", -4.430816798843313),
+                                     -3.7553691953827695),
+                                    ("Wednesdayintersect", -4.448516375942715),
+                                    ("Labor Daythis|last|next <cycle>", -4.448516375942715),
                                     ("intersect by \",\", \"of\", \"from\", \"'s\"year",
-                                     -4.430816798843313),
-                                    ("<part-of-day> of <time>February", -4.430816798843313),
-                                    ("Saturday<time-of-day> am|pm", -4.430816798843313),
+                                     -4.448516375942715),
+                                    ("<part-of-day> of <time>February", -4.448516375942715),
+                                    ("Saturday<time-of-day> am|pm", -4.448516375942715),
                                     ("Martin Luther King's Daythis|last|next <cycle>",
-                                     -4.430816798843313),
-                                    ("on <date><time-of-day> am|pm", -4.430816798843313),
-                                    ("hourmonth", -4.430816798843313),
+                                     -4.448516375942715),
+                                    ("on <date><time-of-day> am|pm", -4.448516375942715),
+                                    ("hourmonth", -4.448516375942715),
                                     ("intersect by \",\", \"of\", \"from\", \"'s\"intersect",
-                                     -4.430816798843313),
-                                    ("dayday", -2.559014621941722),
-                                    ("the <day-of-month> (ordinal)February", -4.02535169073515),
-                                    ("WednesdayOctober", -4.430816798843313),
-                                    ("Wednesdaythis|last|next <cycle>", -4.02535169073515),
+                                     -4.448516375942715),
+                                    ("dayday", -2.576714199041123),
+                                    ("the <day-of-month> (ordinal)February", -4.04305126783455),
+                                    ("WednesdayOctober", -4.448516375942715),
+                                    ("Wednesdaythis|last|next <cycle>", -4.04305126783455),
                                     ("intersect<named-month> <day-of-month> (non ordinal)",
-                                     -3.5145260669691587),
-                                    ("dayyear", -2.9267394020670396),
+                                     -3.5322256440685593),
+                                    ("dayyear", -2.9444389791664407),
                                     ("Saturday<named-month> <day-of-month> (non ordinal)",
-                                     -4.430816798843313),
+                                     -4.448516375942715),
                                     ("<named-month> <day-of-month> (non ordinal)intersect",
-                                     -4.430816798843313),
-                                    ("Thursdayhh:mm", -4.02535169073515),
-                                    ("Thanksgiving Daythis|last|next <cycle>", -4.430816798843313),
-                                    ("Memorial Daythis|last|next <cycle>", -4.430816798843313),
+                                     -4.448516375942715),
+                                    ("Thursdayhh:mm", -4.04305126783455),
+                                    ("Thanksgiving Daythis|last|next <cycle>", -4.448516375942715),
+                                    ("Memorial Daythis|last|next <cycle>", -4.448516375942715),
                                     ("on <date><named-month> <day-of-month> (non ordinal)",
-                                     -4.02535169073515),
-                                    ("TuesdayOctober", -4.430816798843313),
-                                    ("the <day-of-month> (ordinal)March", -4.430816798843313),
-                                    ("Mondaythis|last|next <cycle>", -4.430816798843313),
+                                     -4.04305126783455),
+                                    ("TuesdayOctober", -4.448516375942715),
+                                    ("the <day-of-month> (ordinal)March", -4.448516375942715),
+                                    ("Mondaythis|last|next <cycle>", -4.448516375942715),
                                     ("Fridayintersect by \",\", \"of\", \"from\", \"'s\"",
-                                     -4.02535169073515),
-                                    ("Fridayintersect", -4.430816798843313),
+                                     -4.04305126783455),
+                                    ("Fridayintersect", -4.448516375942715),
                                     ("Thursday<datetime> - <datetime> (interval)",
-                                     -3.7376696182833684),
+                                     -3.7553691953827695),
                                     ("Thursday<time-of-day> - <time-of-day> (interval)",
-                                     -3.5145260669691587),
-                                    ("Tuesdaythis|last|next <cycle>", -4.430816798843313),
+                                     -3.5322256440685593),
+                                    ("Tuesdaythis|last|next <cycle>", -4.448516375942715),
                                     ("Sunday<named-month> <day-of-month> (non ordinal)",
-                                     -4.430816798843313),
-                                    ("dayminute", -2.639057329615259),
-                                    ("intersectyear", -4.430816798843313),
-                                    ("minuteday", -3.5145260669691587),
-                                    ("this|last|next <cycle>Sunday", -4.430816798843313),
-                                    ("Sundaythis|last|next <cycle>", -4.430816798843313),
-                                    ("intersectintersect", -4.430816798843313),
-                                    ("weekday", -4.430816798843313),
-                                    ("dayweek", -3.332204510175204),
-                                    ("Thursday<time-of-day> am|pm", -4.430816798843313),
+                                     -4.448516375942715),
+                                    ("dayminute", -2.6567569067146595),
+                                    ("intersectyear", -4.448516375942715),
+                                    ("minuteday", -3.5322256440685593),
+                                    ("this|last|next <cycle>Sunday", -4.448516375942715),
+                                    ("Sundaythis|last|next <cycle>", -4.448516375942715),
+                                    ("intersectintersect", -4.448516375942715),
+                                    ("weekday", -4.448516375942715),
+                                    ("dayweek", -3.349904087274605),
+                                    ("Thursday<time-of-day> am|pm", -4.448516375942715),
                                     ("Monday<named-month> <day-of-month> (non ordinal)",
-                                     -4.02535169073515),
+                                     -4.04305126783455),
                                     ("<named-month> <day-of-month> (non ordinal)year",
-                                     -4.02535169073515)],
+                                     -4.04305126783455)],
                                n = 54},
                    koData =
-                     ClassData{prior = -1.074514737089049, unseen = -4.762173934797756,
+                     ClassData{prior = -0.9694005571881036, unseen = -4.867534450455582,
                                likelihoods =
                                  HashMap.fromList
-                                   [("daymonth", -1.8632184332102),
-                                    ("TuesdaySeptember", -4.060443010546419),
-                                    ("Wednesdayintersect", -4.060443010546419),
+                                   [("week-endJuly", -4.1666652238017265),
+                                    ("week-endOctober", -3.4735180432417816),
+                                    ("daymonth", -1.9694406464655074),
+                                    ("TuesdaySeptember", -4.1666652238017265),
+                                    ("Wednesdayintersect", -4.1666652238017265),
+                                    ("hourmonth", -3.068052935133617),
                                     ("intersect by \",\", \"of\", \"from\", \"'s\"intersect",
-                                     -4.060443010546419),
-                                    ("SundayFebruary", -4.060443010546419),
-                                    ("WednesdayOctober", -4.060443010546419),
-                                    ("FridayJuly", -3.654977902438255),
+                                     -4.1666652238017265),
+                                    ("SundayFebruary", -4.1666652238017265),
+                                    ("WednesdayOctober", -4.1666652238017265),
+                                    ("week-endintersect", -4.1666652238017265),
+                                    ("FridayJuly", -3.7612001156935624),
                                     ("<named-month> <day-of-month> (non ordinal)intersect",
-                                     -4.060443010546419),
-                                    ("FridaySeptember", -4.060443010546419),
-                                    ("WednesdayFebruary", -4.060443010546419),
-                                    ("minutemonth", -3.144152278672264),
-                                    ("SundayMarch", -4.060443010546419),
+                                     -4.1666652238017265),
+                                    ("FridaySeptember", -4.1666652238017265),
+                                    ("WednesdayFebruary", -4.1666652238017265),
+                                    ("minutemonth", -3.250374491927572),
+                                    ("SundayMarch", -4.1666652238017265),
                                     ("Fridayintersect by \",\", \"of\", \"from\", \"'s\"",
-                                     -4.060443010546419),
-                                    ("MondayFebruary", -3.654977902438255),
-                                    ("Fridayintersect", -4.060443010546419),
+                                     -4.1666652238017265),
+                                    ("MondayFebruary", -3.7612001156935624),
+                                    ("Fridayintersect", -4.1666652238017265),
                                     ("Thursday<time-of-day> - <time-of-day> (interval)",
-                                     -3.654977902438255),
-                                    ("dayminute", -2.6741486494265287),
-                                    ("SaturdaySeptember", -4.060443010546419),
-                                    ("intersectSeptember", -3.144152278672264),
-                                    ("MondayMarch", -4.060443010546419),
-                                    ("on <date>September", -3.654977902438255),
-                                    ("intersectintersect", -4.060443010546419),
-                                    ("Tuesdayintersect", -4.060443010546419),
-                                    ("Sundayintersect", -4.060443010546419)],
-                               n = 28}}),
+                                     -3.7612001156935624),
+                                    ("dayminute", -2.780370862681836),
+                                    ("SaturdaySeptember", -4.1666652238017265),
+                                    ("intersectSeptember", -3.250374491927572),
+                                    ("MondayMarch", -4.1666652238017265),
+                                    ("on <date>September", -3.7612001156935624),
+                                    ("intersectintersect", -4.1666652238017265),
+                                    ("Tuesdayintersect", -4.1666652238017265),
+                                    ("Sundayintersect", -4.1666652238017265)],
+                               n = 33}}),
        ("last <time>",
         Classifier{okData =
-                     ClassData{prior = -1.2729656758128873, unseen = -3.295836866004329,
+                     ClassData{prior = -1.0986122886681098, unseen = -3.295836866004329,
                                likelihoods =
                                  HashMap.fromList
                                    [("Father's Day", -2.5649493574615367),
@@ -1619,16 +1657,18 @@
                                     ("week-end", -2.5649493574615367)],
                                n = 7},
                    koData =
-                     ClassData{prior = -0.3285040669720361, unseen = -3.891820298110627,
+                     ClassData{prior = -0.40546510810816444,
+                               unseen = -3.713572066704308,
                                likelihoods =
                                  HashMap.fromList
-                                   [("Monday", -3.1780538303479458), ("day", -2.2617630984737906),
-                                    ("Sunday", -3.1780538303479458),
-                                    ("time-of-day (latent)", -1.1631508098056809),
+                                   [("intersect", -2.995732273553991),
+                                    ("Monday", -2.995732273553991), ("day", -2.0794415416798357),
+                                    ("Sunday", -2.995732273553991),
                                     ("intersect by \",\", \"of\", \"from\", \"'s\"",
-                                     -2.772588722239781),
-                                    ("hour", -1.1631508098056809)],
-                               n = 18}}),
+                                     -1.742969305058623),
+                                    ("hour", -1.2909841813155656),
+                                    ("week-end", -1.8971199848858813)],
+                               n = 14}}),
        ("March",
         Classifier{okData =
                      ClassData{prior = 0.0, unseen = -2.9444389791664407,
@@ -1771,9 +1811,9 @@
                      ClassData{prior = -infinity, unseen = -0.6931471805599453,
                                likelihoods = HashMap.fromList [], n = 0},
                    koData =
-                     ClassData{prior = 0.0, unseen = -2.995732273553991,
+                     ClassData{prior = 0.0, unseen = -3.1354942159291497,
                                likelihoods = HashMap.fromList [("integer (numeric)", 0.0)],
-                               n = 18}}),
+                               n = 21}}),
        ("about|exactly <duration>",
         Classifier{okData =
                      ClassData{prior = 0.0, unseen = -1.6094379124341003,
@@ -1886,7 +1926,7 @@
                                likelihoods = HashMap.fromList [], n = 0}}),
        ("in <named-month>",
         Classifier{okData =
-                     ClassData{prior = -0.40546510810816444,
+                     ClassData{prior = -0.6931471805599453,
                                unseen = -2.0794415416798357,
                                likelihoods =
                                  HashMap.fromList
@@ -1894,11 +1934,13 @@
                                     ("month", -0.8472978603872037)],
                                n = 2},
                    koData =
-                     ClassData{prior = -1.0986122886681098, unseen = -1.791759469228055,
+                     ClassData{prior = -0.6931471805599453,
+                               unseen = -2.0794415416798357,
                                likelihoods =
                                  HashMap.fromList
-                                   [("October", -0.916290731874155), ("month", -0.916290731874155)],
-                               n = 1}}),
+                                   [("October", -0.8472978603872037),
+                                    ("month", -0.8472978603872037)],
+                               n = 2}}),
        ("<time-of-day> - <time-of-day> (interval)",
         Classifier{okData =
                      ClassData{prior = -0.8873031950009028,
@@ -1950,7 +1992,7 @@
                                n = 1}}),
        ("<named-month> <day-of-month> (non ordinal)",
         Classifier{okData =
-                     ClassData{prior = -0.25131442828090605,
+                     ClassData{prior = -0.2876820724517809,
                                unseen = -3.9318256327243257,
                                likelihoods =
                                  HashMap.fromList
@@ -1964,14 +2006,15 @@
                                     ("Julyinteger (numeric)", -2.120263536200091)],
                                n = 21},
                    koData =
-                     ClassData{prior = -1.5040773967762742, unseen = -3.044522437723423,
+                     ClassData{prior = -1.3862943611198906,
+                               unseen = -3.1354942159291497,
                                likelihoods =
                                  HashMap.fromList
-                                   [("Marchinteger (numeric)", -2.3025850929940455),
-                                    ("Aprilinteger (numeric)", -2.3025850929940455),
-                                    ("month", -1.0498221244986778),
-                                    ("Julyinteger (numeric)", -1.3862943611198906)],
-                               n = 6}}),
+                                   [("Marchinteger (numeric)", -2.3978952727983707),
+                                    ("Aprilinteger (numeric)", -2.3978952727983707),
+                                    ("month", -1.0116009116784799),
+                                    ("Julyinteger (numeric)", -1.2992829841302609)],
+                               n = 7}}),
        ("this|next <day-of-week>",
         Classifier{okData =
                      ClassData{prior = 0.0, unseen = -2.995732273553991,
@@ -2043,13 +2086,13 @@
                                likelihoods = HashMap.fromList [("", 0.0)], n = 1}}),
        ("week-end",
         Classifier{okData =
-                     ClassData{prior = -0.6931471805599453,
+                     ClassData{prior = -1.5040773967762742,
                                unseen = -1.3862943611198906,
                                likelihoods = HashMap.fromList [("", 0.0)], n = 2},
                    koData =
-                     ClassData{prior = -0.6931471805599453,
-                               unseen = -1.3862943611198906,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 2}}),
+                     ClassData{prior = -0.25131442828090605,
+                               unseen = -2.1972245773362196,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 7}}),
        ("after <time-of-day>",
         Classifier{okData =
                      ClassData{prior = -1.6094379124341003,
@@ -2099,11 +2142,11 @@
                                n = 6}}),
        ("<month> dd-dd (interval)",
         Classifier{okData =
-                     ClassData{prior = 0.0, unseen = -2.3978952727983707,
+                     ClassData{prior = 0.0, unseen = -2.5649493574615367,
                                likelihoods =
                                  HashMap.fromList
                                    [("July", -0.6931471805599453), ("month", -0.6931471805599453)],
-                               n = 4},
+                               n = 5},
                    koData =
                      ClassData{prior = -infinity, unseen = -1.0986122886681098,
                                likelihoods = HashMap.fromList [], n = 0}}),
@@ -2118,26 +2161,25 @@
                                likelihoods = HashMap.fromList [("", 0.0)], n = 1}}),
        ("this <time>",
         Classifier{okData =
-                     ClassData{prior = -8.701137698962981e-2,
-                               unseen = -3.4965075614664802,
+                     ClassData{prior = -0.10536051565782628,
+                               unseen = -3.332204510175204,
                                likelihoods =
                                  HashMap.fromList
-                                   [("Thursday", -2.772588722239781),
-                                    ("Martin Luther King's Day", -2.772588722239781),
-                                    ("intersect", -2.772588722239781),
-                                    ("Monday", -2.772588722239781), ("day", -1.3862943611198906),
-                                    ("Thanksgiving Day", -2.772588722239781),
-                                    ("hour", -1.8562979903656263), ("seasons", -2.0794415416798357),
-                                    ("week-end", -2.772588722239781),
-                                    ("part of days", -2.367123614131617)],
-                               n = 11},
+                                   [("Thursday", -2.6026896854443837),
+                                    ("Martin Luther King's Day", -2.6026896854443837),
+                                    ("intersect", -2.6026896854443837),
+                                    ("Monday", -2.6026896854443837), ("day", -1.2163953243244932),
+                                    ("Thanksgiving Day", -2.6026896854443837),
+                                    ("hour", -2.1972245773362196), ("seasons", -1.9095425048844386),
+                                    ("week-end", -2.6026896854443837)],
+                               n = 9},
                    koData =
-                     ClassData{prior = -2.4849066497880004,
-                               unseen = -2.5649493574615367,
+                     ClassData{prior = -2.3025850929940455,
+                               unseen = -2.4849066497880004,
                                likelihoods =
                                  HashMap.fromList
-                                   [("hour", -1.791759469228055),
-                                    ("part of days", -1.791759469228055)],
+                                   [("intersect", -1.7047480922384253),
+                                    ("day", -1.7047480922384253)],
                                n = 1}}),
        ("August",
         Classifier{okData =
diff --git a/Duckling/Ranking/Classifiers/FR.hs b/Duckling/Ranking/Classifiers/FR.hs
--- a/Duckling/Ranking/Classifiers/FR.hs
+++ b/Duckling/Ranking/Classifiers/FR.hs
@@ -63,2287 +63,2493 @@
                                n = 2}}),
        ("du|dans le <part-of-day>",
         Classifier{okData =
-                     ClassData{prior = -0.2657031657330056, unseen = -4.07753744390572,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("soir", -2.114532861491106),
-                                    ("fin de journ\233e", -3.367295829986474),
-                                    ("fin de matin\233e", -3.367295829986474),
-                                    ("d\233but de soir\233e", -3.367295829986474),
-                                    ("d\233but de matin\233e", -3.367295829986474),
-                                    ("apr\232s-midi", -2.9618307218783095),
-                                    ("d\233but de journ\233e", -3.367295829986474),
-                                    ("matin", -2.114532861491106), ("hour", -0.8823891801984737),
-                                    ("fin de soir\233e", -3.367295829986474),
-                                    ("fin d'apr\232s-midi", -2.9618307218783095),
-                                    ("d\233but d'apr\232s-midi", -3.367295829986474)],
-                               n = 23},
-                   koData =
-                     ClassData{prior = -1.455287232606842, unseen = -3.295836866004329,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("soir", -2.5649493574615367), ("matin", -1.3121863889661687),
-                                    ("hour", -1.1786549963416462)],
-                               n = 7}}),
-       ("dans <duration>",
-        Classifier{okData =
-                     ClassData{prior = -8.338160893905101e-2,
-                               unseen = -4.04305126783455,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("week", -2.639057329615259),
-                                    ("<integer> + '\"", -2.9267394020670396),
-                                    ("second", -2.639057329615259), ("day", -2.9267394020670396),
-                                    ("year", -2.639057329615259),
-                                    ("<integer> <unit-of-duration>", -1.1921383466789333),
-                                    ("une <unit-of-duration>", -2.2335922215070942),
-                                    ("hour", -2.4159137783010487), ("month", -3.332204510175204),
-                                    ("minute", -1.9459101490553135)],
-                               n = 23},
-                   koData =
-                     ClassData{prior = -2.5257286443082556, unseen = -2.70805020110221,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("week", -1.9459101490553135), ("day", -1.9459101490553135),
-                                    ("une <unit-of-duration>", -1.540445040947149)],
-                               n = 2}}),
-       ("<time> timezone",
-        Classifier{okData =
-                     ClassData{prior = 0.0, unseen = -2.3025850929940455,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("\224|vers <time-of-day>", -1.5040773967762742),
-                                    ("hour", -0.8109302162163288),
-                                    ("<time-of-day> heures", -1.0986122886681098)],
-                               n = 3},
-                   koData =
-                     ClassData{prior = -infinity, unseen = -1.3862943611198906,
-                               likelihoods = HashMap.fromList [], n = 0}}),
-       ("n <cycle> apr\232s",
-        Classifier{okData =
-                     ClassData{prior = 0.0, unseen = -1.9459101490553135,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("number (0..16)jour (grain)", -0.6931471805599453),
-                                    ("day", -0.6931471805599453)],
-                               n = 2},
-                   koData =
-                     ClassData{prior = -infinity, unseen = -1.0986122886681098,
-                               likelihoods = HashMap.fromList [], n = 0}}),
-       ("integer (numeric)",
-        Classifier{okData =
-                     ClassData{prior = -0.500101660403015, unseen = -5.424950017481403,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 225},
-                   koData =
-                     ClassData{prior = -0.9325954408990987, unseen = -4.997212273764115,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 146}}),
-       ("<named-month>",
-        Classifier{okData =
-                     ClassData{prior = 0.0, unseen = -1.6094379124341003,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("named-month", -0.6931471805599453),
-                                    ("month", -0.6931471805599453)],
-                               n = 1},
-                   koData =
-                     ClassData{prior = -infinity, unseen = -1.0986122886681098,
-                               likelihoods = HashMap.fromList [], n = 0}}),
-       ("apr\232s le travail",
-        Classifier{okData =
-                     ClassData{prior = 0.0, unseen = -1.0986122886681098,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 1},
-                   koData =
-                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
-                               likelihoods = HashMap.fromList [], n = 0}}),
-       ("n prochains <cycle>",
-        Classifier{okData =
-                     ClassData{prior = 0.0, unseen = -3.5553480614894135,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("week", -2.833213344056216),
-                                    ("number (0..16)seconde (grain)", -2.833213344056216),
-                                    ("second", -2.4277482359480516),
-                                    ("integer (numeric)ann\233e (grain)", -2.833213344056216),
-                                    ("integer (numeric)seconde (grain)", -2.833213344056216),
-                                    ("number (0..16)minute (grain)", -2.833213344056216),
-                                    ("integer (numeric)jour (grain)", -2.833213344056216),
-                                    ("day", -2.833213344056216), ("year", -2.833213344056216),
-                                    ("hour", -2.833213344056216), ("month", -2.833213344056216),
-                                    ("integer (numeric)minute (grain)", -2.833213344056216),
-                                    ("integer (numeric)mois (grain)", -2.833213344056216),
-                                    ("minute", -2.4277482359480516),
-                                    ("integer (numeric)semaine (grain)", -2.833213344056216),
-                                    ("integer (numeric)heure (grain)", -2.833213344056216)],
-                               n = 9},
-                   koData =
-                     ClassData{prior = -infinity, unseen = -2.833213344056216,
-                               likelihoods = HashMap.fromList [], n = 0}}),
-       ("<day-of-week> <day-of-month> \224 <time-of-day>)",
-        Classifier{okData =
-                     ClassData{prior = 0.0, unseen = -3.58351893845611,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("dayhour", -0.7827593392496325),
-                                    ("named-dayinteger (numeric)\224|vers <time-of-day>",
-                                     -1.6094379124341003),
-                                    ("named-daynumber (0..16)<time-of-day> heures",
-                                     -2.456735772821304),
-                                    ("named-dayinteger (numeric)<time-of-day> heures",
-                                     -2.169053700369523),
-                                    ("named-daynumber (0..16)\224|vers <time-of-day>",
-                                     -1.9459101490553135)],
-                               n = 15},
-                   koData =
-                     ClassData{prior = -infinity, unseen = -1.791759469228055,
-                               likelihoods = HashMap.fromList [], n = 0}}),
-       ("apr\232s le d\233jeuner",
-        Classifier{okData =
-                     ClassData{prior = 0.0, unseen = -1.0986122886681098,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 1},
-                   koData =
-                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
-                               likelihoods = HashMap.fromList [], n = 0}}),
-       ("<named-day> en quinze",
-        Classifier{okData =
-                     ClassData{prior = 0.0, unseen = -2.70805020110221,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("day", -0.6931471805599453),
-                                    ("named-day", -0.6931471805599453)],
-                               n = 6},
-                   koData =
-                     ClassData{prior = -infinity, unseen = -1.0986122886681098,
-                               likelihoods = HashMap.fromList [], n = 0}}),
-       ("entre <datetime> et <datetime> (interval)",
-        Classifier{okData =
-                     ClassData{prior = -0.25131442828090605,
-                               unseen = -4.127134385045092,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("le <time>le <day-of-month> (non ordinal)",
-                                     -3.417726683613366),
-                                    ("le <time>le <time>", -3.012261575505202),
-                                    ("dayday", -1.7129785913749407),
-                                    ("hourhour", -3.417726683613366),
-                                    ("le <time>intersect", -3.417726683613366),
-                                    ("miditime-of-day (latent)", -3.417726683613366),
-                                    ("intersectle <day-of-month> (non ordinal)",
-                                     -3.417726683613366),
-                                    ("minutehour", -1.7129785913749407),
-                                    ("hh(:|h)mm (time-of-day)time-of-day (latent)",
-                                     -3.012261575505202),
-                                    ("<hour-of-day> <integer> (as relative minutes)<time-of-day> heures",
-                                     -2.7245795030534206),
-                                    ("le <day-of-month> (non ordinal)le <day-of-month> (non ordinal)",
-                                     -3.012261575505202),
-                                    ("hh(:|h)mm (time-of-day)<time-of-day> heures",
-                                     -2.7245795030534206),
-                                    ("intersectintersect", -3.417726683613366),
-                                    ("intersectle <time>", -3.012261575505202),
-                                    ("<hour-of-day> <integer> (as relative minutes)time-of-day (latent)",
-                                     -3.012261575505202)],
-                               n = 21},
-                   koData =
-                     ClassData{prior = -1.5040773967762742,
-                               unseen = -3.4657359027997265,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("<hour-of-day> <integer> (as relative minutes)intersect",
-                                     -2.740840023925201),
-                                    ("dayday", -2.3353749158170367),
-                                    ("le <day-of-month> (non ordinal)intersect",
-                                     -2.740840023925201),
-                                    ("minutehour", -1.824549292051046),
-                                    ("hh(:|h)mm (time-of-day)time-of-day (latent)",
-                                     -2.740840023925201),
-                                    ("le <day-of-month> (non ordinal)le <time>",
-                                     -2.740840023925201),
-                                    ("hh(:|h)mm (time-of-day)intersect", -2.740840023925201),
-                                    ("<hour-of-day> <integer> (as relative minutes)time-of-day (latent)",
-                                     -2.740840023925201)],
-                               n = 6}}),
-       ("soir",
-        Classifier{okData =
-                     ClassData{prior = -8.701137698962981e-2,
-                               unseen = -2.5649493574615367,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 11},
-                   koData =
-                     ClassData{prior = -2.4849066497880004,
-                               unseen = -1.0986122886681098,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 1}}),
-       ("ann\233e (grain)",
-        Classifier{okData =
-                     ClassData{prior = 0.0, unseen = -2.3978952727983707,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 9},
-                   koData =
-                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
-                               likelihoods = HashMap.fromList [], n = 0}}),
-       ("d\233but de semaine",
-        Classifier{okData =
-                     ClassData{prior = 0.0, unseen = -1.0986122886681098,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 1},
-                   koData =
-                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
-                               likelihoods = HashMap.fromList [], n = 0}}),
-       ("<hour-of-day> moins <integer> (as relative minutes)",
-        Classifier{okData =
-                     ClassData{prior = 0.0, unseen = -1.6094379124341003,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("midinumber (0..16)", -0.6931471805599453),
-                                    ("hour", -0.6931471805599453)],
-                               n = 1},
-                   koData =
-                     ClassData{prior = -infinity, unseen = -1.0986122886681098,
-                               likelihoods = HashMap.fromList [], n = 0}}),
-       ("<named-month|named-day> suivant|d'apr\232s",
-        Classifier{okData =
-                     ClassData{prior = -0.10178269430994236,
-                               unseen = -4.174387269895637,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("intersect", -2.5494451709255714),
-                                    ("en semaine", -1.9616585060234524),
-                                    ("intersect by 'de' or ','", -2.5494451709255714),
-                                    ("day", -0.7915872533731978),
-                                    ("named-day", -2.5494451709255714),
-                                    ("le <time>", -1.9616585060234524)],
-                               n = 28},
-                   koData =
-                     ClassData{prior = -2.3353749158170367, unseen = -2.70805020110221,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("en semaine", -1.9459101490553135),
-                                    ("day", -1.540445040947149), ("hour", -1.9459101490553135),
-                                    ("<time-of-day> heures", -1.9459101490553135),
-                                    ("le <time>", -1.9459101490553135)],
-                               n = 3}}),
-       ("seconde (grain)",
-        Classifier{okData =
-                     ClassData{prior = 0.0, unseen = -1.9459101490553135,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 5},
-                   koData =
-                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
-                               likelihoods = HashMap.fromList [], n = 0}}),
-       ("<hour-of-day> et|pass\233 de <number>",
-        Classifier{okData =
-                     ClassData{prior = -0.13353139262452263,
-                               unseen = -3.0910424533583156,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("\224|vers <time-of-day>number (20..60)", -2.3513752571634776),
-                                    ("<time-of-day> heuresinteger (numeric)", -2.3513752571634776),
-                                    ("\224|vers <time-of-day>number (0..16)", -2.3513752571634776),
-                                    ("hour", -0.9650808960435872),
-                                    ("<time-of-day> heuresnumber (20..60)", -1.9459101490553135),
-                                    ("<time-of-day> heuresnumber (0..16)", -1.9459101490553135)],
-                               n = 7},
-                   koData =
-                     ClassData{prior = -2.0794415416798357,
-                               unseen = -2.3025850929940455,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("midiinteger (numeric)", -1.5040773967762742),
-                                    ("hour", -1.5040773967762742)],
-                               n = 1}}),
-       ("<hour-of-day> moins quart",
-        Classifier{okData =
-                     ClassData{prior = 0.0, unseen = -1.6094379124341003,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("midi", -0.6931471805599453), ("hour", -0.6931471805599453)],
-                               n = 1},
-                   koData =
-                     ClassData{prior = -infinity, unseen = -1.0986122886681098,
-                               likelihoods = HashMap.fromList [], n = 0}}),
-       ("de <time-of-day> - <time-of-day> (interval)",
-        Classifier{okData =
-                     ClassData{prior = -0.587786664902119, unseen = -3.8066624897703196,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("hh(:|h)mm (time-of-day)<hour-of-day> <integer> (as relative minutes)",
-                                     -2.6855773452501515),
-                                    ("minuteminute", -1.5869650565820417),
-                                    ("time-of-day (latent)time-of-day (latent)",
-                                     -3.0910424533583156),
-                                    ("<time-of-day> heures<time-of-day> heures",
-                                     -3.0910424533583156),
-                                    ("hh(:|h)mm (time-of-day)hh(:|h)mm (time-of-day)",
-                                     -2.6855773452501515),
-                                    ("hourhour", -2.3978952727983707),
-                                    ("minutehour", -2.174751721484161),
-                                    ("<hour-of-day> <integer> (as relative minutes)<time-of-day> heures",
-                                     -2.3978952727983707),
-                                    ("<hour-of-day> <integer> (as relative minutes)hh(:|h)mm (time-of-day)",
-                                     -2.6855773452501515),
-                                    ("hh(:|h)mm (time-of-day)<time-of-day> heures",
-                                     -3.0910424533583156),
-                                    ("<hour-of-day> <integer> (as relative minutes)<hour-of-day> <integer> (as relative minutes)",
-                                     -2.6855773452501515),
-                                    ("<time-of-day> heurestime-of-day (latent)",
-                                     -3.0910424533583156)],
-                               n = 15},
-                   koData =
-                     ClassData{prior = -0.8109302162163288,
-                               unseen = -3.6635616461296463,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("minutehour", -1.072636802264849),
-                                    ("hh(:|h)mm (time-of-day)time-of-day (latent)",
-                                     -2.2512917986064953),
-                                    ("<hour-of-day> <integer> (as relative minutes)<time-of-day> heures",
-                                     -2.538973871058276),
-                                    ("hh(:|h)mm (time-of-day)<time-of-day> heures",
-                                     -2.538973871058276),
-                                    ("<hour-of-day> <integer> (as relative minutes)time-of-day (latent)",
-                                     -1.845826690498331)],
-                               n = 12}}),
-       ("<datetime>-dd <month>(interval)",
-        Classifier{okData =
-                     ClassData{prior = -1.466337068793427, unseen = -2.772588722239781,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("daymonth", -1.3217558399823195),
-                                    ("<day-of-month> <named-month>named-month",
-                                     -1.6094379124341003),
-                                    ("day of month (premier)named-month", -2.0149030205422647)],
-                               n = 3},
-                   koData =
-                     ClassData{prior = -0.262364264467491, unseen = -3.4011973816621555,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("hourmonth", -1.7578579175523736),
-                                    ("named-monthnamed-month", -2.268683541318364),
-                                    ("monthmonth", -2.268683541318364),
-                                    ("year (latent)named-month", -1.7578579175523736),
-                                    ("yearmonth", -1.7578579175523736),
-                                    ("time-of-day (latent)named-month", -1.7578579175523736)],
-                               n = 10}}),
-       ("semaine (grain)",
-        Classifier{okData =
-                     ClassData{prior = 0.0, unseen = -3.6635616461296463,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 37},
-                   koData =
-                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
-                               likelihoods = HashMap.fromList [], n = 0}}),
-       ("<integer> + '\"",
-        Classifier{okData =
-                     ClassData{prior = 0.0, unseen = -1.3862943611198906,
-                               likelihoods = HashMap.fromList [("integer (numeric)", 0.0)],
-                               n = 2},
-                   koData =
-                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
-                               likelihoods = HashMap.fromList [], n = 0}}),
-       ("demain",
-        Classifier{okData =
-                     ClassData{prior = -0.45198512374305727,
-                               unseen = -2.1972245773362196,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 7},
-                   koData =
-                     ClassData{prior = -1.0116009116784799, unseen = -1.791759469228055,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 4}}),
-       ("mois (grain)",
-        Classifier{okData =
-                     ClassData{prior = 0.0, unseen = -2.3978952727983707,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 9},
-                   koData =
-                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
-                               likelihoods = HashMap.fromList [], n = 0}}),
-       ("intersect by 'mais/par exemple/plut\244t'",
-        Classifier{okData =
-                     ClassData{prior = 0.0, unseen = -3.8066624897703196,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("dayhour", -2.3978952727983707),
-                                    ("named-dayentre <time-of-day> et <time-of-day> (interval)",
-                                     -1.5869650565820417),
-                                    ("le <day-of-month> (non ordinal)<time-of-day> heures",
-                                     -3.0910424533583156),
-                                    ("le <day-of-month> (non ordinal)\224|vers <time-of-day>",
-                                     -2.6855773452501515),
-                                    ("dayminute", -0.9509762898620451),
-                                    ("named-dayentre <datetime> et <datetime> (interval)",
-                                     -1.5869650565820417)],
-                               n = 19},
-                   koData =
-                     ClassData{prior = -infinity, unseen = -1.9459101490553135,
-                               likelihoods = HashMap.fromList [], n = 0}}),
-       ("de <datetime> - <datetime> (interval)",
-        Classifier{okData =
-                     ClassData{prior = -1.410986973710262, unseen = -4.143134726391533,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("day of month (premier)<day-of-week> <day-of-month>",
-                                     -3.4339872044851463),
-                                    ("hh(:|h)mm (time-of-day)<hour-of-day> <integer> (as relative minutes)",
-                                     -3.4339872044851463),
-                                    ("minuteminute", -2.517696472610991),
-                                    ("hh(:|h)mm (time-of-day)hh(:|h)mm (time-of-day)",
-                                     -3.4339872044851463),
-                                    ("dayday", -2.517696472610991),
-                                    ("<day-of-month> <named-month>day of month (premier)",
-                                     -3.4339872044851463),
-                                    ("minutehour", -3.028522096376982),
-                                    ("<hour-of-day> <integer> (as relative minutes)<time-of-day> heures",
-                                     -3.4339872044851463),
-                                    ("<hour-of-day> <integer> (as relative minutes)hh(:|h)mm (time-of-day)",
-                                     -3.4339872044851463),
-                                    ("hh(:|h)mm (time-of-day)<time-of-day> heures",
-                                     -3.4339872044851463),
-                                    ("<hour-of-day> <integer> (as relative minutes)<hour-of-day> <integer> (as relative minutes)",
-                                     -3.4339872044851463),
-                                    ("<day-of-month> <named-month>intersect", -3.4339872044851463),
-                                    ("intersect<day-of-week> <day-of-month>", -3.4339872044851463)],
-                               n = 10},
-                   koData =
-                     ClassData{prior = -0.27958486221916157,
-                               unseen = -4.653960350157523,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("<hour-of-day> <integer> (as relative minutes)intersect",
-                                     -3.951243718581427),
-                                    ("<day-of-month> <named-month>time-of-day (latent)",
-                                     -3.951243718581427),
-                                    ("hourday", -3.0349529867072724),
-                                    ("dayhour", -3.951243718581427),
-                                    ("yearhour", -3.951243718581427),
-                                    ("intersectnamed-day", -3.951243718581427),
-                                    ("time-of-day (latent)year (latent)", -3.951243718581427),
-                                    ("houryear", -3.951243718581427),
-                                    ("day of month (premier)named-day", -3.951243718581427),
-                                    ("time-of-day (latent)intersect", -3.545778610473263),
-                                    ("year (latent)intersect", -3.545778610473263),
-                                    ("yearyear", -3.951243718581427),
-                                    ("time-of-day (latent)time-of-day (latent)",
-                                     -3.951243718581427),
-                                    ("dayday", -2.2464956263430023),
-                                    ("year (latent)year (latent)", -3.951243718581427),
-                                    ("<day-of-week> <day-of-month><day-of-week> <day-of-month>",
-                                     -3.951243718581427),
-                                    ("hourhour", -3.951243718581427),
-                                    ("time-of-day (latent)<day-of-week> <day-of-month>",
-                                     -3.951243718581427),
-                                    ("minutehour", -2.4471663218051534),
-                                    ("hh(:|h)mm (time-of-day)time-of-day (latent)",
-                                     -3.545778610473263),
-                                    ("year (latent)<day-of-week> <day-of-month>",
-                                     -3.951243718581427),
-                                    ("year (latent)time-of-day (latent)", -3.951243718581427),
-                                    ("<hour-of-day> <integer> (as relative minutes)<time-of-day> heures",
-                                     -3.951243718581427),
-                                    ("year (latent)named-day", -3.951243718581427),
-                                    ("time-of-day (latent)named-day", -3.951243718581427),
-                                    ("day of month (premier)intersect", -3.545778610473263),
-                                    ("hh(:|h)mm (time-of-day)<time-of-day> heures",
-                                     -3.951243718581427),
-                                    ("intersectintersect", -3.545778610473263),
-                                    ("hh(:|h)mm (time-of-day)intersect", -3.951243718581427),
-                                    ("yearday", -3.0349529867072724),
-                                    ("<hour-of-day> <integer> (as relative minutes)time-of-day (latent)",
-                                     -3.545778610473263),
-                                    ("<day-of-week> <day-of-month>named-day", -3.951243718581427),
-                                    ("<day-of-week> <day-of-month>intersect", -3.545778610473263)],
-                               n = 31}}),
-       ("<ordinal> <cycle> de <time>",
-        Classifier{okData =
-                     ClassData{prior = 0.0, unseen = -2.890371757896165,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("daymonth", -1.7346010553881064),
-                                    ("ordinals (premier..seizieme)semaine (grain)named-month",
-                                     -1.7346010553881064),
-                                    ("ordinal (digits)jour (grain)named-month",
-                                     -1.7346010553881064),
-                                    ("weekmonth", -1.2237754316221157),
-                                    ("ordinals (premier..seizieme)semaine (grain)intersect",
-                                     -1.7346010553881064)],
-                               n = 6},
-                   koData =
-                     ClassData{prior = -infinity, unseen = -1.791759469228055,
-                               likelihoods = HashMap.fromList [], n = 0}}),
-       ("premi\232re quinzaine de <named-month>(interval)",
-        Classifier{okData =
-                     ClassData{prior = 0.0, unseen = -1.6094379124341003,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("named-month", -0.6931471805599453),
-                                    ("month", -0.6931471805599453)],
-                               n = 1},
-                   koData =
-                     ClassData{prior = -infinity, unseen = -1.0986122886681098,
-                               likelihoods = HashMap.fromList [], n = 0}}),
-       ("n <cycle> suivants",
-        Classifier{okData =
-                     ClassData{prior = -0.6931471805599453,
-                               unseen = -2.3978952727983707,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("hour", -1.6094379124341003), ("month", -1.6094379124341003),
-                                    ("integer (numeric)mois (grain)", -1.6094379124341003),
-                                    ("integer (numeric)heure (grain)", -1.6094379124341003)],
-                               n = 2},
-                   koData =
-                     ClassData{prior = -0.6931471805599453,
-                               unseen = -2.3978952727983707,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("number (0..16)jour (grain)", -1.2039728043259361),
-                                    ("day", -1.2039728043259361)],
-                               n = 2}}),
-       ("intersect",
-        Classifier{okData =
-                     ClassData{prior = -0.2911008792005665,
-                               unseen = -6.9440872082295275,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("apr\232s <time-of-day>named-month", -5.844510134151319),
-                                    ("<day-of-month> <named-month><dim time> <part-of-day>",
-                                     -5.844510134151319),
-                                    ("intersect<dim time> du matin", -5.844510134151319),
-                                    ("<hour-of-day> <integer> (as relative minutes)intersect",
-                                     -5.844510134151319),
-                                    ("hh(:|h)mm (time-of-day)named-day", -5.844510134151319),
-                                    ("demain<time-of-day> heures", -5.844510134151319),
-                                    ("hourday", -4.640537329825383),
-                                    ("<day-of-month> <named-month>year", -5.556828061699537),
-                                    ("dayhour", -1.6960983506589422),
-                                    ("daymonth", -3.0719214119115374),
-                                    ("monthyear", -4.745897845483209),
-                                    ("dernier <cycle> de <time> (latent)year", -5.333684510385328),
-                                    ("named-month<dim time> du matin", -5.844510134151319),
-                                    ("<day-of-month> <named-month>\224|vers <time-of-day>",
-                                     -4.109909078763212),
-                                    ("dd mmyear", -4.997212273764115),
-                                    ("le <day-of-month> (non ordinal)<dim time> du matin",
-                                     -5.844510134151319),
-                                    ("hh(:|h)mm (time-of-day)<day-of-week> <day-of-month>",
-                                     -6.249975242259483),
-                                    ("named-month\224|vers <time-of-day>", -4.997212273764115),
-                                    ("named-dayday of month (premier)", -5.556828061699537),
-                                    ("<time-of-day> heuresdu|dans le <part-of-day>",
-                                     -4.745897845483209),
-                                    ("<hour-of-day> et quart<dim time> <part-of-day>",
-                                     -5.556828061699537),
-                                    ("<day-of-week> <day-of-month>named-month", -5.556828061699537),
-                                    ("le <time>du|dans le <part-of-day>", -5.333684510385328),
-                                    ("\224|vers <time-of-day>ce <part-of-day>", -5.556828061699537),
-                                    ("le <day-of-month> (non ordinal)<dim time> du soir",
-                                     -4.997212273764115),
-                                    ("entre <datetime> et <datetime> (interval)named-day",
-                                     -5.844510134151319),
-                                    ("<hour-of-day> et demice <part-of-day>", -5.556828061699537),
-                                    ("le <day-of-month> (non ordinal)<time-of-day> heures",
-                                     -4.640537329825383),
-                                    ("<hour-of-day> <integer> (as relative minutes)<day-of-week> <day-of-month>",
-                                     -6.249975242259483),
-                                    ("le <day-of-month> (non ordinal)named-month",
-                                     -4.2350722217172185),
-                                    ("monthhour", -4.1705337005796475),
-                                    ("le <time><time-of-day> heures", -5.151362953591374),
-                                    ("hourmonth", -5.333684510385328),
-                                    ("<time-of-day> heuresle <time>", -5.333684510385328),
-                                    ("dayday", -3.898599985096005),
-                                    ("aujourd'hui<hour-of-day> <integer> (as relative minutes)",
-                                     -5.556828061699537),
-                                    ("apr\232s <time-of-day>named-day", -5.844510134151319),
-                                    ("named-dayle <cycle> prochain|suivant|d'apr\232s",
-                                     -4.863680881139593),
-                                    ("named-dayapr\232s <time-of-day>", -5.556828061699537),
-                                    ("hourhour", -3.2295503561151206),
-                                    ("<day-of-week> <day-of-month>\224|vers <time-of-day>",
-                                     -4.5452271500210575),
-                                    ("le <time>intersect", -5.556828061699537),
-                                    ("\224|vers <time-of-day><dim time> <part-of-day>",
-                                     -6.249975242259483),
-                                    ("<time-of-day> heuresintersect", -5.844510134151319),
-                                    ("intersectnamed-month", -4.997212273764115),
-                                    ("intersect<time-of-day> heures", -5.556828061699537),
-                                    ("<hour-of-day> et quartce <part-of-day>", -5.556828061699537),
-                                    ("dayyear", -3.8520799694611125),
-                                    ("named-dayce|dans le <cycle>", -5.556828061699537),
-                                    ("apr\232s-demain\224|vers <time-of-day>", -5.333684510385328),
-                                    ("le <ordinal> <cycle> de <time>year", -6.249975242259483),
-                                    ("demain\224|vers <time-of-day>", -5.333684510385328),
-                                    ("le <day-of-month> (non ordinal)intersect",
-                                     -3.6472855568150995),
-                                    ("hourminute", -6.249975242259483),
-                                    ("dd-dd <month>(interval)year", -6.249975242259483),
-                                    ("intersect<day-of-month> <named-month>", -5.844510134151319),
-                                    ("minutemonth", -5.844510134151319),
-                                    ("\224|vers <time-of-day>demain", -6.249975242259483),
-                                    ("minutehour", -4.378173065357892),
-                                    ("named-daydu|dans le <part-of-day>", -5.556828061699537),
-                                    ("named-monthyear", -4.745897845483209),
-                                    ("entre <datetime> et <datetime> (interval)named-month",
-                                     -6.249975242259483),
-                                    ("intersectdu|dans le <part-of-day>", -3.898599985096005),
-                                    ("le <day-of-month> \224 <datetime>du|dans le <part-of-day>",
-                                     -5.844510134151319),
-                                    ("named-month<dim time> <part-of-day>", -5.844510134151319),
-                                    ("le <day-of-month> (non ordinal)apr\232s <time-of-day>",
-                                     -6.249975242259483),
-                                    ("named-day<day-of-month> <named-month>", -5.556828061699537),
-                                    ("named-dayle <time>", -4.109909078763212),
-                                    ("le <day-of-month> (non ordinal)<dim time> <part-of-day>",
-                                     -4.5452271500210575),
-                                    ("dd/-mm<time-of-day> heures", -5.844510134151319),
-                                    ("de <datetime> - <datetime> (interval)named-month",
-                                     -5.844510134151319),
-                                    ("apr\232s <time-of-day>le <time>", -5.844510134151319),
-                                    ("named-day<time-of-day> heures", -5.556828061699537),
-                                    ("<hour-of-day> et quartdemain", -5.556828061699537),
-                                    ("<time-of-day> heuresce <time>", -6.249975242259483),
-                                    ("<day-of-month> <named-month>du|dans le <part-of-day>",
-                                     -5.844510134151319),
-                                    ("named-dayintersect", -6.249975242259483),
-                                    ("le <time><dim time> du matin", -5.844510134151319),
-                                    ("apr\232s <time-of-day>intersect", -6.249975242259483),
-                                    ("le <day-of-month> (non ordinal)\224|vers <time-of-day>",
-                                     -4.304065093204169),
-                                    ("hierdu|dans le <part-of-day>", -6.249975242259483),
-                                    ("intersect<dim time> <part-of-day>", -5.844510134151319),
-                                    ("dayminute", -4.745897845483209),
-                                    ("<ordinal> <cycle> de <time>year", -5.844510134151319),
-                                    ("le <time>\224|vers <time-of-day>", -4.5452271500210575),
-                                    ("<day-of-month> <named-month><dim time> du matin",
-                                     -5.844510134151319),
-                                    ("intersectyear", -5.556828061699537),
-                                    ("<day-of-week> <day-of-month><time-of-day> heures",
-                                     -5.151362953591374),
-                                    ("minuteday", -3.279560776689782),
-                                    ("<datetime> - <datetime> (interval)named-month",
-                                     -4.997212273764115),
-                                    ("<day-of-month> <named-month><time-of-day> heures",
-                                     -4.745897845483209),
-                                    ("aujourd'hui\224|vers <time-of-day>", -5.333684510385328),
-                                    ("day of month (premier)intersect", -6.249975242259483),
-                                    ("entre <time-of-day> et <time-of-day> (interval)named-day",
-                                     -5.844510134151319),
-                                    ("named-day<named-month|named-day> suivant|d'apr\232s",
-                                     -5.333684510385328),
-                                    ("<dim time> <part-of-day>apr\232s <time-of-day>",
-                                     -6.249975242259483),
-                                    ("named-month<time-of-day> heures", -5.556828061699537),
-                                    ("<time-of-day> heuresce <part-of-day>", -5.556828061699537),
-                                    ("le <time>named-month", -5.151362953591374),
-                                    ("apr\232s le <day-of-month>named-month", -6.249975242259483),
-                                    ("\224|vers <time-of-day>du|dans le <part-of-day>",
-                                     -5.151362953591374),
-                                    ("intersectintersect", -5.844510134151319),
-                                    ("de <time-of-day> - <time-of-day> (interval)named-day",
-                                     -5.333684510385328),
-                                    ("de <datetime> - <datetime> (interval)named-day",
-                                     -5.844510134151319),
-                                    ("named-dayde <time-of-day> - <time-of-day> (interval)",
-                                     -5.844510134151319),
-                                    ("dayweek", -4.052750664923264),
-                                    ("weekyear", -4.863680881139593),
-                                    ("<hour-of-day> <integer> (as relative minutes)named-day",
-                                     -5.844510134151319),
-                                    ("hh(:|h)mm (time-of-day)intersect", -5.844510134151319),
-                                    ("named-monthintersect", -5.844510134151319),
-                                    ("dd/-mm\224|vers <time-of-day>", -5.333684510385328),
-                                    ("day of month (premier)named-month", -4.5452271500210575),
-                                    ("named-day\224|vers <time-of-day>", -4.863680881139593),
-                                    ("<day-of-month> <named-month>intersect", -5.844510134151319),
-                                    ("intersect\224|vers <time-of-day>", -4.997212273764115),
-                                    ("le <time>year", -4.745897845483209),
-                                    ("le <time><dim time> <part-of-day>", -5.844510134151319),
-                                    ("<time-of-day> - <time-of-day> (interval)named-day",
-                                     -4.997212273764115),
-                                    ("apr\232s-demain<time-of-day> heures", -5.844510134151319),
-                                    ("<datetime> - <datetime> (interval)named-day",
-                                     -5.333684510385328)],
-                               n = 438},
-                   koData =
-                     ClassData{prior = -1.3761075158128977, unseen = -6.124683390894205,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("<hour-of-day> <integer> (as relative minutes)intersect",
-                                     -5.429345628954441),
-                                    ("hh(:|h)mm (time-of-day)named-day", -5.429345628954441),
-                                    ("year<time-of-day> - <time-of-day> (interval)",
-                                     -4.736198448394496),
-                                    ("demain<time-of-day> heures", -4.736198448394496),
-                                    ("hourday", -3.2321210516182215),
-                                    ("<day-of-month> <named-month>year", -5.429345628954441),
-                                    ("demainavant <time-of-day>", -5.429345628954441),
-                                    ("dayhour", -2.4336133554004498),
-                                    ("le lendemain du <time>named-month", -5.429345628954441),
-                                    ("daymonth", -3.8199077165203406),
-                                    ("monthday", -5.429345628954441),
-                                    ("monthyear", -4.736198448394496),
-                                    ("yearhour", -4.736198448394496),
-                                    ("houryear", -5.0238805208462765),
-                                    ("aujourd'hui<time-of-day> heures", -5.429345628954441),
-                                    ("named-month\224|vers <time-of-day>", -3.724597536716016),
-                                    ("<time-of-day> heuresdu|dans le <part-of-day>",
-                                     -4.736198448394496),
-                                    ("<day-of-week> <day-of-month>named-month", -4.04305126783455),
-                                    ("le <time>du|dans le <part-of-day>", -5.0238805208462765),
-                                    ("le <day-of-month> (non ordinal)<hour-of-day> <integer> (as relative minutes)",
-                                     -4.736198448394496),
-                                    ("named-month<day-of-month> <named-month>", -5.429345628954441),
-                                    ("<time-of-day> heuresle <day-of-month> (non ordinal)",
-                                     -5.0238805208462765),
-                                    ("le <day-of-month> (non ordinal)<time-of-day> heures",
-                                     -5.429345628954441),
-                                    ("aujourd'huidu|dans le <part-of-day>", -5.0238805208462765),
-                                    ("le <day-of-month> (non ordinal)named-month",
-                                     -5.429345628954441),
-                                    ("monthhour", -3.2321210516182215),
-                                    ("hourmonth", -4.176582660459073),
-                                    ("dayday", -3.6375861597263857),
-                                    ("named-dayapr\232s <time-of-day>", -5.0238805208462765),
-                                    ("hourhour", -3.8199077165203406),
-                                    ("named-day<hour-of-day> <integer> (as relative minutes)",
-                                     -5.0238805208462765),
-                                    ("dayyear", -4.176582660459073),
-                                    ("le <cycle> de <time>named-month", -5.0238805208462765),
-                                    ("year<hour-of-day> <integer> (as relative minutes)",
-                                     -4.736198448394496),
-                                    ("demain\224|vers <time-of-day>", -4.513054897080286),
-                                    ("<dim time> <part-of-day><hour-of-day> <integer> (as relative minutes)",
-                                     -5.0238805208462765),
-                                    ("hourminute", -5.0238805208462765),
-                                    ("minutemonth", -4.736198448394496),
-                                    ("named-monthyear", -4.736198448394496),
-                                    ("intersect by 'de' or ','year", -5.0238805208462765),
-                                    ("named-day<time-of-day> - <time-of-day> (interval)",
-                                     -3.724597536716016),
-                                    ("named-day<datetime> - <datetime> (interval)",
-                                     -5.0238805208462765),
-                                    ("named-day<day-of-month> <named-month>", -4.04305126783455),
-                                    ("weekmonth", -5.0238805208462765),
-                                    ("named-dayle <time>", -5.0238805208462765),
-                                    ("avant <time-of-day>named-day", -5.429345628954441),
-                                    ("de <datetime> - <datetime> (interval)named-month",
-                                     -5.429345628954441),
-                                    ("le <day-of-month> (non ordinal)year", -5.0238805208462765),
-                                    ("named-day<time-of-day> heures", -5.429345628954441),
-                                    ("<time-of-day> heuresnamed-day", -3.925268232178167),
-                                    ("apr\232s <time-of-day><time-of-day> heures",
-                                     -5.0238805208462765),
-                                    ("<time-of-day> heuresdd/-mm", -5.429345628954441),
-                                    ("<time-of-day> - <time-of-day> (interval)du|dans le <part-of-day>",
-                                     -5.0238805208462765),
-                                    ("<hour-of-day> <integer> (as relative minutes)named-month",
-                                     -5.0238805208462765),
-                                    ("le <day-of-month> (non ordinal)\224|vers <time-of-day>",
-                                     -4.736198448394496),
-                                    ("dayminute", -4.330733340286331),
-                                    ("named-monthdu|dans le <part-of-day>", -5.0238805208462765),
-                                    ("intersectyear", -5.0238805208462765),
-                                    ("minuteday", -4.736198448394496),
-                                    ("aujourd'hui\224|vers <time-of-day>", -4.736198448394496),
-                                    ("<datetime>-dd <month>(interval)year", -5.0238805208462765),
-                                    ("<time-of-day> - <time-of-day> (interval)named-month",
-                                     -4.513054897080286),
-                                    ("le <day-of-month> (non ordinal)avant <time-of-day>",
-                                     -5.429345628954441),
-                                    ("<dim time> <part-of-day>apr\232s <time-of-day>",
-                                     -5.429345628954441),
-                                    ("named-month<time-of-day> heures", -4.330733340286331),
-                                    ("demainapr\232s <time-of-day>", -5.429345628954441),
-                                    ("<hour-of-day> <integer> (as relative minutes)named-day",
-                                     -5.0238805208462765),
-                                    ("<hour-of-day> <integer> (as relative minutes)year",
-                                     -4.513054897080286),
-                                    ("<time-of-day> - <time-of-day> (interval)intersect",
-                                     -5.429345628954441),
-                                    ("apr\232s <time-of-day>\224|vers <time-of-day>",
-                                     -4.513054897080286),
-                                    ("\224|vers <time-of-day>named-day", -4.736198448394496),
-                                    ("le <time>year", -5.0238805208462765),
-                                    ("apr\232s <time-of-day>le <day-of-month> (non ordinal)",
-                                     -5.429345628954441),
-                                    ("de <datetime> - <datetime> (interval)<day-of-month> <named-month>",
-                                     -5.429345628954441),
-                                    ("minuteyear", -4.04305126783455),
-                                    ("yearminute", -4.736198448394496),
-                                    ("<dim time> <part-of-day><time-of-day> heures",
-                                     -5.429345628954441)],
-                               n = 148}}),
-       ("season",
-        Classifier{okData =
-                     ClassData{prior = 0.0, unseen = -1.3862943611198906,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 2},
-                   koData =
-                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
-                               likelihoods = HashMap.fromList [], n = 0}}),
-       ("ce <day-of-week>",
-        Classifier{okData =
-                     ClassData{prior = 0.0, unseen = -1.6094379124341003,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("day", -0.6931471805599453),
-                                    ("named-day", -0.6931471805599453)],
-                               n = 1},
-                   koData =
-                     ClassData{prior = -infinity, unseen = -1.0986122886681098,
-                               likelihoods = HashMap.fromList [], n = 0}}),
-       ("le <cycle> de <time>",
-        Classifier{okData =
-                     ClassData{prior = -0.8472978603872037, unseen = -2.70805020110221,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("monthmonth", -1.9459101490553135),
-                                    ("mois (grain)named-month", -1.9459101490553135),
-                                    ("weekday", -1.540445040947149),
-                                    ("semaine (grain)<day-of-month> <named-month>",
-                                     -1.540445040947149)],
-                               n = 3},
-                   koData =
-                     ClassData{prior = -0.5596157879354228, unseen = -2.833213344056216,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("semaine (grain)year (latent)", -1.6739764335716716),
-                                    ("weekhour", -1.6739764335716716),
-                                    ("semaine (grain)time-of-day (latent)", -1.6739764335716716),
-                                    ("weekyear", -1.6739764335716716)],
-                               n = 4}}),
-       ("<hour-of-day> et trois quarts",
-        Classifier{okData =
-                     ClassData{prior = 0.0, unseen = -1.6094379124341003,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("hour", -0.6931471805599453),
-                                    ("<time-of-day> heures", -0.6931471805599453)],
-                               n = 1},
-                   koData =
-                     ClassData{prior = -infinity, unseen = -1.0986122886681098,
-                               likelihoods = HashMap.fromList [], n = 0}}),
-       ("le <day-of-month> \224 <datetime>",
-        Classifier{okData =
-                     ClassData{prior = -0.325422400434628, unseen = -3.58351893845611,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("integer (numeric)<time-of-day> heures", -1.9459101490553135),
-                                    ("integer (numeric)<dim time> du soir", -2.8622008809294686),
-                                    ("integer (numeric)intersect", -2.456735772821304),
-                                    ("integer (numeric)<dim time> du matin", -2.8622008809294686),
-                                    ("hour", -0.916290731874155),
-                                    ("integer (numeric)time-of-day (latent)", -2.169053700369523),
-                                    ("integer (numeric)<dim time> <part-of-day>",
-                                     -2.456735772821304)],
-                               n = 13},
-                   koData =
-                     ClassData{prior = -1.2809338454620642, unseen = -2.995732273553991,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("integer (numeric)year (latent)", -1.3350010667323402),
-                                    ("year", -1.3350010667323402), ("hour", -2.2512917986064953),
-                                    ("integer (numeric)time-of-day (latent)", -2.2512917986064953)],
-                               n = 5}}),
-       ("yyyy-mm-dd",
-        Classifier{okData =
-                     ClassData{prior = 0.0, unseen = -1.6094379124341003,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 3},
-                   koData =
-                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
-                               likelihoods = HashMap.fromList [], n = 0}}),
-       ("le <cycle> dernier",
-        Classifier{okData =
-                     ClassData{prior = 0.0, unseen = -2.70805020110221,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("week", -1.540445040947149),
-                                    ("ann\233e (grain)", -1.9459101490553135),
-                                    ("semaine (grain)", -1.540445040947149),
-                                    ("mois (grain)", -1.9459101490553135),
-                                    ("year", -1.9459101490553135), ("month", -1.9459101490553135)],
-                               n = 4},
-                   koData =
-                     ClassData{prior = -infinity, unseen = -1.9459101490553135,
-                               likelihoods = HashMap.fromList [], n = 0}}),
-       ("year (latent)",
-        Classifier{okData =
-                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
-                               likelihoods = HashMap.fromList [], n = 0},
-                   koData =
-                     ClassData{prior = 0.0, unseen = -3.044522437723423,
-                               likelihoods = HashMap.fromList [("integer (numeric)", 0.0)],
-                               n = 19}}),
-       ("soir de no\235l",
-        Classifier{okData =
-                     ClassData{prior = 0.0, unseen = -1.0986122886681098,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 1},
-                   koData =
-                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
-                               likelihoods = HashMap.fromList [], n = 0}}),
-       ("fin de journ\233e",
-        Classifier{okData =
-                     ClassData{prior = 0.0, unseen = -1.0986122886681098,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 1},
-                   koData =
-                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
-                               likelihoods = HashMap.fromList [], n = 0}}),
-       ("du <datetime>-<day-of-week> dd <month>(interval)",
-        Classifier{okData =
-                     ClassData{prior = -0.5108256237659907, unseen = -2.70805020110221,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("intersectnamed-daynamed-month", -1.9459101490553135),
-                                    ("day of month (premier)named-daynamed-month",
-                                     -1.9459101490553135),
-                                    ("<day-of-week> <day-of-month>named-daynamed-month",
-                                     -1.9459101490553135),
-                                    ("daydaymonth", -1.252762968495368)],
-                               n = 3},
-                   koData =
-                     ClassData{prior = -0.916290731874155, unseen = -2.5649493574615367,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("year (latent)named-daynamed-month", -1.791759469228055),
-                                    ("hourdaymonth", -1.791759469228055),
-                                    ("time-of-day (latent)named-daynamed-month",
-                                     -1.791759469228055),
-                                    ("yeardaymonth", -1.791759469228055)],
-                               n = 2}}),
-       ("milieu de semaine",
-        Classifier{okData =
-                     ClassData{prior = 0.0, unseen = -1.0986122886681098,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 1},
-                   koData =
-                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
-                               likelihoods = HashMap.fromList [], n = 0}}),
-       ("noel",
-        Classifier{okData =
-                     ClassData{prior = -0.2876820724517809,
-                               unseen = -1.6094379124341003,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 3},
-                   koData =
-                     ClassData{prior = -1.3862943611198906,
-                               unseen = -1.0986122886681098,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 1}}),
-       ("fin de matin\233e",
-        Classifier{okData =
-                     ClassData{prior = 0.0, unseen = -1.0986122886681098,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 1},
-                   koData =
-                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
-                               likelihoods = HashMap.fromList [], n = 0}}),
-       ("le <day-of-month> (non ordinal)",
-        Classifier{okData =
-                     ClassData{prior = -0.4228568508200336, unseen = -3.713572066704308,
-                               likelihoods =
-                                 HashMap.fromList [("integer (numeric)", -2.5317807984289897e-2)],
-                               n = 38},
-                   koData =
-                     ClassData{prior = -1.0647107369924282,
-                               unseen = -3.1354942159291497,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("integer (numeric)", -0.2578291093020998),
-                                    ("numbers 22..29 32..39 .. 52..59", -1.4816045409242156)],
-                               n = 20}}),
-       ("du dd-<day-of-week> dd <month>(interval)",
-        Classifier{okData =
-                     ClassData{prior = 0.0, unseen = -1.6094379124341003,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("named-daynamed-month", -0.6931471805599453),
-                                    ("daymonth", -0.6931471805599453)],
-                               n = 1},
-                   koData =
-                     ClassData{prior = -infinity, unseen = -1.0986122886681098,
-                               likelihoods = HashMap.fromList [], n = 0}}),
-       ("en semaine",
-        Classifier{okData =
-                     ClassData{prior = -1.1856236656577395,
-                               unseen = -2.5649493574615367,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 11},
-                   koData =
-                     ClassData{prior = -0.3646431135879093, unseen = -3.295836866004329,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 25}}),
-       ("numbers 22..29 32..39 .. 52..59",
-        Classifier{okData =
-                     ClassData{prior = -2.3025850929940455,
-                               unseen = -1.6094379124341003,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("number (20..60)number (0..16)", -0.6931471805599453)],
-                               n = 1},
-                   koData =
-                     ClassData{prior = -0.10536051565782628,
-                               unseen = -2.5649493574615367,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("integer (numeric)integer (numeric)", -0.2876820724517809),
-                                    ("integer (numeric)number (0..16)", -1.791759469228055)],
-                               n = 9}}),
-       ("<day-of-week> prochain",
-        Classifier{okData =
-                     ClassData{prior = 0.0, unseen = -2.1972245773362196,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("day", -0.6931471805599453),
-                                    ("named-day", -0.6931471805599453)],
-                               n = 3},
-                   koData =
-                     ClassData{prior = -infinity, unseen = -1.0986122886681098,
-                               likelihoods = HashMap.fromList [], n = 0}}),
-       ("intersect by 'de' or ','",
-        Classifier{okData =
-                     ClassData{prior = -0.2719337154836418, unseen = -4.394449154672439,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("dayhour", -3.283414346005772),
-                                    ("hourmonth", -3.6888794541139363),
-                                    ("dayday", -1.742969305058623),
-                                    ("named-dayle <cycle> prochain|suivant|d'apr\232s",
-                                     -2.3025850929940455),
-                                    ("named-day<time-of-day> - <time-of-day> (interval)",
-                                     -3.283414346005772),
-                                    ("named-dayle <time>", -1.491654876777717),
-                                    ("named-dayle <cycle> dernier", -3.6888794541139363),
-                                    ("named-day<named-month|named-day> suivant|d'apr\232s",
-                                     -2.772588722239781),
-                                    ("week-endnamed-month", -3.6888794541139363),
-                                    ("dayweek", -1.5488132906176655)],
-                               n = 32},
-                   koData =
-                     ClassData{prior = -1.4350845252893227,
-                               unseen = -3.6109179126442243,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("hourday", -2.890371757896165),
-                                    ("dayhour", -2.890371757896165),
-                                    ("daymonth", -1.9740810260220096),
-                                    ("du|dans le <part-of-day>noel", -2.890371757896165),
-                                    ("en semainenamed-month", -2.4849066497880004),
-                                    ("hourmonth", -2.4849066497880004),
-                                    ("dayday", -2.4849066497880004),
-                                    ("en semaineintersect", -2.4849066497880004),
-                                    ("named-dayle <time>", -2.4849066497880004),
-                                    ("named-day<time-of-day> heures", -2.890371757896165),
-                                    ("week-endnamed-month", -2.4849066497880004)],
-                               n = 10}}),
-       ("named-month",
-        Classifier{okData =
-                     ClassData{prior = 0.0, unseen = -4.499809670330265,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 88},
-                   koData =
-                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
-                               likelihoods = HashMap.fromList [], n = 0}}),
-       ("ce <part-of-day>",
-        Classifier{okData =
-                     ClassData{prior = 0.0, unseen = -2.772588722239781,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("soir", -1.6094379124341003),
-                                    ("apr\232s-midi", -1.0986122886681098),
-                                    ("hour", -0.7621400520468967)],
-                               n = 6},
-                   koData =
-                     ClassData{prior = -infinity, unseen = -1.3862943611198906,
-                               likelihoods = HashMap.fromList [], n = 0}}),
-       ("hh(:|h)mm (time-of-day)",
-        Classifier{okData =
-                     ClassData{prior = 0.0, unseen = -3.258096538021482,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 24},
-                   koData =
-                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
-                               likelihoods = HashMap.fromList [], n = 0}}),
-       ("number (20..60)",
-        Classifier{okData =
-                     ClassData{prior = 0.0, unseen = -1.791759469228055,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 4},
-                   koData =
-                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
-                               likelihoods = HashMap.fromList [], n = 0}}),
-       ("hier",
-        Classifier{okData =
-                     ClassData{prior = -0.2231435513142097, unseen = -1.791759469228055,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 4},
-                   koData =
-                     ClassData{prior = -1.6094379124341003,
-                               unseen = -1.0986122886681098,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 1}}),
-       ("numbers prefix with -, negative or minus",
-        Classifier{okData =
-                     ClassData{prior = -infinity, unseen = -1.3862943611198906,
-                               likelihoods = HashMap.fromList [], n = 0},
-                   koData =
-                     ClassData{prior = 0.0, unseen = -2.833213344056216,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("integer (numeric)", -0.2876820724517809),
-                                    ("numbers 22..29 32..39 .. 52..59", -2.0794415416798357),
-                                    ("number (0..16)", -2.0794415416798357)],
-                               n = 13}}),
-       ("dd-dd <month>(interval)",
-        Classifier{okData =
-                     ClassData{prior = 0.0, unseen = -2.3978952727983707,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("named-month", -0.6931471805599453),
-                                    ("month", -0.6931471805599453)],
-                               n = 4},
-                   koData =
-                     ClassData{prior = -infinity, unseen = -1.0986122886681098,
-                               likelihoods = HashMap.fromList [], n = 0}}),
-       ("<datetime>-<day-of-week> dd <month>(interval)",
-        Classifier{okData =
-                     ClassData{prior = -0.6931471805599453,
-                               unseen = -3.2188758248682006,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("intersectnamed-daynamed-month", -2.0794415416798357),
-                                    ("day of month (premier)named-daynamed-month",
-                                     -1.791759469228055),
-                                    ("<day-of-week> <day-of-month>named-daynamed-month",
-                                     -1.791759469228055),
-                                    ("daydaymonth", -0.9808292530117262)],
-                               n = 8},
-                   koData =
-                     ClassData{prior = -0.6931471805599453,
-                               unseen = -3.2188758248682006,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("year (latent)named-daynamed-month", -1.5686159179138452),
-                                    ("hourdaymonth", -1.5686159179138452),
-                                    ("time-of-day (latent)named-daynamed-month",
-                                     -1.5686159179138452),
-                                    ("yeardaymonth", -1.5686159179138452)],
-                               n = 8}}),
-       ("<dim time> du soir",
-        Classifier{okData =
-                     ClassData{prior = -0.2231435513142097, unseen = -2.995732273553991,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("\224|vers <time-of-day>", -1.55814461804655),
-                                    ("hour", -0.7472144018302211),
-                                    ("<time-of-day> heures", -1.1526795099383855)],
-                               n = 8},
-                   koData =
-                     ClassData{prior = -1.6094379124341003,
-                               unseen = -2.0794415416798357,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("hour", -0.8472978603872037),
-                                    ("<time-of-day> heures", -0.8472978603872037)],
-                               n = 2}}),
-       ("aujourd'hui",
-        Classifier{okData =
-                     ClassData{prior = 0.0, unseen = -2.639057329615259,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 12},
-                   koData =
-                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
-                               likelihoods = HashMap.fromList [], n = 0}}),
-       ("midi",
-        Classifier{okData =
-                     ClassData{prior = -0.7375989431307791,
-                               unseen = -2.5649493574615367,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 11},
-                   koData =
-                     ClassData{prior = -0.6505875661411494, unseen = -2.639057329615259,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 12}}),
-       ("toussaint",
-        Classifier{okData =
-                     ClassData{prior = 0.0, unseen = -1.9459101490553135,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 5},
-                   koData =
-                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
-                               likelihoods = HashMap.fromList [], n = 0}}),
-       ("d\233but de soir\233e",
-        Classifier{okData =
-                     ClassData{prior = 0.0, unseen = -1.0986122886681098,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 1},
-                   koData =
-                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
-                               likelihoods = HashMap.fromList [], n = 0}}),
-       ("<day-of-week> <day-of-month>",
-        Classifier{okData =
-                     ClassData{prior = -0.24512245803298496,
-                               unseen = -3.6888794541139363,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("named-daynumber (0..16)", -2.5649493574615367),
-                                    ("named-dayinteger (numeric)", -0.8303483020734304),
-                                    ("day", -0.719122666963206)],
-                               n = 18},
-                   koData =
-                     ClassData{prior = -1.5260563034950494, unseen = -2.639057329615259,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("named-dayinteger (numeric)", -0.7731898882334817),
-                                    ("day", -0.7731898882334817)],
-                               n = 5}}),
-       ("d'ici <duration>",
-        Classifier{okData =
-                     ClassData{prior = 0.0, unseen = -2.0794415416798357,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("week", -1.252762968495368), ("day", -1.252762968495368),
-                                    ("<integer> <unit-of-duration>", -0.8472978603872037)],
-                               n = 2},
-                   koData =
-                     ClassData{prior = -infinity, unseen = -1.3862943611198906,
-                               likelihoods = HashMap.fromList [], n = 0}}),
-       ("\224|vers <time-of-day>",
-        Classifier{okData =
-                     ClassData{prior = -0.21936282847430377,
-                               unseen = -5.420534999272286,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("<time> timezone", -4.722953221644475),
-                                    ("<hour-of-day> et|pass\233 de <number>", -4.31748811353631),
-                                    ("hh(:|h)mm (time-of-day)", -4.722953221644475),
-                                    ("midi", -4.31748811353631),
-                                    ("time-of-day (latent)", -1.587459005715325),
-                                    ("<hour-of-day> et|pass\233 de <number> minutes",
-                                     -4.31748811353631),
-                                    ("minuit", -4.722953221644475),
-                                    ("<hour-of-day> et quart", -4.31748811353631),
-                                    ("hour", -0.8622235106038793),
-                                    ("<hour-of-day> et demi", -4.722953221644475),
-                                    ("minute", -2.8511510447428834),
-                                    ("<time-of-day> heures", -1.587459005715325),
-                                    ("<hour-of-day> <integer> (as relative minutes)",
-                                     -3.8066624897703196)],
-                               n = 106},
-                   koData =
-                     ClassData{prior = -1.6247053845648889, unseen = -4.189654742026425,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("hh(:|h)mm (time-of-day)", -3.0757749812275272),
-                                    ("time-of-day (latent)", -1.5353299402803784),
-                                    ("hour", -1.0388930539664873), ("minute", -2.5649493574615367),
-                                    ("<time-of-day> heures", -1.8718021769015913),
-                                    ("<hour-of-day> <integer> (as relative minutes)",
-                                     -3.0757749812275272)],
-                               n = 26}}),
-       ("d\233but <named-month>(interval)",
-        Classifier{okData =
-                     ClassData{prior = 0.0, unseen = -2.3978952727983707,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("named-month", -0.6931471805599453),
-                                    ("month", -0.6931471805599453)],
-                               n = 4},
-                   koData =
-                     ClassData{prior = -infinity, unseen = -1.0986122886681098,
-                               likelihoods = HashMap.fromList [], n = 0}}),
-       ("d\233but de matin\233e",
-        Classifier{okData =
-                     ClassData{prior = 0.0, unseen = -1.9459101490553135,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 5},
-                   koData =
-                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
-                               likelihoods = HashMap.fromList [], n = 0}}),
-       ("apr\232s-midi",
-        Classifier{okData =
-                     ClassData{prior = 0.0, unseen = -2.3025850929940455,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 8},
-                   koData =
-                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
-                               likelihoods = HashMap.fromList [], n = 0}}),
-       ("le <ordinal> <cycle> de <time>",
-        Classifier{okData =
-                     ClassData{prior = 0.0, unseen = -2.4849066497880004,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("daymonth", -1.7047480922384253),
-                                    ("ordinals (premier..seizieme)semaine (grain)named-month",
-                                     -1.7047480922384253),
-                                    ("ordinal (digits)jour (grain)named-month",
-                                     -1.7047480922384253),
-                                    ("weekmonth", -1.2992829841302609),
-                                    ("ordinals (premier..seizieme)semaine (grain)intersect",
-                                     -1.7047480922384253)],
-                               n = 3},
-                   koData =
-                     ClassData{prior = -infinity, unseen = -1.791759469228055,
-                               likelihoods = HashMap.fromList [], n = 0}}),
-       ("ordinals (premier..seizieme)",
-        Classifier{okData =
-                     ClassData{prior = -0.916290731874155, unseen = -1.791759469228055,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 4},
-                   koData =
-                     ClassData{prior = -0.5108256237659907,
-                               unseen = -2.0794415416798357,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 6}}),
-       ("minute (grain)",
-        Classifier{okData =
-                     ClassData{prior = -0.2876820724517809,
-                               unseen = -2.3978952727983707,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 9},
-                   koData =
-                     ClassData{prior = -1.3862943611198906,
-                               unseen = -1.6094379124341003,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 3}}),
-       ("deuxi\232me quinzaine de <named-month>(interval)",
-        Classifier{okData =
-                     ClassData{prior = 0.0, unseen = -1.6094379124341003,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("named-month", -0.6931471805599453),
-                                    ("month", -0.6931471805599453)],
-                               n = 1},
-                   koData =
-                     ClassData{prior = -infinity, unseen = -1.0986122886681098,
-                               likelihoods = HashMap.fromList [], n = 0}}),
-       ("<dim time> <part-of-day>",
-        Classifier{okData =
-                     ClassData{prior = -0.13858616328614667,
-                               unseen = -5.181783550292085,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("dayhour", -1.9980959022258835),
-                                    ("<time-of-day> heuresdu|dans le <part-of-day>",
-                                     -2.9789251552376097),
-                                    ("le <time>du|dans le <part-of-day>", -3.5667118201397288),
-                                    ("\224|vers <time-of-day>ce <part-of-day>",
-                                     -3.7898553714539385),
-                                    ("named-daymatin", -4.07753744390572),
-                                    ("demainsoir", -4.483002552013883),
-                                    ("<hour-of-day> et demice <part-of-day>", -3.7898553714539385),
-                                    ("hourhour", -1.4872702784598928),
-                                    ("aujourd'huiau d\233jeuner", -4.483002552013883),
-                                    ("<hour-of-day> et quartce <part-of-day>", -3.7898553714539385),
-                                    ("demainapr\232s-midi", -4.483002552013883),
-                                    ("minutehour", -2.6112003751122925),
-                                    ("named-daydu|dans le <part-of-day>", -3.7898553714539385),
-                                    ("intersectdu|dans le <part-of-day>", -2.1316272948504063),
-                                    ("le <day-of-month> \224 <datetime>du|dans le <part-of-day>",
-                                     -4.07753744390572),
-                                    ("named-dayfin d'apr\232s-midi", -4.483002552013883),
-                                    ("<day-of-month> <named-month>du|dans le <part-of-day>",
-                                     -4.07753744390572),
-                                    ("hierdu|dans le <part-of-day>", -4.483002552013883),
-                                    ("named-daysoir", -4.483002552013883),
-                                    ("aujourd'huid\233but de matin\233e", -3.5667118201397288),
-                                    ("<time-of-day> heuresce <part-of-day>", -3.7898553714539385),
-                                    ("\224|vers <time-of-day>du|dans le <part-of-day>",
-                                     -3.3843902633457743),
-                                    ("named-dayapr\232s-midi", -4.483002552013883),
-                                    ("intersectapr\232s-midi", -3.5667118201397288),
-                                    ("hiersoir", -4.483002552013883)],
-                               n = 74},
-                   koData =
-                     ClassData{prior = -2.044755983691946, unseen = -3.951243718581427,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("dayhour", -2.833213344056216),
-                                    ("<time-of-day> heuresdu|dans le <part-of-day>",
-                                     -2.5455312716044354),
-                                    ("le <time>du|dans le <part-of-day>", -2.833213344056216),
-                                    ("aujourd'huidu|dans le <part-of-day>", -2.833213344056216),
-                                    ("monthhour", -2.833213344056216),
-                                    ("hourhour", -1.8523840910444898),
-                                    ("<time-of-day> - <time-of-day> (interval)du|dans le <part-of-day>",
-                                     -2.833213344056216),
-                                    ("named-monthdu|dans le <part-of-day>", -2.833213344056216)],
-                               n = 11}}),
-       ("jour de l'an",
-        Classifier{okData =
-                     ClassData{prior = 0.0, unseen = -1.3862943611198906,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 2},
-                   koData =
-                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
-                               likelihoods = HashMap.fromList [], n = 0}}),
-       ("time-of-day (latent)",
-        Classifier{okData =
-                     ClassData{prior = -0.5690945318899665, unseen = -4.553876891600541,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("integer (numeric)", -0.16126814759612226),
-                                    ("number (0..16)", -2.0583881324820035)],
-                               n = 90},
-                   koData =
-                     ClassData{prior = -0.8347976976229721, unseen = -4.304065093204169,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("integer (numeric)", -0.24740817331384096),
-                                    ("numbers 22..29 32..39 .. 52..59", -2.681021528714291),
-                                    ("number (20..60)", -3.597312260588446),
-                                    ("number (0..16)", -2.093234863812172)],
-                               n = 69}}),
-       ("apr\232s-demain",
-        Classifier{okData =
-                     ClassData{prior = 0.0, unseen = -1.6094379124341003,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 3},
-                   koData =
-                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
-                               likelihoods = HashMap.fromList [], n = 0}}),
-       ("year",
-        Classifier{okData =
-                     ClassData{prior = -0.46262352194811296,
-                               unseen = -2.9444389791664407,
-                               likelihoods = HashMap.fromList [("integer (numeric)", 0.0)],
-                               n = 17},
-                   koData =
-                     ClassData{prior = -0.9932517730102834,
-                               unseen = -2.4849066497880004,
-                               likelihoods = HashMap.fromList [("integer (numeric)", 0.0)],
-                               n = 10}}),
-       ("<hour-of-day> et|pass\233 de <number> minutes",
-        Classifier{okData =
-                     ClassData{prior = 0.0, unseen = -3.044522437723423,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("\224|vers <time-of-day>number (20..60)", -2.3025850929940455),
-                                    ("<time-of-day> heuresinteger (numeric)", -2.3025850929940455),
-                                    ("\224|vers <time-of-day>number (0..16)", -2.3025850929940455),
-                                    ("hour", -0.916290731874155),
-                                    ("<time-of-day> heuresnumber (20..60)", -1.8971199848858813),
-                                    ("<time-of-day> heuresnumber (0..16)", -1.8971199848858813)],
-                               n = 7},
-                   koData =
-                     ClassData{prior = -infinity, unseen = -1.9459101490553135,
-                               likelihoods = HashMap.fromList [], n = 0}}),
-       ("<integer> <unit-of-duration>",
-        Classifier{okData =
-                     ClassData{prior = -0.916290731874155, unseen = -4.204692619390966,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("week", -2.580216829592325),
-                                    ("number (0..16)semaine (grain)", -3.0910424533583156),
-                                    ("number (0..16)ann\233e (grain)", -3.0910424533583156),
-                                    ("number (0..16)seconde (grain)", -3.4965075614664802),
-                                    ("number (0..16)jour (grain)", -3.4965075614664802),
-                                    ("second", -3.4965075614664802),
-                                    ("integer (numeric)ann\233e (grain)", -3.4965075614664802),
-                                    ("number (0..16)minute (grain)", -3.0910424533583156),
-                                    ("integer (numeric)jour (grain)", -3.0910424533583156),
-                                    ("day", -2.803360380906535), ("year", -2.803360380906535),
-                                    ("number (0..16)mois (grain)", -3.0910424533583156),
-                                    ("hour", -2.580216829592325),
-                                    ("number (0..16)heure (grain)", -3.0910424533583156),
-                                    ("month", -3.0910424533583156),
-                                    ("integer (numeric)minute (grain)", -2.803360380906535),
-                                    ("minute", -2.3978952727983707),
-                                    ("integer (numeric)semaine (grain)", -3.0910424533583156),
-                                    ("numbers 22..29 32..39 .. 52..59heure (grain)",
-                                     -3.4965075614664802),
-                                    ("integer (numeric)heure (grain)", -3.4965075614664802)],
-                               n = 22},
-                   koData =
-                     ClassData{prior = -0.5108256237659907, unseen = -4.48863636973214,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("week", -3.784189633918261),
-                                    ("number (20..60)minute (grain)", -3.784189633918261),
-                                    ("number (0..16)jour (grain)", -3.0910424533583156),
-                                    ("integer (numeric)ann\233e (grain)", -3.784189633918261),
-                                    ("number (0..16)minute (grain)", -3.784189633918261),
-                                    ("day", -3.0910424533583156), ("year", -3.784189633918261),
-                                    ("hour", -1.2584609896100056),
-                                    ("number (0..16)heure (grain)", -1.9123874570166697),
-                                    ("month", -3.784189633918261),
-                                    ("integer (numeric)minute (grain)", -3.784189633918261),
-                                    ("integer (numeric)mois (grain)", -3.784189633918261),
-                                    ("minute", -3.0910424533583156),
-                                    ("integer (numeric)semaine (grain)", -3.784189633918261),
-                                    ("integer (numeric)heure (grain)", -1.9123874570166697)],
-                               n = 33}}),
-       ("avant-hier",
-        Classifier{okData =
-                     ClassData{prior = 0.0, unseen = -1.0986122886681098,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 1},
-                   koData =
-                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
-                               likelihoods = HashMap.fromList [], n = 0}}),
-       ("d\233but de journ\233e",
-        Classifier{okData =
-                     ClassData{prior = 0.0, unseen = -1.0986122886681098,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 1},
-                   koData =
-                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
-                               likelihoods = HashMap.fromList [], n = 0}}),
-       ("entre <time-of-day> et <time-of-day> (interval)",
-        Classifier{okData =
-                     ClassData{prior = -0.1670540846631662,
-                               unseen = -3.4011973816621555,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("hourhour", -2.6741486494265287),
-                                    ("miditime-of-day (latent)", -2.6741486494265287),
-                                    ("minutehour", -0.9694005571881036),
-                                    ("hh(:|h)mm (time-of-day)time-of-day (latent)",
-                                     -2.268683541318364),
-                                    ("<hour-of-day> <integer> (as relative minutes)<time-of-day> heures",
-                                     -1.9810014688665833),
-                                    ("hh(:|h)mm (time-of-day)<time-of-day> heures",
-                                     -1.9810014688665833),
-                                    ("<hour-of-day> <integer> (as relative minutes)time-of-day (latent)",
-                                     -2.268683541318364)],
-                               n = 11},
-                   koData =
-                     ClassData{prior = -1.8718021769015913,
-                               unseen = -2.4849066497880004,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("minutehour", -1.2992829841302609),
-                                    ("hh(:|h)mm (time-of-day)time-of-day (latent)",
-                                     -1.7047480922384253),
-                                    ("<hour-of-day> <integer> (as relative minutes)time-of-day (latent)",
-                                     -1.7047480922384253)],
-                               n = 2}}),
-       ("matin",
-        Classifier{okData =
-                     ClassData{prior = -0.5108256237659907,
-                               unseen = -2.3978952727983707,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 9},
-                   koData =
-                     ClassData{prior = -0.916290731874155, unseen = -2.0794415416798357,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 6}}),
-       ("en <named-month>",
-        Classifier{okData =
-                     ClassData{prior = 0.0, unseen = -1.9459101490553135,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("named-month", -0.6931471805599453),
-                                    ("month", -0.6931471805599453)],
-                               n = 2},
-                   koData =
-                     ClassData{prior = -infinity, unseen = -1.0986122886681098,
-                               likelihoods = HashMap.fromList [], n = 0}}),
-       ("maintenant",
-        Classifier{okData =
-                     ClassData{prior = 0.0, unseen = -1.3862943611198906,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 2},
-                   koData =
-                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
-                               likelihoods = HashMap.fromList [], n = 0}}),
-       ("<day-of-week> 1er-<day-of-week> dd <month>(interval)",
-        Classifier{okData =
-                     ClassData{prior = 0.0, unseen = -1.9459101490553135,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("named-daynamed-daynamed-month", -0.6931471805599453),
-                                    ("daydaymonth", -0.6931471805599453)],
-                               n = 2},
-                   koData =
-                     ClassData{prior = -infinity, unseen = -1.0986122886681098,
-                               likelihoods = HashMap.fromList [], n = 0}}),
-       ("named-day",
-        Classifier{okData =
-                     ClassData{prior = 0.0, unseen = -4.543294782270004,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 92},
-                   koData =
-                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
-                               likelihoods = HashMap.fromList [], n = 0}}),
-       ("au d\233jeuner",
-        Classifier{okData =
-                     ClassData{prior = 0.0, unseen = -1.0986122886681098,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 1},
-                   koData =
-                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
-                               likelihoods = HashMap.fromList [], n = 0}}),
-       ("le lendemain du <time>",
-        Classifier{okData =
-                     ClassData{prior = -1.0986122886681098,
-                               unseen = -2.1972245773362196,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("day", -1.3862943611198906),
-                                    ("<day-of-month> <named-month>", -1.3862943611198906)],
-                               n = 1},
-                   koData =
-                     ClassData{prior = -0.40546510810816444,
-                               unseen = -2.3978952727983707,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("year (latent)", -1.6094379124341003),
-                                    ("time-of-day (latent)", -1.6094379124341003),
-                                    ("year", -1.6094379124341003), ("hour", -1.6094379124341003)],
-                               n = 2}}),
-       ("le <cycle> prochain|suivant|d'apr\232s",
-        Classifier{okData =
-                     ClassData{prior = 0.0, unseen = -3.970291913552122,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("week", -1.0608719606852628),
-                                    ("ann\233e (grain)", -3.258096538021482),
-                                    ("semaine (grain)", -1.0608719606852628),
-                                    ("mois (grain)", -2.8526314299133175),
-                                    ("day", -2.8526314299133175), ("year", -3.258096538021482),
-                                    ("jour (grain)", -2.8526314299133175),
-                                    ("month", -2.8526314299133175)],
-                               n = 22},
-                   koData =
-                     ClassData{prior = -infinity, unseen = -2.1972245773362196,
-                               likelihoods = HashMap.fromList [], n = 0}}),
-       ("apr\232s <time-of-day>",
-        Classifier{okData =
-                     ClassData{prior = -0.9267620317414506,
-                               unseen = -3.9318256327243257,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("intersect", -1.8325814637483102),
-                                    ("hh(:|h)mm (time-of-day)", -2.8134107167600364),
-                                    ("midi", -3.2188758248682006), ("day", -2.5257286443082556),
-                                    ("time-of-day (latent)", -2.8134107167600364),
-                                    ("hour", -1.6094379124341003), ("minute", -1.8325814637483102),
-                                    ("<time-of-day> heures", -2.8134107167600364),
-                                    ("le <time>", -2.8134107167600364),
-                                    ("<hour-of-day> <integer> (as relative minutes)",
-                                     -2.5257286443082556)],
-                               n = 19},
-                   koData =
-                     ClassData{prior = -0.503905180921417, unseen = -4.2626798770413155,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("demain", -2.8622008809294686),
-                                    ("intersect", -2.169053700369523),
-                                    ("le <day-of-month> (non ordinal)", -3.5553480614894135),
-                                    ("midi", -1.6835458845878222), ("day", -2.639057329615259),
-                                    ("time-of-day (latent)", -2.8622008809294686),
-                                    ("hour", -0.9903987040278769),
-                                    ("<time-of-day> heures", -2.8622008809294686)],
-                               n = 29}}),
-       ("dd/-mm",
-        Classifier{okData =
-                     ClassData{prior = -0.7375989431307791,
-                               unseen = -2.5649493574615367,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 11},
-                   koData =
-                     ClassData{prior = -0.6505875661411494, unseen = -2.639057329615259,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 12}}),
-       ("minuit",
-        Classifier{okData =
-                     ClassData{prior = 0.0, unseen = -1.6094379124341003,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 3},
-                   koData =
-                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
-                               likelihoods = HashMap.fromList [], n = 0}}),
-       ("entre dd et dd <month>(interval)",
-        Classifier{okData =
-                     ClassData{prior = 0.0, unseen = -1.6094379124341003,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("named-month", -0.6931471805599453),
-                                    ("month", -0.6931471805599453)],
-                               n = 1},
-                   koData =
-                     ClassData{prior = -infinity, unseen = -1.0986122886681098,
-                               likelihoods = HashMap.fromList [], n = 0}}),
-       ("une <unit-of-duration>",
-        Classifier{okData =
-                     ClassData{prior = -2.0281482472922856,
-                               unseen = -3.2188758248682006,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("week", -2.4849066497880004),
-                                    ("ann\233e (grain)", -2.4849066497880004),
-                                    ("seconde (grain)", -2.4849066497880004),
-                                    ("semaine (grain)", -2.4849066497880004),
-                                    ("second", -2.4849066497880004),
-                                    ("minute (grain)", -2.4849066497880004),
-                                    ("year", -2.4849066497880004),
-                                    ("heure (grain)", -2.4849066497880004),
-                                    ("hour", -2.4849066497880004), ("minute", -2.4849066497880004)],
-                               n = 5},
-                   koData =
-                     ClassData{prior = -0.14107859825990549,
-                               unseen = -4.394449154672439,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("week", -1.246532418744732),
-                                    ("semaine (grain)", -1.246532418744732),
-                                    ("mois (grain)", -2.772588722239781),
-                                    ("day", -2.3025850929940455),
-                                    ("jour (grain)", -2.3025850929940455),
-                                    ("month", -2.772588722239781)],
-                               n = 33}}),
-       ("<hour-of-day> et quart",
-        Classifier{okData =
-                     ClassData{prior = 0.0, unseen = -2.9444389791664407,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("midi", -2.1972245773362196),
-                                    ("\224|vers <time-of-day>", -1.791759469228055),
-                                    ("hour", -0.8109302162163288),
-                                    ("<time-of-day> heures", -1.2809338454620642)],
-                               n = 7},
-                   koData =
-                     ClassData{prior = -infinity, unseen = -1.6094379124341003,
-                               likelihoods = HashMap.fromList [], n = 0}}),
-       ("number (0..16)",
-        Classifier{okData =
-                     ClassData{prior = -0.2076393647782445, unseen = -3.713572066704308,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 39},
-                   koData =
-                     ClassData{prior = -1.6739764335716716,
-                               unseen = -2.3978952727983707,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 9}}),
-       ("heure (grain)",
-        Classifier{okData =
-                     ClassData{prior = -1.540445040947149, unseen = -2.0794415416798357,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 6},
-                   koData =
-                     ClassData{prior = -0.2411620568168881,
-                               unseen = -3.1780538303479458,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 22}}),
-       ("<named-month|named-day> dernier|pass\233",
-        Classifier{okData =
-                     ClassData{prior = -2.3978952727983707,
-                               unseen = -2.5649493574615367,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("day", -1.791759469228055), ("named-day", -1.791759469228055)],
-                               n = 1},
-                   koData =
-                     ClassData{prior = -9.53101798043249e-2,
-                               unseen = -3.4339872044851463,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("year (latent)", -2.70805020110221),
-                                    ("en semaine", -2.3025850929940455),
-                                    ("day", -1.791759469228055),
-                                    ("\224|vers <time-of-day>", -2.70805020110221),
-                                    ("time-of-day (latent)", -2.70805020110221),
-                                    ("year", -2.70805020110221), ("hour", -1.6094379124341003),
-                                    ("<time-of-day> heures", -2.0149030205422647),
-                                    ("le <time>", -2.3025850929940455)],
-                               n = 10}}),
-       ("dd/-mm/-yyyy",
-        Classifier{okData =
-                     ClassData{prior = 0.0, unseen = -2.70805020110221,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 13},
-                   koData =
-                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
-                               likelihoods = HashMap.fromList [], n = 0}}),
-       ("fin de semaine",
-        Classifier{okData =
-                     ClassData{prior = 0.0, unseen = -1.0986122886681098,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 1},
-                   koData =
-                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
-                               likelihoods = HashMap.fromList [], n = 0}}),
-       ("dd mm yyyy",
-        Classifier{okData =
-                     ClassData{prior = 0.0, unseen = -2.639057329615259,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 12},
-                   koData =
-                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
-                               likelihoods = HashMap.fromList [], n = 0}}),
-       ("day of month (premier)",
-        Classifier{okData =
-                     ClassData{prior = -6.899287148695143e-2,
-                               unseen = -2.772588722239781,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 14},
-                   koData =
-                     ClassData{prior = -2.70805020110221, unseen = -1.0986122886681098,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 1}}),
-       ("jour (grain)",
-        Classifier{okData =
-                     ClassData{prior = -0.1466034741918754, unseen = -3.044522437723423,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 19},
-                   koData =
-                     ClassData{prior = -1.9924301646902063,
-                               unseen = -1.6094379124341003,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 3}}),
-       ("dd mm",
-        Classifier{okData =
-                     ClassData{prior = -0.40546510810816444,
-                               unseen = -2.639057329615259,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 12},
-                   koData =
-                     ClassData{prior = -1.0986122886681098,
-                               unseen = -2.0794415416798357,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 6}}),
-       ("dernier <cycle> de <time> (latent)",
-        Classifier{okData =
-                     ClassData{prior = 0.0, unseen = -3.1354942159291497,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("daymonth", -1.4816045409242156),
-                                    ("semaine (grain)intersect", -1.9924301646902063),
-                                    ("weekmonth", -1.4816045409242156),
-                                    ("semaine (grain)named-month", -1.9924301646902063),
-                                    ("jour (grain)intersect", -1.9924301646902063),
-                                    ("jour (grain)named-month", -1.9924301646902063)],
-                               n = 8},
-                   koData =
-                     ClassData{prior = -infinity, unseen = -1.9459101490553135,
-                               likelihoods = HashMap.fromList [], n = 0}}),
-       ("avant le d\233jeuner",
-        Classifier{okData =
-                     ClassData{prior = 0.0, unseen = -1.0986122886681098,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 1},
-                   koData =
-                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
-                               likelihoods = HashMap.fromList [], n = 0}}),
-       ("1er mai",
-        Classifier{okData =
-                     ClassData{prior = 0.0, unseen = -1.0986122886681098,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 1},
-                   koData =
-                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
-                               likelihoods = HashMap.fromList [], n = 0}}),
-       ("fin de soir\233e",
-        Classifier{okData =
-                     ClassData{prior = 0.0, unseen = -1.0986122886681098,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 1},
-                   koData =
-                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
-                               likelihoods = HashMap.fromList [], n = 0}}),
-       ("<datetime> - <datetime> (interval)",
-        Classifier{okData =
-                     ClassData{prior = -1.0185695809945732, unseen = -4.454347296253507,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("demain<time-of-day> heures", -3.7495040759303713),
-                                    ("day of month (premier)<day-of-week> <day-of-month>",
-                                     -3.056356895370426),
-                                    ("dayhour", -3.3440389678222067),
-                                    ("hh(:|h)mm (time-of-day)<hour-of-day> <integer> (as relative minutes)",
-                                     -3.3440389678222067),
-                                    ("le <day-of-month> (non ordinal)<time-of-day> heures",
-                                     -3.7495040759303713),
-                                    ("minuteminute", -2.044755983691946),
-                                    ("<day-of-month> <named-month><day-of-month> <named-month>",
-                                     -3.3440389678222067),
-                                    ("hh(:|h)mm (time-of-day)hh(:|h)mm (time-of-day)",
-                                     -3.056356895370426),
-                                    ("dayday", -1.8777018990287797),
-                                    ("<day-of-week> <day-of-month><day-of-week> <day-of-month>",
-                                     -3.7495040759303713),
-                                    ("<day-of-month> <named-month>day of month (premier)",
-                                     -3.3440389678222067),
-                                    ("minutehour", -3.3440389678222067),
-                                    ("<hour-of-day> <integer> (as relative minutes)<time-of-day> heures",
-                                     -3.7495040759303713),
-                                    ("<hour-of-day> <integer> (as relative minutes)hh(:|h)mm (time-of-day)",
-                                     -3.056356895370426),
-                                    ("hh(:|h)mm (time-of-day)<time-of-day> heures",
-                                     -3.7495040759303713),
-                                    ("<hour-of-day> <integer> (as relative minutes)<hour-of-day> <integer> (as relative minutes)",
-                                     -3.3440389678222067),
-                                    ("<day-of-month> <named-month>intersect", -3.3440389678222067),
-                                    ("intersect<day-of-week> <day-of-month>", -3.3440389678222067)],
-                               n = 26},
-                   koData =
-                     ClassData{prior = -0.4480247225269604, unseen = -4.836281906951478,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("<hour-of-day> <integer> (as relative minutes)intersect",
-                                     -3.7297014486341915),
-                                    ("monthday", -2.8824035882469876),
-                                    ("intersectnamed-day", -3.7297014486341915),
-                                    ("day of month (premier)named-day", -3.4420193761824103),
-                                    ("named-month<day-of-month> <named-month>",
-                                     -3.7297014486341915),
-                                    ("minuteminute", -3.7297014486341915),
-                                    ("dayday", -1.4961092271270973),
-                                    ("<day-of-week> <day-of-month><day-of-week> <day-of-month>",
-                                     -3.7297014486341915),
-                                    ("day of month (premier)<day-of-month> <named-month>",
-                                     -4.135166556742356),
-                                    ("year<hour-of-day> <integer> (as relative minutes)",
-                                     -3.4420193761824103),
-                                    ("minutehour", -2.631089159966082),
-                                    ("<hour-of-day> <integer> (as relative minutes)<time-of-day> heures",
-                                     -3.4420193761824103),
-                                    ("day of month (premier)intersect", -2.8824035882469876),
-                                    ("hh(:|h)mm (time-of-day)<time-of-day> heures",
-                                     -3.4420193761824103),
-                                    ("intersectintersect", -3.2188758248682006),
-                                    ("hh(:|h)mm (time-of-day)intersect", -3.7297014486341915),
-                                    ("named-monthintersect", -3.7297014486341915),
-                                    ("<day-of-week> <day-of-month>named-day", -3.4420193761824103),
-                                    ("named-monthday of month (premier)", -3.7297014486341915),
-                                    ("<day-of-week> <day-of-month>intersect", -2.8824035882469876),
-                                    ("yearminute", -3.4420193761824103)],
-                               n = 46}}),
-       ("<day-of-month> <named-month>",
-        Classifier{okData =
-                     ClassData{prior = -0.30010459245033816,
-                               unseen = -4.418840607796598,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("integer (numeric)named-month", -0.6931471805599453),
-                                    ("month", -0.6931471805599453)],
-                               n = 40},
-                   koData =
-                     ClassData{prior = -1.349926716949016, unseen = -3.4339872044851463,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("integer (numeric)named-month", -0.6931471805599453),
-                                    ("month", -0.6931471805599453)],
-                               n = 14}}),
-       ("<cycle> prochain|suivant|d'apr\232s",
-        Classifier{okData =
-                     ClassData{prior = -8.338160893905101e-2,
-                               unseen = -4.007333185232471,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("week", -1.0986122886681098),
-                                    ("ann\233e (grain)", -3.295836866004329),
-                                    ("semaine (grain)", -1.0986122886681098),
-                                    ("mois (grain)", -2.890371757896165),
-                                    ("day", -2.6026896854443837), ("year", -3.295836866004329),
-                                    ("jour (grain)", -2.6026896854443837),
-                                    ("month", -2.890371757896165)],
-                               n = 23},
-                   koData =
-                     ClassData{prior = -2.5257286443082556,
-                               unseen = -2.5649493574615367,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("mois (grain)", -1.791759469228055),
-                                    ("day", -1.791759469228055),
-                                    ("jour (grain)", -1.791759469228055),
-                                    ("month", -1.791759469228055)],
-                               n = 2}}),
-       ("fin <named-month>(interval)",
-        Classifier{okData =
-                     ClassData{prior = 0.0, unseen = -1.9459101490553135,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("named-month", -0.6931471805599453),
-                                    ("month", -0.6931471805599453)],
-                               n = 2},
-                   koData =
-                     ClassData{prior = -infinity, unseen = -1.0986122886681098,
-                               likelihoods = HashMap.fromList [], n = 0}}),
-       ("<time-of-day> - <time-of-day> (interval)",
-        Classifier{okData =
-                     ClassData{prior = -1.2321436812926323, unseen = -4.0943445622221,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("hh(:|h)mm (time-of-day)<hour-of-day> <integer> (as relative minutes)",
-                                     -2.691243082785829),
-                                    ("minuteminute", -1.3694872428035094),
-                                    ("time-of-day (latent)time-of-day (latent)",
-                                     -3.3843902633457743),
-                                    ("<time-of-day> heures<time-of-day> heures",
-                                     -3.3843902633457743),
-                                    ("hh(:|h)mm (time-of-day)hh(:|h)mm (time-of-day)",
-                                     -2.468099531471619),
-                                    ("hourhour", -2.691243082785829),
-                                    ("minutehour", -2.468099531471619),
-                                    ("<hour-of-day> <integer> (as relative minutes)<time-of-day> heures",
-                                     -2.691243082785829),
-                                    ("<hour-of-day> <integer> (as relative minutes)hh(:|h)mm (time-of-day)",
-                                     -2.468099531471619),
-                                    ("hh(:|h)mm (time-of-day)<time-of-day> heures",
-                                     -3.3843902633457743),
-                                    ("<hour-of-day> <integer> (as relative minutes)<hour-of-day> <integer> (as relative minutes)",
-                                     -2.691243082785829),
-                                    ("<time-of-day> heurestime-of-day (latent)",
-                                     -3.3843902633457743)],
-                               n = 21},
-                   koData =
-                     ClassData{prior = -0.3448404862917295, unseen = -4.787491742782046,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("time-of-day (latent)time-of-day (latent)",
-                                     -1.7833912195575383),
-                                    ("hourhour", -1.3451362886263831),
-                                    ("time-of-day (latent)<hour-of-day> <integer> (as relative minutes)",
-                                     -4.085976312551584),
-                                    ("hourminute", -4.085976312551584),
-                                    ("minutehour", -1.7346010553881064),
-                                    ("hh(:|h)mm (time-of-day)time-of-day (latent)",
-                                     -2.987364023883474),
-                                    ("<hour-of-day> <integer> (as relative minutes)<time-of-day> heures",
-                                     -3.169685580677429),
-                                    ("hh(:|h)mm (time-of-day)<time-of-day> heures",
-                                     -3.169685580677429),
-                                    ("<hour-of-day> <integer> (as relative minutes)time-of-day (latent)",
-                                     -2.6996819514316934),
-                                    ("time-of-day (latent)<time-of-day> heures",
-                                     -2.2942168433235293)],
-                               n = 51}}),
-       ("<named-day> en huit",
-        Classifier{okData =
-                     ClassData{prior = 0.0, unseen = -2.70805020110221,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("day", -0.6931471805599453),
-                                    ("named-day", -0.6931471805599453)],
-                               n = 6},
-                   koData =
-                     ClassData{prior = -infinity, unseen = -1.0986122886681098,
-                               likelihoods = HashMap.fromList [], n = 0}}),
-       ("<hour-of-day> et demi",
-        Classifier{okData =
-                     ClassData{prior = 0.0, unseen = -2.5649493574615367,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("midi", -1.791759469228055),
-                                    ("\224|vers <time-of-day>", -1.791759469228055),
-                                    ("hour", -0.8754687373538999),
-                                    ("<time-of-day> heures", -1.3862943611198906)],
-                               n = 4},
-                   koData =
-                     ClassData{prior = -infinity, unseen = -1.6094379124341003,
-                               likelihoods = HashMap.fromList [], n = 0}}),
-       ("dernier week-end de <time>",
-        Classifier{okData =
-                     ClassData{prior = 0.0, unseen = -1.6094379124341003,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("named-month", -0.6931471805599453),
-                                    ("month", -0.6931471805599453)],
-                               n = 1},
-                   koData =
-                     ClassData{prior = -infinity, unseen = -1.0986122886681098,
-                               likelihoods = HashMap.fromList [], n = 0}}),
-       ("du dd au dd(interval)",
-        Classifier{okData =
-                     ClassData{prior = 0.0, unseen = -1.0986122886681098,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 1},
-                   koData =
-                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
-                               likelihoods = HashMap.fromList [], n = 0}}),
-       ("ordinal (digits)",
-        Classifier{okData =
-                     ClassData{prior = -1.8718021769015913,
-                               unseen = -1.3862943611198906,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 2},
-                   koData =
-                     ClassData{prior = -0.1670540846631662,
-                               unseen = -2.5649493574615367,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 11}}),
-       ("avant <time-of-day>",
-        Classifier{okData =
-                     ClassData{prior = -1.3862943611198906, unseen = -2.890371757896165,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("time-of-day (latent)", -1.7346010553881064),
-                                    ("hour", -1.2237754316221157),
-                                    ("<time-of-day> heures", -1.7346010553881064)],
-                               n = 4},
-                   koData =
-                     ClassData{prior = -0.2876820724517809,
-                               unseen = -3.5263605246161616,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("intersect", -2.803360380906535),
-                                    ("hh(:|h)mm (time-of-day)", -2.803360380906535),
-                                    ("hier", -2.803360380906535), ("day", -2.803360380906535),
-                                    ("time-of-day (latent)", -1.8870696490323797),
-                                    ("hour", -1.1939224684724346), ("minute", -2.3978952727983707),
-                                    ("<time-of-day> heures", -1.8870696490323797),
-                                    ("<hour-of-day> <integer> (as relative minutes)",
-                                     -2.803360380906535)],
-                               n = 12}}),
-       ("fin d'apr\232s-midi",
-        Classifier{okData =
-                     ClassData{prior = 0.0, unseen = -1.6094379124341003,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 3},
-                   koData =
-                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
-                               likelihoods = HashMap.fromList [], n = 0}}),
-       ("<part-of-day> du <dim time>",
-        Classifier{okData =
-                     ClassData{prior = -0.6931471805599453,
-                               unseen = -1.9459101490553135,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("matin<day-of-month> <named-month>", -1.0986122886681098),
-                                    ("hourday", -1.0986122886681098)],
-                               n = 1},
-                   koData =
-                     ClassData{prior = -0.6931471805599453,
-                               unseen = -1.9459101490553135,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("matinyear (latent)", -1.0986122886681098),
-                                    ("houryear", -1.0986122886681098)],
-                               n = 1}}),
-       ("<time-of-day> heures",
-        Classifier{okData =
-                     ClassData{prior = -0.16251892949777494,
-                               unseen = -5.634789603169249,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("\224|vers <time-of-day>", -1.8025703853322705),
-                                    ("time-of-day (latent)", -1.1538749673431592),
-                                    ("apr\232s <time-of-day>", -4.532599493153256),
-                                    ("hour", -0.7112308559932407),
-                                    ("avant <time-of-day>", -4.532599493153256)],
-                               n = 136},
-                   koData =
-                     ClassData{prior = -1.8971199848858813, unseen = -4.02535169073515,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("\224|vers <time-of-day>", -1.7047480922384253),
-                                    ("time-of-day (latent)", -1.927891643552635),
-                                    ("apr\232s <time-of-day>", -2.6210388241125804),
-                                    ("hour", -0.8292793548845253),
-                                    ("avant <time-of-day>", -2.3978952727983707),
-                                    ("minute", -3.3141860046725258),
-                                    ("<hour-of-day> <integer> (as relative minutes)",
-                                     -3.3141860046725258)],
-                               n = 24}}),
-       ("week-end",
-        Classifier{okData =
-                     ClassData{prior = -0.6931471805599453,
-                               unseen = -1.3862943611198906,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 2},
-                   koData =
-                     ClassData{prior = -0.6931471805599453,
-                               unseen = -1.3862943611198906,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 2}}),
-       ("le <time>",
-        Classifier{okData =
-                     ClassData{prior = -0.2876820724517809, unseen = -5.739792912179234,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("week", -2.4784757594577096),
-                                    ("<named-month|named-day> suivant|d'apr\232s",
-                                     -3.5393477201429726),
-                                    ("<ordinal> <cycle> de <time>", -4.350277936359301),
-                                    ("premi\232re quinzaine de <named-month>(interval)",
-                                     -5.043425116919247),
-                                    ("intersect", -2.0476928433652555),
-                                    ("soir de no\235l", -5.043425116919247),
-                                    ("en semaine", -3.3386770246808215),
-                                    ("toussaint", -4.637960008811082), ("day", -1.3421231428067533),
-                                    ("deuxi\232me quinzaine de <named-month>(interval)",
-                                     -5.043425116919247),
-                                    ("<dim time> <part-of-day>", -4.127134385045092),
-                                    ("dd/-mm", -3.7906621484238787),
-                                    ("dd/-mm/-yyyy", -4.350277936359301),
-                                    ("dd mm yyyy", -3.7906621484238787),
-                                    ("day of month (premier)", -3.9448128282511368),
-                                    ("dd mm", -3.7906621484238787), ("hour", -2.2102117728630306),
-                                    ("month", -4.350277936359301),
-                                    ("dernier <cycle> de <time> (latent)", -4.127134385045092),
-                                    ("<day-of-month> <named-month>", -3.028522096376982),
-                                    ("<cycle> prochain|suivant|d'apr\232s", -2.6920498597557687),
-                                    ("dernier week-end de <time>", -5.043425116919247),
-                                    ("<ordinal> week-end de <time>", -4.637960008811082),
-                                    ("<cycle> dernier", -3.9448128282511368)],
-                               n = 141},
-                   koData =
-                     ClassData{prior = -1.3862943611198906, unseen = -4.812184355372417,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("<named-month|named-day> suivant|d'apr\232s",
-                                     -4.110873864173311),
-                                    ("intersect", -3.1945831322991562),
-                                    ("en semaine", -2.23907168727172), ("day", -1.625967214385311),
-                                    ("<dim time> <part-of-day>", -3.7054087560651467),
-                                    ("dd/-mm", -3.417726683613366),
-                                    ("<named-month|named-day> dernier|pass\233",
-                                     -3.7054087560651467),
-                                    ("day of month (premier)", -4.110873864173311),
-                                    ("dd mm", -3.417726683613366), ("hour", -2.0959708436310467),
-                                    ("<day-of-month> <named-month>", -4.110873864173311),
-                                    ("<time-of-day> - <time-of-day> (interval)",
-                                     -2.406125771934886),
-                                    ("minute", -2.406125771934886),
-                                    ("<hour-of-day> <integer> (as relative minutes)",
-                                     -2.606796467397037)],
-                               n = 47}}),
-       ("apr\232s le <day-of-month>",
-        Classifier{okData =
-                     ClassData{prior = -0.40546510810816444,
-                               unseen = -1.3862943611198906,
-                               likelihoods = HashMap.fromList [("integer (numeric)", 0.0)],
-                               n = 2},
-                   koData =
-                     ClassData{prior = -1.0986122886681098,
-                               unseen = -1.0986122886681098,
-                               likelihoods = HashMap.fromList [("integer (numeric)", 0.0)],
-                               n = 1}}),
-       ("n <cycle> passes|precedents",
-        Classifier{okData =
-                     ClassData{prior = -0.40546510810816444,
-                               unseen = -2.3978952727983707,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("week", -1.6094379124341003),
-                                    ("integer (numeric)ann\233e (grain)", -1.6094379124341003),
-                                    ("year", -1.6094379124341003),
-                                    ("integer (numeric)semaine (grain)", -1.6094379124341003)],
-                               n = 2},
-                   koData =
-                     ClassData{prior = -1.0986122886681098,
-                               unseen = -2.1972245773362196,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("hour", -1.3862943611198906),
-                                    ("number (0..16)heure (grain)", -1.3862943611198906)],
-                               n = 1}}),
-       ("il y a <duration>",
-        Classifier{okData =
-                     ClassData{prior = 0.0, unseen = -2.639057329615259,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("week", -1.8718021769015913), ("year", -1.8718021769015913),
-                                    ("<integer> <unit-of-duration>", -0.9555114450274363),
-                                    ("hour", -1.8718021769015913), ("month", -1.8718021769015913)],
-                               n = 4},
-                   koData =
-                     ClassData{prior = -infinity, unseen = -1.791759469228055,
-                               likelihoods = HashMap.fromList [], n = 0}}),
-       ("<ordinal> week-end de <time>",
-        Classifier{okData =
-                     ClassData{prior = 0.0, unseen = -1.9459101490553135,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("ordinals (premier..seizieme)named-month",
-                                     -0.6931471805599453),
-                                    ("month", -0.6931471805599453)],
-                               n = 2},
-                   koData =
-                     ClassData{prior = -infinity, unseen = -1.0986122886681098,
-                               likelihoods = HashMap.fromList [], n = 0}}),
-       ("<dim time> du matin",
-        Classifier{okData =
-                     ClassData{prior = -0.13353139262452263,
-                               unseen = -2.890371757896165,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("\224|vers <time-of-day>", -1.7346010553881064),
-                                    ("hour", -0.7537718023763802),
-                                    ("<time-of-day> heures", -1.041453874828161)],
-                               n = 7},
-                   koData =
-                     ClassData{prior = -2.0794415416798357, unseen = -1.791759469228055,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("hour", -0.916290731874155),
-                                    ("<time-of-day> heures", -0.916290731874155)],
-                               n = 1}}),
-       ("d\233but d'apr\232s-midi",
-        Classifier{okData =
-                     ClassData{prior = 0.0, unseen = -1.0986122886681098,
-                               likelihoods = HashMap.fromList [("", 0.0)], n = 1},
-                   koData =
-                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
-                               likelihoods = HashMap.fromList [], n = 0}}),
-       ("<hour-of-day> <integer> (as relative minutes)",
-        Classifier{okData =
-                     ClassData{prior = -0.8174448972375224, unseen = -4.430816798843313,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("minuitnumber (0..16)", -3.3202283191284883),
-                                    ("midinumber (20..60)", -3.7256934272366524),
-                                    ("\224|vers <time-of-day>number (20..60)", -3.7256934272366524),
-                                    ("<time-of-day> heuresinteger (numeric)", -1.2833463918674481),
-                                    ("\224|vers <time-of-day>number (0..16)", -3.3202283191284883),
-                                    ("midinumber (0..16)", -3.7256934272366524),
-                                    ("hour", -0.8634925463071842),
-                                    ("<time-of-day> heuresnumber (20..60)", -3.3202283191284883),
-                                    ("\224|vers <time-of-day>integer (numeric)",
-                                     -3.7256934272366524),
-                                    ("<time-of-day> heuresnumber (0..16)", -3.3202283191284883)],
-                               n = 34},
-                   koData =
-                     ClassData{prior = -0.5826053061601215, unseen = -4.624972813284271,
-                               likelihoods =
-                                 HashMap.fromList
-                                   [("time-of-day (latent)numbers 22..29 32..39 .. 52..59",
-                                     -3.9219733362813143),
-                                    ("time-of-day (latent)number (0..16)", -3.5165082281731497),
-                                    ("<time-of-day> heuresinteger (numeric)", -2.6692103677859462),
-                                    ("avant <time-of-day>integer (numeric)", -3.9219733362813143),
-                                    ("time-of-day (latent)integer (numeric)", -1.2829160066660554),
-                                    ("apr\232s <time-of-day>integer (numeric)", -3.228826155721369),
-                                    ("hour", -0.8309308829229983),
-                                    ("\224|vers <time-of-day>integer (numeric)",
-                                     -3.5165082281731497),
-                                    ("<time-of-day> heuresnumber (0..16)", -3.9219733362813143)],
-                               n = 43}}),
+                     ClassData{prior = -0.587786664902119, unseen = -3.8066624897703196,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("soir", -1.3862943611198906),
+                                    ("apr\232s-midi", -2.174751721484161),
+                                    ("matin", -1.8382794848629478), ("hour", -0.7396671961948381)],
+                               n = 20},
+                   koData =
+                     ClassData{prior = -0.8109302162163288,
+                               unseen = -3.6109179126442243,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("soir", -2.1972245773362196),
+                                    ("apr\232s-midi", -2.1972245773362196),
+                                    ("matin", -1.1856236656577395), ("hour", -0.750305594399894)],
+                               n = 16}}),
+       ("dans <duration>",
+        Classifier{okData =
+                     ClassData{prior = -8.338160893905101e-2,
+                               unseen = -4.04305126783455,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("week", -2.639057329615259),
+                                    ("<integer> + '\"", -2.9267394020670396),
+                                    ("second", -2.639057329615259), ("day", -2.9267394020670396),
+                                    ("year", -2.639057329615259),
+                                    ("<integer> <unit-of-duration>", -1.1921383466789333),
+                                    ("une <unit-of-duration>", -2.2335922215070942),
+                                    ("hour", -2.4159137783010487), ("month", -3.332204510175204),
+                                    ("minute", -1.9459101490553135)],
+                               n = 23},
+                   koData =
+                     ClassData{prior = -2.5257286443082556, unseen = -2.70805020110221,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("week", -1.9459101490553135), ("day", -1.9459101490553135),
+                                    ("une <unit-of-duration>", -1.540445040947149)],
+                               n = 2}}),
+       ("<time> timezone",
+        Classifier{okData =
+                     ClassData{prior = 0.0, unseen = -2.3025850929940455,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("\224|vers <time-of-day>", -1.5040773967762742),
+                                    ("hour", -0.8109302162163288),
+                                    ("<time-of-day> heures", -1.0986122886681098)],
+                               n = 3},
+                   koData =
+                     ClassData{prior = -infinity, unseen = -1.3862943611198906,
+                               likelihoods = HashMap.fromList [], n = 0}}),
+       ("n <cycle> apr\232s",
+        Classifier{okData =
+                     ClassData{prior = 0.0, unseen = -1.9459101490553135,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("number (0..16)jour (grain)", -0.6931471805599453),
+                                    ("day", -0.6931471805599453)],
+                               n = 2},
+                   koData =
+                     ClassData{prior = -infinity, unseen = -1.0986122886681098,
+                               likelihoods = HashMap.fromList [], n = 0}}),
+       ("integer (numeric)",
+        Classifier{okData =
+                     ClassData{prior = -0.4793738175333202, unseen = -5.484796933490655,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 239},
+                   koData =
+                     ClassData{prior = -0.9654047826860945, unseen = -5.003946305945459,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 147}}),
+       ("<named-month>",
+        Classifier{okData =
+                     ClassData{prior = 0.0, unseen = -1.6094379124341003,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("named-month", -0.6931471805599453),
+                                    ("month", -0.6931471805599453)],
+                               n = 1},
+                   koData =
+                     ClassData{prior = -infinity, unseen = -1.0986122886681098,
+                               likelihoods = HashMap.fromList [], n = 0}}),
+       ("apr\232s le travail",
+        Classifier{okData =
+                     ClassData{prior = 0.0, unseen = -1.0986122886681098,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 1},
+                   koData =
+                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
+                               likelihoods = HashMap.fromList [], n = 0}}),
+       ("n prochains <cycle>",
+        Classifier{okData =
+                     ClassData{prior = 0.0, unseen = -3.5553480614894135,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("week", -2.833213344056216),
+                                    ("number (0..16)seconde (grain)", -2.833213344056216),
+                                    ("second", -2.4277482359480516),
+                                    ("integer (numeric)ann\233e (grain)", -2.833213344056216),
+                                    ("integer (numeric)seconde (grain)", -2.833213344056216),
+                                    ("number (0..16)minute (grain)", -2.833213344056216),
+                                    ("integer (numeric)jour (grain)", -2.833213344056216),
+                                    ("day", -2.833213344056216), ("year", -2.833213344056216),
+                                    ("hour", -2.833213344056216), ("month", -2.833213344056216),
+                                    ("integer (numeric)minute (grain)", -2.833213344056216),
+                                    ("integer (numeric)mois (grain)", -2.833213344056216),
+                                    ("minute", -2.4277482359480516),
+                                    ("integer (numeric)semaine (grain)", -2.833213344056216),
+                                    ("integer (numeric)heure (grain)", -2.833213344056216)],
+                               n = 9},
+                   koData =
+                     ClassData{prior = -infinity, unseen = -2.833213344056216,
+                               likelihoods = HashMap.fromList [], n = 0}}),
+       ("fin d'ann\233e",
+        Classifier{okData =
+                     ClassData{prior = 0.0, unseen = -1.3862943611198906,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 2},
+                   koData =
+                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
+                               likelihoods = HashMap.fromList [], n = 0}}),
+       ("<day-of-week> <day-of-month> \224 <time-of-day>)",
+        Classifier{okData =
+                     ClassData{prior = 0.0, unseen = -3.58351893845611,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("dayhour", -0.7827593392496325),
+                                    ("named-dayinteger (numeric)\224|vers <time-of-day>",
+                                     -1.6094379124341003),
+                                    ("named-daynumber (0..16)<time-of-day> heures",
+                                     -2.456735772821304),
+                                    ("named-dayinteger (numeric)<time-of-day> heures",
+                                     -2.169053700369523),
+                                    ("named-daynumber (0..16)\224|vers <time-of-day>",
+                                     -1.9459101490553135)],
+                               n = 15},
+                   koData =
+                     ClassData{prior = -infinity, unseen = -1.791759469228055,
+                               likelihoods = HashMap.fromList [], n = 0}}),
+       ("apr\232s le d\233jeuner",
+        Classifier{okData =
+                     ClassData{prior = 0.0, unseen = -1.0986122886681098,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 1},
+                   koData =
+                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
+                               likelihoods = HashMap.fromList [], n = 0}}),
+       ("<named-day> en quinze",
+        Classifier{okData =
+                     ClassData{prior = 0.0, unseen = -2.70805020110221,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("day", -0.6931471805599453),
+                                    ("named-day", -0.6931471805599453)],
+                               n = 6},
+                   koData =
+                     ClassData{prior = -infinity, unseen = -1.0986122886681098,
+                               likelihoods = HashMap.fromList [], n = 0}}),
+       ("entre <datetime> et <datetime> (interval)",
+        Classifier{okData =
+                     ClassData{prior = -0.25131442828090605,
+                               unseen = -4.127134385045092,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("le <time>le <day-of-month> (non ordinal)",
+                                     -3.417726683613366),
+                                    ("le <time>le <time>", -3.012261575505202),
+                                    ("dayday", -1.7129785913749407),
+                                    ("hourhour", -3.417726683613366),
+                                    ("le <time>intersect", -3.417726683613366),
+                                    ("miditime-of-day (latent)", -3.417726683613366),
+                                    ("intersectle <day-of-month> (non ordinal)",
+                                     -3.417726683613366),
+                                    ("minutehour", -1.7129785913749407),
+                                    ("hh(:|h)mm (time-of-day)time-of-day (latent)",
+                                     -3.012261575505202),
+                                    ("<hour-of-day> <integer> (as relative minutes)<time-of-day> heures",
+                                     -2.7245795030534206),
+                                    ("le <day-of-month> (non ordinal)le <day-of-month> (non ordinal)",
+                                     -3.012261575505202),
+                                    ("hh(:|h)mm (time-of-day)<time-of-day> heures",
+                                     -2.7245795030534206),
+                                    ("intersectintersect", -3.417726683613366),
+                                    ("intersectle <time>", -3.012261575505202),
+                                    ("<hour-of-day> <integer> (as relative minutes)time-of-day (latent)",
+                                     -3.012261575505202)],
+                               n = 21},
+                   koData =
+                     ClassData{prior = -1.5040773967762742,
+                               unseen = -3.4657359027997265,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("<hour-of-day> <integer> (as relative minutes)intersect",
+                                     -2.740840023925201),
+                                    ("dayday", -2.3353749158170367),
+                                    ("le <day-of-month> (non ordinal)intersect",
+                                     -2.740840023925201),
+                                    ("minutehour", -1.824549292051046),
+                                    ("hh(:|h)mm (time-of-day)time-of-day (latent)",
+                                     -2.740840023925201),
+                                    ("le <day-of-month> (non ordinal)le <time>",
+                                     -2.740840023925201),
+                                    ("hh(:|h)mm (time-of-day)intersect", -2.740840023925201),
+                                    ("<hour-of-day> <integer> (as relative minutes)time-of-day (latent)",
+                                     -2.740840023925201)],
+                               n = 6}}),
+       ("soir",
+        Classifier{okData =
+                     ClassData{prior = -0.1823215567939546, unseen = -2.833213344056216,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 15},
+                   koData =
+                     ClassData{prior = -1.791759469228055, unseen = -1.6094379124341003,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 3}}),
+       ("ann\233e (grain)",
+        Classifier{okData =
+                     ClassData{prior = 0.0, unseen = -2.3978952727983707,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 9},
+                   koData =
+                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
+                               likelihoods = HashMap.fromList [], n = 0}}),
+       ("d\233but de semaine",
+        Classifier{okData =
+                     ClassData{prior = 0.0, unseen = -1.3862943611198906,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 2},
+                   koData =
+                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
+                               likelihoods = HashMap.fromList [], n = 0}}),
+       ("<hour-of-day> moins <integer> (as relative minutes)",
+        Classifier{okData =
+                     ClassData{prior = 0.0, unseen = -1.6094379124341003,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("midinumber (0..16)", -0.6931471805599453),
+                                    ("hour", -0.6931471805599453)],
+                               n = 1},
+                   koData =
+                     ClassData{prior = -infinity, unseen = -1.0986122886681098,
+                               likelihoods = HashMap.fromList [], n = 0}}),
+       ("<named-month|named-day> suivant|d'apr\232s",
+        Classifier{okData =
+                     ClassData{prior = -0.10178269430994236,
+                               unseen = -4.174387269895637,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("intersect", -2.5494451709255714),
+                                    ("en semaine", -1.9616585060234524),
+                                    ("intersect by 'de' or ','", -2.5494451709255714),
+                                    ("day", -0.7915872533731978),
+                                    ("named-day", -2.5494451709255714),
+                                    ("le <time>", -1.9616585060234524)],
+                               n = 28},
+                   koData =
+                     ClassData{prior = -2.3353749158170367, unseen = -2.70805020110221,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("en semaine", -1.9459101490553135),
+                                    ("day", -1.540445040947149), ("hour", -1.9459101490553135),
+                                    ("<time-of-day> heures", -1.9459101490553135),
+                                    ("le <time>", -1.9459101490553135)],
+                               n = 3}}),
+       ("seconde (grain)",
+        Classifier{okData =
+                     ClassData{prior = 0.0, unseen = -1.9459101490553135,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 5},
+                   koData =
+                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
+                               likelihoods = HashMap.fromList [], n = 0}}),
+       ("<hour-of-day> et|pass\233 de <number>",
+        Classifier{okData =
+                     ClassData{prior = -0.13353139262452263,
+                               unseen = -3.0910424533583156,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("\224|vers <time-of-day>number (20..60)", -2.3513752571634776),
+                                    ("<time-of-day> heuresinteger (numeric)", -2.3513752571634776),
+                                    ("\224|vers <time-of-day>number (0..16)", -2.3513752571634776),
+                                    ("hour", -0.9650808960435872),
+                                    ("<time-of-day> heuresnumber (20..60)", -1.9459101490553135),
+                                    ("<time-of-day> heuresnumber (0..16)", -1.9459101490553135)],
+                               n = 7},
+                   koData =
+                     ClassData{prior = -2.0794415416798357,
+                               unseen = -2.3025850929940455,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("midiinteger (numeric)", -1.5040773967762742),
+                                    ("hour", -1.5040773967762742)],
+                               n = 1}}),
+       ("<hour-of-day> moins quart",
+        Classifier{okData =
+                     ClassData{prior = 0.0, unseen = -1.6094379124341003,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("midi", -0.6931471805599453), ("hour", -0.6931471805599453)],
+                               n = 1},
+                   koData =
+                     ClassData{prior = -infinity, unseen = -1.0986122886681098,
+                               likelihoods = HashMap.fromList [], n = 0}}),
+       ("de <time-of-day> - <time-of-day> (interval)",
+        Classifier{okData =
+                     ClassData{prior = -0.587786664902119, unseen = -3.8066624897703196,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("hh(:|h)mm (time-of-day)<hour-of-day> <integer> (as relative minutes)",
+                                     -2.6855773452501515),
+                                    ("minuteminute", -1.5869650565820417),
+                                    ("time-of-day (latent)time-of-day (latent)",
+                                     -3.0910424533583156),
+                                    ("<time-of-day> heures<time-of-day> heures",
+                                     -3.0910424533583156),
+                                    ("hh(:|h)mm (time-of-day)hh(:|h)mm (time-of-day)",
+                                     -2.6855773452501515),
+                                    ("hourhour", -2.3978952727983707),
+                                    ("minutehour", -2.174751721484161),
+                                    ("<hour-of-day> <integer> (as relative minutes)<time-of-day> heures",
+                                     -2.3978952727983707),
+                                    ("<hour-of-day> <integer> (as relative minutes)hh(:|h)mm (time-of-day)",
+                                     -2.6855773452501515),
+                                    ("hh(:|h)mm (time-of-day)<time-of-day> heures",
+                                     -3.0910424533583156),
+                                    ("<hour-of-day> <integer> (as relative minutes)<hour-of-day> <integer> (as relative minutes)",
+                                     -2.6855773452501515),
+                                    ("<time-of-day> heurestime-of-day (latent)",
+                                     -3.0910424533583156)],
+                               n = 15},
+                   koData =
+                     ClassData{prior = -0.8109302162163288,
+                               unseen = -3.6635616461296463,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("minutehour", -1.072636802264849),
+                                    ("hh(:|h)mm (time-of-day)time-of-day (latent)",
+                                     -2.2512917986064953),
+                                    ("<hour-of-day> <integer> (as relative minutes)<time-of-day> heures",
+                                     -2.538973871058276),
+                                    ("hh(:|h)mm (time-of-day)<time-of-day> heures",
+                                     -2.538973871058276),
+                                    ("<hour-of-day> <integer> (as relative minutes)time-of-day (latent)",
+                                     -1.845826690498331)],
+                               n = 12}}),
+       ("<datetime>-dd <month>(interval)",
+        Classifier{okData =
+                     ClassData{prior = -1.466337068793427, unseen = -2.772588722239781,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("daymonth", -1.3217558399823195),
+                                    ("<day-of-month> <named-month>named-month",
+                                     -1.6094379124341003),
+                                    ("day of month (premier)named-month", -2.0149030205422647)],
+                               n = 3},
+                   koData =
+                     ClassData{prior = -0.262364264467491, unseen = -3.4011973816621555,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("hourmonth", -1.7578579175523736),
+                                    ("named-monthnamed-month", -2.268683541318364),
+                                    ("monthmonth", -2.268683541318364),
+                                    ("year (latent)named-month", -1.7578579175523736),
+                                    ("yearmonth", -1.7578579175523736),
+                                    ("time-of-day (latent)named-month", -1.7578579175523736)],
+                               n = 10}}),
+       ("semaine (grain)",
+        Classifier{okData =
+                     ClassData{prior = -7.79615414697118e-2,
+                               unseen = -3.6635616461296463,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 37},
+                   koData =
+                     ClassData{prior = -2.5902671654458267,
+                               unseen = -1.6094379124341003,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 3}}),
+       ("<integer> + '\"",
+        Classifier{okData =
+                     ClassData{prior = 0.0, unseen = -1.3862943611198906,
+                               likelihoods = HashMap.fromList [("integer (numeric)", 0.0)],
+                               n = 2},
+                   koData =
+                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
+                               likelihoods = HashMap.fromList [], n = 0}}),
+       ("demain",
+        Classifier{okData =
+                     ClassData{prior = -0.45198512374305727,
+                               unseen = -2.1972245773362196,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 7},
+                   koData =
+                     ClassData{prior = -1.0116009116784799, unseen = -1.791759469228055,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 4}}),
+       ("mois (grain)",
+        Classifier{okData =
+                     ClassData{prior = 0.0, unseen = -2.3978952727983707,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 9},
+                   koData =
+                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
+                               likelihoods = HashMap.fromList [], n = 0}}),
+       ("intersect by 'mais/par exemple/plut\244t'",
+        Classifier{okData =
+                     ClassData{prior = 0.0, unseen = -3.8066624897703196,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("dayhour", -2.3978952727983707),
+                                    ("named-dayentre <time-of-day> et <time-of-day> (interval)",
+                                     -1.5869650565820417),
+                                    ("le <day-of-month> (non ordinal)<time-of-day> heures",
+                                     -3.0910424533583156),
+                                    ("le <day-of-month> (non ordinal)\224|vers <time-of-day>",
+                                     -2.6855773452501515),
+                                    ("dayminute", -0.9509762898620451),
+                                    ("named-dayentre <datetime> et <datetime> (interval)",
+                                     -1.5869650565820417)],
+                               n = 19},
+                   koData =
+                     ClassData{prior = -infinity, unseen = -1.9459101490553135,
+                               likelihoods = HashMap.fromList [], n = 0}}),
+       ("de <datetime> - <datetime> (interval)",
+        Classifier{okData =
+                     ClassData{prior = -1.410986973710262, unseen = -4.143134726391533,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("day of month (premier)<day-of-week> <day-of-month>",
+                                     -3.4339872044851463),
+                                    ("hh(:|h)mm (time-of-day)<hour-of-day> <integer> (as relative minutes)",
+                                     -3.4339872044851463),
+                                    ("minuteminute", -2.517696472610991),
+                                    ("hh(:|h)mm (time-of-day)hh(:|h)mm (time-of-day)",
+                                     -3.4339872044851463),
+                                    ("dayday", -2.517696472610991),
+                                    ("<day-of-month> <named-month>day of month (premier)",
+                                     -3.4339872044851463),
+                                    ("minutehour", -3.028522096376982),
+                                    ("<hour-of-day> <integer> (as relative minutes)<time-of-day> heures",
+                                     -3.4339872044851463),
+                                    ("<hour-of-day> <integer> (as relative minutes)hh(:|h)mm (time-of-day)",
+                                     -3.4339872044851463),
+                                    ("hh(:|h)mm (time-of-day)<time-of-day> heures",
+                                     -3.4339872044851463),
+                                    ("<hour-of-day> <integer> (as relative minutes)<hour-of-day> <integer> (as relative minutes)",
+                                     -3.4339872044851463),
+                                    ("<day-of-month> <named-month>intersect", -3.4339872044851463),
+                                    ("intersect<day-of-week> <day-of-month>", -3.4339872044851463)],
+                               n = 10},
+                   koData =
+                     ClassData{prior = -0.27958486221916157,
+                               unseen = -4.653960350157523,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("<hour-of-day> <integer> (as relative minutes)intersect",
+                                     -3.951243718581427),
+                                    ("<day-of-month> <named-month>time-of-day (latent)",
+                                     -3.951243718581427),
+                                    ("hourday", -3.0349529867072724),
+                                    ("dayhour", -3.951243718581427),
+                                    ("yearhour", -3.951243718581427),
+                                    ("intersectnamed-day", -3.951243718581427),
+                                    ("time-of-day (latent)year (latent)", -3.951243718581427),
+                                    ("houryear", -3.951243718581427),
+                                    ("day of month (premier)named-day", -3.951243718581427),
+                                    ("time-of-day (latent)intersect", -3.545778610473263),
+                                    ("year (latent)intersect", -3.545778610473263),
+                                    ("yearyear", -3.951243718581427),
+                                    ("time-of-day (latent)time-of-day (latent)",
+                                     -3.951243718581427),
+                                    ("dayday", -2.2464956263430023),
+                                    ("year (latent)year (latent)", -3.951243718581427),
+                                    ("<day-of-week> <day-of-month><day-of-week> <day-of-month>",
+                                     -3.951243718581427),
+                                    ("hourhour", -3.951243718581427),
+                                    ("time-of-day (latent)<day-of-week> <day-of-month>",
+                                     -3.951243718581427),
+                                    ("minutehour", -2.4471663218051534),
+                                    ("hh(:|h)mm (time-of-day)time-of-day (latent)",
+                                     -3.545778610473263),
+                                    ("year (latent)<day-of-week> <day-of-month>",
+                                     -3.951243718581427),
+                                    ("year (latent)time-of-day (latent)", -3.951243718581427),
+                                    ("<hour-of-day> <integer> (as relative minutes)<time-of-day> heures",
+                                     -3.951243718581427),
+                                    ("year (latent)named-day", -3.951243718581427),
+                                    ("time-of-day (latent)named-day", -3.951243718581427),
+                                    ("day of month (premier)intersect", -3.545778610473263),
+                                    ("hh(:|h)mm (time-of-day)<time-of-day> heures",
+                                     -3.951243718581427),
+                                    ("intersectintersect", -3.545778610473263),
+                                    ("hh(:|h)mm (time-of-day)intersect", -3.951243718581427),
+                                    ("yearday", -3.0349529867072724),
+                                    ("<hour-of-day> <integer> (as relative minutes)time-of-day (latent)",
+                                     -3.545778610473263),
+                                    ("<day-of-week> <day-of-month>named-day", -3.951243718581427),
+                                    ("<day-of-week> <day-of-month>intersect", -3.545778610473263)],
+                               n = 31}}),
+       ("<ordinal> <cycle> de <time>",
+        Classifier{okData =
+                     ClassData{prior = 0.0, unseen = -2.890371757896165,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("daymonth", -1.7346010553881064),
+                                    ("ordinals (premier..seizieme)semaine (grain)named-month",
+                                     -1.7346010553881064),
+                                    ("ordinal (digits)jour (grain)named-month",
+                                     -1.7346010553881064),
+                                    ("weekmonth", -1.2237754316221157),
+                                    ("ordinals (premier..seizieme)semaine (grain)intersect",
+                                     -1.7346010553881064)],
+                               n = 6},
+                   koData =
+                     ClassData{prior = -infinity, unseen = -1.791759469228055,
+                               likelihoods = HashMap.fromList [], n = 0}}),
+       ("premi\232re quinzaine de <named-month>(interval)",
+        Classifier{okData =
+                     ClassData{prior = 0.0, unseen = -1.6094379124341003,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("named-month", -0.6931471805599453),
+                                    ("month", -0.6931471805599453)],
+                               n = 1},
+                   koData =
+                     ClassData{prior = -infinity, unseen = -1.0986122886681098,
+                               likelihoods = HashMap.fromList [], n = 0}}),
+       ("n <cycle> suivants",
+        Classifier{okData =
+                     ClassData{prior = -0.6931471805599453,
+                               unseen = -2.3978952727983707,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("hour", -1.6094379124341003), ("month", -1.6094379124341003),
+                                    ("integer (numeric)mois (grain)", -1.6094379124341003),
+                                    ("integer (numeric)heure (grain)", -1.6094379124341003)],
+                               n = 2},
+                   koData =
+                     ClassData{prior = -0.6931471805599453,
+                               unseen = -2.3978952727983707,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("number (0..16)jour (grain)", -1.2039728043259361),
+                                    ("day", -1.2039728043259361)],
+                               n = 2}}),
+       ("intersect",
+        Classifier{okData =
+                     ClassData{prior = -0.24867991464851183,
+                               unseen = -7.182352111885263,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("apr\232s <time-of-day>named-month", -5.795297583491974),
+                                    ("<day-of-month> <named-month><dim time> <part-of-day>",
+                                     -6.082979655943755),
+                                    ("intersect<dim time> du matin", -6.082979655943755),
+                                    ("<hour-of-day> <integer> (as relative minutes)intersect",
+                                     -6.082979655943755),
+                                    ("hh(:|h)mm (time-of-day)named-day", -6.082979655943755),
+                                    ("<day-of-month> <named-month>d\233but de journ\233e",
+                                     -6.48844476405192),
+                                    ("demain<time-of-day> heures", -6.082979655943755),
+                                    ("hourday", -4.237152965445424),
+                                    ("<day-of-month> <named-month>year", -5.795297583491974),
+                                    ("dayhour", -1.6132474408507682),
+                                    ("daymonth", -3.070718080438554),
+                                    ("monthyear", -4.984367367275645),
+                                    ("<day-of-month> <named-month>d\233but de matin\233e",
+                                     -6.48844476405192),
+                                    ("dernier <cycle> de <time> (latent)year", -5.572154032177765),
+                                    ("aujourd'huimilieu d'apr\232s-midi", -6.48844476405192),
+                                    ("named-month<dim time> du matin", -6.082979655943755),
+                                    ("<day-of-month> <named-month>\224|vers <time-of-day>",
+                                     -4.348378600555649),
+                                    ("dd mmyear", -5.235681795556552),
+                                    ("named-monthd\233but d'apr\232s-midi", -6.48844476405192),
+                                    ("aujourd'huifin d'apr\232s-midi", -6.48844476405192),
+                                    ("le <day-of-month> (non ordinal)<dim time> du matin",
+                                     -6.082979655943755),
+                                    ("named-monthd\233but de matin\233e", -6.48844476405192),
+                                    ("aujourd'huimilieu de matin\233e", -6.48844476405192),
+                                    ("hh(:|h)mm (time-of-day)<day-of-week> <day-of-month>",
+                                     -6.48844476405192),
+                                    ("named-month\224|vers <time-of-day>", -5.235681795556552),
+                                    ("named-dayday of month (premier)", -5.795297583491974),
+                                    ("<time-of-day> heuresdu|dans le <part-of-day>",
+                                     -4.984367367275645),
+                                    ("named-monthd\233but de soir\233e", -6.48844476405192),
+                                    ("<hour-of-day> et quart<dim time> <part-of-day>",
+                                     -5.795297583491974),
+                                    ("<day-of-week> <day-of-month>named-month", -5.795297583491974),
+                                    ("le <time>du|dans le <part-of-day>", -5.572154032177765),
+                                    ("aujourd'huifin de matin\233e", -6.48844476405192),
+                                    ("aujourd'huifin de soir\233e", -6.48844476405192),
+                                    ("\224|vers <time-of-day>ce <part-of-day>", -5.795297583491974),
+                                    ("<day-of-month> <named-month>d\233but d'apr\232s-midi",
+                                     -6.48844476405192),
+                                    ("le <day-of-month> (non ordinal)<dim time> du soir",
+                                     -5.235681795556552),
+                                    ("named-monthmilieu de matin\233e", -6.48844476405192),
+                                    ("aujourd'huid\233but de soir\233e", -6.48844476405192),
+                                    ("named-monthfin de soir\233e", -6.48844476405192),
+                                    ("entre <datetime> et <datetime> (interval)named-day",
+                                     -6.082979655943755),
+                                    ("<hour-of-day> et demice <part-of-day>", -5.795297583491974),
+                                    ("le <time>fin de matin\233e", -6.48844476405192),
+                                    ("intersectmilieu de journ\233e", -6.48844476405192),
+                                    ("intersectfin de journ\233e", -6.48844476405192),
+                                    ("le <day-of-month> (non ordinal)<time-of-day> heures",
+                                     -4.879006851617819),
+                                    ("<hour-of-day> <integer> (as relative minutes)<day-of-week> <day-of-month>",
+                                     -6.48844476405192),
+                                    ("le <day-of-month> (non ordinal)named-month",
+                                     -3.923495406590383),
+                                    ("monthhour", -3.8857550786075357),
+                                    ("le <time><time-of-day> heures", -5.38983247538381),
+                                    ("le <time>fin d'apr\232s-midi", -6.48844476405192),
+                                    ("hourmonth", -4.984367367275645),
+                                    ("named-monthmilieu d'apr\232s-midi", -6.48844476405192),
+                                    ("<time-of-day> heuresle <time>", -4.984367367275645),
+                                    ("dayday", -4.137069506888442),
+                                    ("aujourd'hui<hour-of-day> <integer> (as relative minutes)",
+                                     -5.795297583491974),
+                                    ("apr\232s <time-of-day>named-day", -6.082979655943755),
+                                    ("named-dayle <cycle> prochain|suivant|d'apr\232s",
+                                     -5.102150402932029),
+                                    ("named-dayapr\232s <time-of-day>", -5.38983247538381),
+                                    ("hourhour", -3.4680198779075573),
+                                    ("<day-of-week> <day-of-month>\224|vers <time-of-day>",
+                                     -4.783696671813495),
+                                    ("le <time>intersect", -5.795297583491974),
+                                    ("\224|vers <time-of-day><dim time> <part-of-day>",
+                                     -6.48844476405192),
+                                    ("aujourd'huiau d\233jeuner", -6.48844476405192),
+                                    ("<time-of-day> heuresintersect", -5.572154032177765),
+                                    ("intersectnamed-month", -4.879006851617819),
+                                    ("intersect<time-of-day> heures", -5.795297583491974),
+                                    ("<hour-of-day> et quartce <part-of-day>", -5.795297583491974),
+                                    ("dayyear", -4.090549491253549),
+                                    ("named-dayce|dans le <cycle>", -5.795297583491974),
+                                    ("apr\232s-demain\224|vers <time-of-day>", -5.572154032177765),
+                                    ("intersectfin d'apr\232s-midi", -6.48844476405192),
+                                    ("le <ordinal> <cycle> de <time>year", -6.48844476405192),
+                                    ("intersectmilieu d'apr\232s-midi", -6.48844476405192),
+                                    ("named-monthfin de journ\233e", -6.48844476405192),
+                                    ("le <time>milieu de journ\233e", -6.48844476405192),
+                                    ("aujourd'huid\233but de journ\233e", -6.48844476405192),
+                                    ("demain\224|vers <time-of-day>", -5.572154032177765),
+                                    ("le <day-of-month> (non ordinal)intersect",
+                                     -3.544005784885479),
+                                    ("hourminute", -6.48844476405192),
+                                    ("dd-dd <month>(interval)year", -6.48844476405192),
+                                    ("intersect<day-of-month> <named-month>", -6.082979655943755),
+                                    ("minutemonth", -6.082979655943755),
+                                    ("\224|vers <time-of-day>demain", -6.48844476405192),
+                                    ("minutehour", -4.616642587150328),
+                                    ("named-daydu|dans le <part-of-day>", -6.082979655943755),
+                                    ("aujourd'huimilieu de journ\233e", -6.48844476405192),
+                                    ("named-monthyear", -4.984367367275645),
+                                    ("intersectd\233but de soir\233e", -6.48844476405192),
+                                    ("entre <datetime> et <datetime> (interval)named-month",
+                                     -6.48844476405192),
+                                    ("aujourd'huifin de journ\233e", -6.48844476405192),
+                                    ("intersectdu|dans le <part-of-day>", -4.137069506888442),
+                                    ("le <day-of-month> \224 <datetime>du|dans le <part-of-day>",
+                                     -6.082979655943755),
+                                    ("named-monthd\233but de journ\233e", -6.48844476405192),
+                                    ("named-month<dim time> <part-of-day>", -6.082979655943755),
+                                    ("le <day-of-month> (non ordinal)apr\232s <time-of-day>",
+                                     -6.48844476405192),
+                                    ("named-day<day-of-month> <named-month>", -5.795297583491974),
+                                    ("named-dayle <time>", -4.348378600555649),
+                                    ("le <day-of-month> (non ordinal)<dim time> <part-of-day>",
+                                     -4.090549491253549),
+                                    ("dd/-mm<time-of-day> heures", -6.082979655943755),
+                                    ("de <datetime> - <datetime> (interval)named-month",
+                                     -6.082979655943755),
+                                    ("apr\232s <time-of-day>le <time>", -5.572154032177765),
+                                    ("named-day<time-of-day> heures", -5.795297583491974),
+                                    ("intersectd\233but d'apr\232s-midi", -6.48844476405192),
+                                    ("named-dayfin d'apr\232s-midi", -6.082979655943755),
+                                    ("<hour-of-day> et quartdemain", -5.795297583491974),
+                                    ("<time-of-day> heuresce <time>", -6.48844476405192),
+                                    ("le <time>d\233but d'apr\232s-midi", -6.48844476405192),
+                                    ("<day-of-month> <named-month>du|dans le <part-of-day>",
+                                     -6.082979655943755),
+                                    ("named-dayintersect", -6.48844476405192),
+                                    ("le <time><dim time> du matin", -6.082979655943755),
+                                    ("apr\232s <time-of-day>intersect", -6.082979655943755),
+                                    ("le <day-of-month> (non ordinal)\224|vers <time-of-day>",
+                                     -4.542534614996606),
+                                    ("<day-of-month> <named-month>d\233but de soir\233e",
+                                     -6.48844476405192),
+                                    ("hierdu|dans le <part-of-day>", -6.48844476405192),
+                                    ("le <time>d\233but de soir\233e", -6.48844476405192),
+                                    ("intersect<dim time> <part-of-day>", -6.082979655943755),
+                                    ("dayminute", -4.783696671813495),
+                                    ("intersectd\233but de journ\233e", -6.48844476405192),
+                                    ("<ordinal> <cycle> de <time>year", -6.082979655943755),
+                                    ("le <time>\224|vers <time-of-day>", -4.783696671813495),
+                                    ("<day-of-month> <named-month><dim time> du matin",
+                                     -6.082979655943755),
+                                    ("intersectyear", -5.795297583491974),
+                                    ("<day-of-week> <day-of-month><time-of-day> heures",
+                                     -5.38983247538381),
+                                    ("minuteday", -3.5180302984822185),
+                                    ("le <time>d\233but de matin\233e", -6.48844476405192),
+                                    ("<datetime> - <datetime> (interval)named-month",
+                                     -5.235681795556552),
+                                    ("<day-of-month> <named-month><time-of-day> heures",
+                                     -4.984367367275645),
+                                    ("aujourd'hui\224|vers <time-of-day>", -5.572154032177765),
+                                    ("<day-of-month> <named-month>milieu d'apr\232s-midi",
+                                     -6.48844476405192),
+                                    ("day of month (premier)intersect", -6.48844476405192),
+                                    ("<day-of-month> <named-month>fin d'apr\232s-midi",
+                                     -6.48844476405192),
+                                    ("entre <time-of-day> et <time-of-day> (interval)named-day",
+                                     -6.082979655943755),
+                                    ("named-monthfin de matin\233e", -6.48844476405192),
+                                    ("named-day<named-month|named-day> suivant|d'apr\232s",
+                                     -5.572154032177765),
+                                    ("le <time>milieu de matin\233e", -6.48844476405192),
+                                    ("aujourd'huid\233but de matin\233e", -5.38983247538381),
+                                    ("<dim time> <part-of-day>apr\232s <time-of-day>",
+                                     -6.48844476405192),
+                                    ("le <time>fin de soir\233e", -6.48844476405192),
+                                    ("<day-of-month> <named-month>milieu de matin\233e",
+                                     -6.48844476405192),
+                                    ("<day-of-month> <named-month>fin de soir\233e",
+                                     -6.48844476405192),
+                                    ("named-month<time-of-day> heures", -5.795297583491974),
+                                    ("<day-of-month> <named-month>fin de matin\233e",
+                                     -6.48844476405192),
+                                    ("<time-of-day> heuresce <part-of-day>", -5.795297583491974),
+                                    ("named-monthfin d'apr\232s-midi", -6.48844476405192),
+                                    ("le <time>named-month", -5.235681795556552),
+                                    ("apr\232s le <day-of-month>named-month", -6.48844476405192),
+                                    ("aujourd'huid\233but d'apr\232s-midi", -6.48844476405192),
+                                    ("le <time>milieu d'apr\232s-midi", -6.48844476405192),
+                                    ("\224|vers <time-of-day>du|dans le <part-of-day>",
+                                     -5.38983247538381),
+                                    ("intersectintersect", -6.082979655943755),
+                                    ("de <time-of-day> - <time-of-day> (interval)named-day",
+                                     -5.572154032177765),
+                                    ("de <datetime> - <datetime> (interval)named-day",
+                                     -6.082979655943755),
+                                    ("named-dayde <time-of-day> - <time-of-day> (interval)",
+                                     -6.082979655943755),
+                                    ("dayweek", -4.2912201867157), ("weekyear", -5.102150402932029),
+                                    ("<hour-of-day> <integer> (as relative minutes)named-day",
+                                     -6.082979655943755),
+                                    ("hh(:|h)mm (time-of-day)intersect", -6.082979655943755),
+                                    ("named-monthintersect", -6.082979655943755),
+                                    ("<day-of-month> <named-month>fin de journ\233e",
+                                     -6.48844476405192),
+                                    ("<day-of-month> <named-month>milieu de journ\233e",
+                                     -6.48844476405192),
+                                    ("le <time>fin de journ\233e", -6.48844476405192),
+                                    ("dd/-mm\224|vers <time-of-day>", -5.572154032177765),
+                                    ("intersectfin de matin\233e", -6.48844476405192),
+                                    ("day of month (premier)named-month", -4.696685294823864),
+                                    ("named-day\224|vers <time-of-day>", -5.102150402932029),
+                                    ("named-monthmilieu de journ\233e", -6.48844476405192),
+                                    ("<day-of-month> <named-month>intersect", -6.082979655943755),
+                                    ("intersectfin de soir\233e", -6.48844476405192),
+                                    ("intersectmilieu de matin\233e", -6.48844476405192),
+                                    ("intersect\224|vers <time-of-day>", -5.235681795556552),
+                                    ("le <time>year", -4.984367367275645),
+                                    ("le <time><dim time> <part-of-day>", -6.082979655943755),
+                                    ("<time-of-day> - <time-of-day> (interval)named-day",
+                                     -5.235681795556552),
+                                    ("apr\232s-demain<time-of-day> heures", -6.082979655943755),
+                                    ("le <time>d\233but de journ\233e", -6.48844476405192),
+                                    ("intersectd\233but de matin\233e", -6.48844476405192),
+                                    ("<datetime> - <datetime> (interval)named-day",
+                                     -5.572154032177765)],
+                               n = 549},
+                   koData =
+                     ClassData{prior = -1.5133532392387958, unseen = -6.269096283706261,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("<hour-of-day> <integer> (as relative minutes)intersect",
+                                     -5.574053367981417),
+                                    ("hh(:|h)mm (time-of-day)named-day", -5.574053367981417),
+                                    ("year<time-of-day> - <time-of-day> (interval)",
+                                     -4.880906187421472),
+                                    ("demain<time-of-day> heures", -4.880906187421472),
+                                    ("hourday", -3.2226781108179394),
+                                    ("<day-of-month> <named-month>year", -5.574053367981417),
+                                    ("demainavant <time-of-day>", -5.574053367981417),
+                                    ("dayhour", -2.529530930257994),
+                                    ("le lendemain du <time>named-month", -5.574053367981417),
+                                    ("daymonth", -3.9646154555473165),
+                                    ("monthday", -5.574053367981417),
+                                    ("monthyear", -4.880906187421472),
+                                    ("yearhour", -4.880906187421472),
+                                    ("houryear", -5.168588259873252),
+                                    ("aujourd'hui<time-of-day> heures", -5.574053367981417),
+                                    ("named-month\224|vers <time-of-day>", -3.8693052757429918),
+                                    ("<time-of-day> heuresdu|dans le <part-of-day>",
+                                     -4.880906187421472),
+                                    ("<day-of-week> <day-of-month>named-month", -4.187759006861526),
+                                    ("le <time>du|dans le <part-of-day>", -5.168588259873252),
+                                    ("le <day-of-month> (non ordinal)<hour-of-day> <integer> (as relative minutes)",
+                                     -4.880906187421472),
+                                    ("named-month<day-of-month> <named-month>", -5.574053367981417),
+                                    ("<time-of-day> heuresle <day-of-month> (non ordinal)",
+                                     -4.657762636107262),
+                                    ("le <day-of-month> (non ordinal)<time-of-day> heures",
+                                     -5.574053367981417),
+                                    ("aujourd'huidu|dans le <part-of-day>", -5.168588259873252),
+                                    ("le <day-of-month> (non ordinal)named-month",
+                                     -5.574053367981417),
+                                    ("monthhour", -3.3768287906451975),
+                                    ("hourmonth", -4.321290399486049),
+                                    ("dayday", -3.782293898753362),
+                                    ("named-dayapr\232s <time-of-day>", -4.880906187421472),
+                                    ("hourhour", -3.9646154555473165),
+                                    ("named-day<hour-of-day> <integer> (as relative minutes)",
+                                     -4.657762636107262),
+                                    ("dayyear", -4.321290399486049),
+                                    ("le <cycle> de <time>named-month", -5.168588259873252),
+                                    ("year<hour-of-day> <integer> (as relative minutes)",
+                                     -4.880906187421472),
+                                    ("demain\224|vers <time-of-day>", -4.657762636107262),
+                                    ("<dim time> <part-of-day><hour-of-day> <integer> (as relative minutes)",
+                                     -5.168588259873252),
+                                    ("hourminute", -5.168588259873252),
+                                    ("minutemonth", -4.880906187421472),
+                                    ("named-monthyear", -4.880906187421472),
+                                    ("intersect by 'de' or ','year", -5.168588259873252),
+                                    ("named-day<time-of-day> - <time-of-day> (interval)",
+                                     -3.8693052757429918),
+                                    ("named-day<datetime> - <datetime> (interval)",
+                                     -5.168588259873252),
+                                    ("named-day<day-of-month> <named-month>", -4.187759006861526),
+                                    ("weekmonth", -5.168588259873252),
+                                    ("named-dayle <time>", -5.168588259873252),
+                                    ("avant <time-of-day>named-day", -5.574053367981417),
+                                    ("de <datetime> - <datetime> (interval)named-month",
+                                     -5.574053367981417),
+                                    ("le <day-of-month> (non ordinal)year", -5.168588259873252),
+                                    ("named-day<time-of-day> heures", -5.168588259873252),
+                                    ("<time-of-day> heuresnamed-day", -4.069975971205143),
+                                    ("apr\232s <time-of-day><time-of-day> heures",
+                                     -5.168588259873252),
+                                    ("<time-of-day> heuresdd/-mm", -5.574053367981417),
+                                    ("<time-of-day> - <time-of-day> (interval)du|dans le <part-of-day>",
+                                     -5.168588259873252),
+                                    ("<hour-of-day> <integer> (as relative minutes)named-month",
+                                     -5.168588259873252),
+                                    ("le <day-of-month> (non ordinal)\224|vers <time-of-day>",
+                                     -4.880906187421472),
+                                    ("dayminute", -4.187759006861526),
+                                    ("named-monthdu|dans le <part-of-day>", -5.168588259873252),
+                                    ("intersectyear", -5.168588259873252),
+                                    ("minuteday", -4.880906187421472),
+                                    ("aujourd'hui\224|vers <time-of-day>", -4.880906187421472),
+                                    ("<datetime>-dd <month>(interval)year", -5.168588259873252),
+                                    ("<time-of-day> - <time-of-day> (interval)named-month",
+                                     -4.657762636107262),
+                                    ("le <day-of-month> (non ordinal)avant <time-of-day>",
+                                     -5.574053367981417),
+                                    ("<dim time> <part-of-day>apr\232s <time-of-day>",
+                                     -5.574053367981417),
+                                    ("named-month<time-of-day> heures", -4.475441079313307),
+                                    ("demainapr\232s <time-of-day>", -5.574053367981417),
+                                    ("<hour-of-day> <integer> (as relative minutes)named-day",
+                                     -5.168588259873252),
+                                    ("<hour-of-day> <integer> (as relative minutes)year",
+                                     -4.657762636107262),
+                                    ("<time-of-day> - <time-of-day> (interval)intersect",
+                                     -5.574053367981417),
+                                    ("apr\232s <time-of-day>\224|vers <time-of-day>",
+                                     -4.657762636107262),
+                                    ("\224|vers <time-of-day>named-day", -4.880906187421472),
+                                    ("le <time>year", -5.168588259873252),
+                                    ("apr\232s <time-of-day>le <day-of-month> (non ordinal)",
+                                     -5.168588259873252),
+                                    ("de <datetime> - <datetime> (interval)<day-of-month> <named-month>",
+                                     -5.574053367981417),
+                                    ("minuteyear", -4.187759006861526),
+                                    ("yearminute", -4.880906187421472),
+                                    ("<dim time> <part-of-day><time-of-day> heures",
+                                     -5.574053367981417)],
+                               n = 155}}),
+       ("season",
+        Classifier{okData =
+                     ClassData{prior = 0.0, unseen = -1.3862943611198906,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 2},
+                   koData =
+                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
+                               likelihoods = HashMap.fromList [], n = 0}}),
+       ("ce <day-of-week>",
+        Classifier{okData =
+                     ClassData{prior = 0.0, unseen = -1.6094379124341003,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("day", -0.6931471805599453),
+                                    ("named-day", -0.6931471805599453)],
+                               n = 1},
+                   koData =
+                     ClassData{prior = -infinity, unseen = -1.0986122886681098,
+                               likelihoods = HashMap.fromList [], n = 0}}),
+       ("le <cycle> de <time>",
+        Classifier{okData =
+                     ClassData{prior = -0.8472978603872037, unseen = -2.70805020110221,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("monthmonth", -1.9459101490553135),
+                                    ("mois (grain)named-month", -1.9459101490553135),
+                                    ("weekday", -1.540445040947149),
+                                    ("semaine (grain)<day-of-month> <named-month>",
+                                     -1.540445040947149)],
+                               n = 3},
+                   koData =
+                     ClassData{prior = -0.5596157879354228, unseen = -2.833213344056216,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("semaine (grain)year (latent)", -1.6739764335716716),
+                                    ("weekhour", -1.6739764335716716),
+                                    ("semaine (grain)time-of-day (latent)", -1.6739764335716716),
+                                    ("weekyear", -1.6739764335716716)],
+                               n = 4}}),
+       ("<hour-of-day> et trois quarts",
+        Classifier{okData =
+                     ClassData{prior = 0.0, unseen = -1.6094379124341003,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("hour", -0.6931471805599453),
+                                    ("<time-of-day> heures", -0.6931471805599453)],
+                               n = 1},
+                   koData =
+                     ClassData{prior = -infinity, unseen = -1.0986122886681098,
+                               likelihoods = HashMap.fromList [], n = 0}}),
+       ("le <day-of-month> \224 <datetime>",
+        Classifier{okData =
+                     ClassData{prior = -0.325422400434628, unseen = -3.58351893845611,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("integer (numeric)<time-of-day> heures", -1.9459101490553135),
+                                    ("integer (numeric)<dim time> du soir", -2.8622008809294686),
+                                    ("integer (numeric)intersect", -2.456735772821304),
+                                    ("integer (numeric)<dim time> du matin", -2.8622008809294686),
+                                    ("hour", -0.916290731874155),
+                                    ("integer (numeric)time-of-day (latent)", -2.169053700369523),
+                                    ("integer (numeric)<dim time> <part-of-day>",
+                                     -2.456735772821304)],
+                               n = 13},
+                   koData =
+                     ClassData{prior = -1.2809338454620642, unseen = -2.995732273553991,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("integer (numeric)year (latent)", -1.3350010667323402),
+                                    ("year", -1.3350010667323402), ("hour", -2.2512917986064953),
+                                    ("integer (numeric)time-of-day (latent)", -2.2512917986064953)],
+                               n = 5}}),
+       ("yyyy-mm-dd",
+        Classifier{okData =
+                     ClassData{prior = 0.0, unseen = -1.6094379124341003,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 3},
+                   koData =
+                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
+                               likelihoods = HashMap.fromList [], n = 0}}),
+       ("le <cycle> dernier",
+        Classifier{okData =
+                     ClassData{prior = 0.0, unseen = -2.70805020110221,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("week", -1.540445040947149),
+                                    ("ann\233e (grain)", -1.9459101490553135),
+                                    ("semaine (grain)", -1.540445040947149),
+                                    ("mois (grain)", -1.9459101490553135),
+                                    ("year", -1.9459101490553135), ("month", -1.9459101490553135)],
+                               n = 4},
+                   koData =
+                     ClassData{prior = -infinity, unseen = -1.9459101490553135,
+                               likelihoods = HashMap.fromList [], n = 0}}),
+       ("year (latent)",
+        Classifier{okData =
+                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
+                               likelihoods = HashMap.fromList [], n = 0},
+                   koData =
+                     ClassData{prior = 0.0, unseen = -3.044522437723423,
+                               likelihoods = HashMap.fromList [("integer (numeric)", 0.0)],
+                               n = 19}}),
+       ("soir de no\235l",
+        Classifier{okData =
+                     ClassData{prior = 0.0, unseen = -1.0986122886681098,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 1},
+                   koData =
+                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
+                               likelihoods = HashMap.fromList [], n = 0}}),
+       ("fin de journ\233e",
+        Classifier{okData =
+                     ClassData{prior = 0.0, unseen = -1.791759469228055,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 4},
+                   koData =
+                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
+                               likelihoods = HashMap.fromList [], n = 0}}),
+       ("du <datetime>-<day-of-week> dd <month>(interval)",
+        Classifier{okData =
+                     ClassData{prior = -0.5108256237659907, unseen = -2.70805020110221,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("intersectnamed-daynamed-month", -1.9459101490553135),
+                                    ("day of month (premier)named-daynamed-month",
+                                     -1.9459101490553135),
+                                    ("<day-of-week> <day-of-month>named-daynamed-month",
+                                     -1.9459101490553135),
+                                    ("daydaymonth", -1.252762968495368)],
+                               n = 3},
+                   koData =
+                     ClassData{prior = -0.916290731874155, unseen = -2.5649493574615367,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("year (latent)named-daynamed-month", -1.791759469228055),
+                                    ("hourdaymonth", -1.791759469228055),
+                                    ("time-of-day (latent)named-daynamed-month",
+                                     -1.791759469228055),
+                                    ("yeardaymonth", -1.791759469228055)],
+                               n = 2}}),
+       ("milieu de semaine",
+        Classifier{okData =
+                     ClassData{prior = 0.0, unseen = -1.3862943611198906,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 2},
+                   koData =
+                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
+                               likelihoods = HashMap.fromList [], n = 0}}),
+       ("d\233but d'ann\233e",
+        Classifier{okData =
+                     ClassData{prior = 0.0, unseen = -1.3862943611198906,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 2},
+                   koData =
+                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
+                               likelihoods = HashMap.fromList [], n = 0}}),
+       ("noel",
+        Classifier{okData =
+                     ClassData{prior = -0.2876820724517809,
+                               unseen = -1.6094379124341003,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 3},
+                   koData =
+                     ClassData{prior = -1.3862943611198906,
+                               unseen = -1.0986122886681098,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 1}}),
+       ("fin de matin\233e",
+        Classifier{okData =
+                     ClassData{prior = 0.0, unseen = -1.6094379124341003,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 3},
+                   koData =
+                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
+                               likelihoods = HashMap.fromList [], n = 0}}),
+       ("le <day-of-month> (non ordinal)",
+        Classifier{okData =
+                     ClassData{prior = -0.35667494393873245,
+                               unseen = -3.951243718581427,
+                               likelihoods =
+                                 HashMap.fromList [("integer (numeric)", -1.9802627296179754e-2)],
+                               n = 49},
+                   koData =
+                     ClassData{prior = -1.2039728043259361,
+                               unseen = -3.1780538303479458,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("integer (numeric)", -0.24512245803298496),
+                                    ("numbers 22..29 32..39 .. 52..59", -1.5260563034950494)],
+                               n = 21}}),
+       ("du dd-<day-of-week> dd <month>(interval)",
+        Classifier{okData =
+                     ClassData{prior = 0.0, unseen = -1.6094379124341003,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("named-daynamed-month", -0.6931471805599453),
+                                    ("daymonth", -0.6931471805599453)],
+                               n = 1},
+                   koData =
+                     ClassData{prior = -infinity, unseen = -1.0986122886681098,
+                               likelihoods = HashMap.fromList [], n = 0}}),
+       ("en semaine",
+        Classifier{okData =
+                     ClassData{prior = -1.2656663733312759,
+                               unseen = -2.5649493574615367,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 11},
+                   koData =
+                     ClassData{prior = -0.3313571359544425,
+                               unseen = -3.4011973816621555,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 28}}),
+       ("numbers 22..29 32..39 .. 52..59",
+        Classifier{okData =
+                     ClassData{prior = -2.3025850929940455,
+                               unseen = -1.6094379124341003,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("number (20..60)number (0..16)", -0.6931471805599453)],
+                               n = 1},
+                   koData =
+                     ClassData{prior = -0.10536051565782628,
+                               unseen = -2.5649493574615367,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("integer (numeric)integer (numeric)", -0.2876820724517809),
+                                    ("integer (numeric)number (0..16)", -1.791759469228055)],
+                               n = 9}}),
+       ("<day-of-week> prochain",
+        Classifier{okData =
+                     ClassData{prior = 0.0, unseen = -2.1972245773362196,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("day", -0.6931471805599453),
+                                    ("named-day", -0.6931471805599453)],
+                               n = 3},
+                   koData =
+                     ClassData{prior = -infinity, unseen = -1.0986122886681098,
+                               likelihoods = HashMap.fromList [], n = 0}}),
+       ("intersect by 'de' or ','",
+        Classifier{okData =
+                     ClassData{prior = -0.26469255422708216,
+                               unseen = -4.430816798843313,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("dayhour", -3.3202283191284883),
+                                    ("daymonth", -3.7256934272366524),
+                                    ("hourmonth", -3.7256934272366524),
+                                    ("dayday", -1.7797832781813394),
+                                    ("named-dayle <cycle> prochain|suivant|d'apr\232s",
+                                     -2.339399066116762),
+                                    ("named-day<time-of-day> - <time-of-day> (interval)",
+                                     -3.3202283191284883),
+                                    ("named-dayle <time>", -1.5284688499004333),
+                                    ("named-dayle <cycle> dernier", -3.7256934272366524),
+                                    ("named-day<named-month|named-day> suivant|d'apr\232s",
+                                     -2.8094026953624978),
+                                    ("week-endnamed-month", -3.7256934272366524),
+                                    ("dayweek", -1.5856272637403819),
+                                    ("fin du moisnamed-month", -3.7256934272366524)],
+                               n = 33},
+                   koData =
+                     ClassData{prior = -1.4586150226995167,
+                               unseen = -3.6375861597263857,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("hourday", -2.917770732084279),
+                                    ("dayhour", -2.917770732084279),
+                                    ("daymonth", -2.001480000210124),
+                                    ("du|dans le <part-of-day>noel", -2.917770732084279),
+                                    ("en semainenamed-month", -2.512305623976115),
+                                    ("hourmonth", -2.512305623976115),
+                                    ("dayday", -2.512305623976115),
+                                    ("en semaineintersect", -2.512305623976115),
+                                    ("named-dayle <time>", -2.512305623976115),
+                                    ("named-day<time-of-day> heures", -2.917770732084279),
+                                    ("week-endnamed-month", -2.512305623976115)],
+                               n = 10}}),
+       ("named-month",
+        Classifier{okData =
+                     ClassData{prior = 0.0, unseen = -4.624972813284271,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 100},
+                   koData =
+                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
+                               likelihoods = HashMap.fromList [], n = 0}}),
+       ("milieu d'apr\232s-midi",
+        Classifier{okData =
+                     ClassData{prior = 0.0, unseen = -1.791759469228055,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 4},
+                   koData =
+                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
+                               likelihoods = HashMap.fromList [], n = 0}}),
+       ("ce <part-of-day>",
+        Classifier{okData =
+                     ClassData{prior = 0.0, unseen = -2.772588722239781,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("soir", -1.6094379124341003),
+                                    ("apr\232s-midi", -1.0986122886681098),
+                                    ("hour", -0.7621400520468967)],
+                               n = 6},
+                   koData =
+                     ClassData{prior = -infinity, unseen = -1.3862943611198906,
+                               likelihoods = HashMap.fromList [], n = 0}}),
+       ("hh(:|h)mm (time-of-day)",
+        Classifier{okData =
+                     ClassData{prior = 0.0, unseen = -3.295836866004329,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 25},
+                   koData =
+                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
+                               likelihoods = HashMap.fromList [], n = 0}}),
+       ("number (20..60)",
+        Classifier{okData =
+                     ClassData{prior = 0.0, unseen = -1.791759469228055,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 4},
+                   koData =
+                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
+                               likelihoods = HashMap.fromList [], n = 0}}),
+       ("hier",
+        Classifier{okData =
+                     ClassData{prior = -0.2231435513142097, unseen = -1.791759469228055,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 4},
+                   koData =
+                     ClassData{prior = -1.6094379124341003,
+                               unseen = -1.0986122886681098,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 1}}),
+       ("plus tard",
+        Classifier{okData =
+                     ClassData{prior = -1.5040773967762742,
+                               unseen = -1.3862943611198906,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 2},
+                   koData =
+                     ClassData{prior = -0.25131442828090605,
+                               unseen = -2.1972245773362196,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 7}}),
+       ("numbers prefix with -, negative or minus",
+        Classifier{okData =
+                     ClassData{prior = -infinity, unseen = -1.3862943611198906,
+                               likelihoods = HashMap.fromList [], n = 0},
+                   koData =
+                     ClassData{prior = 0.0, unseen = -2.833213344056216,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("integer (numeric)", -0.2876820724517809),
+                                    ("numbers 22..29 32..39 .. 52..59", -2.0794415416798357),
+                                    ("number (0..16)", -2.0794415416798357)],
+                               n = 13}}),
+       ("dd-dd <month>(interval)",
+        Classifier{okData =
+                     ClassData{prior = 0.0, unseen = -2.3978952727983707,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("named-month", -0.6931471805599453),
+                                    ("month", -0.6931471805599453)],
+                               n = 4},
+                   koData =
+                     ClassData{prior = -infinity, unseen = -1.0986122886681098,
+                               likelihoods = HashMap.fromList [], n = 0}}),
+       ("plus tard <part-of-day>",
+        Classifier{okData =
+                     ClassData{prior = 0.0, unseen = -2.3978952727983707,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("du|dans le <part-of-day>", -0.6931471805599453),
+                                    ("hour", -0.6931471805599453)],
+                               n = 4},
+                   koData =
+                     ClassData{prior = -infinity, unseen = -1.0986122886681098,
+                               likelihoods = HashMap.fromList [], n = 0}}),
+       ("<datetime>-<day-of-week> dd <month>(interval)",
+        Classifier{okData =
+                     ClassData{prior = -0.6931471805599453,
+                               unseen = -3.2188758248682006,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("intersectnamed-daynamed-month", -2.0794415416798357),
+                                    ("day of month (premier)named-daynamed-month",
+                                     -1.791759469228055),
+                                    ("<day-of-week> <day-of-month>named-daynamed-month",
+                                     -1.791759469228055),
+                                    ("daydaymonth", -0.9808292530117262)],
+                               n = 8},
+                   koData =
+                     ClassData{prior = -0.6931471805599453,
+                               unseen = -3.2188758248682006,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("year (latent)named-daynamed-month", -1.5686159179138452),
+                                    ("hourdaymonth", -1.5686159179138452),
+                                    ("time-of-day (latent)named-daynamed-month",
+                                     -1.5686159179138452),
+                                    ("yeardaymonth", -1.5686159179138452)],
+                               n = 8}}),
+       ("<dim time> du soir",
+        Classifier{okData =
+                     ClassData{prior = -0.2231435513142097, unseen = -2.995732273553991,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("\224|vers <time-of-day>", -1.55814461804655),
+                                    ("hour", -0.7472144018302211),
+                                    ("<time-of-day> heures", -1.1526795099383855)],
+                               n = 8},
+                   koData =
+                     ClassData{prior = -1.6094379124341003,
+                               unseen = -2.0794415416798357,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("hour", -0.8472978603872037),
+                                    ("<time-of-day> heures", -0.8472978603872037)],
+                               n = 2}}),
+       ("aujourd'hui",
+        Classifier{okData =
+                     ClassData{prior = 0.0, unseen = -3.2188758248682006,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 23},
+                   koData =
+                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
+                               likelihoods = HashMap.fromList [], n = 0}}),
+       ("midi",
+        Classifier{okData =
+                     ClassData{prior = -1.157452788691043, unseen = -2.5649493574615367,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 11},
+                   koData =
+                     ClassData{prior = -0.37729423114146804,
+                               unseen = -3.258096538021482,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 24}}),
+       ("toussaint",
+        Classifier{okData =
+                     ClassData{prior = 0.0, unseen = -1.9459101490553135,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 5},
+                   koData =
+                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
+                               likelihoods = HashMap.fromList [], n = 0}}),
+       ("d\233but de soir\233e",
+        Classifier{okData =
+                     ClassData{prior = 0.0, unseen = -1.791759469228055,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 4},
+                   koData =
+                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
+                               likelihoods = HashMap.fromList [], n = 0}}),
+       ("<day-of-week> <day-of-month>",
+        Classifier{okData =
+                     ClassData{prior = -0.24512245803298496,
+                               unseen = -3.6888794541139363,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("named-daynumber (0..16)", -2.5649493574615367),
+                                    ("named-dayinteger (numeric)", -0.8303483020734304),
+                                    ("day", -0.719122666963206)],
+                               n = 18},
+                   koData =
+                     ClassData{prior = -1.5260563034950494, unseen = -2.639057329615259,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("named-dayinteger (numeric)", -0.7731898882334817),
+                                    ("day", -0.7731898882334817)],
+                               n = 5}}),
+       ("d'ici <duration>",
+        Classifier{okData =
+                     ClassData{prior = 0.0, unseen = -2.0794415416798357,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("week", -1.252762968495368), ("day", -1.252762968495368),
+                                    ("<integer> <unit-of-duration>", -0.8472978603872037)],
+                               n = 2},
+                   koData =
+                     ClassData{prior = -infinity, unseen = -1.3862943611198906,
+                               likelihoods = HashMap.fromList [], n = 0}}),
+       ("\224|vers <time-of-day>",
+        Classifier{okData =
+                     ClassData{prior = -0.21936282847430377,
+                               unseen = -5.420534999272286,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("<time> timezone", -4.722953221644475),
+                                    ("<hour-of-day> et|pass\233 de <number>", -4.31748811353631),
+                                    ("hh(:|h)mm (time-of-day)", -4.722953221644475),
+                                    ("midi", -4.31748811353631),
+                                    ("time-of-day (latent)", -1.587459005715325),
+                                    ("<hour-of-day> et|pass\233 de <number> minutes",
+                                     -4.31748811353631),
+                                    ("minuit", -4.722953221644475),
+                                    ("<hour-of-day> et quart", -4.31748811353631),
+                                    ("hour", -0.8622235106038793),
+                                    ("<hour-of-day> et demi", -4.722953221644475),
+                                    ("minute", -2.8511510447428834),
+                                    ("<time-of-day> heures", -1.587459005715325),
+                                    ("<hour-of-day> <integer> (as relative minutes)",
+                                     -3.8066624897703196)],
+                               n = 106},
+                   koData =
+                     ClassData{prior = -1.6247053845648889, unseen = -4.189654742026425,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("hh(:|h)mm (time-of-day)", -3.0757749812275272),
+                                    ("time-of-day (latent)", -1.5353299402803784),
+                                    ("hour", -1.0388930539664873), ("minute", -2.5649493574615367),
+                                    ("<time-of-day> heures", -1.8718021769015913),
+                                    ("<hour-of-day> <integer> (as relative minutes)",
+                                     -3.0757749812275272)],
+                               n = 26}}),
+       ("d\233but <named-month>(interval)",
+        Classifier{okData =
+                     ClassData{prior = 0.0, unseen = -2.3978952727983707,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("named-month", -0.6931471805599453),
+                                    ("month", -0.6931471805599453)],
+                               n = 4},
+                   koData =
+                     ClassData{prior = -infinity, unseen = -1.0986122886681098,
+                               likelihoods = HashMap.fromList [], n = 0}}),
+       ("d\233but de matin\233e",
+        Classifier{okData =
+                     ClassData{prior = 0.0, unseen = -2.5649493574615367,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 11},
+                   koData =
+                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
+                               likelihoods = HashMap.fromList [], n = 0}}),
+       ("apr\232s-midi",
+        Classifier{okData =
+                     ClassData{prior = -0.262364264467491, unseen = -2.4849066497880004,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 10},
+                   koData =
+                     ClassData{prior = -1.466337068793427, unseen = -1.6094379124341003,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 3}}),
+       ("le <ordinal> <cycle> de <time>",
+        Classifier{okData =
+                     ClassData{prior = 0.0, unseen = -2.4849066497880004,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("daymonth", -1.7047480922384253),
+                                    ("ordinals (premier..seizieme)semaine (grain)named-month",
+                                     -1.7047480922384253),
+                                    ("ordinal (digits)jour (grain)named-month",
+                                     -1.7047480922384253),
+                                    ("weekmonth", -1.2992829841302609),
+                                    ("ordinals (premier..seizieme)semaine (grain)intersect",
+                                     -1.7047480922384253)],
+                               n = 3},
+                   koData =
+                     ClassData{prior = -infinity, unseen = -1.791759469228055,
+                               likelihoods = HashMap.fromList [], n = 0}}),
+       ("ordinals (premier..seizieme)",
+        Classifier{okData =
+                     ClassData{prior = -0.916290731874155, unseen = -1.791759469228055,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 4},
+                   koData =
+                     ClassData{prior = -0.5108256237659907,
+                               unseen = -2.0794415416798357,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 6}}),
+       ("minute (grain)",
+        Classifier{okData =
+                     ClassData{prior = -0.2876820724517809,
+                               unseen = -2.3978952727983707,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 9},
+                   koData =
+                     ClassData{prior = -1.3862943611198906,
+                               unseen = -1.6094379124341003,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 3}}),
+       ("deuxi\232me quinzaine de <named-month>(interval)",
+        Classifier{okData =
+                     ClassData{prior = 0.0, unseen = -1.6094379124341003,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("named-month", -0.6931471805599453),
+                                    ("month", -0.6931471805599453)],
+                               n = 1},
+                   koData =
+                     ClassData{prior = -infinity, unseen = -1.0986122886681098,
+                               likelihoods = HashMap.fromList [], n = 0}}),
+       ("<dim time> <part-of-day>",
+        Classifier{okData =
+                     ClassData{prior = -8.183001824763224e-2,
+                               unseen = -5.834810737062605,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("<day-of-month> <named-month>d\233but de journ\233e",
+                                     -5.1387352967235715),
+                                    ("dayhour", -1.6123747721074102),
+                                    ("<day-of-month> <named-month>d\233but de matin\233e",
+                                     -5.1387352967235715),
+                                    ("aujourd'huimilieu d'apr\232s-midi", -5.1387352967235715),
+                                    ("named-monthd\233but d'apr\232s-midi", -5.1387352967235715),
+                                    ("aujourd'huifin d'apr\232s-midi", -5.1387352967235715),
+                                    ("named-monthd\233but de matin\233e", -5.1387352967235715),
+                                    ("aujourd'huimilieu de matin\233e", -5.1387352967235715),
+                                    ("<time-of-day> heuresdu|dans le <part-of-day>",
+                                     -3.6346578999472974),
+                                    ("named-monthd\233but de soir\233e", -5.1387352967235715),
+                                    ("le <time>du|dans le <part-of-day>", -4.222444564849416),
+                                    ("aujourd'huifin de matin\233e", -5.1387352967235715),
+                                    ("aujourd'huifin de soir\233e", -5.1387352967235715),
+                                    ("\224|vers <time-of-day>ce <part-of-day>", -4.445588116163626),
+                                    ("<day-of-month> <named-month>d\233but d'apr\232s-midi",
+                                     -5.1387352967235715),
+                                    ("named-daymatin", -4.733270188615407),
+                                    ("named-monthmilieu de matin\233e", -5.1387352967235715),
+                                    ("demainsoir", -5.1387352967235715),
+                                    ("aujourd'huid\233but de soir\233e", -5.1387352967235715),
+                                    ("named-monthfin de soir\233e", -5.1387352967235715),
+                                    ("<hour-of-day> et demice <part-of-day>", -4.445588116163626),
+                                    ("le <time>fin de matin\233e", -5.1387352967235715),
+                                    ("intersectmilieu de journ\233e", -5.1387352967235715),
+                                    ("intersectfin de journ\233e", -5.1387352967235715),
+                                    ("monthhour", -3.3469758274955166),
+                                    ("le <time>fin d'apr\232s-midi", -5.1387352967235715),
+                                    ("named-monthmilieu d'apr\232s-midi", -5.1387352967235715),
+                                    ("hourhour", -2.1430030231695802),
+                                    ("aujourd'huiau d\233jeuner", -5.1387352967235715),
+                                    ("<hour-of-day> et quartce <part-of-day>", -4.445588116163626),
+                                    ("intersectfin d'apr\232s-midi", -5.1387352967235715),
+                                    ("intersectmilieu d'apr\232s-midi", -5.1387352967235715),
+                                    ("named-monthfin de journ\233e", -5.1387352967235715),
+                                    ("le <time>milieu de journ\233e", -5.1387352967235715),
+                                    ("aujourd'huid\233but de journ\233e", -5.1387352967235715),
+                                    ("demainapr\232s-midi", -5.1387352967235715),
+                                    ("minutehour", -3.26693311982198),
+                                    ("named-daydu|dans le <part-of-day>", -4.733270188615407),
+                                    ("aujourd'huimilieu de journ\233e", -5.1387352967235715),
+                                    ("intersectd\233but de soir\233e", -5.1387352967235715),
+                                    ("aujourd'huifin de journ\233e", -5.1387352967235715),
+                                    ("intersectdu|dans le <part-of-day>", -2.787360039560094),
+                                    ("le <day-of-month> \224 <datetime>du|dans le <part-of-day>",
+                                     -4.733270188615407),
+                                    ("named-monthd\233but de journ\233e", -5.1387352967235715),
+                                    ("intersectd\233but d'apr\232s-midi", -5.1387352967235715),
+                                    ("named-dayfin d'apr\232s-midi", -4.733270188615407),
+                                    ("le <time>d\233but d'apr\232s-midi", -5.1387352967235715),
+                                    ("<day-of-month> <named-month>du|dans le <part-of-day>",
+                                     -4.733270188615407),
+                                    ("<day-of-month> <named-month>d\233but de soir\233e",
+                                     -5.1387352967235715),
+                                    ("hierdu|dans le <part-of-day>", -5.1387352967235715),
+                                    ("le <time>d\233but de soir\233e", -5.1387352967235715),
+                                    ("intersectd\233but de journ\233e", -5.1387352967235715),
+                                    ("le <time>d\233but de matin\233e", -5.1387352967235715),
+                                    ("<day-of-month> <named-month>milieu d'apr\232s-midi",
+                                     -5.1387352967235715),
+                                    ("<day-of-month> <named-month>fin d'apr\232s-midi",
+                                     -5.1387352967235715),
+                                    ("named-daysoir", -5.1387352967235715),
+                                    ("named-monthfin de matin\233e", -5.1387352967235715),
+                                    ("le <time>milieu de matin\233e", -5.1387352967235715),
+                                    ("aujourd'huid\233but de matin\233e", -4.0401230080554615),
+                                    ("le <time>fin de soir\233e", -5.1387352967235715),
+                                    ("<day-of-month> <named-month>milieu de matin\233e",
+                                     -5.1387352967235715),
+                                    ("<day-of-month> <named-month>fin de soir\233e",
+                                     -5.1387352967235715),
+                                    ("<day-of-month> <named-month>fin de matin\233e",
+                                     -5.1387352967235715),
+                                    ("<time-of-day> heuresce <part-of-day>", -4.445588116163626),
+                                    ("named-monthfin d'apr\232s-midi", -5.1387352967235715),
+                                    ("aujourd'huid\233but d'apr\232s-midi", -5.1387352967235715),
+                                    ("le <time>milieu d'apr\232s-midi", -5.1387352967235715),
+                                    ("\224|vers <time-of-day>du|dans le <part-of-day>",
+                                     -4.0401230080554615),
+                                    ("<day-of-month> <named-month>fin de journ\233e",
+                                     -5.1387352967235715),
+                                    ("<day-of-month> <named-month>milieu de journ\233e",
+                                     -5.1387352967235715),
+                                    ("le <time>fin de journ\233e", -5.1387352967235715),
+                                    ("intersectfin de matin\233e", -5.1387352967235715),
+                                    ("named-monthmilieu de journ\233e", -5.1387352967235715),
+                                    ("named-dayapr\232s-midi", -5.1387352967235715),
+                                    ("intersectfin de soir\233e", -5.1387352967235715),
+                                    ("intersectmilieu de matin\233e", -5.1387352967235715),
+                                    ("intersectapr\232s-midi", -4.222444564849416),
+                                    ("le <time>d\233but de journ\233e", -5.1387352967235715),
+                                    ("intersectd\233but de matin\233e", -5.1387352967235715),
+                                    ("hiersoir", -5.1387352967235715)],
+                               n = 129},
+                   koData =
+                     ClassData{prior = -2.5437471498109336, unseen = -4.663439094112067,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("dayhour", -3.5553480614894135),
+                                    ("<time-of-day> heuresdu|dans le <part-of-day>",
+                                     -3.2676659890376327),
+                                    ("le <time>du|dans le <part-of-day>", -3.5553480614894135),
+                                    ("aujourd'huidu|dans le <part-of-day>", -3.5553480614894135),
+                                    ("monthhour", -3.5553480614894135),
+                                    ("hourhour", -2.5745188084776873),
+                                    ("<time-of-day> - <time-of-day> (interval)du|dans le <part-of-day>",
+                                     -3.5553480614894135),
+                                    ("named-monthdu|dans le <part-of-day>", -3.5553480614894135)],
+                               n = 11}}),
+       ("jour de l'an",
+        Classifier{okData =
+                     ClassData{prior = 0.0, unseen = -1.3862943611198906,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 2},
+                   koData =
+                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
+                               likelihoods = HashMap.fromList [], n = 0}}),
+       ("time-of-day (latent)",
+        Classifier{okData =
+                     ClassData{prior = -0.5596157879354228, unseen = -4.574710978503383,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("integer (numeric)", -0.15762894420358317),
+                                    ("number (0..16)", -2.0794415416798357)],
+                               n = 92},
+                   koData =
+                     ClassData{prior = -0.8472978603872037, unseen = -4.304065093204169,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("integer (numeric)", -0.24740817331384096),
+                                    ("numbers 22..29 32..39 .. 52..59", -2.681021528714291),
+                                    ("number (20..60)", -3.597312260588446),
+                                    ("number (0..16)", -2.093234863812172)],
+                               n = 69}}),
+       ("apr\232s-demain",
+        Classifier{okData =
+                     ClassData{prior = 0.0, unseen = -1.6094379124341003,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 3},
+                   koData =
+                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
+                               likelihoods = HashMap.fromList [], n = 0}}),
+       ("year",
+        Classifier{okData =
+                     ClassData{prior = -0.46262352194811296,
+                               unseen = -2.9444389791664407,
+                               likelihoods = HashMap.fromList [("integer (numeric)", 0.0)],
+                               n = 17},
+                   koData =
+                     ClassData{prior = -0.9932517730102834,
+                               unseen = -2.4849066497880004,
+                               likelihoods = HashMap.fromList [("integer (numeric)", 0.0)],
+                               n = 10}}),
+       ("<hour-of-day> et|pass\233 de <number> minutes",
+        Classifier{okData =
+                     ClassData{prior = 0.0, unseen = -3.044522437723423,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("\224|vers <time-of-day>number (20..60)", -2.3025850929940455),
+                                    ("<time-of-day> heuresinteger (numeric)", -2.3025850929940455),
+                                    ("\224|vers <time-of-day>number (0..16)", -2.3025850929940455),
+                                    ("hour", -0.916290731874155),
+                                    ("<time-of-day> heuresnumber (20..60)", -1.8971199848858813),
+                                    ("<time-of-day> heuresnumber (0..16)", -1.8971199848858813)],
+                               n = 7},
+                   koData =
+                     ClassData{prior = -infinity, unseen = -1.9459101490553135,
+                               likelihoods = HashMap.fromList [], n = 0}}),
+       ("<integer> <unit-of-duration>",
+        Classifier{okData =
+                     ClassData{prior = -0.916290731874155, unseen = -4.204692619390966,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("week", -2.580216829592325),
+                                    ("number (0..16)semaine (grain)", -3.0910424533583156),
+                                    ("number (0..16)ann\233e (grain)", -3.0910424533583156),
+                                    ("number (0..16)seconde (grain)", -3.4965075614664802),
+                                    ("number (0..16)jour (grain)", -3.4965075614664802),
+                                    ("second", -3.4965075614664802),
+                                    ("integer (numeric)ann\233e (grain)", -3.4965075614664802),
+                                    ("number (0..16)minute (grain)", -3.0910424533583156),
+                                    ("integer (numeric)jour (grain)", -3.0910424533583156),
+                                    ("day", -2.803360380906535), ("year", -2.803360380906535),
+                                    ("number (0..16)mois (grain)", -3.0910424533583156),
+                                    ("hour", -2.580216829592325),
+                                    ("number (0..16)heure (grain)", -3.0910424533583156),
+                                    ("month", -3.0910424533583156),
+                                    ("integer (numeric)minute (grain)", -2.803360380906535),
+                                    ("minute", -2.3978952727983707),
+                                    ("integer (numeric)semaine (grain)", -3.0910424533583156),
+                                    ("numbers 22..29 32..39 .. 52..59heure (grain)",
+                                     -3.4965075614664802),
+                                    ("integer (numeric)heure (grain)", -3.4965075614664802)],
+                               n = 22},
+                   koData =
+                     ClassData{prior = -0.5108256237659907, unseen = -4.48863636973214,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("week", -3.784189633918261),
+                                    ("number (20..60)minute (grain)", -3.784189633918261),
+                                    ("number (0..16)jour (grain)", -3.0910424533583156),
+                                    ("integer (numeric)ann\233e (grain)", -3.784189633918261),
+                                    ("number (0..16)minute (grain)", -3.784189633918261),
+                                    ("day", -3.0910424533583156), ("year", -3.784189633918261),
+                                    ("hour", -1.2584609896100056),
+                                    ("number (0..16)heure (grain)", -1.9123874570166697),
+                                    ("month", -3.784189633918261),
+                                    ("integer (numeric)minute (grain)", -3.784189633918261),
+                                    ("integer (numeric)mois (grain)", -3.784189633918261),
+                                    ("minute", -3.0910424533583156),
+                                    ("integer (numeric)semaine (grain)", -3.784189633918261),
+                                    ("integer (numeric)heure (grain)", -1.9123874570166697)],
+                               n = 33}}),
+       ("avant-hier",
+        Classifier{okData =
+                     ClassData{prior = 0.0, unseen = -1.0986122886681098,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 1},
+                   koData =
+                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
+                               likelihoods = HashMap.fromList [], n = 0}}),
+       ("d\233but de journ\233e",
+        Classifier{okData =
+                     ClassData{prior = 0.0, unseen = -1.791759469228055,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 4},
+                   koData =
+                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
+                               likelihoods = HashMap.fromList [], n = 0}}),
+       ("entre <time-of-day> et <time-of-day> (interval)",
+        Classifier{okData =
+                     ClassData{prior = -0.1670540846631662,
+                               unseen = -3.4011973816621555,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("hourhour", -2.6741486494265287),
+                                    ("miditime-of-day (latent)", -2.6741486494265287),
+                                    ("minutehour", -0.9694005571881036),
+                                    ("hh(:|h)mm (time-of-day)time-of-day (latent)",
+                                     -2.268683541318364),
+                                    ("<hour-of-day> <integer> (as relative minutes)<time-of-day> heures",
+                                     -1.9810014688665833),
+                                    ("hh(:|h)mm (time-of-day)<time-of-day> heures",
+                                     -1.9810014688665833),
+                                    ("<hour-of-day> <integer> (as relative minutes)time-of-day (latent)",
+                                     -2.268683541318364)],
+                               n = 11},
+                   koData =
+                     ClassData{prior = -1.8718021769015913,
+                               unseen = -2.4849066497880004,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("minutehour", -1.2992829841302609),
+                                    ("hh(:|h)mm (time-of-day)time-of-day (latent)",
+                                     -1.7047480922384253),
+                                    ("<hour-of-day> <integer> (as relative minutes)time-of-day (latent)",
+                                     -1.7047480922384253)],
+                               n = 2}}),
+       ("d\233but du mois",
+        Classifier{okData =
+                     ClassData{prior = -0.6931471805599453,
+                               unseen = -1.3862943611198906,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 2},
+                   koData =
+                     ClassData{prior = -0.6931471805599453,
+                               unseen = -1.3862943611198906,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 2}}),
+       ("matin",
+        Classifier{okData =
+                     ClassData{prior = -0.7472144018302211,
+                               unseen = -2.3978952727983707,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 9},
+                   koData =
+                     ClassData{prior = -0.6418538861723948,
+                               unseen = -2.4849066497880004,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 10}}),
+       ("en <named-month>",
+        Classifier{okData =
+                     ClassData{prior = 0.0, unseen = -1.9459101490553135,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("named-month", -0.6931471805599453),
+                                    ("month", -0.6931471805599453)],
+                               n = 2},
+                   koData =
+                     ClassData{prior = -infinity, unseen = -1.0986122886681098,
+                               likelihoods = HashMap.fromList [], n = 0}}),
+       ("maintenant",
+        Classifier{okData =
+                     ClassData{prior = 0.0, unseen = -1.3862943611198906,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 2},
+                   koData =
+                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
+                               likelihoods = HashMap.fromList [], n = 0}}),
+       ("<day-of-week> 1er-<day-of-week> dd <month>(interval)",
+        Classifier{okData =
+                     ClassData{prior = 0.0, unseen = -1.9459101490553135,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("named-daynamed-daynamed-month", -0.6931471805599453),
+                                    ("daydaymonth", -0.6931471805599453)],
+                               n = 2},
+                   koData =
+                     ClassData{prior = -infinity, unseen = -1.0986122886681098,
+                               likelihoods = HashMap.fromList [], n = 0}}),
+       ("named-day",
+        Classifier{okData =
+                     ClassData{prior = 0.0, unseen = -4.553876891600541,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 93},
+                   koData =
+                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
+                               likelihoods = HashMap.fromList [], n = 0}}),
+       ("au d\233jeuner",
+        Classifier{okData =
+                     ClassData{prior = -0.40546510810816444,
+                               unseen = -1.791759469228055,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 4},
+                   koData =
+                     ClassData{prior = -1.0986122886681098,
+                               unseen = -1.3862943611198906,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 2}}),
+       ("le lendemain du <time>",
+        Classifier{okData =
+                     ClassData{prior = -1.0986122886681098,
+                               unseen = -2.1972245773362196,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("day", -1.3862943611198906),
+                                    ("<day-of-month> <named-month>", -1.3862943611198906)],
+                               n = 1},
+                   koData =
+                     ClassData{prior = -0.40546510810816444,
+                               unseen = -2.3978952727983707,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("year (latent)", -1.6094379124341003),
+                                    ("time-of-day (latent)", -1.6094379124341003),
+                                    ("year", -1.6094379124341003), ("hour", -1.6094379124341003)],
+                               n = 2}}),
+       ("le <cycle> prochain|suivant|d'apr\232s",
+        Classifier{okData =
+                     ClassData{prior = 0.0, unseen = -3.970291913552122,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("week", -1.0608719606852628),
+                                    ("ann\233e (grain)", -3.258096538021482),
+                                    ("semaine (grain)", -1.0608719606852628),
+                                    ("mois (grain)", -2.8526314299133175),
+                                    ("day", -2.8526314299133175), ("year", -3.258096538021482),
+                                    ("jour (grain)", -2.8526314299133175),
+                                    ("month", -2.8526314299133175)],
+                               n = 22},
+                   koData =
+                     ClassData{prior = -infinity, unseen = -2.1972245773362196,
+                               likelihoods = HashMap.fromList [], n = 0}}),
+       ("apr\232s <time-of-day>",
+        Classifier{okData =
+                     ClassData{prior = -0.9808292530117262, unseen = -4.219507705176107,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("intersect", -1.7197859696029658),
+                                    ("hh(:|h)mm (time-of-day)", -2.8183982582710754),
+                                    ("midi", -3.5115454388310208), ("day", -2.8183982582710754),
+                                    ("time-of-day (latent)", -2.8183982582710754),
+                                    ("hour", -1.4321038971511848), ("minute", -1.9021075263969205),
+                                    ("<time-of-day> heures", -2.8183982582710754),
+                                    ("le <time>", -3.1060803307228566),
+                                    ("<hour-of-day> <integer> (as relative minutes)",
+                                     -2.5952547069568657)],
+                               n = 27},
+                   koData =
+                     ClassData{prior = -0.4700036292457356,
+                               unseen = -4.6443908991413725,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("demain", -3.248434627109745),
+                                    ("intersect", -2.4375044108934163),
+                                    ("le <day-of-month> (non ordinal)", -3.9415818076696905),
+                                    ("midi", -1.415853163361435), ("day", -3.0252910757955354),
+                                    ("time-of-day (latent)", -3.0252910757955354),
+                                    ("au d\233jeuner", -3.9415818076696905),
+                                    ("hour", -0.8970593699462674),
+                                    ("<time-of-day> heures", -3.0252910757955354)],
+                               n = 45}}),
+       ("dd/-mm",
+        Classifier{okData =
+                     ClassData{prior = -0.7375989431307791,
+                               unseen = -2.5649493574615367,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 11},
+                   koData =
+                     ClassData{prior = -0.6505875661411494, unseen = -2.639057329615259,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 12}}),
+       ("minuit",
+        Classifier{okData =
+                     ClassData{prior = 0.0, unseen = -1.6094379124341003,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 3},
+                   koData =
+                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
+                               likelihoods = HashMap.fromList [], n = 0}}),
+       ("entre dd et dd <month>(interval)",
+        Classifier{okData =
+                     ClassData{prior = 0.0, unseen = -1.6094379124341003,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("named-month", -0.6931471805599453),
+                                    ("month", -0.6931471805599453)],
+                               n = 1},
+                   koData =
+                     ClassData{prior = -infinity, unseen = -1.0986122886681098,
+                               likelihoods = HashMap.fromList [], n = 0}}),
+       ("une <unit-of-duration>",
+        Classifier{okData =
+                     ClassData{prior = -2.174751721484161, unseen = -3.2188758248682006,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("week", -2.4849066497880004),
+                                    ("ann\233e (grain)", -2.4849066497880004),
+                                    ("seconde (grain)", -2.4849066497880004),
+                                    ("semaine (grain)", -2.4849066497880004),
+                                    ("second", -2.4849066497880004),
+                                    ("minute (grain)", -2.4849066497880004),
+                                    ("year", -2.4849066497880004),
+                                    ("heure (grain)", -2.4849066497880004),
+                                    ("hour", -2.4849066497880004), ("minute", -2.4849066497880004)],
+                               n = 5},
+                   koData =
+                     ClassData{prior = -0.12062798778861475,
+                               unseen = -4.532599493153256,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("week", -1.2636920390275583),
+                                    ("semaine (grain)", -1.2636920390275583),
+                                    ("mois (grain)", -2.91235066461494), ("day", -2.12389330425067),
+                                    ("jour (grain)", -2.12389330425067),
+                                    ("month", -2.91235066461494)],
+                               n = 39}}),
+       ("<hour-of-day> et quart",
+        Classifier{okData =
+                     ClassData{prior = 0.0, unseen = -2.9444389791664407,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("midi", -2.1972245773362196),
+                                    ("\224|vers <time-of-day>", -1.791759469228055),
+                                    ("hour", -0.8109302162163288),
+                                    ("<time-of-day> heures", -1.2809338454620642)],
+                               n = 7},
+                   koData =
+                     ClassData{prior = -infinity, unseen = -1.6094379124341003,
+                               likelihoods = HashMap.fromList [], n = 0}}),
+       ("number (0..16)",
+        Classifier{okData =
+                     ClassData{prior = -0.2682639865946794, unseen = -3.713572066704308,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 39},
+                   koData =
+                     ClassData{prior = -1.4469189829363254, unseen = -2.639057329615259,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 12}}),
+       ("heure (grain)",
+        Classifier{okData =
+                     ClassData{prior = -1.540445040947149, unseen = -2.0794415416798357,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 6},
+                   koData =
+                     ClassData{prior = -0.2411620568168881,
+                               unseen = -3.1780538303479458,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 22}}),
+       ("<named-month|named-day> dernier|pass\233",
+        Classifier{okData =
+                     ClassData{prior = -2.3978952727983707,
+                               unseen = -2.5649493574615367,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("day", -1.791759469228055), ("named-day", -1.791759469228055)],
+                               n = 1},
+                   koData =
+                     ClassData{prior = -9.53101798043249e-2,
+                               unseen = -3.4339872044851463,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("year (latent)", -2.70805020110221),
+                                    ("en semaine", -2.3025850929940455),
+                                    ("day", -1.791759469228055),
+                                    ("\224|vers <time-of-day>", -2.70805020110221),
+                                    ("time-of-day (latent)", -2.70805020110221),
+                                    ("year", -2.70805020110221), ("hour", -1.6094379124341003),
+                                    ("<time-of-day> heures", -2.0149030205422647),
+                                    ("le <time>", -2.3025850929940455)],
+                               n = 10}}),
+       ("milieu de journ\233e",
+        Classifier{okData =
+                     ClassData{prior = 0.0, unseen = -1.791759469228055,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 4},
+                   koData =
+                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
+                               likelihoods = HashMap.fromList [], n = 0}}),
+       ("dd/-mm/-yyyy",
+        Classifier{okData =
+                     ClassData{prior = 0.0, unseen = -2.70805020110221,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 13},
+                   koData =
+                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
+                               likelihoods = HashMap.fromList [], n = 0}}),
+       ("fin de semaine",
+        Classifier{okData =
+                     ClassData{prior = 0.0, unseen = -1.3862943611198906,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 2},
+                   koData =
+                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
+                               likelihoods = HashMap.fromList [], n = 0}}),
+       ("dd mm yyyy",
+        Classifier{okData =
+                     ClassData{prior = 0.0, unseen = -2.639057329615259,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 12},
+                   koData =
+                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
+                               likelihoods = HashMap.fromList [], n = 0}}),
+       ("fin du mois",
+        Classifier{okData =
+                     ClassData{prior = 0.0, unseen = -1.6094379124341003,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 3},
+                   koData =
+                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
+                               likelihoods = HashMap.fromList [], n = 0}}),
+       ("day of month (premier)",
+        Classifier{okData =
+                     ClassData{prior = -6.453852113757118e-2,
+                               unseen = -2.833213344056216,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 15},
+                   koData =
+                     ClassData{prior = -2.772588722239781, unseen = -1.0986122886681098,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 1}}),
+       ("jour (grain)",
+        Classifier{okData =
+                     ClassData{prior = -0.2744368457017603, unseen = -3.044522437723423,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 19},
+                   koData =
+                     ClassData{prior = -1.4271163556401458,
+                               unseen = -2.0794415416798357,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 6}}),
+       ("dd mm",
+        Classifier{okData =
+                     ClassData{prior = -0.40546510810816444,
+                               unseen = -2.639057329615259,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 12},
+                   koData =
+                     ClassData{prior = -1.0986122886681098,
+                               unseen = -2.0794415416798357,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 6}}),
+       ("dernier <cycle> de <time> (latent)",
+        Classifier{okData =
+                     ClassData{prior = 0.0, unseen = -3.1354942159291497,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("daymonth", -1.4816045409242156),
+                                    ("semaine (grain)intersect", -1.9924301646902063),
+                                    ("weekmonth", -1.4816045409242156),
+                                    ("semaine (grain)named-month", -1.9924301646902063),
+                                    ("jour (grain)intersect", -1.9924301646902063),
+                                    ("jour (grain)named-month", -1.9924301646902063)],
+                               n = 8},
+                   koData =
+                     ClassData{prior = -infinity, unseen = -1.9459101490553135,
+                               likelihoods = HashMap.fromList [], n = 0}}),
+       ("milieu de matin\233e",
+        Classifier{okData =
+                     ClassData{prior = 0.0, unseen = -1.6094379124341003,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 3},
+                   koData =
+                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
+                               likelihoods = HashMap.fromList [], n = 0}}),
+       ("avant le d\233jeuner",
+        Classifier{okData =
+                     ClassData{prior = 0.0, unseen = -1.0986122886681098,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 1},
+                   koData =
+                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
+                               likelihoods = HashMap.fromList [], n = 0}}),
+       ("1er mai",
+        Classifier{okData =
+                     ClassData{prior = 0.0, unseen = -1.0986122886681098,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 1},
+                   koData =
+                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
+                               likelihoods = HashMap.fromList [], n = 0}}),
+       ("fin de soir\233e",
+        Classifier{okData =
+                     ClassData{prior = 0.0, unseen = -1.791759469228055,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 4},
+                   koData =
+                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
+                               likelihoods = HashMap.fromList [], n = 0}}),
+       ("<datetime> - <datetime> (interval)",
+        Classifier{okData =
+                     ClassData{prior = -1.0185695809945732, unseen = -4.454347296253507,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("demain<time-of-day> heures", -3.7495040759303713),
+                                    ("day of month (premier)<day-of-week> <day-of-month>",
+                                     -3.056356895370426),
+                                    ("dayhour", -3.3440389678222067),
+                                    ("hh(:|h)mm (time-of-day)<hour-of-day> <integer> (as relative minutes)",
+                                     -3.3440389678222067),
+                                    ("le <day-of-month> (non ordinal)<time-of-day> heures",
+                                     -3.7495040759303713),
+                                    ("minuteminute", -2.044755983691946),
+                                    ("<day-of-month> <named-month><day-of-month> <named-month>",
+                                     -3.3440389678222067),
+                                    ("hh(:|h)mm (time-of-day)hh(:|h)mm (time-of-day)",
+                                     -3.056356895370426),
+                                    ("dayday", -1.8777018990287797),
+                                    ("<day-of-week> <day-of-month><day-of-week> <day-of-month>",
+                                     -3.7495040759303713),
+                                    ("<day-of-month> <named-month>day of month (premier)",
+                                     -3.3440389678222067),
+                                    ("minutehour", -3.3440389678222067),
+                                    ("<hour-of-day> <integer> (as relative minutes)<time-of-day> heures",
+                                     -3.7495040759303713),
+                                    ("<hour-of-day> <integer> (as relative minutes)hh(:|h)mm (time-of-day)",
+                                     -3.056356895370426),
+                                    ("hh(:|h)mm (time-of-day)<time-of-day> heures",
+                                     -3.7495040759303713),
+                                    ("<hour-of-day> <integer> (as relative minutes)<hour-of-day> <integer> (as relative minutes)",
+                                     -3.3440389678222067),
+                                    ("<day-of-month> <named-month>intersect", -3.3440389678222067),
+                                    ("intersect<day-of-week> <day-of-month>", -3.3440389678222067)],
+                               n = 26},
+                   koData =
+                     ClassData{prior = -0.4480247225269604, unseen = -4.836281906951478,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("<hour-of-day> <integer> (as relative minutes)intersect",
+                                     -3.7297014486341915),
+                                    ("monthday", -2.8824035882469876),
+                                    ("intersectnamed-day", -3.7297014486341915),
+                                    ("day of month (premier)named-day", -3.4420193761824103),
+                                    ("named-month<day-of-month> <named-month>",
+                                     -3.7297014486341915),
+                                    ("minuteminute", -3.7297014486341915),
+                                    ("dayday", -1.4961092271270973),
+                                    ("<day-of-week> <day-of-month><day-of-week> <day-of-month>",
+                                     -3.7297014486341915),
+                                    ("day of month (premier)<day-of-month> <named-month>",
+                                     -4.135166556742356),
+                                    ("year<hour-of-day> <integer> (as relative minutes)",
+                                     -3.4420193761824103),
+                                    ("minutehour", -2.631089159966082),
+                                    ("<hour-of-day> <integer> (as relative minutes)<time-of-day> heures",
+                                     -3.4420193761824103),
+                                    ("day of month (premier)intersect", -2.8824035882469876),
+                                    ("hh(:|h)mm (time-of-day)<time-of-day> heures",
+                                     -3.4420193761824103),
+                                    ("intersectintersect", -3.2188758248682006),
+                                    ("hh(:|h)mm (time-of-day)intersect", -3.7297014486341915),
+                                    ("named-monthintersect", -3.7297014486341915),
+                                    ("<day-of-week> <day-of-month>named-day", -3.4420193761824103),
+                                    ("named-monthday of month (premier)", -3.7297014486341915),
+                                    ("<day-of-week> <day-of-month>intersect", -2.8824035882469876),
+                                    ("yearminute", -3.4420193761824103)],
+                               n = 46}}),
+       ("<day-of-month> <named-month>",
+        Classifier{okData =
+                     ClassData{prior = -0.24256163717131135,
+                               unseen = -4.653960350157523,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("integer (numeric)named-month", -0.6931471805599453),
+                                    ("month", -0.6931471805599453)],
+                               n = 51},
+                   koData =
+                     ClassData{prior = -1.5353299402803784,
+                               unseen = -3.4339872044851463,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("integer (numeric)named-month", -0.6931471805599453),
+                                    ("month", -0.6931471805599453)],
+                               n = 14}}),
+       ("<cycle> prochain|suivant|d'apr\232s",
+        Classifier{okData =
+                     ClassData{prior = -8.338160893905101e-2,
+                               unseen = -4.007333185232471,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("week", -1.0986122886681098),
+                                    ("ann\233e (grain)", -3.295836866004329),
+                                    ("semaine (grain)", -1.0986122886681098),
+                                    ("mois (grain)", -2.890371757896165),
+                                    ("day", -2.6026896854443837), ("year", -3.295836866004329),
+                                    ("jour (grain)", -2.6026896854443837),
+                                    ("month", -2.890371757896165)],
+                               n = 23},
+                   koData =
+                     ClassData{prior = -2.5257286443082556,
+                               unseen = -2.5649493574615367,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("mois (grain)", -1.791759469228055),
+                                    ("day", -1.791759469228055),
+                                    ("jour (grain)", -1.791759469228055),
+                                    ("month", -1.791759469228055)],
+                               n = 2}}),
+       ("fin <named-month>(interval)",
+        Classifier{okData =
+                     ClassData{prior = 0.0, unseen = -1.9459101490553135,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("named-month", -0.6931471805599453),
+                                    ("month", -0.6931471805599453)],
+                               n = 2},
+                   koData =
+                     ClassData{prior = -infinity, unseen = -1.0986122886681098,
+                               likelihoods = HashMap.fromList [], n = 0}}),
+       ("<time-of-day> - <time-of-day> (interval)",
+        Classifier{okData =
+                     ClassData{prior = -1.2321436812926323, unseen = -4.0943445622221,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("hh(:|h)mm (time-of-day)<hour-of-day> <integer> (as relative minutes)",
+                                     -2.691243082785829),
+                                    ("minuteminute", -1.3694872428035094),
+                                    ("time-of-day (latent)time-of-day (latent)",
+                                     -3.3843902633457743),
+                                    ("<time-of-day> heures<time-of-day> heures",
+                                     -3.3843902633457743),
+                                    ("hh(:|h)mm (time-of-day)hh(:|h)mm (time-of-day)",
+                                     -2.468099531471619),
+                                    ("hourhour", -2.691243082785829),
+                                    ("minutehour", -2.468099531471619),
+                                    ("<hour-of-day> <integer> (as relative minutes)<time-of-day> heures",
+                                     -2.691243082785829),
+                                    ("<hour-of-day> <integer> (as relative minutes)hh(:|h)mm (time-of-day)",
+                                     -2.468099531471619),
+                                    ("hh(:|h)mm (time-of-day)<time-of-day> heures",
+                                     -3.3843902633457743),
+                                    ("<hour-of-day> <integer> (as relative minutes)<hour-of-day> <integer> (as relative minutes)",
+                                     -2.691243082785829),
+                                    ("<time-of-day> heurestime-of-day (latent)",
+                                     -3.3843902633457743)],
+                               n = 21},
+                   koData =
+                     ClassData{prior = -0.3448404862917295, unseen = -4.787491742782046,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("time-of-day (latent)time-of-day (latent)",
+                                     -1.7833912195575383),
+                                    ("hourhour", -1.3451362886263831),
+                                    ("time-of-day (latent)<hour-of-day> <integer> (as relative minutes)",
+                                     -4.085976312551584),
+                                    ("hourminute", -4.085976312551584),
+                                    ("minutehour", -1.7346010553881064),
+                                    ("hh(:|h)mm (time-of-day)time-of-day (latent)",
+                                     -2.987364023883474),
+                                    ("<hour-of-day> <integer> (as relative minutes)<time-of-day> heures",
+                                     -3.169685580677429),
+                                    ("hh(:|h)mm (time-of-day)<time-of-day> heures",
+                                     -3.169685580677429),
+                                    ("<hour-of-day> <integer> (as relative minutes)time-of-day (latent)",
+                                     -2.6996819514316934),
+                                    ("time-of-day (latent)<time-of-day> heures",
+                                     -2.2942168433235293)],
+                               n = 51}}),
+       ("<named-day> en huit",
+        Classifier{okData =
+                     ClassData{prior = 0.0, unseen = -2.70805020110221,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("day", -0.6931471805599453),
+                                    ("named-day", -0.6931471805599453)],
+                               n = 6},
+                   koData =
+                     ClassData{prior = -infinity, unseen = -1.0986122886681098,
+                               likelihoods = HashMap.fromList [], n = 0}}),
+       ("<hour-of-day> et demi",
+        Classifier{okData =
+                     ClassData{prior = 0.0, unseen = -2.5649493574615367,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("midi", -1.791759469228055),
+                                    ("\224|vers <time-of-day>", -1.791759469228055),
+                                    ("hour", -0.8754687373538999),
+                                    ("<time-of-day> heures", -1.3862943611198906)],
+                               n = 4},
+                   koData =
+                     ClassData{prior = -infinity, unseen = -1.6094379124341003,
+                               likelihoods = HashMap.fromList [], n = 0}}),
+       ("dernier week-end de <time>",
+        Classifier{okData =
+                     ClassData{prior = 0.0, unseen = -1.6094379124341003,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("named-month", -0.6931471805599453),
+                                    ("month", -0.6931471805599453)],
+                               n = 1},
+                   koData =
+                     ClassData{prior = -infinity, unseen = -1.0986122886681098,
+                               likelihoods = HashMap.fromList [], n = 0}}),
+       ("du dd au dd(interval)",
+        Classifier{okData =
+                     ClassData{prior = 0.0, unseen = -1.0986122886681098,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 1},
+                   koData =
+                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
+                               likelihoods = HashMap.fromList [], n = 0}}),
+       ("ordinal (digits)",
+        Classifier{okData =
+                     ClassData{prior = -1.9459101490553135,
+                               unseen = -1.3862943611198906,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 2},
+                   koData =
+                     ClassData{prior = -0.15415067982725836,
+                               unseen = -2.639057329615259,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 12}}),
+       ("avant <time-of-day>",
+        Classifier{okData =
+                     ClassData{prior = -1.4469189829363254,
+                               unseen = -2.9444389791664407,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("time-of-day (latent)", -1.791759469228055),
+                                    ("hour", -1.2809338454620642),
+                                    ("<time-of-day> heures", -1.791759469228055)],
+                               n = 4},
+                   koData =
+                     ClassData{prior = -0.2682639865946794,
+                               unseen = -3.6109179126442243,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("intersect", -2.890371757896165),
+                                    ("hh(:|h)mm (time-of-day)", -2.890371757896165),
+                                    ("hier", -2.890371757896165), ("day", -2.890371757896165),
+                                    ("time-of-day (latent)", -1.9740810260220096),
+                                    ("au d\233jeuner", -2.890371757896165),
+                                    ("hour", -1.1856236656577395), ("minute", -2.4849066497880004),
+                                    ("<time-of-day> heures", -1.9740810260220096),
+                                    ("<hour-of-day> <integer> (as relative minutes)",
+                                     -2.890371757896165)],
+                               n = 13}}),
+       ("fin d'apr\232s-midi",
+        Classifier{okData =
+                     ClassData{prior = 0.0, unseen = -2.0794415416798357,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 6},
+                   koData =
+                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
+                               likelihoods = HashMap.fromList [], n = 0}}),
+       ("<part-of-day> du <dim time>",
+        Classifier{okData =
+                     ClassData{prior = -0.6931471805599453,
+                               unseen = -1.9459101490553135,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("matin<day-of-month> <named-month>", -1.0986122886681098),
+                                    ("hourday", -1.0986122886681098)],
+                               n = 1},
+                   koData =
+                     ClassData{prior = -0.6931471805599453,
+                               unseen = -1.9459101490553135,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("matinyear (latent)", -1.0986122886681098),
+                                    ("houryear", -1.0986122886681098)],
+                               n = 1}}),
+       ("<time-of-day> heures",
+        Classifier{okData =
+                     ClassData{prior = -0.1653924946935067, unseen = -5.655991810819852,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("\224|vers <time-of-day>", -1.8238477837795555),
+                                    ("time-of-day (latent)", -1.1526795099383855),
+                                    ("apr\232s <time-of-day>", -4.26619481914876),
+                                    ("hour", -0.7108467576593462),
+                                    ("avant <time-of-day>", -4.553876891600541)],
+                               n = 139},
+                   koData =
+                     ClassData{prior = -1.8809906029559977, unseen = -4.060443010546419,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("\224|vers <time-of-day>", -1.7404661748405046),
+                                    ("time-of-day (latent)", -1.9636097261547143),
+                                    ("apr\232s <time-of-day>", -2.4336133554004498),
+                                    ("hour", -0.8241754429663495),
+                                    ("avant <time-of-day>", -2.4336133554004498),
+                                    ("minute", -3.349904087274605),
+                                    ("<hour-of-day> <integer> (as relative minutes)",
+                                     -3.349904087274605)],
+                               n = 25}}),
+       ("week-end",
+        Classifier{okData =
+                     ClassData{prior = -0.6931471805599453,
+                               unseen = -1.3862943611198906,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 2},
+                   koData =
+                     ClassData{prior = -0.6931471805599453,
+                               unseen = -1.3862943611198906,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 2}}),
+       ("le <time>",
+        Classifier{okData =
+                     ClassData{prior = -0.2500510042341341, unseen = -5.942799375126701,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("week", -2.6820747146989494),
+                                    ("<named-month|named-day> suivant|d'apr\232s",
+                                     -3.742946675384212),
+                                    ("<ordinal> <cycle> de <time>", -4.553876891600541),
+                                    ("premi\232re quinzaine de <named-month>(interval)",
+                                     -5.247024072160486),
+                                    ("intersect", -1.988927534139004),
+                                    ("soir de no\235l", -5.247024072160486),
+                                    ("en semaine", -3.542275979922061),
+                                    ("toussaint", -4.841558964052322), ("day", -1.3968764704504275),
+                                    ("deuxi\232me quinzaine de <named-month>(interval)",
+                                     -5.247024072160486),
+                                    ("<dim time> <part-of-day>", -3.1675825304806504),
+                                    ("dd/-mm", -3.994261103665118),
+                                    ("dd/-mm/-yyyy", -4.553876891600541),
+                                    ("dd mm yyyy", -3.994261103665118),
+                                    ("day of month (premier)", -3.994261103665118),
+                                    ("dd mm", -3.994261103665118), ("hour", -1.9148195619852824),
+                                    ("month", -4.553876891600541),
+                                    ("dernier <cycle> de <time> (latent)", -4.330733340286331),
+                                    ("<day-of-month> <named-month>", -2.6820747146989494),
+                                    ("<cycle> prochain|suivant|d'apr\232s", -2.8956488149970085),
+                                    ("dernier week-end de <time>", -5.247024072160486),
+                                    ("<ordinal> week-end de <time>", -4.841558964052322),
+                                    ("<cycle> dernier", -4.148411783492376)],
+                               n = 176},
+                   koData =
+                     ClassData{prior = -1.5085119938441398, unseen = -4.859812404361672,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("<named-month|named-day> suivant|d'apr\232s",
+                                     -4.1588830833596715),
+                                    ("intersect", -3.242592351485517),
+                                    ("en semaine", -2.0794415416798357),
+                                    ("day", -1.556193397915288),
+                                    ("<dim time> <part-of-day>", -3.7534179752515073),
+                                    ("dd/-mm", -3.4657359027997265),
+                                    ("<named-month|named-day> dernier|pass\233",
+                                     -3.7534179752515073),
+                                    ("day of month (premier)", -4.1588830833596715),
+                                    ("dd mm", -3.4657359027997265), ("hour", -2.1439800628174073),
+                                    ("<day-of-month> <named-month>", -4.1588830833596715),
+                                    ("<time-of-day> - <time-of-day> (interval)",
+                                     -2.4541349911212467),
+                                    ("minute", -2.4541349911212467),
+                                    ("<hour-of-day> <integer> (as relative minutes)",
+                                     -2.6548056865833978)],
+                               n = 50}}),
+       ("apr\232s le <day-of-month>",
+        Classifier{okData =
+                     ClassData{prior = -0.40546510810816444,
+                               unseen = -1.3862943611198906,
+                               likelihoods = HashMap.fromList [("integer (numeric)", 0.0)],
+                               n = 2},
+                   koData =
+                     ClassData{prior = -1.0986122886681098,
+                               unseen = -1.0986122886681098,
+                               likelihoods = HashMap.fromList [("integer (numeric)", 0.0)],
+                               n = 1}}),
+       ("n <cycle> passes|precedents",
+        Classifier{okData =
+                     ClassData{prior = -0.40546510810816444,
+                               unseen = -2.3978952727983707,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("week", -1.6094379124341003),
+                                    ("integer (numeric)ann\233e (grain)", -1.6094379124341003),
+                                    ("year", -1.6094379124341003),
+                                    ("integer (numeric)semaine (grain)", -1.6094379124341003)],
+                               n = 2},
+                   koData =
+                     ClassData{prior = -1.0986122886681098,
+                               unseen = -2.1972245773362196,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("hour", -1.3862943611198906),
+                                    ("number (0..16)heure (grain)", -1.3862943611198906)],
+                               n = 1}}),
+       ("il y a <duration>",
+        Classifier{okData =
+                     ClassData{prior = 0.0, unseen = -2.639057329615259,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("week", -1.8718021769015913), ("year", -1.8718021769015913),
+                                    ("<integer> <unit-of-duration>", -0.9555114450274363),
+                                    ("hour", -1.8718021769015913), ("month", -1.8718021769015913)],
+                               n = 4},
+                   koData =
+                     ClassData{prior = -infinity, unseen = -1.791759469228055,
+                               likelihoods = HashMap.fromList [], n = 0}}),
+       ("<ordinal> week-end de <time>",
+        Classifier{okData =
+                     ClassData{prior = 0.0, unseen = -1.9459101490553135,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("ordinals (premier..seizieme)named-month",
+                                     -0.6931471805599453),
+                                    ("month", -0.6931471805599453)],
+                               n = 2},
+                   koData =
+                     ClassData{prior = -infinity, unseen = -1.0986122886681098,
+                               likelihoods = HashMap.fromList [], n = 0}}),
+       ("<dim time> du matin",
+        Classifier{okData =
+                     ClassData{prior = -0.13353139262452263,
+                               unseen = -2.890371757896165,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("\224|vers <time-of-day>", -1.7346010553881064),
+                                    ("hour", -0.7537718023763802),
+                                    ("<time-of-day> heures", -1.041453874828161)],
+                               n = 7},
+                   koData =
+                     ClassData{prior = -2.0794415416798357, unseen = -1.791759469228055,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("hour", -0.916290731874155),
+                                    ("<time-of-day> heures", -0.916290731874155)],
+                               n = 1}}),
+       ("d\233but d'apr\232s-midi",
+        Classifier{okData =
+                     ClassData{prior = 0.0, unseen = -1.791759469228055,
+                               likelihoods = HashMap.fromList [("", 0.0)], n = 4},
+                   koData =
+                     ClassData{prior = -infinity, unseen = -0.6931471805599453,
+                               likelihoods = HashMap.fromList [], n = 0}}),
+       ("<hour-of-day> <integer> (as relative minutes)",
+        Classifier{okData =
+                     ClassData{prior = -0.8266785731844679, unseen = -4.454347296253507,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("minuitnumber (0..16)", -3.3440389678222067),
+                                    ("midinumber (20..60)", -3.7495040759303713),
+                                    ("\224|vers <time-of-day>number (20..60)", -3.7495040759303713),
+                                    ("<time-of-day> heuresinteger (numeric)", -1.264597426142371),
+                                    ("\224|vers <time-of-day>number (0..16)", -3.3440389678222067),
+                                    ("midinumber (0..16)", -3.7495040759303713),
+                                    ("hour", -0.8591323180342064),
+                                    ("<time-of-day> heuresnumber (20..60)", -3.3440389678222067),
+                                    ("\224|vers <time-of-day>integer (numeric)",
+                                     -3.7495040759303713),
+                                    ("<time-of-day> heuresnumber (0..16)", -3.3440389678222067)],
+                               n = 35},
+                   koData =
+                     ClassData{prior = -0.5753641449035618, unseen = -4.663439094112067,
+                               likelihoods =
+                                 HashMap.fromList
+                                   [("time-of-day (latent)numbers 22..29 32..39 .. 52..59",
+                                     -3.960813169597578),
+                                    ("time-of-day (latent)number (0..16)", -3.5553480614894135),
+                                    ("<time-of-day> heuresinteger (numeric)", -2.5745188084776873),
+                                    ("avant <time-of-day>integer (numeric)", -3.960813169597578),
+                                    ("time-of-day (latent)integer (numeric)", -1.3217558399823195),
+                                    ("apr\232s <time-of-day>integer (numeric)", -3.044522437723423),
+                                    ("hour", -0.8253189536684283),
+                                    ("\224|vers <time-of-day>integer (numeric)",
+                                     -3.5553480614894135),
+                                    ("<time-of-day> heuresnumber (0..16)", -3.960813169597578)],
+                               n = 45}}),
        ("<cycle> dernier",
         Classifier{okData =
                      ClassData{prior = -0.15415067982725836,
diff --git a/Duckling/Time/DE/Corpus.hs b/Duckling/Time/DE/Corpus.hs
--- a/Duckling/Time/DE/Corpus.hs
+++ b/Duckling/Time/DE/Corpus.hs
@@ -630,7 +630,39 @@
   , examples (datetime (2013, 12, 10, 0, 0, 0) Day)
              [ "10.12."
              ]
-  , examples (datetimeInterval ((2013, 2, 12, 18, 30, 0), (2013, 2, 12, 19, 1, 0)) Minute)
+  , examples (datetimeInterval ((2013, 2, 12, 18, 30, 0), (2013, 2, 12, 19, 1, 0)) Minute)
              [ "18:30h - 19:00h"
+             , "18:30h/19:00h"
+             ]
+  , examples (datetimeInterval ((2013, 10, 14, 0, 0, 0), (2013, 10, 16, 0, 0, 0)) Day)
+             [ "14. - 15.10."
+             , "14 - 15.10."
+             , "14. - 15.10"
+             , "14 - 15.10"
+             , "14.10. - 15.10."
+             , "14. - 15.10.2013"
+             , "14.10. - 15.10.2013"
+             , "14./15.10."
+             ]
+  , examples (datetimeInterval ((2018, 10, 14, 0, 0, 0), (2018, 10, 16, 0, 0, 0)) Day)
+             [ "14. - 15.10.18"
+             , "14 - 15.10.18"
+             , "14.10. - 15.10.2018"
+             , "14./15.10.2018"
+             , "vom 14.10. - 15.10.2018"
+             , "14.10. bis 15.10.2018"
+             , "vom 14.10. auf den 15.10.2018"
+             , "vom 14.10. bis zum 15.10.2018"
+             ]
+  , examples (datetime (2013, 10, 10, 0, 0, 0) Day)
+             [ "am 10.10."
+             , "am 10.10"
+             , "10.10"
+             ]
+  , examples (datetime (2013, 2, 12, 10, 10, 0) Minute)
+             [ "um 10.10"
+             ]
+  , examples (datetime (2013, 2, 12, 17, 10, 0) Minute)
+             [ "17h10"
              ]
   ]
diff --git a/Duckling/Time/DE/Rules.hs b/Duckling/Time/DE/Rules.hs
--- a/Duckling/Time/DE/Rules.hs
+++ b/Duckling/Time/DE/Rules.hs
@@ -180,7 +180,7 @@
   { name = "<datetime> - <datetime> (interval)"
   , pattern =
     [ Predicate isNotLatent
-    , regex "\\-|bis"
+    , regex "\\-|bis( zum)?|auf( den)?"
     , Predicate isNotLatent
     ]
   , prod = \tokens -> case tokens of
@@ -189,6 +189,54 @@
       _ -> Nothing
   }
 
+ruleDateDateInterval :: Rule
+ruleDateDateInterval = Rule
+  { name = "dd.(mm.)? - dd.mm.(yy[yy]?)? (interval)"
+  , pattern =
+    [ regex "(?:vo[nm]\\s+)?(10|20|30|31|[012]?[1-9])\\.?((?<=\\.)(?:10|11|12|0?[1-9])(?:\\.?))?"
+    , regex "\\-|/|bis( zum)?|auf( den)?"
+    , regex "(10|20|30|31|[012]?[1-9])\\.(10|11|12|0?[1-9])\\.?((?<=\\.)\\d{2,4})?"
+    ]
+  , prod = \tokens -> case tokens of
+      (Token RegexMatch (GroupMatch (d1:"":_)):
+       _:
+       Token RegexMatch (GroupMatch (d2:m2:"":_)):
+       _) -> do
+          d1 <- parseInt d1
+          d2 <- parseInt d2
+          m2 <- parseInt m2
+          Token Time <$> interval TTime.Closed (monthDay m2 d1) (monthDay m2 d2)
+      (Token RegexMatch (GroupMatch (d1:"":_)):
+       _:
+       Token RegexMatch (GroupMatch (d2:m2:y:_)):
+       _) -> do
+          d1 <- parseInt d1
+          d2 <- parseInt d2
+          m2 <- parseInt m2
+          y <- parseInt y
+          Token Time <$> interval TTime.Closed (yearMonthDay y m2 d1) (yearMonthDay y m2 d2)
+      (Token RegexMatch (GroupMatch (d1:m1:_)):
+       _:
+       Token RegexMatch (GroupMatch (d2:m2:"":_)):
+       _) -> do
+          d1 <- parseInt d1
+          d2 <- parseInt d2
+          m1 <- parseInt m1
+          m2 <- parseInt m2
+          Token Time <$> interval TTime.Closed (monthDay m1 d1) (monthDay m2 d2)
+      (Token RegexMatch (GroupMatch (d1:m1:_)):
+       _:
+       Token RegexMatch (GroupMatch (d2:m2:y:_)):
+       _) -> do
+          d1 <- parseInt d1
+          d2 <- parseInt d2
+          m1 <- parseInt m1
+          m2 <- parseInt m2
+          y <- parseInt y
+          Token Time <$> interval TTime.Closed (yearMonthDay y m1 d1) (yearMonthDay y m2 d2)
+      _ -> Nothing
+  }
+
 ruleNamedmonth7 :: Rule
 ruleNamedmonth7 = Rule
   { name = "named-month"
@@ -268,7 +316,7 @@
   , pattern =
     [ regex "vo[nm]"
     , dimension Time
-    , regex "\\-|bis"
+    , regex "\\-|bis( zum)?|auf( den)?"
     , dimension Time
     ]
   , prod = \tokens -> case tokens of
@@ -328,7 +376,7 @@
   { name = "<month> dd-dd (interval)"
   , pattern =
     [ regex "([012]?\\d|30|31)(ter|\\.)?"
-    , regex "\\-|bis"
+    , regex "\\-|bis( zum)?|auf( den)?"
     , regex "([012]?\\d|30|31)(ter|\\.)?"
     , Predicate isAMonth
     ]
@@ -754,7 +802,7 @@
 ruleMmdd = Rule
   { name = "mm/dd"
   , pattern =
-    [ regex "([012]?[1-9]|10|20|30|31)\\.(0?[1-9]|10|11|12)\\."
+    [ regex "(?:am\\s+)?([012]?[1-9]|10|20|30|31)\\.(10|11|12|0?[1-9])\\.?"
     ]
   , prod = \tokens -> case tokens of
       (Token RegexMatch (GroupMatch (m1:m2:_)):_) -> do
@@ -1565,7 +1613,7 @@
 ruleHhmm = Rule
   { name = "hh:mm"
   , pattern =
-    [ regex "((?:[01]?\\d)|(?:2[0-3]))[:.]([0-5]\\d)(?:uhr|h)?"
+    [ regex "((?:[01]?\\d)|(?:2[0-3]))[:.h]([0-5]\\d)(?:uhr|h)?"
     ]
   , prod = \tokens -> case tokens of
       (Token RegexMatch (GroupMatch (m1:m2:_)):_) -> do
@@ -1715,7 +1763,7 @@
   { name = "<time-of-day> - <time-of-day> (interval)"
   , pattern =
     [ Predicate isATimeOfDay
-    , regex "\\-|bis"
+    , regex "\\-|/|bis"
     , Predicate $ liftM2 (&&) isATimeOfDay isNotLatent
     ]
   , prod = \tokens -> case tokens of
@@ -1929,6 +1977,7 @@
   , ruleChristmas
   , ruleChristmasEve
   , ruleDatetimeDatetimeInterval
+  , ruleDateDateInterval
   , ruleDayofmonthNonOrdinalNamedmonth
   , ruleDayofmonthNonOrdinalOfNamedmonth
   , ruleDayofmonthOrdinal
diff --git a/Duckling/Time/EN/Corpus.hs b/Duckling/Time/EN/Corpus.hs
--- a/Duckling/Time/EN/Corpus.hs
+++ b/Duckling/Time/EN/Corpus.hs
@@ -13,13 +13,13 @@
   , negativeCorpus
   ) where
 
-import Prelude
 import Data.String
+import Prelude
 
+import Duckling.Testing.Types hiding (examples)
 import Duckling.Time.Corpus
 import Duckling.Time.Types hiding (Month)
 import Duckling.TimeGrain.Types hiding (add)
-import Duckling.Testing.Types hiding (examples)
 
 corpus :: Corpus
 corpus = (testContext, allExamples)
@@ -34,6 +34,15 @@
       , "25"
       , "this is the one"
       , "in 61"
+      , "this one"
+      , "this past one"
+      , "at single"
+      , "at a couple of"
+      , "at pairs"
+      , "at a few"
+      , "at dozens"
+      , "single o'clock"
+      , "dozens o'clock"
       ]
 
 allExamples :: [Example]
@@ -47,6 +56,9 @@
              [ "today"
              , "at this time"
              ]
+  , examples (datetime (2013, 2, 1, 0, 0, 0) Day)
+             [ "2/2013"
+             ]
   , examples (datetime (2013, 2, 11, 0, 0, 0) Day)
              ["yesterday"]
   , examples (datetime (2013, 2, 13, 0, 0, 0) Day)
@@ -117,6 +129,8 @@
              , "on 2/15"
              , "February 15"
              , "2 / 15"
+             , "2-15"
+             , "2 - 15"
              ]
   , examples (datetime (2013, 8, 8, 0, 0, 0) Day)
              ["Aug 8"]
@@ -316,7 +330,8 @@
              , "half three"
              ]
   , examples (datetime (2013, 2, 12, 15, 23, 24) Second)
-             ["15:23:24"]
+             [ "15:23:24"
+             ]
   , examples (datetime (2013, 2, 12, 11, 45, 0) Minute)
              [ "a quarter to noon"
              , "11:45am"
@@ -330,13 +345,17 @@
              , "in the evening at eight"
              ]
   , examples (datetime (2013, 9, 20, 19, 30, 0) Minute)
-             ["at 7:30 PM on Fri, Sep 20"]
+             [ "at 7:30 PM on Fri, Sep 20"
+             ]
   , examples (datetime (2013, 2, 16, 9, 0, 0) Hour)
-             ["at 9am on Saturday"]
+             [ "at 9am on Saturday"
+             ]
   , examples (datetime (2013, 2, 16, 9, 0, 0) Hour)
-             ["on Saturday for 9am"]
+             [ "on Saturday for 9am"
+             ]
   , examples (datetime (2014, 7, 18, 19, 0, 0) Minute)
-             ["Fri, Jul 18, 2014 07:00 PM"]
+             [ "Fri, Jul 18, 2014 07:00 PM"
+             ]
   , examples (datetime (2013, 2, 12, 4, 30, 1) Second)
              [ "in a sec"
              , "one second from now"
@@ -351,9 +370,16 @@
              [ "in 2 minutes"
              , "in 2 more minutes"
              , "2 minutes from now"
+             , "in a couple of minutes"
+             , "in a pair of minutes"
              ]
+  , examples (datetime (2013, 2, 12, 4, 33, 0) Second)
+             [ "in three minutes"
+             , "in a few minutes"
+             ]
   , examples (datetime (2013, 2, 12, 5, 30, 0) Second)
-             ["in 60 minutes"]
+             [ "in 60 minutes"
+             ]
   , examples (datetime (2013, 2, 12, 4, 45, 0) Second)
              [ "in a quarter of an hour"
              , "in 1/4h"
@@ -635,11 +661,14 @@
              , "July 13 thru 15"
              , "July 13 through 15"
              , "July 13 - July 15"
+             , "from July 13-15"
              ]
   , examples (datetimeInterval ((2013, 8, 8, 0, 0, 0), (2013, 8, 13, 0, 0, 0)) Day)
-             ["Aug 8 - Aug 12"]
+             [ "Aug 8 - Aug 12"
+             ]
   , examples (datetimeInterval ((2013, 2, 12, 9, 30, 0), (2013, 2, 12, 11, 1, 0)) Minute)
-             ["9:30 - 11:00"]
+             [ "9:30 - 11:00"
+             ]
   , examples (datetimeInterval ((2013, 2, 14, 9, 30, 0), (2013, 2, 14, 11, 1, 0)) Minute)
              [ "from 9:30 - 11:00 on Thursday"
              , "between 9:30 and 11:00 on thursday"
@@ -793,5 +822,16 @@
              ]
   , examples (datetimeInterval ((2013, 3, 21, 0, 0, 0), (2013, 4, 1, 0, 0, 0)) Day)
              [ "late March"
+             ]
+  , examples (datetimeInterval ((2013, 10, 25, 18, 0, 0), (2013, 10, 28, 0, 0, 0)) Hour)
+             [ "last weekend of October"
+             , "last week-end in October"
+             , "last week end of October"
+             ]
+  , examples (datetimeInterval ((2013, 7, 26, 18, 0, 0), (2013, 7, 29, 0, 0, 0)) Hour)
+             [ "last wkend of July"
+             ]
+  , examples (datetimeInterval ((2017, 10, 27, 18, 0, 0), (2017, 10, 30, 0, 0, 0)) Hour)
+             [ "last weekend of October 2017"
              ]
   ]
diff --git a/Duckling/Time/EN/Rules.hs b/Duckling/Time/EN/Rules.hs
--- a/Duckling/Time/EN/Rules.hs
+++ b/Duckling/Time/EN/Rules.hs
@@ -16,22 +16,22 @@
 import Control.Monad (liftM2)
 import Data.Maybe
 import Data.Text (Text)
-import qualified Data.Text as Text
 import Prelude
+import qualified Data.Text as Text
 
 import Duckling.Dimensions.Types
 import Duckling.Duration.Helpers (duration)
 import Duckling.Numeral.Helpers (parseInt)
 import Duckling.Numeral.Types (NumeralData (..))
-import qualified Duckling.Numeral.Types as TNumeral
 import Duckling.Ordinal.Types (OrdinalData (..))
-import qualified Duckling.Ordinal.Types as TOrdinal
 import Duckling.Regex.Types
 import Duckling.Time.Helpers
 import Duckling.Time.Types (TimeData (..))
+import Duckling.Types
+import qualified Duckling.Numeral.Types as TNumeral
+import qualified Duckling.Ordinal.Types as TOrdinal
 import qualified Duckling.Time.Types as TTime
 import qualified Duckling.TimeGrain.Types as TG
-import Duckling.Types
 
 ruleIntersect :: Rule
 ruleIntersect = Rule
@@ -142,7 +142,7 @@
   { name = "this <time>"
   , pattern =
     [ regex "this|current|coming"
-    , dimension Time
+    , Predicate isNotLatent
     ]
   , prod = \tokens -> case tokens of
       (_:Token Time td:_) -> tt $ predNth 0 False td
@@ -166,13 +166,25 @@
   { name = "last <time>"
   , pattern =
     [ regex "(this past|last|previous)"
-    , dimension Time
+    , Predicate isNotLatent
     ]
   , prod = \tokens -> case tokens of
       (_:Token Time td:_) -> tt $ predNth (- 1) False td
       _ -> Nothing
   }
 
+ruleLastWeekendOfMonth :: Rule
+ruleLastWeekendOfMonth = Rule
+  { name = "last weekend of <named-month>"
+  , pattern =
+    [ regex "last\\s(week(\\s|-)?end|wkend)\\s(of|in)"
+    , Predicate isAMonth
+    ]
+  , prod = \tokens -> case tokens of
+      (_:Token Time td2:_) -> tt $ predLastOf weekend td2
+      _ -> Nothing
+  }
+
 ruleTimeBeforeLastAfterNext :: Rule
 ruleTimeBeforeLastAfterNext = Rule
   { name = "<time> before last|after next"
@@ -435,7 +447,9 @@
 ruleTODLatent :: Rule
 ruleTODLatent = Rule
   { name = "time-of-day (latent)"
-  , pattern = [Predicate $ isIntegerBetween 0 23]
+  , pattern =
+    [ Predicate $ liftM2 (&&) isNumeralSafeToUse (isIntegerBetween 0 23)
+    ]
   , prod = \tokens -> case tokens of
       (token:_) -> do
         n <- getIntValue token
@@ -669,6 +683,20 @@
       _ -> Nothing
   }
 
+ruleMMYYYY :: Rule
+ruleMMYYYY = Rule
+  { name = "mm/yyyy"
+  , pattern =
+    [ regex "(0?[1-9]|1[0-2])[/-](\\d{4})"
+    ]
+  , prod = \tokens -> case tokens of
+      (Token RegexMatch (GroupMatch (mm:yy:_)):_) -> do
+        y <- parseInt yy
+        m <- parseInt mm
+        tt $ yearMonthDay y m 1
+      _ -> Nothing
+  }
+
 ruleMMDDYYYY :: Rule
 ruleMMDDYYYY = Rule
   { name = "mm/dd/yyyy"
@@ -699,7 +727,7 @@
 ruleMMDD :: Rule
 ruleMMDD = Rule
   { name = "mm/dd"
-  , pattern = [regex "(0?[1-9]|1[0-2])\\s?/\\s?(3[01]|[12]\\d|0?[1-9])"]
+  , pattern = [regex "(0?[1-9]|1[0-2])\\s?[/-]\\s?(3[01]|[12]\\d|0?[1-9])"]
   , prod = \tokens -> case tokens of
       (Token RegexMatch (GroupMatch (mm:dd:_)):_) -> do
         m <- parseInt mm
@@ -831,11 +859,10 @@
 ruleWeekend :: Rule
 ruleWeekend = Rule
   { name = "week-end"
-  , pattern = [regex "(week(\\s|-)?end|wkend)"]
-  , prod = \_ -> do
-      fri <- intersect (dayOfWeek 5) (hour False 18)
-      mon <- intersect (dayOfWeek 1) (hour False 0)
-      Token Time <$> interval TTime.Open fri mon
+  , pattern =
+    [ regex "(week(\\s|-)?end|wkend)"
+    ]
+  , prod = \_ -> tt weekend
   }
 
 ruleSeasons :: Rule
@@ -897,11 +924,11 @@
     , regex "(3[01]|[12]\\d|0?[1-9])"
     ]
   , prod = \tokens -> case tokens of
-      ( Token Time td
-       :Token RegexMatch (GroupMatch (d1:_))
-       :_
-       :Token RegexMatch (GroupMatch (d2:_))
-       :_) -> do
+      (Token Time td:
+       Token RegexMatch (GroupMatch (d1:_)):
+       _:
+       Token RegexMatch (GroupMatch (d2:_)):
+       _) -> do
         dd1 <- parseInt d1
         dd2 <- parseInt d2
         dom1 <- intersect (dayOfMonth dd1) td
@@ -910,6 +937,31 @@
       _ -> Nothing
   }
 
+ruleIntervalFromMonthDDDD :: Rule
+ruleIntervalFromMonthDDDD = Rule
+  { name = "from <month> dd-dd (interval)"
+  , pattern =
+    [ regex "from"
+    , Predicate isAMonth
+    , regex "(3[01]|[12]\\d|0?[1-9])"
+    , regex "\\-|to|th?ru|through|(un)?til(l)?"
+    , regex "(3[01]|[12]\\d|0?[1-9])"
+    ]
+  , prod = \tokens -> case tokens of
+      (_:
+       Token Time td:
+       Token RegexMatch (GroupMatch (d1:_)):
+       _:
+       Token RegexMatch (GroupMatch (d2:_)):
+       _) -> do
+        dd1 <- parseInt d1
+        dd2 <- parseInt d2
+        dom1 <- intersect (dayOfMonth dd1) td
+        dom2 <- intersect (dayOfMonth dd2) td
+        Token Time <$> interval TTime.Closed dom1 dom2
+      _ -> Nothing
+  }
+
 -- Blocked for :latent time. May need to accept certain latents only, like hours
 ruleIntervalDash :: Rule
 ruleIntervalDash = Rule
@@ -1532,6 +1584,7 @@
   , ruleTimeBeforeLastAfterNext
   , ruleLastDOWOfTime
   , ruleLastCycleOfTime
+  , ruleLastWeekendOfMonth
   , ruleNthTimeOfTime
   , ruleTheNthTimeOfTime
   , ruleNthTimeAfterTime
@@ -1569,6 +1622,7 @@
   , ruleMMDDYYYY
   , ruleYYYYMMDD
   , ruleMMDD
+  , ruleMMYYYY
   , ruleNoonMidnightEOD
   , rulePartOfDays
   , ruleEarlyMorning
@@ -1582,6 +1636,7 @@
   , ruleSeasons
   , ruleTODPrecision
   , rulePrecisionTOD
+  , ruleIntervalFromMonthDDDD
   , ruleIntervalMonthDDDD
   , ruleIntervalDash
   , ruleIntervalFrom
diff --git a/Duckling/Time/FR/Corpus.hs b/Duckling/Time/FR/Corpus.hs
--- a/Duckling/Time/FR/Corpus.hs
+++ b/Duckling/Time/FR/Corpus.hs
@@ -9,10 +9,11 @@
 {-# LANGUAGE OverloadedStrings #-}
 
 module Duckling.Time.FR.Corpus
-  ( corpus ) where
+  ( corpus
+  ) where
 
-import Prelude
 import Data.String
+import Prelude
 
 import Duckling.Lang
 import Duckling.Resolve
@@ -489,14 +490,27 @@
              , "l'après-midi"
              ]
   , examples (datetimeInterval ((2013, 2, 12, 7, 0, 0), (2013, 2, 12, 9, 0, 0)) Hour)
-             [ "en début de matinée"
+             [ "aujourd'hui en début de matinée"
+             , "en début de matinée"
+             , "le 12 février en début de matinée"
              , "aujourd'hui très tôt le matin"
              , "aujourd'hui tôt le matin"
              , "aujourd'hui le matin tôt"
              , "aujourd'hui le matin très tôt"
+             , "le matin très tôt"
+             , "le matin tôt"
+             , "tôt le matin"
+             , "très tôt le matin"
              ]
+  , examples (datetimeInterval ((2013, 2, 12, 9, 0, 0), (2013, 2, 12, 11, 0, 0)) Hour)
+             [ "aujourd'hui en milieu de matinée"
+             , "le 12 février en milieu de matinée"
+             , "en milieu de matinée"
+             ]
   , examples (datetimeInterval ((2013, 2, 12, 10, 0, 0), (2013, 2, 12, 12, 0, 0)) Hour)
-             [ "en fin de matinée"
+             [ "aujourd'hui en fin de matinée"
+             , "en fin de matinée"
+             , "le 12 février en fin de matinée"
              ]
   , examples (datetimeInterval ((2013, 2, 12, 13, 0, 0), (2013, 2, 12, 17, 0, 0)) Hour)
              [ "après déjeuner"
@@ -506,6 +520,9 @@
              ]
   , examples (datetimeInterval ((2013, 2, 12, 12, 0, 0), (2013, 2, 12, 14, 0, 0)) Hour)
              [ "aujourd'hui pendant le déjeuner"
+             , "à l'heure du déjeuner"
+             , "au moment de déjeuner"
+             , "pendant le déjeuner"
              ]
   , examples (datetimeInterval ((2013, 2, 12, 17, 0, 0), (2013, 2, 12, 21, 0, 0)) Hour)
              [ "après le travail"
@@ -515,25 +532,57 @@
              , "dès la matinée"
              ]
   , examples (datetimeInterval ((2013, 2, 12, 12, 0, 0), (2013, 2, 12, 14, 0, 0)) Hour)
-             [ "en début d'après-midi"
+             [ "aujourd'hui en début d'après-midi"
+             , "en début d'après-midi"
+             , "le 12 février en début d'après-midi"
+             , "au début de l'après-midi"
              ]
+  , examples (datetimeInterval ((2013, 2, 12, 14, 0, 0), (2013, 2, 12, 17, 0, 0)) Hour)
+             [ "aujourd'hui en milieu d'après-midi"
+             , "en milieu d'après-midi"
+             , "le 12 février en milieu d'après-midi"
+             , "au milieu de l'après-midi"
+             ]
   , examples (datetimeInterval ((2013, 2, 12, 17, 0, 0), (2013, 2, 12, 19, 0, 0)) Hour)
-             [ "en fin d'après-midi"
+             [ "aujourd'hui en fin d'après-midi"
+             , "en fin d'après-midi"
+             , "le 12 février en fin d'après-midi"
+             , "à la fin de l'après-midi"
              ]
   , examples (datetimeInterval ((2013, 2, 12, 6, 0, 0), (2013, 2, 12, 10, 0, 0)) Hour)
-             [ "en début de journée"
+             [ "aujourd'hui en début de journée"
+             , "le 12 février en début de journée"
+             , "en début de journée"
+             , "au début de la journée"
              ]
+  , examples (datetimeInterval ((2013, 2, 12, 11, 0, 0), (2013, 2, 12, 16, 0, 0)) Hour)
+             [ "aujourd'hui en milieu de journée"
+             , "en milieu de journée"
+             , "le 12 février en milieu de journée"
+             , "au milieu de la journée"
+             ]
   , examples (datetimeInterval ((2013, 2, 12, 17, 0, 0), (2013, 2, 12, 21, 0, 0)) Hour)
-             [ "en fin de journée"
+             [ "aujourd'hui en fin de journée"
+             , "en fin de journée"
+             , "le 12 février en fin de journée"
+             , "à la fin de la journée"
              ]
   , examples (datetimeInterval ((2013, 2, 12, 18, 0, 0), (2013, 2, 13, 0, 0, 0)) Hour)
              [ "ce soir"
+             , "le soir"
+             , "dans la soirée"
              ]
   , examples (datetimeInterval ((2013, 2, 12, 18, 0, 0), (2013, 2, 12, 21, 0, 0)) Hour)
-             [ "en début de soirée"
+             [ "aujourd'hui en début de soirée"
+             , "en début de soirée"
+             , "le 12 février en début de soirée"
+             , "au début de la soirée"
              ]
   , examples (datetimeInterval ((2013, 2, 12, 21, 0, 0), (2013, 2, 13, 0, 0, 0)) Hour)
-             [ "en fin de soirée"
+             [ "aujourd'hui en fin de soirée"
+             , "en fin de soirée"
+             , "le 12 février en fin de soirée"
+             , "à la fin de la soirée"
              ]
   , examples (datetimeInterval ((2013, 2, 13, 18, 0, 0), (2013, 2, 14, 0, 0, 0)) Hour)
              [ "demain soir"
@@ -549,12 +598,15 @@
              ]
   , examples (datetimeInterval ((2013, 2, 11, 0, 0, 0), (2013, 2, 13, 0, 0, 0)) Day)
              [ "en début de semaine"
+             , "au début de la semaine"
              ]
   , examples (datetimeInterval ((2013, 2, 13, 0, 0, 0), (2013, 2, 15, 0, 0, 0)) Day)
              [ "en milieu de semaine"
+             , "au milieu de la semaine"
              ]
   , examples (datetimeInterval ((2013, 2, 14, 0, 0, 0), (2013, 2, 18, 0, 0, 0)) Day)
              [ "en fin de semaine"
+             , "à la fin de la semaine"
              ]
   , examples (datetimeInterval ((2013, 2, 11, 0, 0, 0), (2013, 2, 16, 0, 0, 0)) Day)
              [ "en semaine"
@@ -685,10 +737,12 @@
   , examples (datetimeOpenInterval After (2013, 2, 14, 9, 30, 0) Minute)
              [ "à partir de 9h30 jeudi"
              , "jeudi après 9h30"
+             , "jeudi plus tard que 9h30"
              , "jeudi matin à partir de 9 heures 30"
              ]
   , examples (datetimeOpenInterval After (2013, 11, 1, 16, 0, 0) Hour)
              [ "après 16h le 1er novembre"
+             , "plus tard que 16h le 1er novembre"
              ]
   , examples (datetimeOpenInterval After (2013, 11, 1, 0, 0, 0) Day)
              [ "après le 1er novembre"
@@ -738,7 +792,7 @@
   , examples (datetime (2013, 2, 12, 13, 0, 0) Minute)
              [ "à seize heures CET"
              ]
-  , examples (datetimeInterval ((2013, 3, 25, 0, 0, 0), (2013, 4, 1, 0, 0, 0)) Day)
+  , examples (datetimeInterval ((2013, 3, 21, 0, 0, 0), (2013, 4, 1, 0, 0, 0)) Day)
              [ "fin mars"
              , "fin du mois de mars"
              ]
@@ -759,6 +813,22 @@
   , examples (datetimeInterval ((2013, 12, 10, 0, 0, 0), (2013, 12, 20, 0, 0, 0)) Day)
              [ "mi-décembre"
              ]
+  , examples (datetimeInterval ((2013, 2, 21, 0, 0, 0), (2013, 3, 1, 0, 0, 0)) Day)
+             [ "en fin de mois"
+             , "à la fin du mois"
+             ]
+  , examples (datetimeInterval ((2013, 11, 1, 0, 0, 0), (2014, 1, 1, 0, 0, 0)) Month)
+             [ "en fin d'année"
+             , "à la fin de l'année"
+             ]
+  , examples (datetimeInterval ((2013, 1, 1, 0, 0, 0), (2013, 3, 1, 0, 0, 0)) Month)
+             [ "en début d'année"
+             , "au début de l'année"
+             ]
+  , examples (datetimeInterval ((2013, 3, 1, 0, 0, 0), (2013, 3, 11, 0, 0, 0)) Day)
+             [ "au début du mois"
+             , "en début de mois"
+             ]
   , examples (datetime (2013, 3, 0, 0, 0, 0) Month)
              [ "mars"
              , "en mars"
@@ -770,5 +840,17 @@
              ]
   , examples (datetime (2013, 8, 15, 8, 0, 0) Hour)
              [ "jeudi 15 à 8h"
+             ]
+  , examples (datetimeOpenInterval After (2013, 2, 12, 4, 40, 0) Minute)
+             [ "plus tard"
+             , "un peu plus tard"
+             ]
+  , examples (datetimeInterval ((2013, 2, 12, 12, 0, 0), (2013, 2, 12, 19, 0, 0)) Hour)
+             [ "plus tard dans l'après-midi"
+             , "un peu plus tard dans l'après-midi"
+             ]
+  , examples (datetimeInterval ((2013, 2, 12, 18, 0, 0), (2013, 2, 13, 00, 0, 0)) Hour)
+             [ "plus tard dans la soirée"
+             , "un peu plus tard dans la soirée"
              ]
   ]
diff --git a/Duckling/Time/FR/Rules.hs b/Duckling/Time/FR/Rules.hs
--- a/Duckling/Time/FR/Rules.hs
+++ b/Duckling/Time/FR/Rules.hs
@@ -21,9 +21,9 @@
 import Duckling.Regex.Types
 import Duckling.Time.Helpers
 import Duckling.Time.Types (TimeData (..))
+import Duckling.Types
 import qualified Duckling.Time.Types as TTime
 import qualified Duckling.TimeGrain.Types as TG
-import Duckling.Types
 
 ruleAujourdhui :: Rule
 ruleAujourdhui = Rule
@@ -64,16 +64,146 @@
   , prod = \_ -> tt . cycleNth TG.Day $ - 1
   }
 
+ruleDbutDeSoire :: Rule
+ruleDbutDeSoire = Rule
+  { name = "début de soirée"
+  , pattern =
+    [ regex "(en |au )?d(\x00e9|e)but de (la )?soir(\x00e9|e)e"
+    ]
+  , prod = \_ -> Token Time . partOfDay <$>
+      interval TTime.Open (hour False 18) (hour False 21)
+  }
+
+ruleFinDeSoire :: Rule
+ruleFinDeSoire = Rule
+  { name = "fin de soirée"
+  , pattern =
+    [ regex "(en |(\x00e0|a) la )?fin de (la )?soir(\x00e9|e)e"
+    ]
+  , prod = \_ -> Token Time . partOfDay <$>
+      interval TTime.Open (hour False 21) (hour False 0)
+  }
+
+ruleDbutDeMatine :: Rule
+ruleDbutDeMatine = Rule
+  { name = "début de matinée"
+  , pattern =
+    [ regex "le matin (tr(e|\x00e8)s )?t(\x00f4|o)t|(tr(e|\x00e8)s )?t(\x00f4|o)t le matin|(en |au )?d(\x00e9|e)but de (la )?matin(\x00e9|e)e"
+    ]
+  , prod = \_ -> Token Time . partOfDay <$>
+      interval TTime.Open (hour False 7) (hour False 9)
+  }
+
+ruleMilieuDeMatine :: Rule
+ruleMilieuDeMatine = Rule
+  { name = "milieu de matinée"
+  , pattern =
+    [ regex "(en |au )?milieu de (la )?matin(\x00e9|e)e"
+    ]
+  , prod = \_ -> Token Time . partOfDay <$>
+      interval TTime.Open (hour False 9) (hour False 11)
+  }
+
+ruleFinDeMatine :: Rule
+ruleFinDeMatine = Rule
+  { name = "fin de matinée"
+  , pattern =
+    [ regex "(en |(\x00e0|a) la )?fin de (la )?matin(\x00e9|e)e"
+    ]
+  , prod = \_ -> Token Time . partOfDay <$>
+      interval TTime.Open (hour False 10) (hour False 12)
+  }
+
+ruleDbutDaprsmidi :: Rule
+ruleDbutDaprsmidi = Rule
+  { name = "début d'après-midi"
+  , pattern =
+    [ regex "(au |en )?d(\x00e9|e)but (d'|de l')apr(e|\x00e9|\x00e8)s( |\\-)midi"
+    ]
+  , prod = \_ -> Token Time . partOfDay <$>
+      interval TTime.Open (hour False 12) (hour False 14)
+  }
+
+ruleMilieuDaprsmidi :: Rule
+ruleMilieuDaprsmidi = Rule
+  { name = "milieu d'après-midi"
+  , pattern =
+    [ regex "(au |en )?milieu (d'|de l')apr(e|\x00e9|\x00e8)s( |\\-)midi"
+    ]
+  , prod = \_ -> Token Time . partOfDay <$>
+      interval TTime.Open (hour False 14) (hour False 17)
+  }
+
+ruleFinDaprsmidi :: Rule
+ruleFinDaprsmidi = Rule
+  { name = "fin d'après-midi"
+  , pattern =
+    [ regex "((\x00e0|a) la |en )?fin (d'|de l')apr(e|\x00e9|\x00e8)s( |\\-)midi"
+    ]
+  , prod = \_ -> Token Time . partOfDay <$>
+      interval TTime.Open (hour False 17) (hour False 19)
+  }
+
 ruleDbutDeJourne :: Rule
 ruleDbutDeJourne = Rule
   { name = "début de journée"
   , pattern =
-    [ regex "d(\x00e9|e)but de journ(\x00e9|e)e"
+    [ regex "(en |au )?d(\x00e9|e)but de (la )?journ(\x00e9|e)e"
     ]
-  , prod = \_ -> Token Time . partOfDay . mkLatent <$>
+  , prod = \_ -> Token Time . partOfDay <$>
         interval TTime.Open (hour False 6) (hour False 10)
   }
 
+ruleMilieuDeJourne :: Rule
+ruleMilieuDeJourne = Rule
+  { name = "milieu de journée"
+  , pattern =
+    [ regex "(en |au )?milieu de (la )?journ(\x00e9|e)e"
+    ]
+  , prod = \_ -> Token Time . partOfDay <$>
+      interval TTime.Open (hour False 11) (hour False 16)
+  }
+
+ruleFinDeJourne :: Rule
+ruleFinDeJourne = Rule
+  { name = "fin de journée"
+  , pattern =
+    [ regex "(en |(\x00e0|a) la )?fin de (la )?journ(\x00e9|e)e"
+    ]
+  , prod = \_ -> Token Time . partOfDay <$>
+      interval TTime.Open (hour False 17) (hour False 21)
+  }
+
+ruleDbutDeSemaine :: Rule
+ruleDbutDeSemaine = Rule
+  { name = "début de semaine"
+  , pattern =
+    [ regex "(en |au )?d(\x00e9|e)but de (cette |la )?semaine"
+    ]
+  , prod = \_ -> Token Time <$>
+      interval TTime.Open (dayOfWeek 1) (dayOfWeek 2)
+  }
+
+ruleMilieuDeSemaine :: Rule
+ruleMilieuDeSemaine = Rule
+  { name = "milieu de semaine"
+  , pattern =
+    [ regex "(en |au )?milieu de (cette |la )?semaine"
+    ]
+  , prod = \_ -> Token Time <$>
+      interval TTime.Open (dayOfWeek 3) (dayOfWeek 4)
+  }
+
+ruleFinDeSemaine :: Rule
+ruleFinDeSemaine = Rule
+  { name = "fin de semaine"
+  , pattern =
+    [ regex "(en |(\x00e0|a) la )?fin de (cette |la )?semaine"
+    ]
+  , prod = \_ -> Token Time <$>
+      interval TTime.Open (dayOfWeek 4) (dayOfWeek 7)
+  }
+
 ruleLeLendemainDuTime :: Rule
 ruleLeLendemainDuTime = Rule
   { name = "le lendemain du <time>"
@@ -785,36 +915,6 @@
       interval TTime.Open (hour False 18) (hour False 0)
   }
 
-ruleDbutDeSoire :: Rule
-ruleDbutDeSoire = Rule
-  { name = "début de soirée"
-  , pattern =
-    [ regex "d(\x00e9|e)but de soir(\x00e9|e)e?"
-    ]
-  , prod = \_ -> Token Time . mkLatent . partOfDay <$>
-      interval TTime.Open (hour False 18) (hour False 21)
-  }
-
-ruleFinDeSoire :: Rule
-ruleFinDeSoire = Rule
-  { name = "fin de soirée"
-  , pattern =
-    [ regex "fin de soir(\x00e9|e)e?"
-    ]
-  , prod = \_ -> Token Time . mkLatent . partOfDay <$>
-      interval TTime.Open (hour False 21) (hour False 0)
-  }
-
-ruleDbutDeMatine :: Rule
-ruleDbutDeMatine = Rule
-  { name = "début de matinée"
-  , pattern =
-    [ regex "le matin (tr(e|\x00e8)s )?t(\x00f4|o)t|(tr(e|\x00e8)s )?t(\x00f4|o)t le matin|d(\x00e9|e)but de matin(\x00e9|e)e"
-    ]
-  , prod = \_ -> Token Time . mkLatent . partOfDay <$>
-      interval TTime.Open (hour False 7) (hour False 9)
-  }
-
 ruleNamedday5 :: Rule
 ruleNamedday5 = Rule
   { name = "named-day"
@@ -901,26 +1001,6 @@
   , prod = \_ -> tt $ month 2
   }
 
-ruleMilieuDeJourne :: Rule
-ruleMilieuDeJourne = Rule
-  { name = "milieu de journée"
-  , pattern =
-    [ regex "milieu de journ(\x00e9|e)e"
-    ]
-  , prod = \_ -> Token Time . mkLatent . partOfDay <$>
-      interval TTime.Open (hour False 11) (hour False 16)
-  }
-
-ruleFinDeJourne :: Rule
-ruleFinDeJourne = Rule
-  { name = "fin de journée"
-  , pattern =
-    [ regex "fin de journ(\x00e9|e)e"
-    ]
-  , prod = \_ -> Token Time . mkLatent . partOfDay <$>
-      interval TTime.Open (hour False 17) (hour False 21)
-  }
-
 ruleLeCycleDeTime :: Rule
 ruleLeCycleDeTime = Rule
   { name = "le <cycle> de <time>"
@@ -960,7 +1040,7 @@
 ruleAprsmidi = Rule
   { name = "après-midi"
   , pattern =
-    [ regex "apr(e|\x00e9|\x00e8)s?[ \\-]?midi"
+    [ regex "apr(e|\x00e9|\x00e8)s( |\\-)midi"
     ]
   , prod = \_ -> Token Time . mkLatent . partOfDay <$>
       interval TTime.Open (hour False 12) (hour False 19)
@@ -1056,7 +1136,7 @@
 ruleAprsTimeofday = Rule
   { name = "après <time-of-day>"
   , pattern =
-    [ regex "(apr(e|\x00e8)s|(a|\x00e0) partir de)"
+    [ regex "(apr(e|\x00e8)s|(a|\x00e0) partir de|(un peu )?plus tard que)"
     , dimension Time
     ]
   , prod = \tokens -> case tokens of
@@ -1391,26 +1471,6 @@
       _ -> Nothing
   }
 
-ruleMilieuDeSemaine :: Rule
-ruleMilieuDeSemaine = Rule
-  { name = "milieu de semaine"
-  , pattern =
-    [ regex "(en |au )?milieu de (cette |la )?semaine"
-    ]
-  , prod = \_ -> Token Time <$>
-      interval TTime.Open (dayOfWeek 3) (dayOfWeek 4)
-  }
-
-ruleDbutDeSemaine :: Rule
-ruleDbutDeSemaine = Rule
-  { name = "début de semaine"
-  , pattern =
-    [ regex "(en |au )?d(\x00e9|e)but de (cette |la )?semaine"
-    ]
-  , prod = \_ -> Token Time <$>
-      interval TTime.Open (dayOfWeek 1) (dayOfWeek 2)
-  }
-
 ruleTimeofdayHeures :: Rule
 ruleTimeofdayHeures = Rule
   { name = "<time-of-day> heures"
@@ -1544,7 +1604,7 @@
     ]
   , prod = \tokens -> case tokens of
       (_:Token Time td:_) -> do
-        from <- intersect (dayOfMonth 25) td
+        from <- intersect (dayOfMonth 21) td
         let to = cycleLastOf TG.Day td
         Token Time <$> interval TTime.Closed from to
       _ -> Nothing
@@ -1665,16 +1725,6 @@
   , prod = \_ -> tt $ dayOfWeek 7
   }
 
-ruleFinDeSemaine :: Rule
-ruleFinDeSemaine = Rule
-  { name = "fin de semaine"
-  , pattern =
-    [ regex "(en |(\x00e0|a) la )?fin de (cette |la )?semaine"
-    ]
-  , prod = \_ -> Token Time <$>
-      interval TTime.Open (dayOfWeek 4) (dayOfWeek 7)
-  }
-
 ruleIlYADuration :: Rule
 ruleIlYADuration = Rule
   { name = "il y a <duration>"
@@ -1705,9 +1755,9 @@
 ruleAuDjeuner = Rule
   { name = "au déjeuner"
   , pattern =
-    [ regex "((\x00e0|a) l(')?heure du|pendant( le)?|au)? d(e|\x00e9|\x00e8)jeuner"
+    [ regex "((\x00e0|a) l'heure du|au moment de|pendant( le)?|au)? d(e|\x00e9|\x00e8)jeuner"
     ]
-  , prod = \_ -> Token Time . mkLatent . partOfDay <$>
+  , prod = \_ -> Token Time . partOfDay <$>
       interval TTime.Open (hour False 12) (hour False 14)
   }
 
@@ -1742,26 +1792,6 @@
   , prod = \_ -> tt $ cycleNth TG.Second 0
   }
 
-ruleMilieuDeMatine :: Rule
-ruleMilieuDeMatine = Rule
-  { name = "milieu de matinée"
-  , pattern =
-    [ regex "milieu de matin(\x00e9|e)e"
-    ]
-  , prod = \_ -> Token Time . mkLatent . partOfDay <$>
-      interval TTime.Open (hour False 9) (hour False 11)
-  }
-
-ruleFinDeMatine :: Rule
-ruleFinDeMatine = Rule
-  { name = "fin de matinée"
-  , pattern =
-    [ regex "fin de matin(\x00e9|e)e"
-    ]
-  , prod = \_ -> Token Time . mkLatent . partOfDay <$>
-      interval TTime.Open (hour False 10) (hour False 12)
-  }
-
 ruleDdmmyyyy :: Rule
 ruleDdmmyyyy = Rule
   { name = "dd/-mm/-yyyy"
@@ -1837,16 +1867,6 @@
   , prod = \_ -> tt $ month 11
   }
 
-ruleDbutDaprsmidi :: Rule
-ruleDbutDaprsmidi = Rule
-  { name = "début d'après-midi"
-  , pattern =
-    [ regex "d(\x00e9|e)but d'apr(e|\x00e9|\x00e8)s?[ \\-]?midi"
-    ]
-  , prod = \_ -> Token Time . mkLatent . partOfDay <$>
-      interval TTime.Open (hour False 12) (hour False 14)
-  }
-
 ruleLeTime :: Rule
 ruleLeTime = Rule
   { name = "le <time>"
@@ -1886,26 +1906,6 @@
       _ -> Nothing
   }
 
-ruleMilieuDaprsmidi :: Rule
-ruleMilieuDaprsmidi = Rule
-  { name = "fin d'après-midi"
-  , pattern =
-    [ regex "milieu d'apr(e|\x00e9|\x00e8)s?[ \\-]?midi"
-    ]
-  , prod = \_ -> Token Time . mkLatent . partOfDay <$>
-      interval TTime.Open (hour False 15) (hour False 17)
-  }
-
-ruleFinDaprsmidi :: Rule
-ruleFinDaprsmidi = Rule
-  { name = "fin d'après-midi"
-  , pattern =
-    [ regex "fin d'apr(e|\x00e9|\x00e8)s?[ \\-]?midi"
-    ]
-  , prod = \_ -> Token Time . mkLatent . partOfDay <$>
-      interval TTime.Open (hour False 17) (hour False 19)
-  }
-
 ruleJourDeLan :: Rule
 ruleJourDeLan = Rule
   { name = "jour de l'an"
@@ -1996,14 +1996,64 @@
 ruleFinDuMois = Rule
   { name = "fin du mois"
   , pattern =
-    [ regex "(((a|\x00e0) )?la )?fin (du|de) mois"
+    [ regex "(en |((\x00e0|a) la ))?fin (du|de) (ce )?mois"
     ]
-  , prod = \_ -> do
-      let from = cycleNthAfter False TG.Day (- 10) $ cycleNth TG.Month 1
-          to = cycleNth TG.Month 1
-      Token Time . mkLatent . partOfDay <$> interval TTime.Open from to
+  , prod = \_ -> Token Time <$>
+      interval TTime.Open (dayOfMonth 21) (dayOfMonth 0)
   }
 
+ruleDbutDuMois :: Rule
+ruleDbutDuMois = Rule
+  { name = "début du mois"
+  , pattern =
+    [ regex "(en |au )?d(\x00e9|e)but (du|de) (ce )?mois"
+    ]
+  , prod = \_ -> Token Time <$>
+      interval TTime.Open (dayOfMonth 1) (dayOfMonth 10)
+  }
+
+ruleFinDAnnee :: Rule
+ruleFinDAnnee = Rule
+  { name = "fin d'année"
+  , pattern =
+    [ regex "(en |(\x00e0|a) la )?fin (d'|de l'|de cette )ann(\x00e9|e)e"
+    ]
+  , prod = \_ -> Token Time <$>
+      interval TTime.Open (month 11) (month 1)
+  }
+
+ruleDbutDAnnee :: Rule
+ruleDbutDAnnee = Rule
+  { name = "début d'année"
+  , pattern =
+    [ regex "(en |au )?d(\x00e9|e)but (d'|de l'|de cette )ann(\x00e9|e)e"
+    ]
+  , prod = \_ -> Token Time <$>
+      interval TTime.Open (month 1) (month 3)
+  }
+
+rulePlusTard :: Rule
+rulePlusTard = Rule
+  { name = "plus tard"
+  , pattern =
+    [ regex "(un peu )?plus tard"
+    ]
+  , prod = \_ -> tt $ withDirection TTime.After $ cycleNth TG.Minute 10
+
+  }
+
+rulePlusTardPartofday :: Rule
+rulePlusTardPartofday = Rule
+  { name = "plus tard <part-of-day>"
+  , pattern =
+    [ regex "(un peu )?plus tard"
+    , Predicate isAPartOfDay
+    ]
+  , prod = \tokens -> case tokens of
+      (_:Token Time td:_) -> tt $ notLatent td
+      _ -> Nothing
+  }
+
 ruleTimezone :: Rule
 ruleTimezone = Rule
   { name = "<time> timezone"
@@ -2177,4 +2227,9 @@
   , ruleHourofdayEtDemi
   , ruleFinDuMois
   , ruleTimezone
+  , ruleDbutDuMois
+  , ruleFinDAnnee
+  , ruleDbutDAnnee
+  , rulePlusTard
+  , rulePlusTardPartofday
   ]
diff --git a/Duckling/Time/Helpers.hs b/Duckling/Time/Helpers.hs
--- a/Duckling/Time/Helpers.hs
+++ b/Duckling/Time/Helpers.hs
@@ -15,14 +15,15 @@
     isADayOfWeek, isAMonth, isAnHourOfDay, isAPartOfDay, isATimeOfDay
   , isDOMInteger, isDOMOrdinal, isDOMValue, isGrain, isGrainFinerThan
   , isGrainOfTime, isIntegerBetween, isNotLatent, isOrdinalBetween
-  , isMidnightOrNoon
+  , isMidnightOrNoon, isNumeralSafeToUse
     -- Production
   , cycleLastOf, cycleN, cycleNth, cycleNthAfter, dayOfMonth, dayOfWeek
   , daysOfWeekOfMonth, durationAfter, durationAgo, durationBefore, form, hour
   , hourMinute, hourMinuteSecond, inDuration, intersect, intersectDOM, interval
   , inTimezone, longWEBefore, minute, minutesAfter, minutesBefore, mkLatent
   , month, monthDay, notLatent, nthDOWOfMonth, partOfDay, predLastOf, predNth
-  , predNthAfter, second, timeOfDayAMPM, withDirection, year, yearMonthDay
+  , predNthAfter, second, timeOfDayAMPM, weekend, withDirection, year
+  , yearMonthDay
   , tt
     -- Other
   , getIntValue
@@ -30,18 +31,15 @@
 
 import Control.Monad (liftM2)
 import Data.Maybe
-import Prelude
 import Data.Text (Text)
+import Prelude
 import qualified Data.Time as Time
 import qualified Data.Time.Calendar.WeekDate as Time
 import qualified Data.Time.LocalTime.TimeZone.Series as Series
 
 import Duckling.Dimensions.Types
 import Duckling.Duration.Types (DurationData (DurationData))
-import qualified Duckling.Duration.Types as TDuration
-import qualified Duckling.Numeral.Types as TNumeral
 import Duckling.Ordinal.Types (OrdinalData (OrdinalData))
-import qualified Duckling.Ordinal.Types as TOrdinal
 import Duckling.Time.TimeZone.Parse (parseTimezone)
 import Duckling.Time.Types
   ( TimeData(TimeData)
@@ -59,9 +57,12 @@
   , runPredicate
   , AMPM(..)
   )
+import Duckling.Types
+import qualified Duckling.Duration.Types as TDuration
+import qualified Duckling.Numeral.Types as TNumeral
+import qualified Duckling.Ordinal.Types as TOrdinal
 import qualified Duckling.Time.Types as TTime
 import qualified Duckling.TimeGrain.Types as TG
-import Duckling.Types
 
 getIntValue :: Token -> Maybe Int
 getIntValue (Token Numeral nd) = TNumeral.getIntValue $ TNumeral.value nd
@@ -273,6 +274,10 @@
   TNumeral.isIntegerBetween (TNumeral.value nd) low high
 isIntegerBetween _ _ _ = False
 
+isNumeralSafeToUse :: Predicate
+isNumeralSafeToUse (Token Numeral nd) = TNumeral.okForAnyTime nd
+isNumeralSafeToUse _ = False
+
 isOrdinalBetween :: Int -> Int -> Predicate
 isOrdinalBetween low high (Token Ordinal od) =
   TOrdinal.isBetween (TOrdinal.value od) low high
@@ -479,6 +484,12 @@
     end = intersect' (tue, hour False 0)
     fri = cycleNthAfter False TG.Day (- 3) monday
     tue = cycleNthAfter False TG.Day 1 monday
+
+weekend :: TimeData
+weekend = interval' TTime.Open (fri, mon)
+  where
+    fri = intersect' (dayOfWeek 5, hour False 18)
+    mon = intersect' (dayOfWeek 1, hour False 0)
 
 daysOfWeekOfMonth :: Int -> Int -> TimeData
 daysOfWeekOfMonth dow m = intersect' (dayOfWeek dow, month m)
diff --git a/duckling.cabal b/duckling.cabal
--- a/duckling.cabal
+++ b/duckling.cabal
@@ -1,5 +1,5 @@
 name:                duckling
-version:             0.1.1.0
+version:             0.1.2.0
 synopsis:            A Haskell library for parsing text into structured data.
 description:
   Duckling is a library for parsing text into structured data.
@@ -15,7 +15,8 @@
 stability:           alpha
 cabal-version:       >=1.10
 tested-with:
-  GHC==8.0.2
+  GHC==8.0.2,
+  GHC==8.2.1
 
 extra-source-files:    README.md
                      , PATENTS
@@ -506,7 +507,7 @@
                      , regex-base            >= 0.93.2 && < 0.94
                      , regex-pcre            >= 0.94.4 && < 0.95
                      , text                  >= 1.2.2.1 && < 1.3
-                     , text-show             >= 2.1.2 && < 3.5
+                     , text-show             >= 2.1.2 && < 3.7
                      , time                  >= 1.5.0.1 && < 1.9
                      , timezone-series       >= 0.1.5.1 && < 0.2
                      , unordered-containers  >= 0.2.7.2 && < 0.3
@@ -518,11 +519,11 @@
   main-is:             TestMain.hs
   hs-source-dirs:      tests
   build-depends:       duckling
-                     , base                  >= 4.8.2 && < 5.0
-                     , aeson                 >= 0.11.3.0 && < 1.1
-                     , text                  >= 1.2.2.1 && < 1.3
-                     , time                  >= 1.5.0.1 && < 1.9
-                     , unordered-containers  >= 0.2.7.2 && < 0.3
+                     , base
+                     , aeson
+                     , text
+                     , time
+                     , unordered-containers
                      , tasty                 >= 0.11.1 && < 0.12
                      , tasty-hunit           >= 0.9.2 && < 1.0
   other-modules:       Duckling.Tests
@@ -718,10 +719,10 @@
   other-modules:       Duckling.Ranking.Train
                      , Duckling.Ranking.Generate
   build-depends:       duckling
-                     , base                  >= 4.8.2 && < 5.0
+                     , base
                      , haskell-src-exts      >= 1.18 && < 1.19
-                     , text                  >= 1.2.2.1 && < 1.3
-                     , unordered-containers  >= 0.2.7.2 && < 0.3
+                     , text
+                     , unordered-containers
   default-language:    Haskell2010
   default-extensions:  OverloadedStrings
 
@@ -731,20 +732,58 @@
   ghc-options:         -threaded -rtsopts -with-rtsopts=-N
   other-modules:       Duckling.Data.TimeZone
   build-depends:       duckling
-                     , base                  >= 4.8.2 && < 5.0
-                     , aeson                 >= 0.11.3.0 && < 1.1
-                     , bytestring            >= 0.10.6.0 && < 0.11
+                     , base
+                     , aeson
+                     , bytestring
                      , directory             >= 1.2.2.0 && < 1.4
-                     , extra                 >= 1.4.10 && < 1.6
+                     , extra
                      , filepath              >= 1.4.0.0 && < 1.5
                      , snap-core             >= 1.0.2.0 && < 1.1
                      , snap-server           >= 1.0.1.1 && < 1.1
-                     , text                  >= 1.2.2.1 && < 1.3
-                     , text-show             >= 2.1.2 && < 3.5
-                     , time                  >= 1.5.0.1 && < 1.9
+                     , text
+                     , text-show
+                     , time
                      , timezone-olson        >= 0.1.7 && < 0.2
-                     , timezone-series       >= 0.1.5.1 && < 0.2
-                     , unordered-containers  >= 0.2.7.2 && < 0.3
+                     , timezone-series
+                     , unordered-containers
+  default-language:    Haskell2010
+  default-extensions:  OverloadedStrings
+
+executable duckling-request-sample
+  main-is:             DucklingRequestSample.hs
+  hs-source-dirs:      exe
+  ghc-options:         -threaded -rtsopts -with-rtsopts=-N
+  other-modules:       Duckling.Data.TimeZone
+  build-depends:       duckling
+                     , base
+                     , dependent-sum
+                     , directory             >= 1.2.2.0 && < 1.4
+                     , extra
+                     , filepath              >= 1.4.0.0 && < 1.5
+                     , text
+                     , time
+                     , timezone-olson        >= 0.1.7 && < 0.2
+                     , timezone-series
+                     , unordered-containers
+  default-language:    Haskell2010
+  default-extensions:  OverloadedStrings
+
+executable duckling-expensive
+  main-is:             DucklingExpensive.hs
+  hs-source-dirs:      exe
+  ghc-options:         -threaded -rtsopts -with-rtsopts=-N
+  other-modules:       Duckling.Data.TimeZone
+  build-depends:       duckling
+                     , base
+                     , dependent-sum
+                     , directory             >= 1.2.2.0 && < 1.4
+                     , extra
+                     , filepath              >= 1.4.0.0 && < 1.5
+                     , text
+                     , time
+                     , timezone-olson        >= 0.1.7 && < 0.2
+                     , timezone-series
+                     , unordered-containers
   default-language:    Haskell2010
   default-extensions:  OverloadedStrings
 
diff --git a/exe/DucklingExpensive.hs b/exe/DucklingExpensive.hs
new file mode 100644
--- /dev/null
+++ b/exe/DucklingExpensive.hs
@@ -0,0 +1,16 @@
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# OPTIONS -fno-full-laziness #-}
+module Main (main) where
+import Duckling.Debug
+import Control.Monad
+import System.Environment
+import Duckling.Lang
+import Data.Some
+import Duckling.Dimensions.Types
+
+main :: IO ()
+main = do
+  (repeatCount :: Int) <- read . head <$> getArgs
+  void $ replicateM repeatCount $ void $ do
+    debug EN "Monday 3rd at 9.30am or 2.30pm, Saturday 8th at 10.30am, Tuesday 11th at 2pm, Wednesday 12th at 2.30pm, Friday 14th at 12.30pm xx" [This Time]
+    debug ES "Horario es de Lunes a Viernes de 2 pm a 10 pm. S\195\161bado de 9 am a 7 pm" [This Time]
diff --git a/exe/DucklingRequestSample.hs b/exe/DucklingRequestSample.hs
new file mode 100644
--- /dev/null
+++ b/exe/DucklingRequestSample.hs
@@ -0,0 +1,22 @@
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# OPTIONS -fno-full-laziness #-}
+module Main (main) where
+import Duckling.Debug
+import Control.Monad
+import System.Environment
+import Duckling.Lang
+import Data.Some
+import Duckling.Dimensions.Types
+
+main :: IO ()
+main = do
+  (repeatCount :: Int) <- read . head <$> getArgs
+  void $ replicateM repeatCount $ void $ do
+    debug EN "My number is 123" [This PhoneNumber,This Distance,This Numeral,This Email]
+    debug EN "Wednesday 5:00PM 3/29/2017" [This Numeral,This Time]
+    debug ZH "12:30pm" [This Time]
+    debug EN "tomorrow at 4pm" [This Time]
+    debug EN "Tomorrow at 12.30?" [This Time]
+    debug EN "Wednesday 9am" [This Time]
+    debug EN "Sure do! Will 11:30 work?" [This Time,This AmountOfMoney]
+    debug EN "8:00am" [This Time]