From 2627a17a43ffe3f803de7a5837144e1bdce0d9c8 Mon Sep 17 00:00:00 2001
From: JohannaSimoens <johanna.simoens@gmail.com>
Date: Tue, 18 Jun 2019 11:08:45 +0200
Subject: [PATCH] Portuguese V1

---
 grammar/it/src/rules.rs    |   25 +-
 grammar/pt/src/rules.rs    | 1863 +++++++++++++++++++++++++++++++++---
 grammar/pt/src/training.rs |  337 ++++++-
 3 files changed, 2093 insertions(+), 132 deletions(-)

diff --git a/grammar/it/src/rules.rs b/grammar/it/src/rules.rs
index 5961793a..0916ae2c 100644
--- a/grammar/it/src/rules.rs
+++ b/grammar/it/src/rules.rs
@@ -91,11 +91,11 @@ pub fn rules_finance(b: &mut RuleSetBuilder<Dimension>) -> RustlingResult<()> {
     );
     // This is not recognized for a very obscure reason
     b.rule_1_terminal("RUB",
-                      b.reg(r#"rub(?:l[oi])?"#)?,
+                      b.reg(r#"rub(?:l[oi])?(?: russ[oi])?"#)?,
                       |_| Ok(MoneyUnitValue { unit: Some("RUB") })
     );
     b.rule_1_terminal("INR",
-                      b.reg(r#"inr|rupi[ae]"#)?,
+                      b.reg(r#"inr|rupi[ae](?: indian[ae])?"#)?,
                       |_| Ok(MoneyUnitValue { unit: Some("INR") })
     );
     b.rule_1_terminal("JPY",
@@ -317,6 +317,16 @@ pub fn rules_duration(b: &mut RuleSetBuilder<Dimension>) -> RustlingResult<()> {
              b.reg(r#"(?:all'in)?circa|più o meno"#)?,
              |duration, _| Ok(duration.value().clone().precision(Precision::Approximate))
     );
+    b.rule_2("exactly <duration>",
+             b.reg(r#"esattamente"#)?,
+             duration_check!(),
+             |_, duration| Ok(duration.value().clone().precision(Precision::Exact))
+    );
+    b.rule_2("<duration> exactly",
+             duration_check!(),
+             b.reg(r#"(?:esatt|precis)(?:[aoie]|amente)"#)?,
+             |duration, _| Ok(duration.value().clone().precision(Precision::Exact))
+    );
     b.rule_2("during <duration>",
              b.reg(r#"(?:durante|per)"#)?,
              duration_check!(),
@@ -884,6 +894,11 @@ pub fn rules_time(b: &mut RuleSetBuilder<Dimension>) -> RustlingResult<()> {
              integer_check_by_range!(1, 23),
              |_, integer| Ok(helpers::hour(integer.value().value as u32, integer.value().value < 12)?.not_latent())
     );
+    b.rule_2("<time-of-day> oclock",
+             b.reg(r#"l['e]"#)?,
+             integer_check_by_range!(1, 23),
+             |_, integer| Ok(helpers::hour(integer.value().value as u32, integer.value().value < 12)?.not_latent())
+    );
     b.rule_2("around <time-of-day>",
              b.reg(r#"verso|interno a|(?:approssim|indic|orient)ativamente|(?:all'in)?circa|più o meno|pressappoco|suppergiù|grosso modo"#)?,
              time_check!(form!(Form::TimeOfDay(_))),
@@ -1729,9 +1744,9 @@ pub fn rules_temperature(b: &mut RuleSetBuilder<Dimension>) -> RustlingResult<()
                      latent: false,
                  })
              });
-    b.rule_2("<latent temp> temp below zero",
-             temperature_check!(),
-             b.reg(r#"(?:grad[oi] |° )?(?:sotto (?:lo )?zero)"#)?,
+    b.rule_2("<temp> temp below zero",
+             temperature_check!(|temp: &TemperatureValue| !temp.latent),
+             b.reg(r#"sotto (?:lo )?zero"#)?,
              |a, _| {
                  Ok(TemperatureValue {
                      value: -1.0 * a.value().value,
diff --git a/grammar/pt/src/rules.rs b/grammar/pt/src/rules.rs
index a0d570d8..c1354700 100644
--- a/grammar/pt/src/rules.rs
+++ b/grammar/pt/src/rules.rs
@@ -27,6 +27,7 @@ pub fn rules_finance(b: &mut RuleSetBuilder<Dimension>) -> RustlingResult<()> {
              amount_of_money_check!(|money: &AmountOfMoneyValue| money.unit != Some("cent")),
              number_check!(),
              |a, b| helpers::compose_money_number(&a.value(), &b.value()));
+
     b.rule_1_terminal("$",
         b.reg(r#"\$|d[oó]lar(?:es)?"#)?,
         |_| Ok(MoneyUnitValue { unit: Some("$") })
@@ -40,73 +41,91 @@ pub fn rules_finance(b: &mut RuleSetBuilder<Dimension>) -> RustlingResult<()> {
         |_| Ok(MoneyUnitValue { unit: Some("£") })
     );
     b.rule_1_terminal("GBP",
-                      b.reg(r#"gbp|libras? esterlinas?"#)?,
+                      b.reg(r#"gbp|libras? esterlinas?|libras? inglesas?|libras? britânicas?"#)?,
                       |_| Ok(MoneyUnitValue { unit: Some("GBP") })
     );
     b.rule_1_terminal("USD",
-        b.reg(r#"d[oó]lar(?:es)? americanos?"#)?,
+        b.reg(r#"d[oó]lar(?:es)? americanos?|d[oó]lar(?:es)? estadunidenses?|us[d\$]"#)?,
         |_| Ok(MoneyUnitValue { unit: Some("USD") })
     );
     b.rule_1_terminal("CAD",
-                      b.reg(r#"d[oó]lar(?:es)? canadenses?"#)?,
+                      b.reg(r#"d[oó]lar(?:es)? canadenses?|cad"#)?,
                       |_| Ok(MoneyUnitValue { unit: Some("CAD") })
     );
     b.rule_1_terminal("AUD",
-                      b.reg(r#"d[oó]lar(?:es) australianos?"#)?,
+                      b.reg(r#"d[oó]lar(?:es)? australianos?"#)?,
                       |_| Ok(MoneyUnitValue { unit: Some("AUD") })
     );
     b.rule_1_terminal("Bitcoin",
-        b.reg(r#"฿|bitcoins?"#)?,
+        b.reg(r#"฿|bitcoins?|btc|xbt"#)?,
         |_| Ok(MoneyUnitValue { unit: Some("฿") })
     );
-    b.rule_1_terminal("GBP",
-        b.reg(r#"libras? inglesas?"#)?,
-        |_| Ok(MoneyUnitValue { unit: Some("GBP") })
-    );
     b.rule_1_terminal("JPY",
-                      b.reg(r#"jpy|[yi]en(?:es)?(?: japoneses?)?"#)?,
+                      b.reg(r#"jpy|[yi]en(?:es?)?(?: japoneses?)?"#)?,
                       |_| Ok(MoneyUnitValue { unit: Some("JPY") })
     );
     b.rule_1_terminal("¥",
                       b.reg(r#"¥"#)?,
                       |_| Ok(MoneyUnitValue { unit: Some("¥") })
     );
+    b.rule_1_terminal("₽",
+                          b.reg(r#"₽"#)?,
+                          |_| Ok(MoneyUnitValue { unit: Some("₽") })
+    );
     b.rule_1_terminal("KRW",
-                      b.reg(r#"wons?|₩"#)?,
+                      b.reg(r#"krw|₩|won(?:e?s)? (?:sul[- ])?coreanos?|won(?:e?s)?"#)?,
                       |_| Ok(MoneyUnitValue { unit: Some("KRW") })
     );
-//    b.rule_1_terminal("RMB|CNH|CNY",
-//                      b.reg(r#""#)?,
-//                      |_| Ok(MoneyUnitValue { unit: Some("CNY") })
-//    );
+    b.rule_1_terminal("RMB|CNH|CNY",
+                      b.reg(r#"yuan(?:e?s)?(?: chineses?)?|renminbis?"#)?,
+                      |_| Ok(MoneyUnitValue { unit: Some("CNY") })
+    );
     b.rule_1_terminal("INR",
                       b.reg(r#"r[uú]pias?"#)?,
                       |_| Ok(MoneyUnitValue { unit: Some("INR") })
     );
-//    b.rule_1_terminal("HKD",
-//                      b.reg(r#""#)?,
-//                      |_| Ok(MoneyUnitValue { unit: Some("HKD") })
-//    );
+    b.rule_1_terminal("INR",
+                          b.reg(r#"r[uú]pias? indianas?"#)?,
+                          |_| Ok(MoneyUnitValue { unit: Some("INR") })
+        );
+    b.rule_1_terminal("HKD",
+                      b.reg(r#"d[oó]lar(?:es)? de hong kong"#)?,
+                      |_| Ok(MoneyUnitValue { unit: Some("HKD") })
+    );
     b.rule_1_terminal("CHF",
-                      b.reg(r#"francos? suíços?"#)?,
+                      b.reg(r#"francos? su[íi]ços?"#)?,
                       |_| Ok(MoneyUnitValue { unit: Some("CHF") })
     );
-//    b.rule_1_terminal("KR",
-//                      b.reg(r#""#)?,
-//                      |_| Ok(MoneyUnitValue { unit: Some("KR") })
-//    );
-//    b.rule_1_terminal("DKK",
-//                      b.reg(r#""#)?,
-//                      |_| Ok(MoneyUnitValue { unit: Some("DKK") })
-//    );
-//    b.rule_1_terminal("NOK",
-//                      b.reg(r#""#)?,
-//                      |_| Ok(MoneyUnitValue { unit: Some("NOK") })
-//    );
-//    b.rule_1_terminal("SEK",
-//                      b.reg(r#""#)?,
-//                      |_| Ok(MoneyUnitValue { unit: Some("SEK") })
-//    );
+    b.rule_1_terminal("KR",
+                      b.reg(r#"kr|coroas?"#)?,
+                      |_| Ok(MoneyUnitValue { unit: Some("KR") })
+    );
+    b.rule_1_terminal("DKK",
+                      b.reg(r#"dkk|coroas? dinamarquesas?"#)?,
+                      |_| Ok(MoneyUnitValue { unit: Some("DKK") })
+    );
+    b.rule_1_terminal("NOK",
+                      b.reg(r#"nok|coroas? norueguesas?"#)?,
+                      |_| Ok(MoneyUnitValue { unit: Some("NOK") })
+    );
+    b.rule_1_terminal("SEK",
+                      b.reg(r#"sek|coroas? suecas?"#)?,
+                      |_| Ok(MoneyUnitValue { unit: Some("SEK") })
+    );
+
+    b.rule_1_terminal("RUB",
+                      b.reg(r#"rub"#)?,
+                      |_| Ok(MoneyUnitValue { unit: Some("RUB") })
+    );
+    b.rule_1_terminal("RUB",
+                      b.reg(r#"rublos?"#)?,
+                      |_| Ok(MoneyUnitValue { unit: Some("RUB") })
+    );
+    b.rule_1_terminal("RUB",
+                      b.reg(r#"rublos? russos?"#)?,
+                      |_| Ok(MoneyUnitValue { unit: Some("RUB") })
+    );
+
     b.rule_1_terminal("cent",
                       b.reg(r#"centavos?"#)?,
                       |_| Ok(MoneyUnitValue { unit: Some("cent") })
@@ -143,7 +162,7 @@ pub fn rules_finance(b: &mut RuleSetBuilder<Dimension>) -> RustlingResult<()> {
                  })
              });
     b.rule_2("about <amount-of-money>",
-             b.reg(r#"cerca de"#)?,
+             b.reg(r#"quase|aproximadamente|cerca de|por (?:cerca|volta) de|em torno de|uns|umas"#)?,
              amount_of_money_check!(),
              |_, a| {
                  Ok(AmountOfMoneyValue {
@@ -151,17 +170,17 @@ pub fn rules_finance(b: &mut RuleSetBuilder<Dimension>) -> RustlingResult<()> {
                      ..a.value().clone()
                  })
              });
-//    b.rule_2("<amount-of-money> about",
-//             amount_of_money_check!(),
-//             b.reg(r#""#)?,
-//             |a, _| {
-//                 Ok(AmountOfMoneyValue {
-//                     precision: Approximate,
-//                     ..a.value().clone()
-//                 })
-//             });
+    b.rule_2("<amount-of-money> about",
+             amount_of_money_check!(),
+             b.reg(r#"aproximadamente|mais ou menos"#)?,
+             |a, _| {
+                 Ok(AmountOfMoneyValue {
+                     precision: Approximate,
+                     ..a.value().clone()
+                 })
+             });
     b.rule_2("exactly <amount-of-money>",
-             b.reg(r#"exatamente"#)?,
+             b.reg(r#"exatamente|precisamente"#)?,
              amount_of_money_check!(),
              |_, a| {
                  Ok(AmountOfMoneyValue {
@@ -169,16 +188,16 @@ pub fn rules_finance(b: &mut RuleSetBuilder<Dimension>) -> RustlingResult<()> {
                      ..a.value().clone()
                  })
              });
-//    b.rule_2("<amount-of-money> exactly",
-//             amount_of_money_check!(),
-//             b.reg(r#""#)?,
-//             |a, _| {
-//                 Ok(AmountOfMoneyValue {
-//                     precision: Exact,
-//                     ..a.value().clone()
-//                 })
-//             }
-//    );
+    b.rule_2("<amount-of-money> exactly",
+             amount_of_money_check!(),
+             b.reg(r#"exatamente|precisamente|exatos?"#)?,
+             |a, _| {
+                 Ok(AmountOfMoneyValue {
+                     precision: Exact,
+                     ..a.value().clone()
+                 })
+             }
+    );
     Ok(())
 }
 
@@ -211,8 +230,12 @@ pub fn rules_duration(b: &mut RuleSetBuilder<Dimension>) -> RustlingResult<()> {
                       b.reg(r#"anos?"#)?,
                       |_| Ok(UnitOfDurationValue::new(Grain::Year))
     );
+    b.rule_1_terminal("trimester (unit-of-duration)",
+                      b.reg(r#"trimestres?"#)?,
+                      |_| Ok(UnitOfDurationValue::new(Grain::Quarter))
+    );
     b.rule_1_terminal("quarter of an hour",
-                      b.reg(r#"quarto de hora"#)?,
+                      b.reg(r#"(?:um )?quarto de hora"#)?,
                       |_| Ok(DurationValue::new(PeriodComp::minutes(15).into()))
     );
     b.rule_1_terminal("half an hour",
@@ -223,6 +246,16 @@ pub fn rules_duration(b: &mut RuleSetBuilder<Dimension>) -> RustlingResult<()> {
                       b.reg(r#"tr[eê]s quartos de hora"#)?,
                       |_| Ok(DurationValue::new(PeriodComp::minutes(45).into()))
     );
+    b.rule_3("<number> h <number>",
+             integer_check_by_range!(0),
+             b.reg(r#"h(?:oras?)?"#)?,
+             integer_check_by_range!(0,59),
+             |hour, _, minute| {
+                 let hour_period = Period::from(PeriodComp::new(Grain::Hour, hour.value().clone().value));
+                 let minute_period = Period::from(PeriodComp::new(Grain::Minute, minute.value().clone().value));
+                 Ok(DurationValue::new(hour_period + minute_period))
+             }
+    );
     b.rule_2("<integer> <unit-of-duration>",
              integer_check_by_range!(0),
              unit_of_duration_check!(),
@@ -231,7 +264,7 @@ pub fn rules_duration(b: &mut RuleSetBuilder<Dimension>) -> RustlingResult<()> {
     b.rule_3("<integer> <unit-of-duration> and a half",
              integer_check_by_range!(0),
              unit_of_duration_check!(),
-             b.reg(r#"e meia"#)?,
+             b.reg(r#"e mei[ao]"#)?,
              |integer, uod, _| {
                  let half_period: Period = uod.value().grain.half_period().map(|a| a.into()).ok_or_else(|| RuleError::Invalid)?;
                  Ok(DurationValue::new(half_period + PeriodComp::new(uod.value().grain, integer.value().value)))
@@ -246,11 +279,30 @@ pub fn rules_duration(b: &mut RuleSetBuilder<Dimension>) -> RustlingResult<()> {
 //                 Ok(DurationValue::new(half_period + PeriodComp::new(uod.value().grain, integer.value().value)))
 //             }
 //    );
+    // FUTUR
     b.rule_2("in <duration> (future moment)",
-             b.reg(r#"em"#)?,
+             b.reg(r#"em|daqui a|dentro de"#)?,
              duration_check!(),
              |_, duration| duration.value().in_present()
     );
+    // FUTUR
+    b.rule_2("<duration> later",
+             duration_check!(),
+             b.reg(r#"depois"#)?,
+             |duration, _| duration.value().in_present()
+    );
+    // PAST
+    b.rule_2("<duration> ago",
+             duration_check!(),
+             b.reg(r#"atr[aá]s"#)?,
+             |duration, _| duration.value().ago()
+    );
+    // PAST
+    b.rule_2("<duration> ago",
+             b.reg(r#"há|faz"#)?,
+             duration_check!(),
+             |_, duration| duration.value().ago()
+    );
     b.rule_3("<duration> y <duration>",
              duration_check!(|duration: &DurationValue| !duration.suffixed),
              b.reg(r#"e"#)?,
@@ -267,24 +319,35 @@ pub fn rules_duration(b: &mut RuleSetBuilder<Dimension>) -> RustlingResult<()> {
              integer_check_by_range!(0),
              |duration, integer| helpers::compose_duration_with_integer(duration.value(), integer.value())
     );
-    b.rule_2("<duration> ago",
+    b.rule_2("during <duration>",
+             b.reg(r#"por|durante"#)?,
              duration_check!(),
-             b.reg(r#"atr[aá]s"#)?,
-             |duration, _| duration.value().ago()
+             |_, duration| Ok(duration.value().clone().prefixed())
     );
-    b.rule_2("<duration> later",
+    b.rule_2("approx <duration>",
+             b.reg(r#"aproximadamente|cerca de|por cerca de|por volta de|em torno de"#)?,
              duration_check!(),
-             b.reg(r#"depois"#)?,
-             |duration, _| duration.value().in_present()
+             |_, duration| Ok(duration.value().clone().precision(Precision::Approximate))
     );
-    b.rule_2("during <duration>",
-             b.reg(r#"por"#)?,
+    b.rule_2("<duration> approx",
              duration_check!(),
-             |_, duration| Ok(duration.value().clone().prefixed())
+             b.reg(r#"aproximadamente|mais ou? menos"#)?,
+             |duration, _| Ok(duration.value().clone().precision(Precision::Approximate))
+    );
+    b.rule_2("precisely <duration>",
+             b.reg(r#"exactamente|precisamente"#)?,
+             duration_check!(),
+             |_, duration| Ok(duration.value().clone().precision(Precision::Exact))
+    );
+    b.rule_2("precisely <duration>",
+             duration_check!(),
+             b.reg(r#"exactamente|precisamente"#)?,
+             |duration , _| Ok(duration.value().clone().precision(Precision::Exact))
     );
     Ok(())
 }
 
+
 pub fn rules_cycle(b: &mut RuleSetBuilder<Dimension>) -> RustlingResult<()> {
     b.rule_1_terminal("second (cycle)",
                       b.reg(r#"segundos?"#)?,
@@ -314,7 +377,124 @@ pub fn rules_cycle(b: &mut RuleSetBuilder<Dimension>) -> RustlingResult<()> {
                       b.reg(r#"anos?"#)?,
                       |_| CycleValue::new(Grain::Year)
     );
-
+    b.rule_1_terminal("trimester (cycle)",
+                          b.reg(r#"trimestres?"#)?,
+                          |_| CycleValue::new(Grain::Year)
+    );
+    // FUTUR
+    b.rule_2("next <cycle> ",
+             b.reg(r#"(?:n?[oa] )?próxim[oa]"#)?,
+             cycle_check!(),
+             |_, cycle| helpers::cycle_nth(cycle.value().grain, 1)
+    );
+    // FUTUR
+    b.rule_2("<cycle> next",
+             cycle_check!(),
+             b.reg(r#"que vem|depois"#)?,
+             |cycle, _| helpers::cycle_nth(cycle.value().grain, 1)
+    );
+    // FUTUR
+    b.rule_3("o <cycle> next",
+             b.reg(r#"n?[oa]"#)?,
+             cycle_check!(),
+             b.reg(r#"que vem|depois"#)?,
+             |_, cycle, _| helpers::cycle_nth(cycle.value().grain, 1)
+    );
+    // PAST
+    b.rule_2("last <cycle> ",
+             b.reg(r#"[oa] últim[oa]"#)?,
+             cycle_check!(),
+             |_, cycle| helpers::cycle_nth(cycle.value().grain, -1)
+    );
+    // PAST
+    b.rule_2("<cycle> last",
+             cycle_check!(),
+             b.reg(r#"atr[aá]s|antes|passad[oa]|anteriore"#)?,
+             |cycle, _| helpers::cycle_nth(cycle.value().grain, -1)
+    );
+    // PAST
+    b.rule_3("o <cycle> last",
+             b.reg(r#"o|a"#)?,
+             cycle_check!(),
+             b.reg(r#"atr[aá]s|antes|passad[oa]|anteriore"#)?,
+             |_, cycle, _| helpers::cycle_nth(cycle.value().grain, -1)
+    );
+    // FUTUR (Date|Time) period
+    b.rule_3("os next n <cycle>",
+            b.reg(r#"(?:n?[ao]s )?próxim[ao]s"#)?,
+            integer_check_by_range!(2, 9999),
+            cycle_check!(),
+            |_, integer, cycle| helpers::cycle_n_not_immediate(cycle.value().grain, integer.value().value)
+    );
+    // FUTUR (Date|Time) period
+    b.rule_4("os n next <cycle>",
+             b.reg(r#"n?[ao]s"#)?,
+             integer_check_by_range!(2, 9999),
+             b.reg(r#"próxim[ao]s"#)?,
+             cycle_check!(),
+             |_, integer, _, cycle| helpers::cycle_n_not_immediate(cycle.value().grain, integer.value().value)
+    );
+    // FUTUR (Date|Time) period
+    b.rule_3("n next <cycle>",
+             integer_check_by_range!(2, 9999),
+             b.reg(r#"próxim[ao]s"#)?,
+             cycle_check!(),
+             |integer, _, cycle| helpers::cycle_n_not_immediate(cycle.value().grain, integer.value().value)
+    );
+    // FUTUR (Date|Time) period
+    b.rule_4("os n <cycle> next ",
+             b.reg(r#"n?[ao]s"#)?,
+             integer_check_by_range!(2, 9999),
+             cycle_check!(),
+             b.reg(r#"que vem|depois"#)?,
+             |_, integer, cycle, _| helpers::cycle_n_not_immediate(cycle.value().grain, integer.value().value)
+    );
+    // PAST (Date|Time) period
+    b.rule_4("os n <cycle> last ",
+            b.reg(r#"n?[ao]s"#)?,
+            integer_check_by_range!(2, 9999),
+            cycle_check!(),
+            b.reg(r#"passad[oa]s|anteriores"#)?,
+            |_, integer, cycle, _| helpers::cycle_n_not_immediate(cycle.value().grain, -1 * integer.value().value)
+    );
+    // PAST (Date|Time) period
+    b.rule_3("os last n <cycle>",
+            b.reg(r#"(?:n?[ao]s )?últim[ao]s"#)?,
+            integer_check_by_range!(2, 9999),
+            cycle_check!(),
+            |_, integer,cycle| helpers::cycle_n_not_immediate(cycle.value().grain, -1 * integer.value().value)
+    );
+    // PAST (Date|Time) period
+    b.rule_4("o n last <cycle>",
+             b.reg(r#"n?[oa]s"#)?,
+             integer_check_by_range!(2, 9999),
+             b.reg(r#"últim[ao]s"#)?,
+             cycle_check!(),
+             |_, integer, _, cycle| helpers::cycle_n_not_immediate(cycle.value().grain, -1 * integer.value().value)
+    );
+    // PAST (Date|Time) period
+    b.rule_3("n last <cycle>",
+             integer_check_by_range!(2, 9999),
+             b.reg(r#"últim[ao]s"#)?,
+             cycle_check!(),
+             |integer, _, cycle| helpers::cycle_n_not_immediate(cycle.value().grain, -1 * integer.value().value)
+    );
+//    b.rule_2("last <cycle> ",
+//             b.reg(r#"h[àá]"#)?,
+//             cycle_check!(),
+//             |_, cycle| helpers::cycle_nth(cycle.value().grain, -1)
+//    );
+//    b.rule_3("in <cycle>",
+//             b.reg(r#"daqui a|dentro de"#)?,
+//             integer_check_by_range!(2, 9999),
+//             cycle_check!(),
+//             |_, integer, cycle| helpers::cycle_nth(cycle.value().grain, integer.value().value)
+//    );
+//    b.rule_2("in <cycle>",
+//             b.reg(r#"daqui a|dentro de"#)?,
+//             cycle_check!(),
+//             |_, cycle| helpers::cycle_nth(cycle.value().grain, 1)
+//    );
     Ok(())
 }
 
@@ -324,12 +504,14 @@ pub fn rules_time(b: &mut RuleSetBuilder<Dimension>) -> RustlingResult<()> {
              time_check!(|time: &TimeValue| !time.latent),
              |a, b| a.value().intersect(b.value())
     );
-    b.rule_3("intersect by `de`",
-             time_check!(|time: &TimeValue| !time.latent),
-             b.reg(r#"de"#)?,
-             time_check!(|time: &TimeValue| !time.latent),
-             |a, _, b| a.value().intersect(b.value())
-    );
+
+//    b.rule_3("intersect by `de`",
+//             datetime_check!(|datetime: &DatetimeValue| !datetime.latent),
+//             b.reg(r#"d[eo]"#)?,
+//             datetime_check!(|datetime: &DatetimeValue| !datetime.latent),
+//             |a, _, b| a.value().intersect(b.value())
+//    );
+
     b.rule_3("two time tokens separated by \",\"",
              time_check!(|time: &TimeValue| !time.latent),
              b.reg(r#","#)?,
@@ -337,31 +519,31 @@ pub fn rules_time(b: &mut RuleSetBuilder<Dimension>) -> RustlingResult<()> {
              |a, _, b| a.value().intersect(b.value())
     );
     b.rule_1_terminal("named-day",
-                      b.reg(r#"segunda(?:[- ]feira)?"#)?,
+                      b.reg(r#"(segunda|2ª)(?:[- ]feira| f.)?"#)?,
                       |_| helpers::day_of_week(Weekday::Mon)
     );
     b.rule_1_terminal("named-day",
-                      b.reg(r#"ter[cç]a(?:[- ]feira)?"#)?,
+                      b.reg(r#"(ter[cç]a|3ª)(?:[- ]feira| f.)?"#)?,
                       |_| helpers::day_of_week(Weekday::Tue)
     );
     b.rule_1_terminal("named-day",
-                      b.reg(r#"quarta(?:[- ]feira)?"#)?,
+                      b.reg(r#"(quarta|4ª)(?:[- ]feira| f.)?"#)?,
                       |_| helpers::day_of_week(Weekday::Wed)
     );
     b.rule_1_terminal("named-day",
-                      b.reg(r#"quinta(?:[- ]feira)?"#)?,
+                      b.reg(r#"(quinta|5ª)(?:[- ]feira| f.)?"#)?,
                       |_| helpers::day_of_week(Weekday::Thu)
     );
     b.rule_1_terminal("named-day",
-                      b.reg(r#"sexta(?:[- ]feira)?"#)?,
+                      b.reg(r#"(sexta|6ª)(?:[- ]feira| f.)?"#)?,
                       |_| helpers::day_of_week(Weekday::Fri)
     );
     b.rule_1_terminal("named-day",
-                      b.reg(r#"s[aá]bado"#)?,
+                      b.reg(r#"s[aá]bado|s[aá]b."#)?,
                       |_| helpers::day_of_week(Weekday::Sat)
     );
     b.rule_1_terminal("named-day",
-                      b.reg(r#"domingo"#)?,
+                      b.reg(r#"domingo|dom."#)?,
                       |_| helpers::day_of_week(Weekday::Sun)
     );
     b.rule_1_terminal("named-month",
@@ -413,34 +595,1153 @@ pub fn rules_time(b: &mut RuleSetBuilder<Dimension>) -> RustlingResult<()> {
                       |_| helpers::month(12)
     );
     b.rule_1_terminal("right now",
-                      b.reg(r#"agora mesmo"#)?,
+                      b.reg(r#"neste exato momento"#)?,
                       |_| helpers::cycle_nth(Grain::Second, 0)
     );
     b.rule_1_terminal("now",
-                      b.reg(r#"agora"#)?,
-                      |_| helpers::cycle_nth(Grain::Day, 0)
+                      b.reg(r#"agora(?: mesmo)?|neste momento"#)?,
+                      |_| helpers::cycle_nth(Grain::Second, 0)
     );
+    // Date HOLIDAY
+    b.rule_1_terminal("Christmas",
+                      b.reg(r#"(?:dia de )?natal"#)?,
+                      |_| helpers::month_day(12, 25)
+    );
+    // Date HOLIDAY
+    b.rule_1_terminal("New year's eve",
+        b.reg(r#"ano novo|primeiro dia do ano"#)?,
+        |_| Ok(helpers::month_day(1, 1)?.form(Form::Celebration))
+    );
+    // Date HOLIDAY
+    b.rule_1_terminal("Christmas",
+        b.reg(r#"véspera de natal|(?:a )?noite de natal"#)?,
+        |_| {
+            let start = helpers::month_day(12, 24)?.intersect(&helpers::hour(18, false)?)?;
+            let end = helpers::month_day(12, 25)?.intersect(&helpers::hour(0, false)?)?;
+            Ok(start.span_to(&end, false)?
+                 .form(Form::Celebration))
+        }
+    );
+    // Date HOLIDAY
+    b.rule_1_terminal("All saint's day",
+        b.reg(r#"(?:(?:no )?dia de )?(?:todos os santos|finados)"#)?,
+        |_| Ok(helpers::month_day(11, 1)?.form(Form::Celebration))
+    );
+    // Date HOLIDAY
+    b.rule_1_terminal("1st of May",
+        b.reg(r#"dia do (?:trabalho|trabalhador)"#)?,
+        |_| Ok(helpers::month_day(5, 1)?.form(Form::Celebration))
+    );
+    // Date
     b.rule_1_terminal("today",
                       b.reg(r#"hoje"#)?,
                       |_| helpers::cycle_nth(Grain::Day, 0)
     );
+    // Date
     b.rule_1_terminal("tomorrow",
                       b.reg(r#"amanh[aã]"#)?,
                       |_| helpers::cycle_nth(Grain::Day, 1)
     );
+    // Date
     b.rule_1_terminal("yesterday",
                       b.reg(r#"ontem"#)?,
                       |_| helpers::cycle_nth(Grain::Day, -1)
     );
-//    b.rule_1_terminal("the day after tomorrow",
-//                      b.reg(r#""#)?,
-//                      |_| helpers::cycle_nth(Grain::Day, 2)
+    // Date
+    b.rule_1_terminal("the day after tomorrow",
+                      b.reg(r#"(?:o )?dia depois de amanhã"#)?,
+                      |_| helpers::cycle_nth(Grain::Day, 2)
+    );
+    // Date
+    b.rule_1_terminal("the day after tomorrow",
+                      b.reg(r#"depois de amanhã"#)?,
+                      |_| helpers::cycle_nth(Grain::Day, 2)
+    );
+    // Date
+    b.rule_1_terminal("the day before yesterday",
+                      b.reg(r#"anteontem"#)?,
+                      |_| helpers::cycle_nth(Grain::Day, -2)
+    );
+    // Date
+    b.rule_2("this <day-of-week>", //assumed to be in the future
+             b.reg(r#"n?est[ea]"#)?,
+             time_check!(form!(Form::DayOfWeek{..})),
+             |_, time| time.value().the_nth_not_immediate(0)
+    );
+    // DateTime IS IT NECESSARY ?
+    b.rule_2("this <datetime>",
+             b.reg(r#"n?est[ea]|(?:n?[oa])? próxim[oa]"#)?,
+             time_check!(),
+             |_, time| time.value().the_nth(0)
+    );
+    // Date period
+    b.rule_2("'prep'? month 'prep' <named-month>",
+             b.reg(r#"(?:o )?mês de"#)?,
+             time_check!(form!(Form::Month(_))),
+             |_, time| Ok(time.value().clone())
+    );
+    b.rule_2("month 'preposition' <named-month>",
+             b.reg(r#"mês de"#)?,
+             time_check!(form!(Form::Month(_))),
+             |_, a| Ok(a.value().clone())
+    );
+    // Date period
+    b.rule_2("this <cycle>",
+             b.reg(r#"d?est[ea]"#)?,
+             cycle_check!(),
+             |_, cycle| helpers::cycle_nth(cycle.value().grain, 0)
+    );
+    b.rule_2("in <datetime>",
+             b.reg(r#"durante|em|para(?: [oa])?|n[oa]"#)?,
+             time_check!(),
+             |_, a| Ok(a.value().clone())
+    );
+    b.rule_2("in approximately <part-of-day> (approximation)",
+             b.reg(r#"pela"#)?,
+             time_check!(|time: &TimeValue| form!(Form::PartOfDay(_))(time) || form!(Form::Meal)(time)),
+             |_, a| Ok(a.value().clone())
+    );
+//    b.rule_2("last <time>",
+//             b.reg(r#"hà"#)?,
+//             time_check!(),
+//             |_, a| {
+//                 a.value().the_nth(-1)
+//             }
 //    );
-//    b.rule_1_terminal("the day before yesterday",
-//                      b.reg(r#""#)?,
-//                      |_| helpers::cycle_nth(Grain::Day, -2)
+    // Date-period
+    b.rule_2("beginning <named-month>(interval)",
+             b.reg(r#"(?:n)?o? (começo|início) d[eo](?: mês de)?"#)?,
+             time_check!(form!(Form::Month(_))),
+             |_, month| {
+                 let start = month.value().intersect(&helpers::day_of_month(1)?)?;
+                 let end = month.value().intersect(&helpers::day_of_month(5)?)?;
+                 start.span_to(&end, true)
+             }
+    );
+    // Date-period
+    b.rule_1_terminal("end of this month",
+                      b.reg(r#"n?o (fim|final) (do|deste) mês"#)?,
+                      |_| {
+                          let month = helpers::cycle_nth(Grain::Month, 1)?;
+                        Ok(helpers::cycle_nth_after(Grain::Day, -10, &month)?
+                            .span_to(&month, false)?
+                            .latent()
+                            .form(Form::PartOfMonth))
+                    }
+    );
+    // Date-period
+    b.rule_2("end of <named-month>(interval)",
+             b.reg(r#"n?o (?:fim|final) d[eo](?: mês de)?"#)?,
+             time_check!(form!(Form::Month(_))),
+             |_, month| {
+                 let start = month.value().intersect(&helpers::day_of_month(25)?)?;
+                 let end = helpers::cycle(Grain::Day)?.last_of(month.value())?;
+                 start.span_to(&end, true)
+             }
+    );
+    // Date period
+    b.rule_2("middle of <named-month>",
+             b.reg(r#"(?:em )?meados de|na metade(?: do mês)? de"#)?,
+             time_check!(form!(Form::Month(_))),
+             |_, month| {
+                 let start = month.value().intersect(&helpers::day_of_month(10)?)?;
+                 let end = month.value().intersect(&helpers::day_of_month(19)?)?;
+                 start.span_to(&end, true)
+             }
+    );
+    b.rule_2("fist half of <named-month>(interval)",
+             b.reg(r#"n?a primeira quinzena(?: do mês)? de"#)?,
+             time_check!(form!(Form::Month(_))),
+             |_, month| {
+                 let start = month.value().intersect(&helpers::day_of_month(1)?)?;
+                 let end = month.value().intersect(&helpers::day_of_month(14)?)?;
+                 start.span_to(&end, true)
+             }
+    );
+    b.rule_2("second half of <named-month>(interval)",
+             b.reg(r#"n?a segunda quinzena(?: do mês)? de"#)?,
+             time_check!(form!(Form::Month(_))),
+             |_, month| {
+                 let start = month.value().intersect(&helpers::day_of_month(15)?)?;
+                 let end = helpers::cycle(Grain::Day)?.last_of(month.value())?;
+                 start.span_to(&end, true)
+             }
+    );
+    // Date period
+    b.rule_2("next <named-month>",
+             b.reg(r#"n?o próximo mês de"#)?,
+             time_check!(form!(Form::Month(_))),
+             |_, time| time.value().the_nth_not_immediate(0)
+    );
+    // Date period
+    b.rule_2("for next <named-month>",
+             b.reg(r#"(para|durante) o próximo mês de"#)?,
+             time_check!(form!(Form::Month(_))),
+             |_, time| time.value().the_nth_not_immediate(0)
+    );
+    // Date period
+//    b.rule_4("next n <cycle>",
+//            b.reg(r#"os próximos"#)?,
+//            integer_check_by_range!(2, 9999),
+//            cycle_check!(),
+//            |_, integer, _, cycle| helpers::cycle_n_not_immediate(cycle.value().grain, integer.value().value)
+//    );
+    // Date period
+//    b.rule_4("n <cycle> next",
+//            b.reg(r#"os"#)?,
+//            integer_check_by_range!(2, 9999),
+//            b.reg(r#"próximos"#)?,
+//            cycle_check!(),
+//            |_, integer, _, cycle| helpers::cycle_n_not_immediate(cycle.value().grain, integer.value().value)
+//    );
+    // Date period
+    b.rule_2("last <named-month>",
+             b.reg(r#"n?o último mês de"#)?,
+             time_check!(form!(Form::Month(_))),
+             |_, time| time.value().the_nth(-1)
+    );
+    // Date period
+    b.rule_2("for last <named-month>",
+             b.reg(r#"(para|durante) o último mês de"#)?,
+             time_check!(form!(Form::Month(_))),
+             |_, time| time.value().the_nth(-1)
+    );
+    // Date
+    b.rule_2("next <named-day>",
+             b.reg(r#"n[oa] próxim[oa]|nest[ae]"#)?,
+             time_check!(form!(Form::DayOfWeek{..})),
+             |_, time| time.value().the_nth_not_immediate(0)
+    );
+    // Date
+    b.rule_2("<named-day> next",
+             time_check!(form!(Form::DayOfWeek{..})),
+             b.reg(r#"(?:da semana )?que vem"#)?,
+             |time, _| time.value().the_nth_not_immediate(0)
+    );
+    // Date
+    b.rule_2("<named-day> next",
+             time_check!(form!(Form::DayOfWeek{..})),
+             b.reg(r#"da próxima semana"#)?,
+             |time, _| time.value().the_nth_not_immediate(0)
+    );
+    // Date
+    b.rule_2("for next <named-day>",
+             b.reg(r#"(?:para |n)?o próximo"#)?,
+             time_check!(form!(Form::DayOfWeek{..})),
+             |_, time| time.value().the_nth_not_immediate(0)
+    );
+    // Date
+    b.rule_2("for next <named-day>",
+             b.reg(r#"próximo"#)?,
+             time_check!(form!(Form::DayOfWeek{..})),
+             |_, time| time.value().the_nth_not_immediate(0)
+    );
+    // Date
+    b.rule_2("last <named-day>",
+             b.reg(r#"últim[ao]"#)?,
+             time_check!(form!(Form::DayOfWeek{..})),
+             |_, time| time.value().the_nth(-1)
+    );
+    // Date
+    b.rule_2("last <named-day>",
+             b.reg(r#"n?[ao] últim[ao]"#)?,
+             time_check!(form!(Form::DayOfWeek{..})),
+             |_, time| time.value().the_nth(-1)
+    );
+    // Date
+    b.rule_2("for last <named-day>",
+             b.reg(r#"(?:para [oa]|nest[ea])? últim[ao]"#)?,
+             time_check!(form!(Form::DayOfWeek{..})),
+             |_, time| time.value().the_nth(-1)
+    );
+    // Date
+    b.rule_3("for <named-day> last",
+             b.reg(r#"para o|n?[oa]"#)?,
+             time_check!(form!(Form::DayOfWeek{..})),
+             b.reg(r#"atr[aá]s|antes|passad[oa]|anteriore"#)?,
+             |_, time, _| time.value().the_nth(-1)
+    );
+    // Date
+    b.rule_2("<named-day> last",
+             time_check!(form!(Form::DayOfWeek{..})),
+             b.reg(r#"atr[aá]s|antes|passad[oa]|anteriore"#)?,
+             |time, _| time.value().the_nth(-1)
+    );
+    // Date
+    b.rule_2("<named-day> of last week",
+             time_check!(form!(Form::DayOfWeek{..})),
+             b.reg(r#"da semana passada"#)?,
+             |time, _| time.value().the_nth(-1)
+    );
+    // Date
+    b.rule_3("for <named-day> of last week",
+             b.reg(r#"para o|n?[oa]"#)?,
+             time_check!(form!(Form::DayOfWeek{..})),
+             b.reg(r#"da semana passada"#)?,
+             |_, time, _| time.value().the_nth(-1)
+    );
+    // Date-Period
+    b.rule_1("year",
+             integer_check_by_range!(1000, 2100),
+             |integer| {
+                 helpers::year(integer.value().value as i32)
+             }
+    );
+    // Date-Period
+//    b.rule_1("year (latent)",
+//             integer_check_by_range!(-1000, 999),
+//             |integer| {
+//                 Ok(helpers::year(integer.value().value as i32)?.latent())
+//             }
 //    );
+    // Date-Period
+    b.rule_1("year (latent)",
+             integer_check_by_range!(2101, 2200),
+             |integer| {
+                 Ok(helpers::year(integer.value().value as i32)?.latent())
+             }
+    );
+    // Date-Period
+    b.rule_2("in year",
+             b.reg(r#"em|[dn]?o ano(?: de)?"#)?,
+             integer_check_by_range!(1000, 2100),
+             |_, integer| helpers::year(integer.value().value as i32)
+    );
+
+    b.rule_3("<datetime> de <year>",
+             time_check!(|time: &TimeValue| !time.latent),
+             b.reg(r#"d[eo]"#)?,
+             time_check!(form!(Form::Year(_))),
+             |a, _, b| a.value().intersect(b.value())
+    );
 
+
+
+    // Date-Period
+//    b.rule_2("in year",
+//             b.reg(r#"em"#)?,
+//             integer_check_by_range!(1000, 2100),
+//             |_, integer| helpers::year(integer.value().value as i32)
+//    );
+    // Date-Period
+    b.rule_2("in year",
+             b.reg(r#"(para|durante) o ano( de)?"#)?,
+             integer_check_by_range!(1000, 2100),
+             |_, integer| helpers::year(integer.value().value as i32)
+    );
+    // Date
+    b.rule_2("<day-of-month> ordinal",
+             b.reg(r#"o"#)?,
+             ordinal_check_by_range!(1, 31),
+             |_, integer| Ok(helpers::day_of_month(integer.value().value as u32)?)
+    );
+    // Date
+    b.rule_2("dia + integer",
+            b.reg(r#"dia"#)?,
+            integer_check_by_range!(1, 31),
+            |_, integer| Ok(helpers::day_of_month(integer.value().value as u32)?)
+    );
+    // Date
+    b.rule_3("<day-of-week> day <day-of-month>",
+             time_check!(form!(Form::DayOfWeek{..})),
+             b.reg(r#"dia"#)?,
+             integer_check_by_range!(1, 31),
+             |dow, _, integer| dow.value().intersect(&helpers::day_of_month(integer.value().value as u32)?)
+    );
+    // Date
+    b.rule_3("<day-of-month>(integer) de <named-month>",
+             integer_check_by_range!(1, 31),
+             b.reg(r#"de"#)?,
+             time_check!(form!(Form::Month(_))),
+             |integer, _, month| month.value().intersect(&helpers::day_of_month(integer.value().value as u32)?)
+    );
+    // Date
+    b.rule_3("<day-of-month>(ordinal) de <named-month>",
+             ordinal_check_by_range!(1, 31),
+             b.reg(r#"(?:dia )?de"#)?,
+             time_check!(form!(Form::Month(_))),
+             |integer, _, month| month.value().intersect(&helpers::day_of_month(integer.value().value as u32)?)
+    );
+    // Date
+    b.rule_4("o <day-of-month>(ordinal) de <named-month>",
+             b.reg(r#"(?:d|n)?o"#)?,
+             ordinal_check_by_range!(1, 31),
+             b.reg(r#"(?:dia )?de"#)?,
+             time_check!(form!(Form::Month(_))),
+             |_, integer, _, month| month.value().intersect(&helpers::day_of_month(integer.value().value as u32)?)
+    );
+    // Date
+    b.rule_4("o <day-of-month>(integer) de <named-month>",
+             b.reg(r#"(?:d|n)?o"#)?,
+             integer_check_by_range!(1, 31),
+             b.reg(r#"(?:dia )?de"#)?,
+             time_check!(form!(Form::Month(_))),
+             |_, integer, _, month| month.value().intersect(&helpers::day_of_month(integer.value().value as u32)?)
+    );
+    // Date
+    b.rule_4("dia <day-of-month>(integer) de <named-month>",
+             b.reg(r#"(?:(?:d|n)?o )?dia"#)?,
+             integer_check_by_range!(1, 31),
+             b.reg(r#"de"#)?,
+             time_check!(form!(Form::Month(_))),
+             |_, integer, _, month| month.value().intersect(&helpers::day_of_month(integer.value().value as u32)?)
+    );
+    // Date
+    b.rule_4("dia <day-of-month>(ordinal) de <named-month>",
+             b.reg(r#"(?:(?:d|n)?o )?dia"#)?,
+             ordinal_check_by_range!(1, 31),
+             b.reg(r#"de"#)?,
+             time_check!(form!(Form::Month(_))),
+             |_, integer, _, month| month.value().intersect(&helpers::day_of_month(integer.value().value as u32)?)
+    );
+    // Date
+    b.rule_4("<day-of-week> <day-of-month>(ordinal) de <named-month>",
+             time_check!(form!(Form::DayOfWeek{..})),
+             ordinal_check_by_range!(1, 31),
+             b.reg(r#"de"#)?,
+             time_check!(form!(Form::Month(_))),
+             |_, integer, _, month| month.value().intersect(&helpers::day_of_month(integer.value().value as u32)?)
+    );
+    // Date
+    b.rule_4("<day-of-week> <day-of-month>(integer) de <named-month>",
+             time_check!(form!(Form::DayOfWeek{..})),
+             integer_check_by_range!(1, 31),
+             b.reg(r#"de"#)?,
+             time_check!(form!(Form::Month(_))),
+             |_, integer, _, month| month.value().intersect(&helpers::day_of_month(integer.value().value as u32)?)
+    );
+    // Date
+    b.rule_5("<day-of-week> dia <day-of-month>(integer) de <named-month>",
+             time_check!(form!(Form::DayOfWeek{..})),
+             b.reg(r#"dia"#)?,
+             integer_check_by_range!(1, 31),
+             b.reg(r#"de"#)?,
+             time_check!(form!(Form::Month(_))),
+             |_, _, integer, _, month| month.value().intersect(&helpers::day_of_month(integer.value().value as u32)?)
+    );
+    // Date period
+    b.rule_1_terminal("beginning of week",
+                      b.reg(r#"n?o (início|começo) (da|desta) semana"#)?,
+                      |_| helpers::day_of_week(Weekday::Mon)
+                          ?.span_to(&helpers::day_of_week(Weekday::Tue)?, false)
+    );
+    // Date period
+    b.rule_1_terminal("middle of week",
+                      b.reg(r#"n?[oa] (meio|metade) da semana"#)?,
+                      |_| helpers::day_of_week(Weekday::Wed)
+                          ?.span_to(&helpers::day_of_week(Weekday::Thu)?, false)
+    );
+    // Date period
+    b.rule_1_terminal("end of week (not weekend)",
+                      b.reg(r#"(fim|final) d[ae] semana"#)?,
+                      |_| helpers::day_of_week(Weekday::Thu)
+                          ?.span_to(&helpers::day_of_week(Weekday::Sun)?, false)
+    );
+    // Date period
+    b.rule_1_terminal("for the end of week (not weekend)",
+                      b.reg(r#"n?o (fim|final) d[ae] semana"#)?,
+                      |_| helpers::day_of_week(Weekday::Thu)
+                          ?.span_to(&helpers::day_of_week(Weekday::Sun)?, false)
+    );
+    // Date period
+    b.rule_1_terminal("during the week",
+                      b.reg(r#"(?:para|durante )?(?:esta|a) semana"#)?,
+                      |_| helpers::day_of_week(Weekday::Mon)
+                          ?.span_to(&helpers::day_of_week(Weekday::Fri)?, false)
+    );
+    // Date period
+    b.rule_1_terminal("week-end",
+                      b.reg(r#"para? (o|este) (fim|final) de semana"#)?,
+                      |_| {
+                          let friday = helpers::day_of_week(Weekday::Fri)?
+                              .intersect(&helpers::hour(18, false)?)?;
+                          let monday = helpers::day_of_week(Weekday::Mon)?
+                              .intersect(&helpers::hour(0, false)?)?;
+                          friday.span_to(&monday, false)
+                      }
+    );
+    b.rule_2("dernier week-end de <time>",
+             b.reg(r#"(?:o )?último (fim|final) de semana(?: de| do)?"#)?,
+             time_check!(form!(Form::Month(_))),
+             |_, time| {
+                 let week_day_start = helpers::day_of_week(Weekday::Fri)?.intersect(&helpers::hour(18, false)?)?;
+                 let week_day_end = helpers::day_of_week(Weekday::Mon)?.intersect(&helpers::hour(0, false)?)?;
+                 let week_day = week_day_start.span_to(&week_day_end, false)?;
+                 week_day.last_of(time.value())
+             }
+    );
+    b.rule_4("o <ordinal> week-end of <time>",
+             b.reg(r#"(?:o )?"#)?,
+             ordinal_check!(),
+             b.reg(r#"(fim|final) de semana(?: de| do)?"#)?,
+             time_check!(form!(Form::Month(_))),
+             |_, ordinal, _, time| {
+                 let week_day_start = helpers::day_of_week(Weekday::Fri)?.intersect(&helpers::hour(18, false)?)?;
+                 let week_day_end = helpers::day_of_week(Weekday::Mon)?.intersect(&helpers::hour(0, false)?)?;
+                 let week_day = week_day_start.span_to(&week_day_end, false)?;
+                 let week_ends_of_time = time.value().intersect(&week_day)?;
+                 week_ends_of_time.the_nth(ordinal.value().value - 1)
+             }
+    );
+    b.rule_3("o <ordinal> week-end of <time>",
+             ordinal_check!(),
+             b.reg(r#"(fim|final) de semana(?: de| do)?"#)?,
+             time_check!(form!(Form::Month(_))),
+             |ordinal, _, time| {
+                 let week_day_start = helpers::day_of_week(Weekday::Fri)?.intersect(&helpers::hour(18, false)?)?;
+                 let week_day_end = helpers::day_of_week(Weekday::Mon)?.intersect(&helpers::hour(0, false)?)?;
+                 let week_day = week_day_start.span_to(&week_day_end, false)?;
+                 let week_ends_of_time = time.value().intersect(&week_day)?;
+                 week_ends_of_time.the_nth(ordinal.value().value - 1)
+             }
+    );
+    // Date period
+    b.rule_1_terminal("season",
+                      b.reg(r#"verão"#)?,
+                      |_| helpers::month_day(6, 21)?
+                          .span_to(&helpers::month_day(9, 23)?, false)
+    );
+    // Date period
+    b.rule_1_terminal("season",
+                      b.reg(r#"outono"#)?,
+                      |_| helpers::month_day(9, 23)?
+                          .span_to(&helpers::month_day(12, 21)?, false)
+    );
+    // Date period
+    b.rule_1_terminal("season",
+                      b.reg(r#"inverno"#)?,
+                      |_| helpers::month_day(12, 21)?
+                          .span_to(&helpers::month_day(3, 20)?, false)
+    );
+    // Date period
+    b.rule_1_terminal("season",
+                      b.reg(r#"primavera"#)?,
+                      |_| helpers::month_day(3, 20)?
+                          .span_to(&helpers::month_day(6, 21)?, false)
+    );
+    // Time
+    b.rule_1_terminal("noon",
+                      b.reg(r#"(?:a?o )?meio[- ]dia"#)?,
+                      |_| helpers::hour(12, false)
+    );
+    // Time
+    b.rule_1_terminal("noon",
+                      b.reg(r#"meio[- ]dia"#)?,
+                      |_| helpers::hour(12, false)
+    );
+    // Time
+    b.rule_1_terminal("midnight",
+                      b.reg(r#"(?:a )?meia[- ]noite"#)?,
+                      |_| helpers::hour(0, false)
+    );
+    b.rule_1("time-of-day (latent) (1 to 23)",
+             integer_check_by_range!(1, 23),
+             |integer| {
+                 Ok(helpers::hour(integer.value().value as u32, integer.value().value <= 12)?.latent())
+             }
+    );
+    b.rule_1("time-of-day (latent) (0)",
+             integer_check_by_range!(0, 0),
+             |_| Ok(helpers::hour(0, false)?.latent())
+    );
+    b.rule_1("time-of-day (latent) (half)",
+            number_check!(|number: &NumberValue| {
+                let hour = (number.value() - 0.5) as u32;
+                hour as f32 == (number.value() - 0.5) && hour >= 1 && hour <= 23
+            }),
+             |number| {
+                let hour = number.value().value() as u32;
+                Ok(helpers::hour_minute(hour, 30, hour <= 12)?.latent())
+             }
+    );
+    b.rule_1("time-of-day (latent) (quarter)",
+            number_check!(|number: &NumberValue| {
+                let hour = (number.value() - 0.25) as u32;
+                hour as f32 == (number.value() - 0.25) && hour >= 1 && hour <= 23
+            }),
+             |number| {
+                let hour = number.value().value() as u32;
+                Ok(helpers::hour_minute(hour, 15, hour <= 12)?.latent())
+             }
+    );
+    // Time
+    b.rule_2("<time-of-day> hour",
+             time_check!(form!(Form::TimeOfDay(_))),
+             b.reg(r#"horas?"#)?,
+             |time, _| Ok(time.value().clone().not_latent())
+    );
+    // Time
+    b.rule_2("<time-of-day> am|pm",
+             time_check!(form!(Form::TimeOfDay(_))),
+             b.reg(r#"([ap])\.?m\.?"#)?,
+             |a, text_match| {
+                 let day_period = if text_match.group(1) == "a" {
+                     helpers::hour(0, false)?.span_to(&helpers::hour(12, false)?, false)?
+                 } else {
+                     helpers::hour(12, false)?.span_to(&helpers::hour(0, false)?, false)?
+                 };
+                 Ok(a.value().intersect(&day_period)?.form(a.value().form.clone()))
+             }
+    );
+    // Time period
+    b.rule_1_terminal("morning",
+                      b.reg(r#"manh[aã]|madrugada"#)?,
+                      |_| Ok(helpers::hour(4, false)?.span_to(&helpers::hour(12, false)?, false)?
+                          .form(Form::PartOfDay(PartOfDayForm::Morning))
+                          .latent())
+    );
+    // Time period
+    b.rule_1_terminal("beginning of morning",
+                      b.reg(r#"(?:para |(?:logo )?n?o )?(começo|início) da manh[aã]"#)?,
+                      |_| Ok(helpers::hour(4, false)?
+                          .span_to(&helpers::hour(9, false)?, false)?
+                          .latent()
+                          .form(Form::PartOfDay(PartOfDayForm::Morning)))
+    );
+    // Time period
+    b.rule_1_terminal("beginning of morning",
+                      b.reg(r#"(?:para |n?o )?logo (à|de) manh[aã]"#)?,
+                      |_| Ok(helpers::hour(4, false)?
+                          .span_to(&helpers::hour(9, false)?, false)?
+                          .latent()
+                          .form(Form::PartOfDay(PartOfDayForm::Morning)))
+    );
+    b.rule_1_terminal("beginning of morning",
+                      b.reg(r#"primeiras horas da manh[aã]"#)?,
+                      |_| Ok(helpers::hour(4, false)?
+                          .span_to(&helpers::hour(9, false)?, false)?
+                          .latent()
+                          .form(Form::PartOfDay(PartOfDayForm::Morning)))
+    );
+    // Time period
+    b.rule_1_terminal("end of morning",
+                      b.reg(r#"(?:para |n?o )?(fim|final) da manh[aã]"#)?,
+                      |_| Ok(helpers::hour(10, false)?
+                          .span_to(&helpers::hour(12, false)?, false)?
+                          .latent()
+                          .form(Form::PartOfDay(PartOfDayForm::Morning)))
+    );
+    // Time period
+    b.rule_1_terminal("end of morning",
+                      b.reg(r#"(fim|final) da manh[aã]"#)?,
+                      |_| Ok(helpers::hour(10, false)?
+                          .span_to(&helpers::hour(12, false)?, false)?
+                          .latent()
+                          .form(Form::PartOfDay(PartOfDayForm::Morning)))
+    );
+    // Time period
+    b.rule_1_terminal("end of morning",
+                      b.reg(r#"nas últimas horas da manh[aã]"#)?,
+                      |_| Ok(helpers::hour(10, false)?
+                          .span_to(&helpers::hour(12, false)?, false)?
+                          .latent()
+                          .form(Form::PartOfDay(PartOfDayForm::Morning)))
+    );
+    // Time period
+    b.rule_1_terminal("afternoon",
+                      b.reg(r#"tarde"#)?,
+                      |_| Ok(helpers::hour(12, false)?.span_to(&helpers::hour(19, false)?, false)?
+                          .form(Form::PartOfDay(PartOfDayForm::Afternoon))
+                          .latent())
+    );
+    // Time period
+    b.rule_1_terminal("beginning of afternoon",
+        b.reg(r#"(?:para |n?o )(começo|início) da tarde"#)?,
+        |_| {
+            Ok(helpers::hour(12, false)?
+                    .span_to(&helpers::hour(15, false)?, false)?
+                    .latent()
+                    .form(Form::PartOfDay(PartOfDayForm::Afternoon)))
+        }
+    );
+    // Time period
+    b.rule_1_terminal("beginning of afternoon",
+        b.reg(r#"(?:para |n?o )?logo (à|de) tarde"#)?,
+        |_| {
+            Ok(helpers::hour(12, false)?
+                    .span_to(&helpers::hour(15, false)?, false)?
+                    .latent()
+                    .form(Form::PartOfDay(PartOfDayForm::Afternoon)))
+        }
+    );
+    // Time period
+    b.rule_1_terminal("middle afternoon",
+                      b.reg(r#"(?:para |n?o )?meio da tarde"#)?,
+                      |_| {
+                          Ok(helpers::hour(15, false)?
+                              .span_to(&helpers::hour(17, false)?, false)?
+                              .latent()
+                              .form(Form::PartOfDay(PartOfDayForm::Afternoon)))
+                      }
+    );
+    // Time period
+    b.rule_1_terminal("middle afternoon",
+                      b.reg(r#"em plena tarde"#)?,
+                      |_| {
+                          Ok(helpers::hour(15, false)?
+                              .span_to(&helpers::hour(17, false)?, false)?
+                              .latent()
+                              .form(Form::PartOfDay(PartOfDayForm::Afternoon)))
+                      }
+    );
+    // Time period nas últimas horas
+    b.rule_1_terminal("end of afternoon",
+                      b.reg(r#"(?:para |n?o )(fim|final) da tarde"#)?,
+                      |_| {
+                          Ok(helpers::hour(15, false)?
+                              .span_to(&helpers::hour(17, false)?, false)?
+                              .latent()
+                              .form(Form::PartOfDay(PartOfDayForm::Afternoon)))
+                      }
+    );
+    b.rule_1_terminal("end of afternoon",
+                      b.reg(r#"nas últimas horas da tarde"#)?,
+                      |_| {
+                          Ok(helpers::hour(15, false)?
+                              .span_to(&helpers::hour(17, false)?, false)?
+                              .latent()
+                              .form(Form::PartOfDay(PartOfDayForm::Afternoon)))
+                      }
+    );
+    // Time period
+    b.rule_1_terminal("end of afternoon",
+                      b.reg(r#"(fim|final) da tarde"#)?,
+                      |_| {
+                          Ok(helpers::hour(15, false)?
+                              .span_to(&helpers::hour(17, false)?, false)?
+                              .latent()
+                              .form(Form::PartOfDay(PartOfDayForm::Afternoon)))
+                      }
+    );
+    // Time period
+    b.rule_1_terminal("evening",
+                      b.reg(r#"noite"#)?,
+                      |_| Ok(helpers::hour(18, false)?.span_to(&helpers::hour(0, false)?, false)?
+                          .form(Form::PartOfDay(PartOfDayForm::Evening))
+                          .latent())
+    );
+    // Time period
+    b.rule_1_terminal("beginning of evening",
+                      b.reg(r#"(?:para |n?o )(começo|início) da noite"#)?,
+                      |_| {
+                          Ok(helpers::hour(18, false)?
+                              .span_to(&helpers::hour(21, false)?, false)?
+                              .latent()
+                              .form(Form::PartOfDay(PartOfDayForm::Evening)))
+                      }
+    );
+    // Time period
+    b.rule_1_terminal("beginning of evening",
+                      b.reg(r#"(começo|início) da noite"#)?,
+                      |_| {
+                          Ok(helpers::hour(18, false)?
+                              .span_to(&helpers::hour(21, false)?, false)?
+                              .latent()
+                              .form(Form::PartOfDay(PartOfDayForm::Evening)))
+                      }
+    );
+    // Time period
+    b.rule_1_terminal("beginning of evening",
+                      b.reg(r#"(?:para |n?o )?logo (à|de) noite"#)?,
+                      |_| {
+                          Ok(helpers::hour(18, false)?
+                              .span_to(&helpers::hour(21, false)?, false)?
+                              .latent()
+                              .form(Form::PartOfDay(PartOfDayForm::Evening)))
+                      }
+    );
+    // Time period
+    b.rule_1_terminal("end of evening",
+                      b.reg(r#"(?:para |n?o )?(fim|final|tarde) da noite"#)?,
+                      |_| {
+                          Ok(helpers::hour(21, false)?
+                              .span_to(&helpers::hour(0, false)?, false)?
+                              .latent()
+                              .form(Form::PartOfDay(PartOfDayForm::Evening)))
+                      }
+    );
+    // Time period
+    b.rule_1_terminal("end of evening",
+                      b.reg(r#"(fim|final|tarde) da noite"#)?,
+                      |_| {
+                          Ok(helpers::hour(21, false)?
+                              .span_to(&helpers::hour(0, false)?, false)?
+                              .latent()
+                              .form(Form::PartOfDay(PartOfDayForm::Evening)))
+                      }
+    );
+    // Time period
+    b.rule_1_terminal("end of evening",
+                      b.reg(r#"nas últimas horas da noite"#)?,
+                      |_| {
+                          Ok(helpers::hour(21, false)?
+                              .span_to(&helpers::hour(0, false)?, false)?
+                              .latent()
+                              .form(Form::PartOfDay(PartOfDayForm::Evening)))
+                      }
+    );
+    // Time period
+    b.rule_1_terminal("lunch",
+                      b.reg(r#"almoço"#)?,
+                      |_| Ok(helpers::hour(12, false)?
+                          .span_to(&helpers::hour(14, false)?, false)?
+                          .latent()
+                          .form(Form::Meal))
+    );
+    // Time period
+    b.rule_1_terminal("lunch",
+                      b.reg(r#"d?a hora doalmoço"#)?,
+                      |_| Ok(helpers::hour(12, false)?
+                          .span_to(&helpers::hour(14, false)?, false)?
+                          .latent()
+                          .form(Form::Meal))
+    );
+    // Time period
+    b.rule_2("this <part-of-day>",
+             b.reg(r#"d?esta|d[ea]"#)?,
+             time_check!(|time: &TimeValue| form!(Form::PartOfDay(_))(time) || form!(Form::Meal)(time)),
+             |_, pod| Ok(helpers::cycle_nth(Grain::Day, 0)?
+                 .intersect(pod.value())?
+                 .form(pod.value().form.clone()))
+    );
+    // Time
+    b.rule_2("<time-of-day> <part-of-day>",
+             time_check!(excluding_form!(Form::PartOfDay(_))),
+             time_check!(|time: &TimeValue| form!(Form::PartOfDay(_))(time) || form!(Form::Meal)(time)),
+             |a, b| a.value().intersect(b.value())
+    );
+    b.rule_2("<dim time> da manha",
+             time_check!(form!(Form::TimeOfDay(_))),
+             b.reg(r#"(?:d[ea]|à) manh[aã]"#)?,
+             |a, _| {
+                 let period = helpers::hour(0, false)?
+                     .span_to(&helpers::hour(12, false)?, false)?;
+                 a.value().intersect(&period)
+             }
+    );
+    b.rule_2("<dim time> da noite",
+             time_check!(form!(Form::TimeOfDay(_))),
+             b.reg(r#"(?:d[ea]|à) noite"#)?,
+             |a, _| {
+                 let period = helpers::hour(16, false)?
+                     .span_to(&helpers::hour(0, false)?, false)?;
+                 a.value().intersect(&period)
+             }
+    );
+    // Time period
+    b.rule_3("<part-of-day> de <time>",
+            time_check!(|time: &TimeValue| form!(Form::PartOfDay(_))(time) || form!(Form::Meal)(time)),
+            b.reg(r#"d?esta|d[ea]"#)?,
+            time_check!(|time: &TimeValue| excluding_form!(Form::Year(_))(time) && excluding_form!(Form::Month(_))(time)),
+            |part_of_day, _, time| time.value().intersect(part_of_day.value())
+    );
+    // Time period
+    b.rule_3("<time> à <part-of-day>",
+            time_check!(|time: &TimeValue| excluding_form!(Form::Year(_))(time) && excluding_form!(Form::Month(_))(time)),
+            b.reg(r#"à"#)?,
+            time_check!(|time: &TimeValue| form!(Form::PartOfDay(_))(time) || form!(Form::Meal)(time)),
+            |time, _, part_of_day| time.value().intersect(part_of_day.value())
+    );
+    // Time period
+    b.rule_3("<time-of-day> de <time>",
+            time_check!(excluding_form!(Form::PartOfDay(_))),
+            b.reg(r#"d?esta|d[ea]"#)?,
+            time_check!(|time: &TimeValue| excluding_form!(Form::Year(_))(time) && excluding_form!(Form::Month(_))(time)),
+            |part_of_day, _, time| time.value().intersect(part_of_day.value())
+    );
+    b.rule_1_terminal("half (relative minutes)",
+                      b.reg(r#"meia"#)?,
+                      |_| Ok(RelativeMinuteValue(30))
+    );
+    b.rule_1("number (as relative minutes)",
+             integer_check_by_range!(1, 59),
+             |integer| Ok(RelativeMinuteValue(integer.value().value as i32))
+    );
+    b.rule_2("<integer> minutes (as relative minutes)",
+             integer_check_by_range!(1, 59),
+             b.reg(r#"minutos?"#)?,
+             |integer, _| Ok(RelativeMinuteValue(integer.value().value as i32))
+    );
+    // Time (ambiguity with Duration) ex: seis horas e vinte minutos
+    b.rule_3("<hour-of-day> and <relative minutes>",
+             time_check!(form!(Form::TimeOfDay(TimeOfDayForm::Hour { .. }))),
+             b.reg(r#"e"#)?,
+             relative_minute_check!(),
+             |time, _, relative_minute| helpers::hour_relative_minute(
+                 time.value().form_time_of_day()?.full_hour(),
+                 relative_minute.value().0,
+                 time.value().form_time_of_day()?.is_12_clock())
+    );
+    // Time
+    b.rule_2("at <time-of-day>",
+             b.reg(r#"às?|para"#)?,
+             time_check!(form!(Form::TimeOfDay(_))),
+             |_, tod| Ok(tod.value().clone().not_latent())
+    );
+    // Time
+    b.rule_2("around <time-of-day>",
+             b.reg(r#"lá (?:pelas?|pelo)|por volta d(?:e|as)"#)?,
+             time_check!(form!(Form::TimeOfDay(_))),
+             |_, a| Ok(a.value().clone().not_latent())
+    );
+    // Time
+    b.rule_2("<time-of-day> approx",
+             time_check!(form!(Form::TimeOfDay(_))),
+             b.reg(r#"mais ou menos"#)?,
+             |a, _| Ok(a.value().clone().not_latent())
+    );
+    // Time
+    b.rule_4("<integer> (as relative minutes) para o <hour-of-day>",
+             b.reg(r#"às|aos"#)?,
+             relative_minute_check!(),
+             b.reg(r#"para (?:o|as)"#)?,
+             time_check!(|time: &TimeValue| !time.latent && form!(Form::TimeOfDay(TimeOfDayForm::Hour { .. }))(time)),
+             |_, minutes, _, time| helpers::hour_relative_minute(
+                 time.value().form_time_of_day()?.full_hour(),
+                 -1 * minutes.value().0,
+                 time.value().form_time_of_day()?.is_12_clock()
+             )
+    );
+    // Time
+    b.rule_3("<integer> (as relative minutes) para o <hour-of-day>",
+             relative_minute_check!(),
+             b.reg(r#"para (?:o|as)"#)?,
+             time_check!(|time: &TimeValue| !time.latent && form!(Form::TimeOfDay(TimeOfDayForm::Hour { .. }))(time)),
+             |minutes, _, time| helpers::hour_relative_minute(
+                 time.value().form_time_of_day()?.full_hour(),
+                 -1 * minutes.value().0,
+                 time.value().form_time_of_day()?.is_12_clock()
+             )
+    );
+    // Time period
+    b.rule_1_terminal("beginning of day",
+                      b.reg(r#"(?:n?o )?(começo|início) do dia"#)?,
+                      |_| {
+                          Ok(helpers::hour(6, false)?
+                              .span_to(&helpers::hour(10, false)?, false)?
+                              .latent()
+                              .form(Form::PartOfDay(PartOfDayForm::Morning)))
+                      }
+    );
+    // Time period
+    b.rule_1_terminal("beginning of day",
+                      b.reg(r#"(começo|início) do dia"#)?,
+                      |_| {
+                          Ok(helpers::hour(6, false)?
+                              .span_to(&helpers::hour(10, false)?, false)?
+                              .latent()
+                              .form(Form::PartOfDay(PartOfDayForm::Morning)))
+                      }
+    );
+    // Time period
+    b.rule_1_terminal("middle of day",
+                      b.reg(r#"(?:n[ao] )(metade|meio) do dia"#)?,
+                      |_| {
+                          Ok(helpers::hour(11, false)?
+                              .span_to(&helpers::hour(16, false)?, false)?
+                              .latent()
+                              .form(Form::PartOfDay(PartOfDayForm::None)))
+                      }
+    );
+    // Time period
+    b.rule_1_terminal("middle of day",
+                      b.reg(r#"(metade|meio) do dia"#)?,
+                      |_| {
+                          Ok(helpers::hour(11, false)?
+                              .span_to(&helpers::hour(16, false)?, false)?
+                              .latent()
+                              .form(Form::PartOfDay(PartOfDayForm::None)))
+                      }
+    );
+    // Time period
+    b.rule_1_terminal("end of day",
+                      b.reg(r#"(?:para |n?o |ao )?(fim|final|acabar) d?o dia"#)?,
+                      |_| {
+                          Ok(helpers::hour(17, false)?
+                              .span_to(&helpers::hour(21, false)?, false)?
+                              .latent()
+                              .form(Form::PartOfDay(PartOfDayForm::Evening)))
+                      }
+    );
+    // Time period
+    b.rule_1_terminal("end of day",
+                      b.reg(r#"(fim|final|acabar) d?o dia"#)?,
+                      |_| {
+                          Ok(helpers::hour(17, false)?
+                              .span_to(&helpers::hour(21, false)?, false)?
+                              .latent()
+                              .form(Form::PartOfDay(PartOfDayForm::Evening)))
+                      }
+    );
+    // Time period
+    b.rule_1_terminal("end of day",
+                      b.reg(r#"nas últimas horas d?o dia"#)?,
+                      |_| {
+                          Ok(helpers::hour(17, false)?
+                              .span_to(&helpers::hour(21, false)?, false)?
+                              .latent()
+                              .form(Form::PartOfDay(PartOfDayForm::Evening)))
+                      }
+    );
+    // Time period
+    b.rule_4("between <datetime> and <datetime> (interval)",
+             b.reg(r#"entre(?: as?| o)?"#)?,
+             time_check!(|time: &TimeValue| excluding_form!(Form::Year(_))(time)),
+             b.reg(r#"e(?: as?| a?o)?"#)?,
+             time_check!(|time: &TimeValue| excluding_form!(Form::Year(_))(time)),
+             |_, a, _, b| a.value().span_to(b.value(), false)
+    );
+    // Time period
+    b.rule_4("between <datetime> and <datetime> (interval)",
+             b.reg(r#"entre(?: as?| a?o)?"#)?,
+             time_check!(|time: &TimeValue| excluding_form!(Form::Year(_))(time)),
+             b.reg(r#"e"#)?,
+             time_check!(|time: &TimeValue| excluding_form!(Form::Year(_))(time)),
+             |_, a, _, b| a.value().span_to(b.value(), false)
+    );
+    // Time period
+    b.rule_4("between <time-of-day> e as <time-of-day> (interval)",
+             b.reg(r#"entre(?: as?| o)?"#)?,
+             time_check!(form!(Form::TimeOfDay(_))),
+             b.reg(r#"e(?: a)?"#)?,
+             time_check!(form!(Form::TimeOfDay(_))),
+             |_, a, _, b| a.value().span_to(b.value(), false)
+    );
+    // Time period
+    b.rule_4("between <time-of-day> e as <time-of-day> (interval)",
+             b.reg(r#"entre(?: as?| o)?"#)?,
+             time_check!(form!(Form::TimeOfDay(_))),
+             b.reg(r#"e as"#)?,
+             time_check!(form!(Form::TimeOfDay(_))),
+             |_, a, _, b| a.value().span_to(b.value(), false)
+    );
+    // Time period
+    b.rule_4("from <time-of-day> to <time-of-day> (interval)",
+             b.reg(r#"das?"#)?,
+             time_check!(form!(Form::TimeOfDay(_))),
+             b.reg(r#"às?"#)?,
+             time_check!(),
+             |_, a, _, b| a.value().span_to(b.value(), false)
+    );
+    // Time period
+    b.rule_4("from <time-of-day> to <time-of-day> (interval)",
+             b.reg(r#"d[oe]"#)?,
+             time_check!(),
+             b.reg(r#"às?"#)?,
+             time_check!(),
+             |_, a, _, b| a.value().span_to(b.value(), false)
+    );
+    // Time period
+    b.rule_2("from <time-of-day>",
+             b.reg(r#"a partir( das?| de| desta| do)"#)?,
+             time_check!(form!(Form::TimeOfDay(_))),
+             |_, time| Ok(time.value().clone().mark_after_start())
+    );
+    // Time period
+    b.rule_2("from <time-of-day>",
+             b.reg(r#"do início do|desde as?"#)?,
+             time_check!(form!(Form::TimeOfDay(_))),
+             |_, time| Ok(time.value().clone().mark_after_start())
+    );
+    // Time period
+    b.rule_2("after <date-time>",
+             b.reg(r#"(desde|a partir|depois)( desta| das?| de| d?o)"#)?,
+             time_check!(),
+             |_, time| Ok(time.value().clone().mark_after_start())
+    );
+    b.rule_2("after <date-time>",
+             b.reg(r#"depois"#)?,
+             time_check!(),
+             |_, time| Ok(time.value().clone().mark_after_start())
+    );
+    // Time period
+    b.rule_2("from <date-time>",
+             b.reg(r#"desde(?: as?)?"#)?,
+             time_check!(),
+             |_, time| Ok(time.value().clone().mark_after_start())
+    );
+    // Time period
+    b.rule_2("from <time-of-day>",
+             b.reg(r#"a partir(?: d[oe])?|desde(?: as?)?"#)?,
+             time_check!(form!(Form::TimeOfDay(_))),
+             |_, time| Ok(time.value().clone().mark_after_start())
+    );
+    // Time period
+    b.rule_3("from <time-of-day> on",
+             b.reg(r#"do|de|das"#)?,
+             time_check!(form!(Form::TimeOfDay(_))),
+             b.reg(r#"em diante"#)?,
+             |_, time, _| Ok(time.value().clone().mark_after_start())
+    );
+    // Time period
+    b.rule_3("from <part-of-day> on",
+             b.reg(r#"do|de|das"#)?,
+             time_check!(|time: &TimeValue| form!(Form::PartOfDay(_))(time) || form!(Form::Meal)(time)),
+             b.reg(r#"em diante"#)?,
+             |_, pod, _| Ok(pod.value().clone().mark_after_start())
+    );
+    // Time period
+    b.rule_3("from <datetime> on",
+             b.reg(r#"(?:do|de|das)(?: dia)?"#)?,
+             time_check!(),
+             b.reg(r#"em diante"#)?,
+             |_, pod, _| Ok(pod.value().clone().mark_after_start())
+    );
+    // Time period
+//    b.rule_4("from <date-time> to <date-time> (interval)",
+//             b.reg(r#"do|de|das"#)?,
+//             datetime_check!(),
+//             b.reg(r#"[àa]s?|ao?|[aà]té"#)?,
+//             datetime_check!(),
+//             |_, a, _, b| a.value().span_to(b.value(), false)
+//    );
+    // Date period
+    b.rule_6("from dd to dd <month>(interval)",
+             b.reg(r#"do|de|das"#)?,
+             integer_check_by_range!(1, 31),
+             b.reg(r#"[àa]s?|ao?|[aà]té"#)?,
+             integer_check_by_range!(1, 31),
+             b.reg(r#"de"#)?,
+             time_check!(form!(Form::Month(_))),
+             |_, a, _, b, _,month| {
+                 let start = month.value().intersect(&helpers::day_of_month(a.value().value as u32)?)?;
+                 let end = month.value().intersect(&helpers::day_of_month(b.value().value as u32)?)?;
+                 start.span_to(&end, true)
+             }
+    );
+    // Time period
+//    b.rule_4("from <date-time> to <date-time> (interval)",
+//             b.reg(r#"a partir (d[ae]|das|desta)"#)?,
+//             datetime_check!(),
+//             b.reg(r#"para as"#)?,
+//             datetime_check!(),
+//             |_, a, _, b| a.value().span_to(b.value(), false)
+//    );
+    // Time period
+    b.rule_2("before <datetime>",
+             b.reg(r#"antes d[ao]s?"#)?,
+             time_check!(),
+             |_, time| Ok(time.value().clone().mark_before_end())
+    );
+    // Time period
+    b.rule_2("before <datetime>",
+             b.reg(r#"[àa]té(?: as?| o| de)?"#)?,
+             time_check!(),
+             |_, time| Ok(time.value().clone().mark_before_end())
+    );
+    // Time period
+    b.rule_2("before <part-of-day>",
+             b.reg(r#"àté(?: as| o| de)?"#)?,
+             time_check!(|time: &TimeValue| form!(Form::PartOfDay(_))(time) || form!(Form::Meal)(time)),
+             |_, pod| Ok(pod.value().clone().mark_before_end())
+    );
+    // Time period
+    b.rule_2("before <part-of-day>",
+             b.reg(r#"àté"#)?,
+             time_check!(|time: &TimeValue| form!(Form::PartOfDay(_))(time) || form!(Form::Meal)(time)),
+             |_, pod| Ok(pod.value().clone().mark_before_end())
+    );
+    // Time
     b.rule_1_terminal("hh(:|h)mm (time-of-day)",
                       b.reg(r#"((?:[01]?\d)|(?:2[0-3]))[:h\.]([0-5]\d)"#)?,
                       |text_match| {
@@ -449,6 +1750,15 @@ pub fn rules_time(b: &mut RuleSetBuilder<Dimension>) -> RustlingResult<()> {
                           helpers::hour_minute(hour, minute, hour < 12)
                       }
     );
+    // Time
+    b.rule_1_terminal("hh(h) (time-of-day)",
+                      b.reg(r#"((?:[01]?\d)|(?:2[0-3]))[h\.]"#)?,
+                      |text_match| {
+                          let hour: u32 = text_match.group(1).parse()?;
+                          helpers::hour(hour, hour < 12)
+                      }
+    );
+    // Time
     b.rule_1_terminal("hh:mm:ss",
                       b.reg(r#"((?:[01]?\d)|(?:2[0-3]))[:.]([0-5]\d)[:.]([0-5]\d)"#)?,
                       |text_match| helpers::hour_minute_second(
@@ -458,29 +1768,46 @@ pub fn rules_time(b: &mut RuleSetBuilder<Dimension>) -> RustlingResult<()> {
                           true
                       )
     );
+    // Date
     b.rule_1_terminal("dd[/-.]mm[/-.]yyyy",
-                      b.reg(r#"(3[01]|[12]\d|0?[1-9])[-/.](0?[1-9]|1[0-2])[-/.](\d{2,4})"#)?,
+                      b.reg(r#"(?:no dia )?(3[01]|[12]\d|0?[1-9])[-/.](0?[1-9]|1[0-2])[-/.](\d{2,4})"#)?,
                       |text_match| helpers::year_month_day(
                           text_match.group(3).parse()?,
                           text_match.group(2).parse()?,
                           text_match.group(1).parse()?
                       )
     );
+    // Date
     b.rule_1_terminal("yyyy-mm-dd",
-                      b.reg(r#"(\d{2,4})-(0?[1-9]|1[0-2])-(3[01]|[12]\d|0?[1-9])"#)?,
+                      b.reg(r#"(?:no dia )?(\d{2,4})-(0?[1-9]|1[0-2])-(3[01]|[12]\d|0?[1-9])"#)?,
                       |text_match| helpers::year_month_day(
                           text_match.group(1).parse()?,
                           text_match.group(2).parse()?,
                           text_match.group(3).parse()?
                       )
     );
+    // Date
     b.rule_1_terminal("dd[/-]mm",
-                      b.reg(r#"(3[01]|[12]\d|0?[1-9])[-/](0?[1-9]|1[0-2])"#)?,
+                      b.reg(r#"(?:no dia )?(3[01]|[12]\d|0?[1-9])[-/](0?[1-9]|1[0-2])"#)?,
                       |text_match| helpers::month_day(
                           text_match.group(2).parse()?,
                           text_match.group(1).parse()?
                       )
     );
+    // Date time complement
+//    b.rule_3("<time> <part-of-day>",
+//            time_check!(|time: &TimeValue| excluding_form!(Form::Year(_))(time) && excluding_form!(Form::Month(_))(time)),
+//            b.reg(r#"à|de|da"#)?,
+//            time_check!(|time: &TimeValue| form!(Form::PartOfDay(_))(time) || form!(Form::Meal)(time)),
+//            |time, _, part_of_day| time.value().intersect(part_of_day.value())
+//    );
+    // Date time complement
+    b.rule_3("<datetime> <part-of-day>",
+            time_check!(excluding_form!(Form::TimeOfDay(_))),
+            b.reg(r#"à|d[ea]"#)?,
+            time_check!(|time: &TimeValue| form!(Form::PartOfDay(_))(time) || form!(Form::Meal)(time)),
+            |time, _, part_of_day| time.value().intersect(part_of_day.value())
+    );
     Ok(())
 }
 
@@ -534,7 +1861,7 @@ pub fn rules_temperature(b: &mut RuleSetBuilder<Dimension>) -> RustlingResult<()
              });
     b.rule_2("<latent temp> below zero",
              temperature_check!(),
-             b.reg(r#"abaixo de cero"#)?,
+             b.reg(r#"abaixo de zero"#)?,
              |a, _| {
                  Ok(TemperatureValue {
                      value: -1.0 * a.value().value,
@@ -542,20 +1869,40 @@ pub fn rules_temperature(b: &mut RuleSetBuilder<Dimension>) -> RustlingResult<()
                      ..*a.value()
                  })
              });
+    b.rule_2("<latent temp> below zero",
+             b.reg(r#"menos"#)?,
+             temperature_check!(),
+             |_, a| {
+                 Ok(TemperatureValue {
+                     value: -1.0 * a.value().value,
+                     latent: false,
+                     ..*a.value()
+                 })
+             });
     Ok(())
 }
 
 pub fn rules_numbers(b: &mut RuleSetBuilder<Dimension>) -> RustlingResult<()> {
-    b.rule_2("intersect",
+
+    b.rule_2("intersect numbers",
              number_check!(|number: &NumberValue| number.grain().unwrap_or(0) > 1),
              number_check!(),
              |a, b| helpers::compose_numbers(&a.value(), &b.value())
     );
-    b.rule_1_terminal("number (0..10)",
-                      b.reg(r#"(cero|uma?|dois|duas|tr[eéê]s|quatro|cinco|s[eé]is|sete|oito|nove|dez)"#)?,
+
+
+    b.rule_3("intersect numbers",
+             number_check!(|number: &NumberValue| number.grain().unwrap_or(0) > 1),
+             b.reg(r#"e"#)?,
+             number_check!(),
+             |a, _,b| helpers::compose_numbers(&a.value(), &b.value())
+    );
+
+    b.rule_1_terminal("numbers (0..9)",
+                      b.reg(r#"(zero|uma?|dois|duas|tr[eéê]s|quatro|cinco|s[eé]is|meia|sete|oito|nove)"#)?,
                       |text_match| {
                           let value = match text_match.group(1).as_ref() {
-                              "cero" => 0,
+                              "zero" => 0,
                               "um" => 1,
                               "uma" => 1,
                               "dois" => 2,
@@ -567,17 +1914,171 @@ pub fn rules_numbers(b: &mut RuleSetBuilder<Dimension>) -> RustlingResult<()> {
                               "cinco" => 5,
                               "seis" => 6,
                               "séis" => 6,
+                              "meia" => 6,
                               "sete" => 7,
                               "oito" => 8,
                               "nove" => 9,
+                              _ => return Err(RuleError::Invalid.into()),
+                          };
+                          IntegerValue::new(value)
+                      }
+    );
+
+    b.rule_1_terminal("numbers (10..19)",
+                      b.reg(r#"(dezesseis|dezasseis|dezessete|dezoito|dezenove|dezanove|dez|onze|doze|treze|quatorze|catorze|quinze)"#)?,
+                      |text_match| {
+                          let value = match text_match.group(1).as_ref() {
                               "dez" => 10,
+                              "onze" => 11,
+                              "doze" => 12,
+                              "treze" => 13,
+                              "quatorze" => 14,
+                              "catorze" => 14,
+                              "quinze" => 15,
+                              "dezesseis" => 16,
+                              "dezasseis" => 16,
+                              "dezessete" => 17,
+                              "dezoito" => 18,
+                              "dezenove" => 19,
+                              "dezanove" => 19,
                               _ => return Err(RuleError::Invalid.into()),
                           };
                           IntegerValue::new(value)
                       }
     );
 
+    b.rule_1_terminal("numbers (20..90)",
+                 b.reg(r#"(vinte|trinta|quarenta|cinquenta|sessenta|setenta|oitenta|noventa)"#)?,
+                 |text_match| {
+                     let value = match text_match.group(1).as_ref() {
+                         "vinte" => 20,
+                         "trinta" => 30,
+                         "quarenta" => 40,
+                         "cinquenta" => 50,
+                         "sessenta" => 60,
+                         "setenta" => 70,
+                         "oitenta" => 80,
+                         "noventa" => 90,
+                         _ => return Err(RuleError::Invalid.into()),
+                     };
+                     IntegerValue::new(value)
+                 }
+        );
+
+    b.rule_3("numbers (21...99)",
+                 integer_check_by_range!(20, 90, |integer: &IntegerValue| integer.value % 10 == 0),
+                 b.reg(r#"e"#)?,
+                 integer_check_by_range!(1, 9),
+                 |x, _, y| IntegerValue::new(x.value().value + y.value().value)
+    );
+
+    b.rule_1_terminal("cem",
+                      b.reg(r#"cem"#)?,
+                      |_| IntegerValue::new_with_grain(100,2)
+    );
+
+    b.rule_3("numbers (101...199)",
+                 b.reg(r#"cento"#)?,
+                 b.reg(r#"e"#)?,
+                 integer_check_by_range!(1, 99),
+                 |_, _, y| IntegerValue::new_with_grain(100 + y.value().value, 2)
+    );
+
+    b.rule_1_terminal("numbers (200..900)",
+             b.reg(r#"(duzent|trezent|quatrocent|quinhent|seiscent|setecent|oitocent|novecent)(?:[oa]s)"#)?,
+             |text_match| {
+                 let value = match text_match.group(1).as_ref() {
+                     "duzent" => 200,
+                     "trezent" => 300,
+                     "quatrocent" => 400,
+                     "quinhent" => 500,
+                     "seiscent" => 600,
+                     "setecent" => 700,
+                     "oitocent" => 800,
+                     "novecent" => 900,
+                     _ => return Err(RuleError::Invalid.into()),
+                 };
+                 IntegerValue::new_with_grain(value,2)
+             }
+    );
+
+    b.rule_1_terminal("thousand",
+        b.reg(r#"mil|k"#)?,
+        |_| IntegerValue::new_with_grain(1000, 3)
+    );
+
+    b.rule_2("thousands",
+        integer_check_by_range!(1, 999),
+        b.reg(r#"mil|k"#)?,
+        |a, _| {
+            Ok(IntegerValue {
+                   value: a.value().value * 1000,
+                   grain: Some(3),
+                   ..IntegerValue::default()
+               })
+    });
+
+    b.rule_2("one million",
+        integer_check! (|integer: &IntegerValue| integer.value == 1),
+        b.reg(r#"milhão"#)?,
+        |_,_| IntegerValue::new_with_grain(1000000, 6)
+    );
+
+    b.rule_2("millions",
+        integer_check_by_range!(2, 999),
+        b.reg(r#"milhões"#)?,
+        |a, _| {
+            Ok(IntegerValue {
+                   value: a.value().value * 1000000,
+                   grain: Some(6),
+                   ..IntegerValue::default()
+               })
+    });
+
+    b.rule_2("one billion",
+        integer_check! (|integer: &IntegerValue| integer.value == 1),
+        b.reg(r#"bilhão"#)?,
+        |_,_| IntegerValue::new_with_grain(1000000000, 9)
+    );
+
+    b.rule_2("billions",
+        integer_check_by_range!(2, 999),
+        b.reg(r#"bilhões"#)?,
+        |a, _| {
+            Ok(IntegerValue {
+                   value: a.value().value * 1000000000,
+                   grain: Some(9),
+                   ..IntegerValue::default()
+               })
+    });
+
+//    b.rule_3("numbers (1,000,000...999,999,999)",
+//                 integer_check_by_range!(1000000, 999000000),
+//                 b.reg(r#"e?"#)?,
+//                 integer_check_by_range!(1, 999999),
+//                 |a, _, c| IntegerValue::new_with_grain(a.value().value + c.value().value,3)
+//    );
+//    b.rule_3("numbers (1,000...999,999)",
+//                 integer_check_by_range!(1000, 999000),
+//                 b.reg(r#"e?"#)?,
+//                 integer_check_by_range!(1, 999),
+//                 |a, _, c| IntegerValue::new_with_grain(a.value().value + c.value().value,3)
+//    );
+//    b.rule_3("numbers (200...999)",
+//                integer_check_by_range!(200, 900, |integer: &IntegerValue| integer.value % 100 == 0),
+//                 b.reg(r#"e"#)?,
+//                 integer_check_by_range!(1, 99),
+//                 |x, _, y| IntegerValue::new_with_grain(x.value().value + y.value().value,2)
+//    );
 
+    b.rule_1_terminal("some",
+                      b.reg(r#"algumas|alguns"#)?,
+                      |_| IntegerValue::new_with_grain(3, 1)
+    );
+    b.rule_1_terminal("several",
+                      b.reg(r#"v[àa]rios"#)?,
+                      |_| IntegerValue::new_with_grain(4, 1)
+    );
     b.rule_1_terminal("integer (numeric)",
                       b.reg(r#"(\d{1,18})"#)?,
                       |text_match| IntegerValue::new(text_match.group(0).parse()?));
@@ -652,29 +2153,171 @@ pub fn rules_numbers(b: &mut RuleSetBuilder<Dimension>) -> RustlingResult<()> {
                      }
                  })
              });
-    b.rule_1_terminal("ordinals (primero..10)",
-                      b.reg(r#"(primer|segund|terceir|quart|quint|sext|s[eéè]tim|oitav|non|d[eéè]cim)(?:[oa]s?)?"#)?,
+
+
+    b.rule_1_terminal("ordinals (primeiro..9)",
+                      b.reg(r#"(primeir|segund|terceir|quart|quint|sext|s[eéè]tim|oitav|non)(?:[oa]s?)?"#)?,
                       |text_match| {
                           let value = match text_match.group(1).as_ref() {
-                              "primer" => 1,
+                              "primeir" => 1,
                               "segund" => 2,
                               "terceir" => 3,
                               "quart" => 4,
                               "quint" => 5,
                               "sext" => 6,
-                              "séptim" => 7,
-                              "sèptim" => 7,
-                              "septim" => 7,
+                              "sétim" => 7,
+                              "sètim" => 7,
+                              "setim" => 7,
                               "oitav" => 8,
-                              "noven" => 9,
-                              "décim" => 10,
-                              "dècim" => 10,
-                              "decim" => 10,
+                              "non" => 9,
                               _ => return Err(RuleError::Invalid.into())
                           };
                           Ok(OrdinalValue::new(value))
                       }
     );
+    b.rule_1_terminal("ordinals (10..90)",
+                          b.reg(r#"(d[eéè]cim|vig[eéè]sim|trig[eéè]sim|quadrag[eéè]sim|quinquag[eéè]sim|sexag[eéè]sim|septuag[eéè]sim|setuag[eéè]sim|octog[eéè]sim|nonag[eéè]sim)(?:[oa]s?)?"#)?,
+                          |text_match| {
+                              let value = match text_match.group(1).as_ref() {
+                                  "décim" => 10,
+                                  "dècim" => 10,
+                                  "decim" => 10,
+                                  "vigésim" => 20,
+                                  "vigèsim" => 20,
+                                  "vigesim" => 20,
+                                  "trigésim" => 30,
+                                  "trigèsim" => 30,
+                                  "trigesim" => 30,
+                                  "quadragésim" => 40,
+                                  "quadragèsim" => 40,
+                                  "quadragesim" => 40,
+                                  "quinquagésim" => 50,
+                                  "quinquagesim" => 50,
+                                  "quinquagèsim" => 50,
+                                  "sexagésim" => 60,
+                                  "sexagèsim" => 60,
+                                  "sexagesim" => 60,
+                                  "septuagésim" => 70,
+                                  "septuagèsim" => 70,
+                                  "septuagesim" => 70,
+                                  "setuagèsim" => 70,
+                                  "setuagesim" => 70,
+                                  "setuagésim" => 70,
+                                  "octogésim" => 80,
+                                  "octogèsim" => 80,
+                                  "octogesim" => 80,
+                                  "nonagésim" => 90,
+                                  "nonagèsim" => 90,
+                                  "nonagesim" => 90,
+                                  _ => return Err(RuleError::Invalid.into())
+                              };
+                              Ok(OrdinalValue::new(value))
+                          }
+    );
+
+    b.rule_2("ordinals (11..99)",
+        ordinal_check_by_range!(10, 90),
+        ordinal_check_by_range!(1, 9),
+        |a, b| {
+            Ok(OrdinalValue::new(a.value().value + b.value().value))
+        }
+    );
+
+    b.rule_1_terminal("ordinals (100..900)",
+                              b.reg(r#"(cent[eéè]sim|ducent[eéè]sim|trecent[eéè]sim|tricent[eéè]sim|quadrin?gent[eéè]sim|quingent[eéè]sim|sexcent[eéè]sim|seiscent[eéè]sim|setingent[eéè]sim|septigent[eéè]sim|septingent[eéè]sim|octingent[eéè]sim|octigent[eéè]sim|nongent[eéè]sim|noningent[eéè]sim)(?:[oa]s?)?"#)?,
+                              |text_match| {
+                                  let value = match text_match.group(1).as_ref() {
+                                      "centésim" => 100,
+                                      "centèsim" => 100,
+                                      "centesim" => 100,
+                                      "ducentésim" => 200,
+                                      "ducentèsim" => 200,
+                                      "ducentesim" => 200,
+                                      "trecentésim" => 300,
+                                      "trecentèsim" => 300,
+                                      "trecentesim" => 300,
+                                      "tricentésim" => 300,
+                                      "tricentèsim" => 300,
+                                      "tricentesim" => 300,
+                                      "quadrigentésim" => 400,
+                                      "quadrigentèsim" => 400,
+                                      "quadrigentesim" => 400,
+                                      "quadringentésim" => 400,
+                                      "quadringentèsim" => 400,
+                                      "quadringentesim" => 400,
+                                      "quingentésim" => 500,
+                                      "quingentesim" => 500,
+                                      "quingentèsim" => 500,
+                                      "sexcentésim" => 600,
+                                      "sexcentèsim" => 600,
+                                      "sexcentesim" => 600,
+                                      "seiscentésim" => 600,
+                                      "seiscentèsim" => 600,
+                                      "seiscentesim" => 600,
+                                      "setingentésim" => 700,
+                                      "setingentèsim" => 700,
+                                      "setingentesim" => 700,
+                                      "septingentèsim" => 700,
+                                      "septingentesim" => 700,
+                                      "septingentésim" => 700,
+                                      "septigentésim" => 700,
+                                      "septigentèsim" => 700,
+                                      "septigentesim" => 700,
+                                      "octingentésim" => 800,
+                                      "octingentèsim" => 800,
+                                      "octingentesim" => 800,
+                                      "octigentèsim" => 800,
+                                      "octigentésim" => 800,
+                                      "octigentesim" => 800,
+                                      "nongentésim" => 900,
+                                      "nongentèsim" => 900,
+                                      "nongentesim" => 900,
+                                      "noningentésim" => 900,
+                                      "noningentèsim" => 900,
+                                      "noningentesim" => 900,
+                                      _ => return Err(RuleError::Invalid.into())
+                                  };
+                                  Ok(OrdinalValue::new(value))
+                              }
+    );
+
+    b.rule_2("ordinals (101..999)",
+        ordinal_check_by_range!(100, 900),
+        ordinal_check_by_range!(1, 99),
+        |a, b| {
+            Ok(OrdinalValue::new(a.value().value + b.value().value))
+        }
+    );
+
+    b.rule_1_terminal("ordinal thousand",
+                      b.reg(r#"(mil[eéè]sim)(?:[oa]s?)?"#)?,
+                      |text_match| {
+                          let value = match text_match.group(1).as_ref() {
+                              "milésim" => 1000,
+                              "milèsim" => 1000,
+                              "milesim" => 1000,
+                              _ => return Err(RuleError::Invalid.into())
+                          };
+                          Ok(OrdinalValue::new_with_grain(value,3))
+                      }
+    );
+
+    b.rule_2("ordinal thousands",
+        integer_check_by_range!(1, 999),
+        ordinal_check! (|ordinal: &OrdinalValue| ordinal.value == 1000),
+        |a, b| {
+            Ok(OrdinalValue::new(a.value().value * b.value().value))
+        }
+    );
+
+    b.rule_2("ordinal thousands + number",
+        ordinal_check_by_range!(1000,999000),
+        ordinal_check_by_range!(1, 999),
+        |a, b| {
+            Ok(OrdinalValue::new(a.value().value + b.value().value))
+        }
+    );
+
     b.rule_1_terminal("ordinal (digits)",
                       b.reg(r#"0*(\d+)[ºªoa]"#)?,
                       |text_match| {
diff --git a/grammar/pt/src/training.rs b/grammar/pt/src/training.rs
index 03e02c14..503ec5e6 100644
--- a/grammar/pt/src/training.rs
+++ b/grammar/pt/src/training.rs
@@ -5,39 +5,342 @@ use rustling_ontology_values::ResolverContext;
 
 pub fn examples_numbers(v: &mut Vec<::rustling::train::Example<Dimension>>) {
     example!(v, check_integer(1), "1", "um", "uma");
+    example!(v, check_integer(11), "onze");
+    example!(v, check_integer(17), "dezessete");
+    example!(v, check_integer(21), "vinte e um");
+    example!(v, check_integer(23), "vinte e três");
+    example!(v, check_integer(70), "setenta");
+    example!(v, check_integer(78), "setenta e oito");
+    example!(v, check_integer(73), "setenta e três");
+    example!(v, check_integer(80), "oitenta");
+    example!(v, check_integer(81), "oitenta e um");
+    example!(v, check_integer(90), "noventa");
+    example!(v, check_integer(91), "noventa e um");
+    example!(v, check_integer(99), "noventa e nove");
+    example!(v, check_integer(5000), "cinco mil");
+    example!(v, check_integer(200000), "duzentos mil");
+    example!(v, check_integer(21011), "vinte e um mil e onze");
+    example!(v, check_integer(721012), "setecentos e vinte e um mil e doze");
+    example!(v, check_integer(31256721), "trinta e um milhões duzentos e cinquenta e seis mil setecentos e vinte e um");
+    example!(v, check_integer(33), "33", "trinta e três");
+    example!(v, check_integer(100000), "100.000", "100000", "100K", "100k", "cem mil");
+    // TODO: Check if want/need support for M = 1000000 ?
+    //example!(v, check_integer(3000000), "3M", "3000000", "3.000.000", "três milhões");
+    //example!(v, check_integer(1200000), "1.200.000", "1200000", "1,2M", "um milhão e duzentos mil");
+    //example!(v, check_integer(-1200000), "- 1.200.000", "-1200000", "menos 1200000", "-1,2M", "menos um milhão e duzentos mil");
+    // TODO : float temperature
+    //example!(v, check_float(1.1), "1,1", "1,10", "um vígula um", "um vírgula dez");
+    example!(v, check_float(0.5), "0,5", "0,50", "zero vírgula cinco", "zero vírgula cinquenta");
+    example!(v, check_float(32.75), "32,75", "trinta e dois vírgula setenta e cinco");
+    example!(v, check_float(10.08), "10,08", "dez vírgula zero oito");
+    example!(v, check_ordinal(1), "1o", "1a", "primeiro", "primeira", "1º", "1ª");
+    example!(v, check_ordinal(3), "3o", "3a", "3º", "3ª", "terceiro", "terceira");
+    example!(v, check_ordinal(2), "segundo", "2º", "2o");
+    example!(v, check_ordinal(5), "quinto", "5º", "5o");
 }
 
 pub fn examples_percentage(v: &mut Vec<::rustling::train::Example<Dimension>>) {
-    example!(v, check_percentage(0.3), "0,3%", "cero vírgula tres porcento", "cero virgula tres porcento");
-    example!(v, check_percentage(5.0), "5%", "cinco porcento");
-    example!(v, check_percentage(355.0), "355 %", "355 por cento", "355 porcento");
+    example!(v, check_percentage(0.3), "0,3%", "zero vírgula três por cento");
+    example!(v, check_percentage(15.0), "15%", "quinze por cento");
+    example!(v, check_percentage(355.0), "355 %", "355 por cento", "trezentos e cinquenta e cinco por cento");
 }
 
 pub fn examples_temperature(v: &mut Vec<::rustling::train::Example<Dimension>>) {
-    example!(v, check_temperature(3.0, Some("degree")), "tres graus", "3 graus", "3°", "3 °");
-    example!(v, check_temperature(32.0, Some("celsius")), "32°C", "32° C", "32° c", "32°c", "32 °c");
-    example!(v, check_temperature(-27.0, Some("degree")), "-27 graus");
-    example!(v, check_temperature(-27.0, Some("celsius")), "-27 graus celsius", "menos 27 graus centigrados", "-27C", "-27°C", "-27° C", "-27°c", "-27° c", "- 27 c");
-    example!(v, check_temperature(-5.0, Some("fahrenheit")), "menos cinco graus fahrenheit", "cinco graus fahrenheit abaixo de cero", "-5 °F", "-5°F", "-5°f", "-5° f", "- 5°f");
-    example!(v, check_temperature(168.0, Some("fahrenheit")), "168 graus fahrenheit", "168° F", "168 F", "168f");
-    example!(v, check_temperature(10.0, Some("kelvin")), "dez kelvin", "10°K", "10° K", "10 °K", "10°k", "dez graus kelvin");
+    example!(v, check_temperature(3.0, Some("degree")), "três graus", "3 graus");
+    example!(v, check_temperature(32.0, Some("celsius")), "trinta e dois graus celsius", "trinta e dois graus centígrados", "32°C", "32°c");
+    example!(v, check_temperature(-27.0, Some("degree")), "menos 27 graus", "27 graus abaixo de zero","menos vinte e sete graus");
+    example!(v, check_temperature(-27.0, Some("celsius")), "menos 27 graus celsius", "menos 27 graus centígrados", "-27°C", "-27°c");
+    example!(v, check_temperature(-5.0, Some("fahrenheit")), "menos cinco graus fahrenheit", "cinco graus fahrenheit abaixo de zero", "-5°F", "-5°f");
+    example!(v, check_temperature(168.0, Some("fahrenheit")), "cento e sessenta e oito fahrenheit", "cento e sessenta e oito graus fahrenheit", "168 graus fahrenheit", "168°F", "168°f");
+    example!(v, check_temperature(10.0, Some("kelvin")), "dez kelvin", "10K", "10k", "dez graus kelvin");
 }
 
 pub fn examples_finance(v: &mut Vec<::rustling::train::Example<Dimension>>) {
-    example!(v, check_finance(800.0, Some("$"), Precision::Exact), "800 $", "800$");
-    example!(v, check_finance(45.0, Some("EUR"), Precision::Exact), "45€", "45 €", "45 euros");
-    example!(v, check_finance(2.05, Some("EUR"), Precision::Exact), "2,05 €", "2,05€", "dois euros e cinco centavos");
-    example!(v, check_finance(2.0, Some("£"), Precision::Exact), "2 £", "2£", "duas libras");
-    example!(v, check_finance(10.0, Some("GBP"), Precision::Exact), "dez libras esterlinas");
+    // Problem with $ at the begginning: US$800, $10
+    //example!(v, check_finance(800.0, Some("$"), Precision::Exact), "US$800", "$800", "oitocentos dólares");
+    example!(v, check_finance(10.0, Some("$"), Precision::Approximate), "uns dez dólares", "dez dólares mais ou menos");
+    //example!(v, check_finance(10.0, Some("USD"), Precision::Approximate), "uns dez dólares americanos", "US$10 mais ou menos", "quase $10", "uns 10 USD");
+    example!(v, check_finance(3.0, Some("AUD"), Precision::Exact), "três dólares australianos");
+    example!(v, check_finance(3.5, Some("AUD"), Precision::Exact), "3,5 dólares australianos", "três dólares australianos e cinquenta centavos");
+    example!(v, check_finance(0.0, Some("HKD"), Precision::Exact), "zero dólares de hong kong");
+    example!(v, check_finance(125.0, Some("CAD"), Precision::Exact), "125 CAD", "cento e vinte e cinco dólares canadenses");
+    example!(v, check_finance(45.0, Some("EUR"), Precision::Exact), "45€", "quarenta e cinco euros");
+    // TODO: Support money amounts with cents dois vírgula cinco euros =/= 2.5
+    //example!(v, check_finance(2.05, Some("EUR"), Precision::Exact), "2,05€", "dois vírgula cinco euros");
+    example!(v, check_finance(2.0, Some("£"), Precision::Exact), "2£", "duas libras");
+    example!(v, check_finance(20.0, Some("GBP"), Precision::Exact), "vinte libras esterlinas");
+    example!(v, check_finance(38.0, Some("CHF"), Precision::Exact), "38 francos suiços", "trinta e oito francos suiços");
+    example!(v, check_finance(447.0, Some("KR"), Precision::Exact), "447 coroas", "quatrocentos e quarenta e sete coroas");
+    example!(v, check_finance(10000.0, Some("DKK"), Precision::Exact), "dez mil DKK", "10.000 coroas dinamarquesas");
+    example!(v, check_finance(100.0, Some("NOK"), Precision::Exact), "100 coroas norueguesas", "cem coroas norueguesas", "100NOK");
+    example!(v, check_finance(2005.0, Some("SEK"), Precision::Exact), "2005 coroas suecas", "duas mil e cinco coroas suecas");
+    example!(v, check_finance(96.0, Some("INR"), Precision::Approximate), "aproximadamente 96 rúpias", "umas noventa e seis rúpias");
+    example!(v, check_finance(5.3, Some("RUB"), Precision::Exact), "cinco rublos e trinta centavos", "5,3 rublos");
+    example!(v, check_finance(89.0, Some("JPY"), Precision::Exact), "exatamente 89 JPY", "89 ienes", "exatamente oitenta e nove ienes japoneses");
     example!(v, check_finance(8.0, Some("¥"), Precision::Exact), "8¥");
-    example!(v, check_finance(3.0, Some("฿"), Precision::Exact), "3฿", "3 ฿", "tres bitcoins");
+    example!(v, check_finance(100.0, Some("CNY"), Precision::Exact), "cem yuanes exatos", "exatamente 100 yuanes chineses");
+    example!(v, check_finance(7.0, Some("KRW"), Precision::Exact), "7KRW", "7₩", "sete wones sul-coreanos");
+    example!(v, check_finance(3.0, Some("฿"), Precision::Exact), "3฿", "3BTC", "3XBT", "três bitcoins");
+    example!(v, check_finance(15.0, Some("$"), Precision::Approximate), "uns quinze dólares");
+    example!(v, check_finance(3000000.0, Some("EUR"), Precision::Exact), "três milhões de euros");
 }
 
 pub fn examples_time(v: &mut Vec<::rustling::train::Example<Dimension>>) {
     let c = ResolverContext::new(Interval::starting_at(Moment(Local.ymd(2013, 2, 12).and_hms(4, 30, 0)), Grain::Second));
+
+    // Days
+    example!(v, check_moment!(c, [2013, 2, 12, 4, 30, 00]), "agora", "agora mesmo", "neste exato momento", "neste momento");
     example!(v, check_moment!(c, [2013, 2, 12]), "hoje");
+    // only "ontem", "anteontem" and "amanhã" are supported
+    //example!(v, check_moment!(c, [2013, 2, 11]), "ontem", "no dia anterior", "na véspera", "um dia antes");
+    //example!(v, check_moment!(c, [2013, 2, 10]), "antes de ontem", "anteontem");
+    //example!(v, check_moment!(c, [2013, 2, 13]), "amanhã", "no dia seguinte", "um dia depois", "no dia depois");
+    // TODO: depois de amanha / after(tomorow)
+    example!(v, check_moment!(c, [2013, 2, 14]), "depois de amanhã");
+    // AMBIGUITY sexta(ordinal) and sexta-feira
+    //example!(v, check_moment!(c, [2013, 2, 15]), "sexta-feira", "sexta", "6ª feira");
+    // same type of ambiguity as above
+    //example!(v, check_moment!(c, [2013, 2, 18]), "segunda-feira", "segunda", "esta segunda", "seg.", "2ª", "2ª feira");
+    example!(v, check_moment!(c, [2013, 2, 18]), "segunda-feira 18 de fevereiro", "na segunda-feira dia 18 de fevereiro", "na segunda-feira dia dezoito de fevereiro", "na segunda dezoito de fevereiro");
+    // same type of ambiguity as above
+    //example!(v, check_moment!(c, [2013, 2, 19]), "terça-feira", "terça", "3ª feira", "ter.", "esta terça");
+    example!(v, check_moment!(c, [2013, 2, 13]), "quarta-feira 13 de fevereiro", "na 4ª feira dia 13 de fevereiro", "na quarta dia treze de fevereiro", "na 4ª dia treze de fevereiro");
+    // same type of ambiguity as above
+    //example!(v, check_moment!(c, [2013, 2, 14]), "quinta-feira", "dois dias depois", "dois dias mais tarde", "quinta", "5ª feira");
+
+    example!(v, check_moment!(c, [2013, 2, 16]), "sábado", "no sábado", "sáb.");
+    example!(v, check_moment!(c, [2013, 2, 17]), "domingo", "no domingo", "dom.");
+
+    example!(v, check_moment!(c, [2013, 3, 1]), "dia primeiro de março", "no dia primeiro de março", "1º de março", "6ª feira dia primeiro de março", "na sexta-feira dia primeiro de março");
+    example!(v, check_moment!(c, [2013, 3, 1]), "no dia primeiro de março de 2013", "no dia 1 de março de 2013", "em 1º de março de 2013", "em 1 de março do ano de 2013", "1/3/2013", "01/03/2013", "01/03/13", "01-03-2013");
+    example!(v, check_moment!(c, [2013, 3, 2]), "no dia 2 de março", "2 de março", "dois de março", "em 2/3", "no 02/03");
+    example!(v, check_moment!(c, [2013, 3, 2]), "no dia 2", "dia 2");
+    example!(v, check_moment!(c, [2013, 3, 3]), "no dia 3 de março", "dia três de março", "3 de março", "no 3/3", "em 03/03");
+    example!(v, check_moment!(c, [2013, 4, 5]), "no dia 5 de abril", "5 de abril", "dia 5 de abril");
+    example!(v, check_moment!(c, [2015, 3, 3]), "no dia 3 de março de 2015", "em 3 de março de 2015", "3 de março de 2015", "3/3/2015", "03/03/2015", "03/03/15", "3-3-2015");
+    example!(v, check_moment!(c, [2013, 2, 15]), "no dia 15 de fevereiro", "15 de fevereiro", "quinze de fevereiro");
+    // TODO: fev, fev. not supported for fevereiro
+    //example!(v, check_moment!(c, [2013, 2, 15]), "15/02/2013", "15/02/13", "15 fev. 2013", "15 fev 2013", "15 de fevereiro de 2013", "quinze de fevereiro de 2013");
+    example!(v, check_moment!(c, [2013, 2, 16]), "no dia 16", "dia dezesseis");
+    example!(v, check_moment!(c, [2013, 2, 17]), "17 de fevereiro", "no dia 17 de fevereiro", "17/2", "17/02", "no 17/02");
+    example!(v, check_moment!(c, [2013, 2, 13]), "quarta-feira dia 13", "quarta dia 13", "4ª f. dia 13", "quarta-feira dia treze");
+    example!(v, check_moment!(c, [2014, 2, 20]), "20/02/2014", "20/2/2014", "20/02/14", "20.02.2014", "20.02.14", "20-02-2014", "20-2-2014", "20-02-14");
+    example!(v, check_moment!(c, [2013, 10, 31]), "31 de outubro", "no 31 de outubro");
+    example!(v, check_moment!(c, [2014, 2, 20]), "20/02/2014", "20/2/2014", "20/02/14", "20.02.2014", "20.02.14", "20-02-2014", "20-2-2014", "20-02-14");
+    example!(v, check_moment!(c, [1974, 10, 31]), "31/10/1974", "31/10/74");
+    // when today is Tuesday, "segunda que vem" is a week from now
+    example!(v, check_moment!(c, [2013, 2, 18]), "na próxima segunda", "segunda que vem", "na segunda-feira da semana que vem", "2ª feira da semana que vem");
+
+    example!(v, check_moment!(c, [2013, 2, 19]), "na terça-feira que vem", "na próxima terça", "na 3ª feira que vem", "na terça da semana que vem", "na terça da próxima semana");
+    example!(v, check_moment!(c, [2013, 2, 13]), "na quarta-feira que vem", "na próxima quarta", "na quarta-feira da próxima semana", "na 4ª feira da próxima semana", "4ª feira da próxima semana", "na quarta-feira da semana que vem");
+    example!(v, check_moment!(c, [2013, 2, 11]), "segunda-feira desta semana", "na segunda desta semana");
+    example!(v, check_moment!(c, [2013, 2, 12]), "terça-feira desta semana", "na terça desta semana", "na 3ª feira desta semana");
+    example!(v, check_moment!(c, [2013, 2, 13]), "quarta-feira desta semana", "quarta desta semana", "4ª feira desta semana");
+    // resolution: date period Interval instead of Grain week
+    //example!(v, check_moment!(c, [2013, 2, 11], Grain::Week), "esta semana");
+    example!(v, check_moment!(c, [2013, 2, 4], Grain::Week), "a semana passada", "a última semana");
+    example!(v, check_moment!(c, [2013, 2, 18], Grain::Week), "a próxima semana", "a semana que vem");
+    example!(v, check_moment!(c, [2013, 1]), "o mês passado", "o último mês");
+    example!(v, check_moment!(c, [2013, 3]), "o mês que vem", "o próximo mês");
+    example!(v, check_moment!(c, [2012]), "o ano passado", "o último ano");
+    example!(v, check_moment!(c, [2013]), "este ano");
+    example!(v, check_moment!(c, [2014]), "o ano que vem", "o próximo ano");
+
+    example!(v, check_moment!(c, [2013, 2, 10]), "o domingo passado", "o domingo da semana passada", "o último domingo");
+    example!(v, check_moment!(c, [2013, 10, 3]), "o terceiro dia de outubro", "o 3º dia de outubro", "o 3º dia de outubro", "dia 3 de outubro");
+    //example!(v, check_moment!(c, [2014, 10, 6], Grain::Week), "primeira semana de outubro de 2014", "a primeira semana de outubro de 2014");
+    //example!(v, check_moment!(c, [2013, 10, 7], Grain::Week), "a semana do dia 7 de outubro", "a semana de sete de outubro");
+    // fix_example!(v, check_moment!(c, [2015, 10, 31]), "último dia de outubro de 2015", "o último dia de outubro de 2015");
+    // fix_example!(v, check_moment!(c, [2014, 9, 22], Grain::Week), "última semana de setembro de 2014", "a última semana de setembro de 2014", "a última semana do mês de setembro de 2014", "a última semana de setembro do ano de 2014");
+
+    // Day times
+    example!(v, check_moment!(c, [2013, 2, 12, 15]), "às quinze horas", "às três da tarde");
+    // Ambiguity Duration // Time
+    //example!(v, check_moment!(c, [2013, 2, 12, 15, 0]), "15:00", "15h");
+    // Ambiguity Duration // Time
+    //example!(v, check_moment!(c, [2013, 2, 13, 00]), "meia-noite", "zero hora");
+    // FIXME: PROBLEM 12 horas
+    //example!(v, check_moment!(c, [2013, 2, 12, 12]), "meio-dia", "hoje ao meio-dia", "às doze horas");
+    example!(v, check_moment!(c, [2013, 2, 12, 12, 15]), "ao meio-dia e quinze", "às doze horas e quinze minutos");
+    example!(v, check_moment!(c, [2013, 2, 12, 11, 55]), "cinco para o meio-dia", "às onze e cinquenta e cinco", "às onze horas e cinquenta e cinco minutos");
+    example!(v, check_moment!(c, [2013, 2, 12, 12, 30]), "ao meio-dia e meia", "às doze horas e trinta minutos", "às doze e trinta");
+
+    example!(v, check_moment!(c, [2013, 2, 13, 00, 03]), "à zero hora e três minutos");
+    //Is today at midnight 13/12 or 12/12 ?
+    //example!(v, check_moment!(c, [2013, 2, 13, 00, 03]), "hoje à meia-noite e três");
+    example!(v, check_moment!(c, [2013, 2, 12, 15, 15]), "às quinze e quinze", "às quinze horas e quinze minutos", "às três e quinze da tarde", "15:15", "15h15");
+    example!(v, check_moment!(c, [2013, 2, 13, 15, 15]), "amanhã às três e quinze da tarde");
+    example!(v, check_moment!(c, [2013, 2, 12, 15, 30]), "às quinze e trinta", "às quinze horas e trinta minutos", "às três e meia da tarde", "15:30", "15h30");
+    example!(v, check_moment!(c, [2013, 2, 12, 11, 45]), "às quinze para o meio-dia", "11:45", "às onze horas e quarenta e cinco minutos", "hoje às 11h45");
+
+    // Day + day time
+    example!(v, check_moment!(c, [2013, 3, 2, 5, 0]), "2 de março às 5:00");
+    example!(v, check_moment!(c, [2013, 3, 2, 5]), "2 de março às 5h", "no dia 2 de março às 5h", "em 02/03 às 5h da manhã", "em 02/03 às 5h da manhã");
+    example!(v, check_moment!(c, [2013, 3, 2, 5]), "2 de março lá pelas 5h", "no dia 2 de março por volta das 5h da manhã", "2 de março lá pelas cinco horas mais ou menos");
+    example!(v, check_moment!(c, [2013, 3, 2, 5]), "no dia 2 às cinco", "dia dois às cinco horas", "no dia dois às cinco da manhã", "no dia 02 às cinco horas da manhã", "no dia 02 às cinco horas da madrugada");
+    example!(v, check_moment!(c, [2013, 2, 16, 6]), "no dia 16 às 6 da manhã","no dia 16 às 6 da madrugada");
+    example!(v, check_moment!(c, [2013, 2, 16, 18]), "dia 16 às 18h", "no sábado dia 16 às 6 da tarde");
+    example!(v, check_moment!(c, [2013, 2, 13, 11]), "amanhã às 11 horas", "amanhã às onze horas", "amanhã às onze");
+    // Ambiguity ? "depois de amanhã às 11h" -> After((tomorrow, 11h) or -> (the day after tomorrow , 11h) + Is Grain OK ?
+    example!(v, check_moment!(c, [2013, 2, 14, 11]), "quinta-feira às 11h", "depois de amanhã às 11h");
+    // Warning! Grain
+    example!(v, check_moment!(c, [2013, 2, 14, 11, 0]), "o dia depois de amanhã às 11:00");
+    example!(v, check_moment!(c, [2013, 2, 15, 12]), "na sexta-feira às 12h", "sexta-feira ao meio-dia", "ao meio-dia da sexta-feira");
+    example!(v, check_moment!(c, [2013, 2, 15, 16]), "sexta-feira dia quinze às dezesseis horas", "na sexta-feira dia quinze às dezesseis horas", "na sexta-feira dia 15 às 16h", "na sexta dia quinze às quatro da tarde");
+    example!(v, check_moment!(c, [2013, 2, 15, 16, 0]), "sexta-feira dia 15 às 16h00");
+    example!(v, check_moment!(c, [2013, 2, 13, 11]), "quarta-feira às 11h", "quarta-feira às 11 da manhã");
+
+    // In + duration / duration + ago
+    example!(v, check_moment!(c, [2013, 2, 12, 4, 30, 1]), "dentro de um segundo", "em um segundo");
+    example!(v, check_moment!(c, [2013, 2, 12, 4, 31, 0]), "dentro de um minuto", "em um minuto");
+    example!(v, check_moment!(c, [2013, 2, 12, 4, 32, 0]), "dentro de 2 minutos", "em 2 minutos");
+    example!(v, check_moment!(c, [2013, 2, 12, 5, 30, 0]), "dentro de 60 minutos", "em 60 minutos");
+    example!(v, check_moment!(c, [2013, 2, 12, 5, 30]), "dentro de uma hora", "em uma hora");
+    example!(v, check_moment!(c, [2013, 2, 13, 4, 30]), "dentro de 24 horas", "dentro de vinte e quatro horas");
+    example!(v, check_moment!(c, [2013, 2, 13]), "dentro de um dia", "em um dia", "dentro de um dia");
+    example!(v, check_moment!(c, [2013, 2, 19]), "dentro de sete dias", "em sete dias");
+    example!(v, check_moment!(c, [2013, 2, 19]), "dentro de uma semana");
+    example!(v, check_moment!(c, [2013, 4, 12]), "dentro de dois meses", "em dois meses");
+    example!(v, check_moment!(c, [2014, 2]), "dentro de um ano", "em um ano");
+    example!(v, check_moment!(c, [2013, 2, 12, 2, 30]), "faz duas horas", "há duas horas");
+    example!(v, check_moment!(c, [2013, 1, 22]), "faz três semanas", "há três semanas");
+    example!(v, check_moment!(c, [2012, 11, 12]), "há três meses", "faz três meses");
+    example!(v, check_moment!(c, [2011, 2]), "faz dois anos", "há dois anos");
+
+    // Seasons
+    example!(v, check_moment_span!(c, [2013, 6, 21], [2013, 9, 24]), "este verão");
+    example!(v, check_moment_span!(c, [2012, 12, 21], [2013, 3, 21]), "este inverno");
+
+    // Holidays
+    example!(v, check_moment!(c, [2013, 12, 25]), "Natal", "dia de natal");
+    example!(v, check_moment_span!(c, [2013, 12, 24, 18], [2013, 12, 25, 00]), "véspera de natal", "a noite de natal");
+    example!(v, check_moment!(c, [2014, 1, 1]), "primeiro dia do ano", "ano novo", "primeiro de janeiro", "no dia primeiro de janeiro", "no primeiro dia de janeiro");
+    example!(v, check_moment!(c, [2013, 11, 1]), "todos os santos", "no dia de todos os santos", "dia de finados", "dia de todos os santos");
+    example!(v, check_moment!(c, [2013, 05, 1]), "dia do trabalho", "dia do trabalhador");
+
+    // Part of day (morning, afternoon...)
+    example!(v, check_moment_span!(c, [2013, 2, 12, 12], [2013, 2, 12, 19]), "esta tarde", "pela tarde", "hoje pela tarde");
+    example!(v, check_moment_span!(c, [2013, 2, 12, 15], [2013, 2, 12, 17]), "meio da tarde", "em plena tarde", "no meio da tarde");
+    example!(v, check_moment_span!(c, [2013, 2, 12, 4], [2013, 2, 12, 9]), "logo de manhã", "no início da manhã", "logo no início da manhã", "primeiras horas da manhã");
+    example!(v, check_moment_span!(c, [2013, 2, 12, 11], [2013, 2, 12, 16]), "no meio do dia");
+    example!(v, check_moment!(c, [2013, 2, 12, 12]), "ao meio-dia", "às doze horas");
+    example!(v, check_moment_span!(c, [2013, 2, 12, 10], [2013, 2, 12, 12]), "no final da manhã", "nas últimas horas da manhã");
+    // TODO: ?? Before lunch, after work, etc
+    //example!(v, check_moment_span!(c, [2013, 2, 12, 13], [2013, 2, 12, 17]), "depois de comer", "depois da hora de comer");
+    //example!(v, check_moment_span!(c, [2013, 2, 12, 10], [2013, 2, 12, 12]), "antes de comer");
+    //example!(v, check_moment_span!(c, [2013, 2, 12, 12], [2013, 2, 12, 14]), "durante a refeição", "na hora da refeição" );
+    //example!(v, check_moment_span!(c, [2013, 2, 12, 17], [2013, 2, 12, 21]), "depois do trabalho", "ao sair do trabalho");
+    example!(v, check_moment_span!(c, [2013, 2, 12, 12], [2013, 2, 12, 15]), "no começo da tarde", "logo à tarde", "no início da tarde");
+    example!(v, check_moment_span!(c, [2013, 2, 12, 15], [2013, 2, 12, 17]), "no final da tarde", "nas últimas horas da tarde", "no fim da tarde");
+    example!(v, check_moment_span!(c, [2013, 2, 12, 6], [2013, 2, 12, 10]), "no início do dia", "no começo do dia");
+    example!(v, check_moment_span!(c, [2013, 2, 12, 11], [2013, 2, 12, 16]), "na metade do dia", "no meio do dia");
+    example!(v, check_moment_span!(c, [2013, 2, 12, 17], [2013, 2, 12, 21]), "no final do dia", "ao fim do dia", "ao acabar o dia");
+    example!(v, check_moment_span!(c, [2013, 2, 12, 18], [2013, 2, 13, 00]), "esta noite", "de noite");
+    example!(v, check_moment_span!(c, [2013, 2, 12, 18], [2013, 2, 12, 21]), "no início da noite", "logo à noite");
+    example!(v, check_moment_span!(c, [2013, 2, 12, 21], [2013, 2, 13, 00]), "tarde da noite", "no final da noite", "no fim da noite");
+    example!(v, check_moment_span!(c, [2013, 2, 18, 4], [2013, 2, 18, 12]), "segunda-feira de manhã", "na segunda pela manhã");
+    example!(v, check_moment_span!(c, [2013, 2, 18, 12], [2013, 2, 18, 19]), "segunda de tarde", "segunda-feira pela tarde");
+    example!(v, check_moment_span!(c, [2013, 2, 18, 15], [2013, 2, 18, 17]), "segunda-feira no final da tarde", "no fim da tarde de segunda", "no fim da tarde de segunda-feira");
+
+    example!(v, check_moment_span!(c, [2013, 2, 15, 4], [2013, 2, 15, 12]), "dia quinze de fevereiro pela manhã", "no dia quinze de fevereiro pela manhã");
+    example!(v, check_moment!(c, [2013, 2, 12, 20]), "hoje às oito da noite", "8 da noite", "às oito da noite");
+    example!(v, check_moment!(c, [2013, 2, 13, 3]), "3 da manhã", "às três da manhã");
+
+    // Part of the week/month
+    example!(v, check_moment_span!(c, [2013, 2, 13, 18], [2013, 2, 14, 00]), "amanhã de noite", "na quarta-feira de noite", "na noite de quarta-feira");
+    example!(v, check_moment_span!(c, [2013, 2, 11, 18], [2013, 2, 12, 00]), "ontem à noite");
+    // Ambiguity: end of the week =/= week-end
+    //example!(v, check_moment_span!(c, [2013, 2, 15, 18], [2013, 2, 18, 00]), "este fim de semana", "este final de semana", "no próximo final de semana");
+    example!(v, check_moment_span!(c, [2013, 2, 11], [2013, 2, 13]), "no começo da semana", "no início desta semana");
+    example!(v, check_moment_span!(c, [2013, 2, 13], [2013, 2, 15]), "no meio da semana", "na metade da semana");
+    example!(v, check_moment_span!(c, [2013, 2, 14], [2013, 2, 18]), "no final da semana", "no fim de semana");
+    example!(v, check_moment_span!(c, [2013, 2, 11], [2013, 2, 16]), "durante a semana");
+    example!(v, check_moment_span!(c, [2013, 2, 19], [2013, 3, 01]), "no final do mês", "no final do mês");
+    example!(v, check_moment_span!(c, [2013, 9, 6, 18], [2013, 9, 9, 00]), "o primeiro fim de semana de setembro", "o primeiro final de semana de setembro", "o primeiro fim de semana do mês de setembro");
+    example!(v, check_moment_span!(c, [2013, 9, 13, 18], [2013, 9, 16, 00]), "o segundo final de semana de setembro");
+    example!(v, check_moment_span!(c, [2013, 9, 27, 18], [2013, 9, 30, 00]), "o último fim de semana de setembro");
+
+    // Intervals involving cycles
+    example!(v, check_moment_span!(c, [2013, 2, 12, 4, 29, 58], [2013, 2, 12, 4, 30, 00]), "2 últimos segundos", "os dois últimos segundos");
+    example!(v, check_moment_span!(c, [2013, 2, 12, 4, 30, 01], [2013, 2, 12, 4, 30, 04]), "os próximos 3 segundos", "os 3 próximos segundos");
+    example!(v, check_moment_span!(c, [2013, 2, 12, 4, 28], [2013, 2, 12, 4, 30]), "os 2 últimos minutos", "últimos dois minutos");
+    example!(v, check_moment_span!(c, [2013, 2, 12, 4, 31], [2013, 2, 12, 4, 34]), "nos próximos três minutos", "durante os próximos três minutos");
+    example!(v, check_moment_span!(c, [2013, 2, 12, 5], [2013, 2, 12, 8]), "as 3 próximas horas");
+    example!(v, check_moment_span!(c, [2013, 2, 10], [2013, 2, 12]), "últimos dois dias");
+    example!(v, check_moment_span!(c, [2013, 2, 13], [2013, 2, 16]), "próximos 3 dias", "os próximos 3 dias");
+    example!(v, check_moment_span!(c, [2013, 1, 28], [2013, 2, 11]), "últimas 2 semanas", "as duas últimas semanas");
+    example!(v, check_moment_span!(c, [2013, 2, 18], [2013, 3, 11]), "as próximas três semanas", "as três próximas semanas");
+    example!(v, check_moment_span!(c, [2012, 12], [2013, 02]), "últimos dois meses", "os últimos dois meses");
+    example!(v, check_moment_span!(c, [2013, 3], [2013, 6]), "os três próximos meses");
+    example!(v, check_moment_span!(c, [2011], [2013]), "os últimos 2 anos", "os dois anos anteriores");
+    example!(v, check_moment_span!(c, [2014], [2017]), "os próximos 3 anos", "os três próximos anos");
+
+    // Explicit intervals
+    // FIXME:
+    // fix_example!(v, check_moment_span!(c, [2013, 7, 13], [2013, 7, 16]),  "13 julho - 15 julho",  "de 13 a 15 de julho",  "do dia 13 ao dia 15 de julho",  "de sábado dia 13 a domingo dia 15 de julho",  "de sábado dia 13 até domingo dia 15 de julho",  "do dia 13 a domingo dia 15");
+
+    // FIXME: Resolution error (second date bad resolution) + "13-15 julho" not supported
+    // example!(v, check_moment_span!(c, [2013, 7, 13], [2013, 7, 16]), "13-15 julho", "entre dia 13 e dia 15 de julho");
+    // FIXME: Resolution issue 10 --> 11 , + "de segunda dia primeiro a quarta-feira dia 10 de julho" not parsed
+    // fix_example!(v, check_moment_span!(c, [2013, 7, 1], [2013, 7, 10]), "do dia 1 ao dia 10 de julho", "de segunda dia primeiro a quarta-feira dia 10 de julho");
+    // FIXME: Resolution eror : 06/18 -> 06/19
+    //example!(v, check_moment_span!(c, [2013, 2, 13], [2013, 2, 18]), "do dia 13 ao dia 18", "entre dia 13 e dia 18");
+    example!(v, check_moment_span!(c, [2023, 2, 1], [2023, 3, 1]), "entre fevereiro e março de dois mil e vinte e três", "entre o mês de fevereiro e o mês de março de dois mil e vinte e três");
+    // FIXME: Resolution error : "primeiro de julho" -> 06/01 but "de 10 de junho a primeiro de julho" -> 06/02
+    // example!(v, check_moment_span!(c, [2013, 6, 10], [2013, 7, 2]), "de 10 de junho a primeiro de julho", "entre o dia dez de junho e dia primeiro de julho", "entre o dia 10 de junho e o dia primeiro de julho", "de 10 de junho a 1º de julho");
+    // FIXME: Resolution error: start: 2017-04-06T00:00:00+02:00, end: 2017-06-09T00:00:00+02:00, 8 --> 9
+    // example!(v, check_moment_span!(c, [2017,4,6], [2017,6,9]), "do dia seis de abril ao dia oito de junho de dois mil e dezessete", "de seis de abril ao dia oito de junho de dois mil e dezessete");
+    // TODO: OK, but abbreviation "5ª f." not supported, "09:30 - 11:00" as interval not supported
+    // fix_example!(v, check_moment_span!(c, [2013, 2, 14, 9, 30], [2013, 2, 14, 11]), "09:30 - 11:00 na quinta-feira", "das 9h30 às 11h na quinta-feira", "das 9 e meia às 11 de quinta-feira", "na quinta-feira das 9h30 às 11h", "quinta-feira entre 9 e meia e 11", "quinta das 9h30 às 11h", "5ª f. entre as 09:30 e as 11:00");
+    example!(v, check_moment_with_direction!(c, [2013, 3, 8], Direction::After), "a partir do dia 08", "desde o dia 8 de março", "do dia 8 de março em diante");
+    example!(v, check_moment_with_direction!(c, [2013, 2, 14, 9, 30], Direction::After), "a partir das 09h30 de quinta-feira", "quinta pela manhã das 9 e meia em diante");
+    example!(v, check_moment_with_direction!(c, [2013, 11, 1, 16], Direction::After), "depois das 16h do dia um de novembro", "depois das 4 da tarde do dia um de novembro", "no dia um de novembro depois das 16 horas");
+    example!(v, check_moment_with_direction!(c, [2013, 11, 1], Direction::After), "depois do dia um de novembro");
+
+    example!(v, check_moment_with_direction!(c, [2013, 2, 12, 16], Direction::Before), "antes das 16h", "até as 4 da tarde");
+    example!(v, check_moment_with_direction!(c, [2013, 2, 12, 16, 0], Direction::Before), "até as 16:00");
+    // FIXME: Same as below (Interval(..-..) expected but got Before(..))
+    // example!(v, check_moment_span!(c, [2013, 2, 13, 0], [2013, 2, 13, 6]), "amanhã até as seis horas", "amanhã antes das 6h", "até as 6 horas amanhã");
+    // FIXME: Same as below (Interval(..-..) expected but got After(..))
+    // todo_example!(v, check_moment_with_direction!(c, [2013, 2, 20, 10], Direction::After), "13/02/20 18:00", "no dia 20 a partir das 10 horas", "desde as dez horas no dia vinte");
+    example!(v, check_moment_with_direction!(c, [2013, 2, 15, 12], Direction::After), "na sexta-feira a partir do meio-dia", "na sexta-feira do meio-dia em diante", "desde sexta-feira ao meio-dia");
+    // FIXME: Resolved as: Before(13/02/20 18:00), but what is expected is: Interval(13/02/20 00:00 - 13/02/20 18:00)
+    //example!(v, check_moment_span!(c, [2013, 2, 20], [2013, 2, 20, 18]), "no dia 20 até as 18h");
+    // TODO: Do not support 14-20 (dash as time period) and set. (abbreviation of month)
+    // FIXME: "14" ---> 2014/01/01 (bad resolution) and 20 de setembro 2014 --> OK
+    //example!(v, check_moment_span!(c, [2014, 9, 14], [2014, 9, 21]), "14-20 set. 2014", "de 14 a 20 de setembro 2014");
+
+    example!(v, check_moment!(c, [2013, 2, 26]), "dentro de 2 semanas", "em duas semanas");
+    example!(v, check_moment!(c, [2013, 5, 12]), "dentro de 3 meses", "em três meses");
+    example!(v, check_moment!(c, [2013, 2, 27]),"em 15 dias","dentro de 15 dias");
+    example!(v, check_moment_span!(c, [2013, 2, 12, 5], [2013, 2, 12, 7]), "das 5 às 7", "entre 5 e 7 horas", "de 5 à sete horas");
+    example!(v, check_moment_span!(c, [2013, 2, 14, 9], [2013, 2, 14, 11]), "quinta-feira das 9 às 11", "na quinta-feira entre as 9 e as 11");
+
+    // FIXME: "entre as doze e as cartorze horas" (bad resolution: doze)
+    //example!(v, check_moment_span!(c, [2013, 2, 12, 12], [2013, 2, 12, 14]), "do meio-dia às 14h", "entre o meio-dia e as duas da tarde", "entre as doze e as cartorze horas");
+    example!(v, check_moment_span!(c, [2013, 2, 12, 11, 30], [2013, 2, 12, 13, 30]), "das 11h30 à 1h30", "das 11 e meia à uma e meia");
+    example!(v, check_moment!(c, [2013, 9, 21, 13, 30]), "às 13:30 de sábado dia 21 de setembro", "às 13h30 de sábado dia 21 de setembro");
+    example!(v, check_moment_span!(c, [2013, 3, 25], [2013, 4, 1]), "no final de março", "no fim do mês de março");
+    example!(v, check_moment_span!(c, [2013, 4, 1], [2013, 4, 6]), "no começo de abril", "no início do mês de abril");
+    example!(v, check_moment_span!(c, [2013, 4, 1], [2013, 4, 15]), "a primeira quinzena de abril", "na primeira quinzena do mês de abril");
+    example!(v, check_moment_span!(c, [2013, 4, 15], [2013, 5, 01]), "a segunda quinzena de abril", "na segunda quinzena do mês de abril");
+    example!(v, check_moment_span!(c, [2013, 12, 10], [2013, 12, 20]),  "meados de dezembro", "em meados de dezembro", "na metade do mês de dezembro");
+    example!(v, check_moment!(c, [2013, 3]), "março", "em março", "durante o mês de março", "o mês de março");
+    example!(v, check_moment!(c, [2013, 2, 12, 4, 45, 0]), "dentro de quinze minutos");
+    example!(v, check_moment!(c, [2013, 2, 12, 5, 0, 0]), "dentro de meia hora", "dentro de trinta minutos");
+    example!(v, check_moment!(c, [2013, 2, 12, 5, 15, 0]), "dentro de quarenta e cinco minutos");
+    example!(v, check_moment!(c, [2016, 12, 15]), "15.12.2016", "15.12.16", "15/12/2016");
 }
 
 pub fn examples_durations(v: &mut Vec<::rustling::train::Example<Dimension>>) {
-    example!(v, check_duration!([0, 0, 0, 0, 1]), "por uma hora");
+    example!(v, check_duration!([0, 0, 0, 0, 2]), "durante duas horas", "por duas horas");
+    // TODO: support "todo o dia"?
+    // example!(v, check_duration!([0, 0, 0, 1]), "durante um dia", "por um dia", "todo o dia");
+    example!(v, check_duration!([0, 1, 0]), "durante um mês", "por um mês");
+    example!(v, check_duration!([1]), "durante um ano", "por um ano");
+    example!(v, check_duration!([0, 0, 0, 0, 0, 1, 3]), "durante um minuto e três segundos", "um minuto e três segundos");
+    example!(v, check_duration!([0, 0, 0, 0, 1, 30], Precision::Approximate), "cerca de uma hora e meia", "uma hora e meia mais ou menos", "uma hora e meia aproximadamente", "por volta de 1h30");
+    example!(v, check_duration!([0, 0, 0, 0, 0, 15], Precision::Approximate), "durante um quarto de hora mais o menos", "aproximadamente durante um quarto de hora");
+    example!(v, check_duration!([0, 0, 0, 0, 1]), "durante uma hora", "por uma hora");
+    example!(v, check_duration!([0, 0, 2]), "durante 2 semanas", "por duas semanas");
 }