!= ===============================================================
!= HFST Pmatch rule file converted from Flex source file MsrPat.ll
!= by flex2pmatch.py
!= ===============================================================

!= ===============================================
!= Pmatch shorthand regular expression definitions
!= ===============================================

Define UNIMPLEMENTED [ "" ] ;
Define AnyChar [Alpha|Num|Punct|Whitespace|"­"] ;
Define Upper [UppercaseAlpha|"&"] ;
Define AZ
     ["A"|"B"|"C"|"D"|"E"|"F"|"G"|"H"|"I"|"J"|"K"|"L"|"M"|"N"|"O"|"P"|"Q"|"R"|"S"|"T"|"U"|"V"|"W"|"X"|"Y"|"Z"] ;
Define Az
     ["a"|"b"|"c"|"d"|"e"|"f"|"g"|"h"|"i"|"j"|"k"|"l"|"m"|"n"|"o"|"p"|"q"|"r"|"s"|"t"|"u"|"v"|"w"|"x"|"y"|"z"] ;
Define NST [AnyChar - [Whitespace|"<"|">"]] ;
Define NS [ NST ] ;
Define NSTagComma [AnyChar - [Whitespace|"<"|">"|","]] ;
Define NSHash [AnyChar - [Whitespace|"#"|"<"|">"]] ;
Define NSDash [AnyChar - [Whitespace|"-"|"<"|">"]] ;
Define NSColon [AnyChar - [Whitespace|":"|"<"|">"]] ;
Define NSDashColon [AnyChar - [Whitespace|":"|"-"|"<"|">"]] ;
Define NoTag [AnyChar - ["\n"|"<"|">"]] ;
Define NoTags [ NoTag+ ] ;
Define NoQuote [AnyChar - ["\n"|"\""|"'"|"´"|"«"|"»"|"<"|">"]] ;
Define NoDQuote [AnyChar - ["\""|"\n"|"<"|">"]] ;
Define NoQuoteVbar [AnyChar - ["\n"|"\""|"'"|"|"|"´"|"«"|"»"|"<"|">"]] ;
Define NoQuoteHash [AnyChar - ["\n"|"\""|"'"|"´"|"#"|"«"|"»"|"<"|">"]] ;
Define NoQuoteHashVbar
     [AnyChar - ["\n"|"\""|"'"|"´"|"#"|"|"|"«"|"»"|"<"|">"]] ;
Define NoComma [AnyChar - ["\n"|","|"<"|">"]] ;
Define NoCommaPeriod [AnyChar - ["\n"|","|"."|"<"|">"]] ;
Define NoLPar [AnyChar - ["\n"|"("|"<"|">"]] ;
Define UpperDigit [UppercaseAlpha|Num] ;
Define UpperDigitDash [UppercaseAlpha|Num|"-"] ;
Define Lower [ LowercaseAlpha ] ;
Define LowerDigit [LowercaseAlpha|Num] ;
Define LowerDigitDash [LowercaseAlpha|Num|"-"] ;
Define DigitDash [Num|"-"] ;
Define DigitDashes [ DigitDash+ ] ;
Define DigitComma [Num|","] ;
Define DigitCommas [ DigitComma+ ] ;
Define DigitUscore [Num|"_"] ;
Define DigitUscores [ DigitUscore+ ] ;
Define AsciiAlpha [ AZ | Az ] ;
Define AlphaDigit [Alpha|Num] ;
Define AlphaDigitDash [Alpha|Num|"-"] ;
Define AlphaDigitDashUnder [Alpha|Num|"-"|"_"] ;
Define Num02 ["0"|"1"|"2"] ;
Define Num03 ["0"|"1"|"2"|"3"] ;
Define Num06 ["0"|"1"|"2"|"3"|"4"|"5"|"6"] ;
Define Num12 ["1"|"2"] ;
Define Num19 ["1"|"2"|"3"|"4"|"5"|"6"|"7"|"8"|"9"] ;
Define Num13 ["1"|"2"|"3"] ;
Define YearNum [ Num12 Num^3 ] ;
Define Nums6 [ Num^6 ] ;
Define Nums4 [ Num^4 ] ;
Define Nums2 [ Num^2 ] ;
Define Nums [ Num+ ] ;
Define Nums12 [ Num (Num) ] ;
Define Num12DigitDashes [ Num12 DigitDashes ] ;
Define Num01X [ ["0"|"1"] Num ] ;
Define Num02X [ Num02 Num ] ;
Define Num12X [ Num12 Num ] ;
Define Num13X [ Num13 Num ] ;
Define Num19x [ Num19 (Num) ] ;
Define Num19X [ Num19 Num ] ;
Define Num12Nums [ Num12 Nums ] ;
Define NumsDotNums [ Nums {.} Nums ] ;
Define Nums2DotNums2 [ Nums2 {.} Nums2 ] ;
Define NumsColonNums [ Nums {:} Nums ] ;
Define NumDotNums2 [ Num {.} Nums2 ] ;
Define Nums12DotNums2 [ Nums12 {.} Nums2 ] ;
Define NumsSlashNums [ Nums {/} Nums ] ;
Define NumsSlashNums [ Nums {/} Nums ] ;
Define NumsCommaNums [ Nums {,} Nums ] ;
Define NumsCommaNums [ Nums {,} Nums ] ;
Define NumsSpNums [ Nums { } Nums ] ;
Define NumRange [ Nums {-} Nums ] ;
Define Nums2Range [ Nums2 {-} Nums2 ] ;
Define NumsSpRange [ Nums { - } Nums ] ;
Define HhMm [ Num02X {.} Nums2 ] ;
Define CapWord [ Upper NS* ] ;
Define CapWord2 [ Upper NS+ ] ;
Define CapWord3 [ Upper NS^>1 ] ;
Define CapWord4 [ Upper NS^>2 ] ;
Define Word [ NS+ ] ;
Define UpperWord [ Upper+ ] ;
Define LowerWord [ Lower+ ] ;
Define CapWord2iska [ CapWord2 {iska} ] ;
Define CapWord2ska [ CapWord2 {ska} ] ;
Define CapWord2sk [ CapWord2 {sk} ] ;
Define CapWord2s [ CapWord2 {s} ] ;
Define CapWord2Dash [ CapWord2 {-} ] ;
Define WordDash [ Word {-} ] ;
Define Word%_iska [ Word {iska} ] ;
Define Word%_isk [ Word {isk} ] ;
Define Word%_ska [ Word {ska} ] ;
Define Word%_sk [ Word {sk} ] ;
Define Word%_s [ Word {s} ] ;
Define UpperWord%_s [ UpperWord {:s} ] ;
Define LowerWord%_a [ LowerWord {a} ] ;
Define LowerWord%_e [ LowerWord {e} ] ;
Define LowerWord%_s [ LowerWord {s} ] ;
Define EndTagEnamex [ {</ENAMEX>} ] ;
Define StartTagEnamex
     [ {<ENAMEX TYPE=} "\"" UpperWord "\"" { SBT=} "\"" UpperWord "\"" {>} ] ;
Define WordBoundary [ [Whitespace|Punct] - ["<"|">"] | # ] ;
Define Aa ["A"|"a"] ;
Define Bb ["B"|"b"] ;
Define Cc ["C"|"c"] ;
Define Dd ["D"|"d"] ;
Define Ee ["E"|"e"] ;
Define Ff ["F"|"f"] ;
Define Gg ["G"|"g"] ;
Define Hh ["H"|"h"] ;
Define Ii ["I"|"i"] ;
Define Jj ["J"|"j"] ;
Define Kk ["K"|"k"] ;
Define Ll ["L"|"l"] ;
Define Mm ["M"|"m"] ;
Define Nn ["N"|"n"] ;
Define Oo ["O"|"o"] ;
Define Pp ["P"|"p"] ;
Define Qq ["Q"|"q"] ;
Define Rr ["R"|"r"] ;
Define Ss ["S"|"s"] ;
Define Tt ["T"|"t"] ;
Define Uu ["U"|"u"] ;
Define Vv ["V"|"v"] ;
Define Ww ["W"|"w"] ;
Define Xx ["X"|"x"] ;
Define Yy ["Y"|"y"] ;
Define Zz ["Z"|"z"] ;

!= ============================
!= Additional recognition rules
!= ============================

!C Ignore already tagged names and exceptions.
!C Note that this might not always work correctly since Pmatch rules
!C are in principle order-independent.
Define IgnoreTagged
     [ {<Except>} [AnyChar - "<"]* {</Except>}
       | {<} [{Ena} | {Nu} | {Ti}] {mex} Alpha+ {>} [AnyChar - "<"]+ {</}
         [{Ena} | {Nu} | {Ti}] {mex} Alpha* {>} ] ;

!= ==================================================
!= Pmatch definitions for converted Flex source begin
!= ==================================================

!= ==========================================================
!= Pmatch definitions for Flex regular expression definitions
!= ==========================================================

!# 
!# 	File: MsrPatB.ll
!# 	"out-of-dictionary items"
!# 	Author: Dimitrios Kokkinakis
!# 	Version: 090102
!# 	Finds: names of measures strings
!# 

!R NUM	Ett|En|[Tt]vå|[Tt]re|[Ff]yra|[Ff]em|[Ss]ex|[Ss]ju|[^\n\t ]*[Åå]tta|[Nn]io|[^\n\t ]+tio|[Tt]io|[Ee]lva|[Tt]olv|[Tt]retton|[Ff]jorton|[Ff]emton|[Ss]exton|[Ss]jutton|[Aa]rton|[Nn]itton|[Tt]jugo|[Tt]jugoen[Tt]jugotvå|tjugofem

Define NUM
     [ {Ett} | {En} | Tt {vå} | Tt {re} | Ff {yra} | Ff {em} | Ss {ex}
       | Ss {ju} | NS* ["Å"|"å"] {tta} | Nn {io} | Word {tio} | Tt {io}
       | Ee {lva} | Tt {olv} | Tt {retton} | Ff {jorton} | Ff {emton}
       | Ss {exton} | Ss {jutton} | Aa {rton} | Nn {itton} | Tt {jugo}
       | Tt {jugoen} Tt {jugotvå} | {tjugofem} ] ;

!R CITAT	\"|\´|\'|\'\'|`|\»|\«

Define CITAT [ "\"" | {´} | {'} | {''} | {`} | {»} | {«} ] ;

!= =================================
!= Pmatch definitions for Flex rules
!= =================================

!#  EXCEPTIONS 

!R "\<ENAMEX TYPE\="\"(EVN|LOC|MSR|OBJ|ORG|PRS|WRK|TME|MDC|TRM)"\" SBT\=\""(ANM|ARL|AST|ATH|ATL|CLC|CLT|CLU|CMP|CRP|DAT|DEN|EDU|FIN|FNC|FWP|GPL|HPL|HUM|MDC|MDA|MDD|MDO|MTH|PER|PLT|PPL|PRD|PRJ|PRZ|RLG|RTV|STR|TVR|TRM|VHA|VHG|VHW|WAA|WAO|WMD|WMO|WTH)\"\>[^\n\<]+\<\/ENAMEX\>
!A {ECHO;}
!I Ignored exception rule

!R "\<NUMEX TYPE\=\"MSR\" SBT\=\""(DGR|VLM|TMP|INX|DST|CUR|DEN|PRC|CMU|WMU|XXX|TEL|LST|AGE|WEB|CVU|CRD|ELU)\"\>[^\n\<]+\<\/NUMEX\>
!A {ECHO;}
!I Ignored exception rule

!R ({NUM}|[0-9]+)" "[^\n ]*metaboliter
!A {ECHO;}

Define Except001 [ [NUM | Nums] { } NS* {metaboliter} ] ; 1

!R ([0-9]+\-)?[0-9]+(\%)?" "(mer" "|mindre" "|extra" ")?(kilo)?kalorier
!A {printXXX(yytext,0);}

Define NumexMsrXxx001a
     [ (Ins(Nums) {-}) Ins(Nums) ({%}) { } ({mer } | {mindre } | {extra }) ({kilo})
       {kalorier} ] ;
Define NumexMsrXxx001 [ NumexMsrXxx001a   EndTag(NumexMsrXxx) ] ; 2

!R [0-9]+kcal\/[0-9]+" "gram
!A {printXXX(yytext,0);}

Define NumexMsrXxx002a [ Ins(Nums) {kcal/} Ins(Nums) { gram} ] ;
Define NumexMsrXxx002 [ NumexMsrXxx002a   EndTag(NumexMsrXxx) ] ; 3

!R [0-9]+\-[0-9]+" kcal\/"[md]l
!A {printXXX(yytext,0);}

Define NumexMsrXxx003a [ Ins(NumRange) { kcal/} ["m"|"d"] {l} ] ;
Define NumexMsrXxx003 [ NumexMsrXxx003a   EndTag(NumexMsrXxx) ] ; 4

!R ([0-9]+" "[0-9]+|[0-9]+|[0-9]+[\-\.\,][0-9]+|[0-9]+[\-\.\,][0-9]+.[0-9]+)" "(kalorier|kcal|kilokalorier)(\/dygn|\/dag|\/d)?
!A {printXXX(yytext,0);}

Define NumexMsrXxx004a
     [ [Ins(NumsSpNums) | Ins(Nums) | Ins(Nums) ["-"|"."|","] Ins(Nums)
          | Ins(Nums) ["-"|"."|","] Ins(Nums) AnyChar Ins(Nums)]
       { } [{kalorier} | {kcal} | {kilokalorier}] ({/dygn} | {/dag} | {/d}) ] ;
Define NumexMsrXxx004 [ NumexMsrXxx004a   EndTag(NumexMsrXxx) ] ; 5

!R ([0-9]+|[0-9]+[\-\.\,][0-9]+)" "(kilo|kalorier|kcal|kilokalorier)(\/dygn|\/dag|\/d)
!A {printXXX(yytext,0);}

Define NumexMsrXxx005a
     [Ins(Nums) | Ins(Nums) ["-"|"."|","] Ins(Nums)] { }
     [{kilo} | {kalorier} | {kcal} | {kilokalorier}]
     [{/dygn} | {/dag} | {/d}] ;
Define NumexMsrXxx005 [ NumexMsrXxx005a   EndTag(NumexMsrXxx) ] ; 6

!R ([0-9]+|[0-9]+\.[0-9]+)" "(kilobequerel|[Bb]ecquerel|[Bb]ecquerell|Bq|MBq|MBq\/ml|Bq\/kg)(" per "[^\n\t ]*gram|" per "[^\n\t ]*meter|\/m3|\/ml)?
!A {printXXX(yytext,0);}

Define NumexMsrXxx006a
     [ [Ins(Nums) | Ins(NumsDotNums)] { }
       [{kilobequerel} | Bb {ecquerel} | Bb {ecquerell} | {Bq} | {MBq}
          | {MBq/ml} | {Bq/kg}]
       ({ per } NS* {gram} | { per } NS* {meter} | {/m3} | {/ml}) ] ;
Define NumexMsrXxx006 [ NumexMsrXxx006a   EndTag(NumexMsrXxx) ] ; 7

!R [0-9]+" "kilopond
!A {printXXX(yytext,0);}

Define NumexMsrXxx007a [ Ins(Nums) { kilopond} ] ;
Define NumexMsrXxx007 [ NumexMsrXxx007a   EndTag(NumexMsrXxx) ] ; 8

!R [0-9]+" cal per kg"
!A {printXXX(yytext,0);}

Define NumexMsrXxx008a [ Ins(Nums) { cal per kg} ] ;
Define NumexMsrXxx008 [ NumexMsrXxx008a   EndTag(NumexMsrXxx) ] ; 9

!#  Computer Unit - CMU

!R ([Dd]rygt" "|[Uu]pp" till ")?(en|två|tre|fyra|fem|sex|sju|åtta|nio|tio|[0-9]+|[0-9]+[0-9\-\,]+)" "([MmKk]bit|[Gg]igabit|[Mm]egabit|Mb|Kb|Mbyte|megabyte|kilobit|kilobyte|gigabyte)\/(s|sek|sekund)
!A {printCMU(yytext,0);}

Define NumexMsrCmu001a
     [ (Dd {rygt } | Uu {pp till })
       [{en} | {två} | {tre} | {fyra} | {fem} | {sex} | {sju} | {åtta}
          | {nio} | {tio} | Ins(Nums) | Ins(Nums) [Num|"-"|","]+]
       { }
       [["M"|"m"|"K"|"k"] {bit} | Gg {igabit} | Mm {egabit} | {Mb} | {Kb}
          | {Mbyte} | {megabyte} | {kilobit} | {kilobyte} | {gigabyte}]
       {/} [{s} | {sek} | {sekund}] ] ;
Define NumexMsrCmu001 [ NumexMsrCmu001a   EndTag(NumexMsrCmu) ] ; 10

!R ([Dd]rygt" "|[Uu]pp" till ")?(en|två|tre|fyra|fem|sex|sju|åtta|nio|tio|[0-9]+|[0-9][0-9\-\,]+)" "([MK]bps|[Mm]bit|[Gg]igabit|[Mm]egabit|Kb|megabyte|kilobit|kilobyte|gigabyte)
!A {printCMU(yytext,0);}

Define NumexMsrCmu002a
     [ (Dd {rygt } | Uu {pp till })
       [{en} | {två} | {tre} | {fyra} | {fem} | {sex} | {sju} | {åtta}
          | {nio} | {tio} | Ins(Nums) | Num [Num|"-"|","]+]
       { }
       [["M"|"K"] {bps} | Mm {bit} | Gg {igabit} | Mm {egabit} | {Kb}
          | {megabyte} | {kilobit} | {kilobyte} | {gigabyte}] ] ;
Define NumexMsrCmu002 [ NumexMsrCmu002a   EndTag(NumexMsrCmu) ] ; 11

!R ([Dd]rygt" "|[Uu]pp" till ")?([0-9]+" ")?[0-9]+" "(kilobit|bits|Mbit|bitar|megabit|megabyte|kilobyte|gigabyte)" per sekund"
!A {printCMU(yytext,0);}

Define NumexMsrCmu003a
     [ (Dd {rygt } | Uu {pp till }) (Ins(Nums) { }) Ins(Nums) { }
       [{kilobit} | {bits} | {Mbit} | {bitar} | {megabit} | {megabyte}
          | {kilobyte} | {gigabyte}]
       { per sekund} ] ;
Define NumexMsrCmu003 [ NumexMsrCmu003a   EndTag(NumexMsrCmu) ] ; 12

!R ([Dd]rygt" "|[Uu]pp" till ")?{NUM}(\-{NUM})?" "(kilobit|Mbit|bitar|megabit|megabyte|kilobyte|gigabyte)" per sekund"
!A {printCMU(yytext,0);}

Define NumexMsrCmu004a
     [ (Dd {rygt } | Uu {pp till }) Ins(NUM) ({-} Ins(NUM)) { }
       [{kilobit} | {Mbit} | {bitar} | {megabit} | {megabyte} | {kilobyte}
          | {gigabyte}]
       { per sekund} ] ;
Define NumexMsrCmu004 [ NumexMsrCmu004a   EndTag(NumexMsrCmu) ] ; 13

!R [0-9][0-9\-]+" "[MKk][Bb]" "
!A {int i=0;printf("<NUMEX TYPE=\"MSR\" SBT=\"CMU\">"); 	for(;i<yyleng-1;putchar(yytext[i++])); printf("</NUMEX> "); }

Define NumexMsrCmu005a [ Num DigitDashes { } ["M"|"K"|"k"] Bb ] ;
Define NumexMsrCmu005 [ NumexMsrCmu005a   RC({ })   EndTag(NumexMsrCmu) ] ; 14

!R (32|64|128)" bitar"
!A {printCMU(yytext,0);}

Define NumexMsrCmu006a [ [{32} | {64} | {128}] { bitar} ] ;
Define NumexMsrCmu006 [ NumexMsrCmu006a   EndTag(NumexMsrCmu) ] ; 15

!R ([0-9][0-9\-\,]+" "miljoner|[0-9]+x[0-9]+|[0-9]+" x "[0-9]+)" "(dpi|pixlar)
!A {printCMU(yytext,0);}

Define NumexMsrCmu007a
     [Num [Num|"-"|","]+ { miljoner} | Ins(Nums) {x} Ins(Nums) | Ins(Nums) { x } Ins(Nums)] { }
     [{dpi} | {pixlar}] ;
Define NumexMsrCmu007 [ NumexMsrCmu007a   EndTag(NumexMsrCmu) ] ; 16

!#  SPEED 

!R ([Oo]mkring" "|[Uu]ngefär" "|[Nn]ästan" "|[Mm]inst" "|[Cc]irka" "|[Cc]:a" "|[Cc]a" "|till" ")?([0-9\-]+" ")?("en halv"|[0-9\-]+)" "([Kk]m\/[sh]|m\/min|km\/tim|"meter per sekund"|"kilometer i timmen"|"meter i sekunden")
!A {printSPD(yytext,0);}

Define NumexMsrSpd001a
     [ (Oo {mkring } | Uu {ngefär } | Nn {ästan } | Mm {inst } | Cc {irka }
         | Cc {:a } | Cc {a } | {till })
       (DigitDashes { }) [{en halv} | DigitDashes] { }
       [Kk {m/} ["s"|"h"] | {m/min} | {km/tim} | {meter per sekund}
          | {kilometer i timmen} | {meter i sekunden}] ] ;
Define NumexMsrSpd001 [ NumexMsrSpd001a   EndTag(NumexMsrSpd) ] ; 17

!R ([Oo]mkring" "|[Uu]ngefär" "|[Nn]ästan" "|[Mm]inst" "|[Cc]irka" "|[Cc]:a" "|[Cc]a" "|till" ")?[0-9]+(\,[0-9]+)?" knop"(s" fart")?
!A {printSPD(yytext,0);}

Define NumexMsrSpd002a
     [ (Oo {mkring } | Uu {ngefär } | Nn {ästan } | Mm {inst } | Cc {irka }
         | Cc {:a } | Cc {a } | {till })
       Ins(Nums) ({,} Ins(Nums)) { knop} ({s fart}) ] ;
Define NumexMsrSpd002 [ NumexMsrSpd002a   EndTag(NumexMsrSpd) ] ; 18

!R ([Dd]rygt" "|kring" "|ca" "|[Uu]ngefär" "|upp" till ")?([0-9]+|[0-9]+[\.\-\,0-9]*[0-9]+|tio)" "m\/s
!A {printSPD(yytext,0);}

Define NumexMsrSpd003a
     [ (Dd {rygt } | {kring } | {ca } | Uu {ngefär } | {upp till })
       [Ins(Nums) | Ins(Nums) [Num|"."|"-"|","]* Ins(Nums) | {tio}] { m/s} ] ;
Define NumexMsrSpd003 [ NumexMsrSpd003a   EndTag(NumexMsrSpd) ] ; 19

!R ([Oo]mkring" "|[Uu]ngefär" "|[Nn]ästan" "|[Mm]inst" "|[Cc]irka" "|[Cc]:a" "|[Cc]a" ")?[0-9]+(" till "[0-9]+|" eller "[0-9]+|[\-\,][0-9]+)?" "(m\/min|miles|[Kk]m|kilometre|meter)(\/time|" i timmen"|" i sekunden")
!A {printSPD(yytext,0);}

Define NumexMsrSpd004a
     [ (Oo {mkring } | Uu {ngefär } | Nn {ästan } | Mm {inst } | Cc {irka }
         | Cc {:a } | Cc {a })
       Ins(Nums) ({ till } Ins(Nums) | { eller } Ins(Nums) | ["-"|","] Ins(Nums)) { }
       [{m/min} | {miles} | Kk {m} | {kilometre} | {meter}]
       [{/time} | { i timmen} | { i sekunden}] ] ;
Define NumexMsrSpd004 [ NumexMsrSpd004a   EndTag(NumexMsrSpd) ] ; 20

!R ([Oo]mkring" "|[Uu]ngefär" "|[Nn]ästan" "|[Mm]inst" "|[Cc]irka" "|[Cc]:a" "|[Cc]a" ")?[0-9]+([\-\,][0-9]+)?" "varv(\/minut|\/min|\/time|i" "minuten)
!A {printSPD(yytext,0);}

Define NumexMsrSpd005a
     [ (Oo {mkring } | Uu {ngefär } | Nn {ästan } | Mm {inst } | Cc {irka }
         | Cc {:a } | Cc {a })
       Ins(Nums) (["-"|","] Ins(Nums)) { varv}
       [{/minut} | {/min} | {/time} | {i minuten}] ] ;
Define NumexMsrSpd005 [ NumexMsrSpd005a   EndTag(NumexMsrSpd) ] ; 21

!R [0-9]+(\-[0-9]+)?" "Km\/([sh]|tim|time|timmen|sekunden)
!A {printSPD(yytext,0);}

Define NumexMsrSpd006a
     [ Ins(Nums) ({-} Ins(Nums)) { Km/}
       [["s"|"h"] | {tim} | {time} | {timmen} | {sekunden}] ] ;
Define NumexMsrSpd006 [ NumexMsrSpd006a   EndTag(NumexMsrSpd) ] ; 22

!R [Hh]astighet" "(på|av)" "("cirka "|"minst ")?([0-9]+[\,\- ][0-9]+|[0-9]+)(" kilometer i "timmen|" per "sekund|" meter i "sekunden|" ml\/kg"|" ml\/min")?
!A {printSPD(yytext,2);}

Define NumexMsrSpd007a
     [ ({cirka } | {minst }) [Ins(Nums) [Whitespace|","|"-"] Ins(Nums) | Ins(Nums)]
       ({ kilometer i timmen} | { per sekund} | { meter i sekunden}
         | { ml/kg} | { ml/min}) ] ;
Define NumexMsrSpd007
     [ NumexMsrSpd007a
       LC(Hh {astighet } [{på} | {av}] { })
       EndTag(NumexMsrSpd) ] ; 23

!R [0-9]+" "mm\/h
!A {printSPD(yytext,0);}

Define NumexMsrSpd008a [ Ins(Nums) { mm/h} ] ;
Define NumexMsrSpd008 [ NumexMsrSpd008a   EndTag(NumexMsrSpd) ] ; 24

!#  PRESSURE - PSS 

!R \+[0-9]+±[0-9]+" mm"(" Hg"|Hg)
!A {printPSS(yytext,0);}

Define NumexMsrPss001a [ {+} Ins(Nums) {±} Ins(Nums) { mm} [{ Hg} | {Hg}] ] ;
Define NumexMsrPss001 [ NumexMsrPss001a   EndTag(NumexMsrPss) ] ; 25

!R [Mm]ellan" "[0-9]+" och "[0-9]+" mm "[Hh][Gg]
!A {printPSS(yytext,0);}

Define NumexMsrPss002a [ Mm {ellan } Ins(Nums) { och } Ins(Nums) { mm } Hh Gg ] ;
Define NumexMsrPss002 [ NumexMsrPss002a   EndTag(NumexMsrPss) ] ; 26

!R ([0-9]+" ")?upp" "(mot|till)" "[0-9]+" mm"(" H"[Gg]|H[Gg])
!A {printPSS(yytext,0);}

Define NumexMsrPss003a
     [ (Ins(Nums) { }) {upp } [{mot} | {till}] { } Ins(Nums) { mm} [{ H} Gg | {H} Gg] ] ;
Define NumexMsrPss003 [ NumexMsrPss003a   EndTag(NumexMsrPss) ] ; 27

!R [0-9]+" "till" "[0-9]+" mm "H[Gg]
!A {printPSS(yytext,0);}

Define NumexMsrPss004a [ Ins(Nums) { till } Ins(Nums) { mm H} Gg ] ;
Define NumexMsrPss004 [ NumexMsrPss004a   EndTag(NumexMsrPss) ] ; 28

!R från" "[0-9]+" till "[0-9]+" mm "H[Gg]
!A {printPSS(yytext,1);}

Define NumexMsrPss005a [ Ins(Nums) { till } Ins(Nums) { mm H} Gg ] ;
Define NumexMsrPss005
     [ NumexMsrPss005a
       LC({från })
       EndTag(NumexMsrPss) ] ; 29

!R [0-9]+" mm "H[Gg]
!A {printPSS(yytext,0);}

Define NumexMsrPss006a [ Ins(Nums) { mm H} Gg ] ;
Define NumexMsrPss006 [ NumexMsrPss006a   EndTag(NumexMsrPss) ] ; 30

!R ([Cc]irka" "|[Öö]ver" "|[Uu]nder" "|"\< ")?([0-9]\,[0-9]\/|[0-9]+\,[0-9]+)?[0-9][0-9\/\-]*" "(mm" H"[Gg]|mmHg|hektopascal|millibar)
!A {printPSS(yytext,0);}

Define NumexMsrPss007a
     [ (Cc {irka } | ["Ö"|"ö"] {ver } | Uu {nder } | {< })
       (Num {,} Num {/} | Ins(NumsCommaNums)) Num [Num|"/"|"-"]* { }
       [{mm H} Gg | {mmHg} | {hektopascal} | {millibar}] ] ;
Define NumexMsrPss007 [ NumexMsrPss007a   EndTag(NumexMsrPss) ] ; 31

!R [^\n\t ]*tryck" "(kring|på|är)" "("högst "|"omkring ")?[0-9]+[0-9\/\-]*(" mmHg"|" mm "[Hh][Gg]|" mm "[Gg]|mmHg)?
!A {printPSS(yytext,2);}

Define NumexMsrPss008a
     [ ({högst } | {omkring }) Ins(Nums) [Num|"/"|"-"]*
       ({ mmHg} | { mm } Hh Gg | { mm } Gg | {mmHg}) ] ;
Define NumexMsrPss008
     [ NumexMsrPss008a
       LC({tryck } [{kring} | {på} | {är}] { })
       EndTag(NumexMsrPss) ] ; 32

!R [^\n\t ]*"trycket "("under ")?[0-9]+\/[0-9]+(" mm "[Gg]|mmHg|" mm Hg"|" mmHg")?
!A {printPSS(yytext,1);}

Define NumexMsrPss009a
     [ ({under }) Ins(NumsSlashNums) ({ mm } Gg | {mmHg} | { mm Hg} | { mmHg}) ] ;
Define NumexMsrPss009
     [ NumexMsrPss009a
       LC({trycket })
       EndTag(NumexMsrPss) ] ; 33

!R [^\n\t ]*"trycket är "[0-9]+\/[0-9]+(" mm "[Gg]|mmHg|" mm Hg"|" mmHg")?
!A {printPSS(yytext,2);}

Define NumexMsrPss010a
     [ Ins(NumsSlashNums) ({ mm } Gg | {mmHg} | { mm Hg} | { mmHg}) ] ;
Define NumexMsrPss010
     [ NumexMsrPss010a
       LC({trycket är })
       EndTag(NumexMsrPss) ] ; 34

!#  MOD (Jyrki Niemi): Rule was split because of different left
!# 	   contexts. Should the context be 2 or 3 words, preposition included
!# 	   or exluded from the named entity?
!# 	[^\n\t ]*trycket" "(ökad" "från|"ökade med")" "[0-9]+\/[0-9]+(" till "[0-9]+\/[0-9]+|[0-9]+\,[0-9]+)?(" mm "[Gg]|mmHg|" mm Hg")?	{printPSS(yytext,2);}
!# 	

!R [^\n\t ]*trycket" ökad från "[0-9]+\/[0-9]+(" till "[0-9]+\/[0-9]+|[0-9]+\,[0-9]+)?(" mm "[Gg]|mmHg|" mm Hg")?
!A {printPSS(yytext,2);}

Define NumexMsrPss011a
     [ {från } Ins(NumsSlashNums) ({ till } Ins(NumsSlashNums) | Ins(NumsCommaNums))
       ({ mm } Gg | {mmHg} | { mm Hg}) ] ;
Define NumexMsrPss011
     [ NumexMsrPss011a
       LC({trycket ökad })
       EndTag(NumexMsrPss) ] ; 35

!R [^\n\t ]*trycket" ökade med "[0-9]+\/[0-9]+(" till "[0-9]+\/[0-9]+|[0-9]+\,[0-9]+)?(" mm "[Gg]|mmHg|" mm Hg")?
!A {printPSS(yytext,2);}

Define NumexMsrPss012a
     [ {med } Ins(NumsSlashNums) ({ till } Ins(NumsSlashNums) | Ins(NumsCommaNums))
       ({ mm } Gg | {mmHg} | { mm Hg}) ] ;
Define NumexMsrPss012
     [ NumexMsrPss012a
       LC({trycket ökade })
       EndTag(NumexMsrPss) ] ; 36

!R [^\n\t ]*tryck" mellan "[0-9]+" och "[0-9]+
!A {printPSS(yytext,2);}

Define NumexMsrPss013a [ Ins(Nums) { och } Ins(Nums) ] ;
Define NumexMsrPss013
     [ NumexMsrPss013a
       LC({tryck mellan })
       EndTag(NumexMsrPss) ] ; 37

!R ([0-9\-]+" "[0-9\-]+|[1-9]+" \, "[0-9]+|[0-9]+|[1-9]+\,[0-9]+|[0-9]+±[0-9]+)" mg H"[Gg]
!A {printPSS(yytext,0);}

Define NumexMsrPss014a
     [ [DigitDashes { } DigitDashes | Num19+ { , } Ins(Nums) | Ins(Nums)
          | Num19+ {,} Ins(Nums) | Ins(Nums) {±} Ins(Nums)]
       { mg H} Gg ] ;
Define NumexMsrPss014 [ NumexMsrPss014a   EndTag(NumexMsrPss) ] ; 38

!R [0-9]+[\,\/][0-9]+(" mm "[Gg]|" mm "[Hh]g|mmHg)
!A {printPSS(yytext,0);}

Define NumexMsrPss015a
     [ Ins(Nums) [","|"/"] Ins(Nums) [{ mm } Gg | { mm } Hh {g} | {mmHg}] ] ;
Define NumexMsrPss015 [ NumexMsrPss015a   EndTag(NumexMsrPss) ] ; 39

!R "En millibar"
!A {printPSS(yytext,0);}

Define NumexMsrPss016a [ {En millibar} ] ;
Define NumexMsrPss016 [ NumexMsrPss016a   EndTag(NumexMsrPss) ] ; 40

!R [Bb]lodtryck" "(är|ligger|ligg)" : "[0-9]+\/[0-9]+(" mm "[Gg]|" mm "[Hh]g|mmHg)?
!A {printPSS(yytext,3);}

Define NumexMsrPss017a
     [ Ins(NumsSlashNums) ({ mm } Gg | { mm } Hh {g} | {mmHg}) ] ;
Define NumexMsrPss017
     [ NumexMsrPss017a
       LC(Bb {lodtryck } [{är} | {ligger} | {ligg}] { : })
       EndTag(NumexMsrPss) ] ; 41

!R [Bb]lodtryck" ( > "[0-9]+\/[0-9]+(" mm "[Gg]|" mm "[Hh]g|mmHg)?
!A {printPSS(yytext,3);}

Define NumexMsrPss018a
     [ Ins(NumsSlashNums) ({ mm } Gg | { mm } Hh {g} | {mmHg}) ] ;
Define NumexMsrPss018
     [ NumexMsrPss018a
       LC(Bb {lodtryck ( > })
       EndTag(NumexMsrPss) ] ; 42

!R [Bb]lodtryck" "(är|ligger|ligg)" "[0-9]+\/[0-9]+(" mm "[Gg]|" mm "[Hh]g|mmHg)?
!A {printPSS(yytext,2);}

Define NumexMsrPss019a
     [ Ins(NumsSlashNums) ({ mm } Gg | { mm } Hh {g} | {mmHg}) ] ;
Define NumexMsrPss019
     [ NumexMsrPss019a
       LC(Bb {lodtryck } [{är} | {ligger} | {ligg}] { })
       EndTag(NumexMsrPss) ] ; 43

!R [Bb]lodtryck" som "(är|ligger|ligg)" "[0-9]+\/[0-9]+(" mm "[Gg]|" mm "[Hh]g|mmHg)?
!A {printPSS(yytext,3);}

Define NumexMsrPss020a
     [ Ins(NumsSlashNums) ({ mm } Gg | { mm } Hh {g} | {mmHg}) ] ;
Define NumexMsrPss020
     [ NumexMsrPss020a
       LC(Bb {lodtryck som } [{är} | {ligger} | {ligg}] { })
       EndTag(NumexMsrPss) ] ; 44

!#  particularly in med texts 

!R [Bb]lodtrycket" ligger på "[0-9]+\/[0-9]+
!A {printPSS(yytext,3);}

Define NumexMsrPss021a [ Ins(NumsSlashNums) ] ;
Define NumexMsrPss021
     [ NumexMsrPss021a
       LC(Bb {lodtrycket ligger på })
       EndTag(NumexMsrPss) ] ; 45

!R ([Bb]lodtryck|tryck|[Bb]ltr|BT)" "(liggande|stående)" "[0-9]+\/[0-9]+
!A {printPSS(yytext,2);}

Define NumexMsrPss022a [ Ins(NumsSlashNums) ] ;
Define NumexMsrPss022
     [ NumexMsrPss022a
       LC([Bb {lodtryck} | {tryck} | Bb {ltr} | {BT}] { }
          [{liggande} | {stående}] { })
       EndTag(NumexMsrPss) ] ; 46

!R ([Bb]lodtryck|tryck|[Bb]ltr|[Bb][Tt])" "[0-9]+\/[0-9]+(" mm "[Gg]|" mm "[Hh]g|" "mmHg|mmHg)?
!A {printPSS(yytext,1);}

Define NumexMsrPss023a
     [ Ins(NumsSlashNums) ({ mm } Gg | { mm } Hh {g} | { mmHg} | {mmHg}) ] ;
Define NumexMsrPss023
     [ NumexMsrPss023a
       LC([Bb {lodtryck} | {tryck} | Bb {ltr} | Bb Tt] { })
       EndTag(NumexMsrPss) ] ; 47

!R ([Bb]lodtryck|tryck|[Bb]ltr|BT)" "[:\,]" "[0-9]+\/[0-9]+(" mm "[Gg]|" mm "[Hh]g|" "mmHg|mmHg)?
!A {printPSS(yytext,2);}

Define NumexMsrPss024a
     [ Ins(NumsSlashNums) ({ mm } Gg | { mm } Hh {g} | { mmHg} | {mmHg}) ] ;
Define NumexMsrPss024
     [ NumexMsrPss024a
       LC([Bb {lodtryck} | {tryck} | Bb {ltr} | {BT}] { } [":"|","] { })
       EndTag(NumexMsrPss) ] ; 48

!R \=[0-9]+" mm Hg"
!A {printPSS(yytext,0);}

Define NumexMsrPss025a [ {=} Ins(Nums) { mm Hg} ] ;
Define NumexMsrPss025 [ NumexMsrPss025a   EndTag(NumexMsrPss) ] ; 49

!#  MOD (Jyrki Niemi): Rule was split into two by the number of
!# 	   words in the context:
!# 	(B[Ll]"\. tr "|B[Ll]"\.tr ")[0-9]+\/[0-9]+	{printPSS(yytext,2);}
!# 	

!R B[Ll]"\. tr "[0-9]+\/[0-9]+
!A {printPSS(yytext,2);}

Define NumexMsrPss026a [ Ins(NumsSlashNums) ] ;
Define NumexMsrPss026
     [ NumexMsrPss026a
       LC({B} Ll {. tr })
       EndTag(NumexMsrPss) ] ; 50

!R B[Ll]"\.tr "[0-9]+\/[0-9]+
!A {printPSS(yytext,1);}

Define NumexMsrPss027a [ Ins(NumsSlashNums) ] ;
Define NumexMsrPss027
     [ NumexMsrPss027a
       LC({B} Ll {.tr })
       EndTag(NumexMsrPss) ] ; 51

!R (cirka" "|ca" ")?([0-9]+" \- "[0-9]+|[0-9]+|[0-9]+\-[0-9]+|[0-9]+\,[0-9]+)" slag"(\/min|\/minut|" i minuten"|" per minut")
!A {printXXX(yytext,0);}

Define NumexMsrXxx009a
     [ ({cirka } | {ca }) [Ins(NumsSpRange) | Ins(Nums) | Ins(NumRange) | Ins(NumsCommaNums)]
       { slag} [{/min} | {/minut} | { i minuten} | { per minut}] ] ;
Define NumexMsrXxx009 [ NumexMsrXxx009a   EndTag(NumexMsrXxx) ] ; 52

!R ([Vv]id|[Uu]nder|[Öö]ver)" "([0-9]+|[0-9]+" "[0-9]+)" "(varv|slag)\/minut
!A {printXXX(yytext,1);}

Define NumexMsrXxx010a
     [ [Ins(Nums) | Ins(NumsSpNums)] { } [{varv} | {slag}] {/minut} ] ;
Define NumexMsrXxx010
     [ NumexMsrXxx010a
       LC([Vv {id} | Uu {nder} | ["Ö"|"ö"] {ver}] { })
       EndTag(NumexMsrXxx) ] ; 53

!R "BT "[\>\<]" "[0-9]+\/[0-9]+
!A {int i=5; printf("BT "); putchar(yytext[3]); 	printf(" <NUMEX TYPE=\"MSR\" SBT=\"PSS\">"); for(;i<yyleng;putchar(yytext[i++])); printf("</NUMEX>"); }

Define NumexMsrPss028a [ Ins(NumsSlashNums) ] ;
Define NumexMsrPss028
     [ NumexMsrPss028a
       LC({BT } [">"|"<"] { })
       EndTag(NumexMsrPss) ] ; 54

!R "BT "(över|under|knappt|\:)" "[0-9]+(\/[0-9]+)?
!A {printPSS(yytext,2);}

Define NumexMsrPss029a [ Ins(Nums) ({/} Ins(Nums)) ] ;
Define NumexMsrPss029
     [ NumexMsrPss029a
       LC({BT } [{över} | {under} | {knappt} | {:}] { })
       EndTag(NumexMsrPss) ] ; 55

!R ([Ll]igg|[Ss]tå)" "(över|under|knappt|\:)" "[0-9]+\/[0-9]+
!A {printPSS(yytext,2);}

Define NumexMsrPss030a [ Ins(NumsSlashNums) ] ;
Define NumexMsrPss030
     [ NumexMsrPss030a
       LC([Ll {igg} | Ss {tå}] { } [{över} | {under} | {knappt} | {:}] { })
       EndTag(NumexMsrPss) ] ; 56

!R "BT "[0-9]+\/[0-9]+
!A {printPSS(yytext,1);}

Define NumexMsrPss031a [ Ins(NumsSlashNums) ] ;
Define NumexMsrPss031
     [ NumexMsrPss031a
       LC({BT })
       EndTag(NumexMsrPss) ] ; 57

!R [Bb]lodtrycket" "[\>\<]" "[0-9]+\/[0-9]+
!A {printPSS(yytext,2);}

Define NumexMsrPss032a [ Ins(NumsSlashNums) ] ;
Define NumexMsrPss032
     [ NumexMsrPss032a
       LC(Bb {lodtrycket } [">"|"<"] { })
       EndTag(NumexMsrPss) ] ; 58

!R [0-9]+mmHg
!A {printPSS(yytext,0);}

Define NumexMsrPss033a [ Ins(Nums) {mmHg} ] ;
Define NumexMsrPss033 [ NumexMsrPss033a   EndTag(NumexMsrPss) ] ; 59

!R ([Bb]lodtryck|tryck|[Bb]ltr|BT|bt)"\-fall ner till "[0-9]+(\/[0-9]+)?
!A {printPSS(yytext,3);}

Define NumexMsrPss034a [ Ins(Nums) ({/} Ins(Nums)) ] ;
Define NumexMsrPss034
     [ NumexMsrPss034a
       LC([Bb {lodtryck} | {tryck} | Bb {ltr} | {BT} | {bt}]
          {-fall ner till })
       EndTag(NumexMsrPss) ] ; 60

!R [Bb]lodtrycksstegring" till "[a-z]+" "[0-9]+(\/[0-9]+)?
!A {printPSS(yytext,3);}

Define NumexMsrPss035a [ Ins(Nums) ({/} Ins(Nums)) ] ;
Define NumexMsrPss035
     [ NumexMsrPss035a
       LC(Bb {lodtrycksstegring till } LowerWord { })
       EndTag(NumexMsrPss) ] ; 61

!R [Hh][Bb]" "(strax" under "|strax" över ")?[1-9][0-9][0-9]?(" "g\/[Ll])?
!A {printXXX(yytext,1);}

Define NumexMsrXxx011a
     [ ({strax under } | {strax över }) Num19 Ins(Nums12) ({ g/} Ll) ] ;
Define NumexMsrXxx011
     [ NumexMsrXxx011a
       LC(Hh Bb { })
       EndTag(NumexMsrXxx) ] ; 62

!R [Hh][Bb]" "[1-9][0-9]\-[0-9]+(" "g\/[Ll])?
!A {printXXX(yytext,1);}

Define NumexMsrXxx012a [ Num19X {-} Ins(Nums) ({ g/} Ll) ] ;
Define NumexMsrXxx012
     [ NumexMsrXxx012a
       LC(Hh Bb { })
       EndTag(NumexMsrXxx) ] ; 63

!R [Hh][Bb]" < "[1-9][0-9]+(" "g\/[Ll])?
!A {printXXX(yytext,2);}

Define NumexMsrXxx013a [ Num19 Ins(Nums) ({ g/} Ll) ] ;
Define NumexMsrXxx013
     [ NumexMsrXxx013a
       LC(Hh Bb { < })
       EndTag(NumexMsrXxx) ] ; 64

!R [Hh][Bb]" på "(strax" under "|strax" över ")?[1-9][0-9][0-9]?(" "g\/[Ll])?
!A {printXXX(yytext,2);}

Define NumexMsrXxx014a
     [ ({strax under } | {strax över }) Num19 Ins(Nums12) ({ g/} Ll) ] ;
Define NumexMsrXxx014
     [ NumexMsrXxx014a
       LC(Hh Bb { på })
       EndTag(NumexMsrXxx) ] ; 65

!#  Electrical Unit - ELU

!R ([Mm]er" än "|[Cc]irka" "|[Mm]inst" ")?([0-9\-]+" ")?([0-9]+|[0-9]+" "[0-9]+\/[0-9]+|[0-9]+\/[0-9]+|[0-9]+\.[0-9]+|[0-9]+\,[0-9]+|[0-9]+\-[0-9]+|[0-9]+" "[0-9]+)" "(miljon" "|miljoner" ")?(TWh|[^\n\t ]*watt|[^\n\t ]*wattimme|[^\n\t ]*wattimmar)(\/min)?
!A {printELU(yytext,0);}

Define NumexMsrElu001a
     [ (Mm {er än } | Cc {irka } | Mm {inst }) (DigitDashes { })
       [Ins(Nums) | Ins(Nums) { } Ins(NumsSlashNums) | Ins(NumsSlashNums) | Ins(NumsDotNums)
          | Ins(NumsCommaNums) | Ins(NumRange) | Ins(NumsSpNums)]
       { } ({miljon } | {miljoner })
       [{TWh} | NS* {watt} | NS* {wattimme} | NS* {wattimmar}] ({/min}) ] ;
Define NumexMsrElu001 [ NumexMsrElu001a   EndTag(NumexMsrElu) ] ; 66

!R ([Mm]er" än "|[Cc]irka" "|[Mm]inst" ")?([Nn]"ågra få"|[Ee]n" "kvarts|[Ee]tt" "halvt|[Ee]tt" "halv|[Dd]"rygt en"|[Tt]vå|[Tt]re|[Ff]yra|[Ff]em|[Ss]ex|sju|åtta|nio|tio|tolv|[0-9]+\-tals)" "(miljon" "|miljoner" ")?(TWh|[^\n\t ]*watt[^\n\t ]*wattimme|[^\n\t ]*wattimmar)(\/min)?
!A {printELU(yytext,0);}

Define NumexMsrElu002a
     [ (Mm {er än } | Cc {irka } | Mm {inst })
       [Nn {ågra få} | Ee {n kvarts} | Ee {tt halvt} | Ee {tt halv}
          | Dd {rygt en} | Tt {vå} | Tt {re} | Ff {yra} | Ff {em} | Ss {ex}
          | {sju} | {åtta} | {nio} | {tio} | {tolv} | Ins(Nums) {-tals}]
       { } ({miljon } | {miljoner })
       [{TWh} | NS* {watt} NS* {wattimme} | NS* {wattimmar}] ({/min}) ] ;
Define NumexMsrElu002 [ NumexMsrElu002a   EndTag(NumexMsrElu) ] ; 67

!R (60|80|220|240)" W"
!A {printELU(yytext,0);}

Define NumexMsrElu003a [ [{60} | {80} | {220} | {240}] { W} ] ;
Define NumexMsrElu003 [ NumexMsrElu003a   EndTag(NumexMsrElu) ] ; 68

!R ([0-9]+" "|[0-9]+[\,\.])?[0-9][0-9\-]*" "(kilo|m)?volt" "
!A {int i=0; printf("<NUMEX TYPE=\"MSR\" SBT=\"ELU\">"); 	for(;i<yyleng-1;putchar(yytext[i++])); printf("</NUMEX> "); }

Define NumexMsrElu004a
     [ (Ins(Nums) { } | Ins(Nums) [","|"."]) Num DigitDash* { } ({kilo} | {m}) {volt} ] ;
Define NumexMsrElu004 [ NumexMsrElu004a   RC({ })   EndTag(NumexMsrElu) ] ; 69

!R ([0-9\-]+" ")?(tio|fem|tjugo|[0-9][0-9\-\,]*)" "(milli)?amp[eèé]re
!A {printELU(yytext,0);}

Define NumexMsrElu005a
     [ (DigitDashes { }) [{tio} | {fem} | {tjugo} | Num [Num|"-"|","]*] { }
       ({milli}) {amp} ["e"|"è"|"é"] {re} ] ;
Define NumexMsrElu005 [ NumexMsrElu005a   EndTag(NumexMsrElu) ] ; 70

!R [0-9]+" "kW\/[0-9]+" "hk
!A {printELU(yytext,0);}

Define NumexMsrElu006a [ Ins(Nums) { kW/} Ins(Nums) { hk} ] ;
Define NumexMsrElu006 [ NumexMsrElu006a   EndTag(NumexMsrElu) ] ; 71

!R ([0-9]+|[0-9]+\,[0-9]+|[0-9]+" "[0-9]+)" lux"
!A {printELU(yytext,0);}

Define NumexMsrElu007a [ [Ins(Nums) | Ins(NumsCommaNums) | Ins(NumsSpNums)] { lux} ] ;
Define NumexMsrElu007 [ NumexMsrElu007a   EndTag(NumexMsrElu) ] ; 72

!R ([Mm]inst" "|[Mm]indre" än ")?[0-9]+" "[Jj]oule(" per "[^\n\t ]*meter)?
!A {printELU(yytext,0);}

Define NumexMsrElu008a
     [ (Mm {inst } | Mm {indre än }) Ins(Nums) { } Jj {oule} ({ per } NS* {meter}) ] ;
Define NumexMsrElu008 [ NumexMsrElu008a   EndTag(NumexMsrElu) ] ; 73

!R [Uu]pptill" "[0-9]+\-[0-9]+" "mA
!A {printELU(yytext,0);}

Define NumexMsrElu009a [ Uu {pptill } Ins(NumRange) { mA} ] ;
Define NumexMsrElu009 [ NumexMsrElu009a   EndTag(NumexMsrElu) ] ; 74

!R [0-9]+" "(kilo[Vv]olt|kV|kV:s|mA)
!A {printELU(yytext,0);}

Define NumexMsrElu010a
     [ Ins(Nums) { } [{kilo} Vv {olt} | {kV} | {kV:s} | {mA}] ] ;
Define NumexMsrElu010 [ NumexMsrElu010a   EndTag(NumexMsrElu) ] ; 75

!R ([Cc]yklar|till)" "[0-9]+" "W
!A {printELU(yytext,1);}

Define NumexMsrElu011a [ Ins(Nums) { W} ] ;
Define NumexMsrElu011
     [ NumexMsrElu011a
       LC([Cc {yklar} | {till}] { })
       EndTag(NumexMsrElu) ] ; 76

!R till" "[0-9]+W
!A {printELU(yytext,1);}

Define NumexMsrElu012a [ Ins(Nums) {W} ] ;
Define NumexMsrElu012
     [ NumexMsrElu012a
       LC({till })
       EndTag(NumexMsrElu) ] ; 77

!#  FREQUENCY 

!R [Vv]ar" "[1-9][0-9\-]*(e|\:e|\:de)" "([^\n ]*dag|sekund|minut|timme|timma|dag|vecka|veckan|månad|år)
!A {printFRQ(yytext,0);}

Define NumexMsrFrq001a
     [ Vv {ar } Num19 DigitDash* [{e} | {:e} | {:de}] { }
       [NS* {dag} | {sekund} | {minut} | {timme} | {timma} | {dag} | {vecka}
          | {veckan} | {månad} | {år}] ] ;
Define NumexMsrFrq001 [ NumexMsrFrq001a   EndTag(NumexMsrFrq) ] ; 78

!R [Vv]ar" "[0-9]\-[0-9]" "(minut|timme|timma)
!A {printFRQ(yytext,0);}

Define NumexMsrFrq002a
     [ Vv {ar } Num {-} Num { } [{minut} | {timme} | {timma}] ] ;
Define NumexMsrFrq002 [ NumexMsrFrq002a   EndTag(NumexMsrFrq) ] ; 79

!R ([Vv]arannan" \, ")?[Vv]ar" "[^\n\t ]*(femt|fjärd|tredj|ond)e" "([^\n ]*dag|sekund|minut|timme|timma|dag|vecka|månad)
!A {printFRQ(yytext,0);}

Define NumexMsrFrq003a
     [ (Vv {arannan , }) Vv {ar } NS* [{femt} | {fjärd} | {tredj} | {ond}]
       {e }
       [NS* {dag} | {sekund} | {minut} | {timme} | {timma} | {dag} | {vecka}
          | {månad}] ] ;
Define NumexMsrFrq003 [ NumexMsrFrq003a   EndTag(NumexMsrFrq) ] ; 80

!R [Vv]arannan" "(sekund|minut|timme|timma|dag|helg|vecka|månad)
!A {printFRQ(yytext,0);}

Define NumexMsrFrq004a
     [ Vv {arannan }
       [{sekund} | {minut} | {timme} | {timma} | {dag} | {helg} | {vecka}
          | {månad}] ] ;
Define NumexMsrFrq004 [ NumexMsrFrq004a   EndTag(NumexMsrFrq) ] ; 81

!R ([Hh]ögst" "|under" "|över" ")?([0-9]+\,[0-9]+±[0-9]+\,[0-9]+|[0-9]+x[0-9]+|[0-9]+\/[0-9\,]+|[0-9\-]+" "[0-9\-]+|[0-9]+" \- "[0-9]+|[1-9]+" \, "[0-9]+|[0-9]+|[0-9]+\,[0-9]+|[0-9]+\.[0-9]+|[0-9]+\-[0-9]+|[Tt]vå|[Tt]re|[Ff]yra|[Ff]em|tusen|[Ff]lera)" "(gånger|ggr)"\/"(day|kg\/dag|kg\/day|kg\/min|kg\/timme|min|timme|dygn|vecka|dag|dagl|dagligen|mån|månaden|v)(" i en vecka"|" i "[^\n ]+" veckor"|" sista dygnet")?
!A {printFRQ(yytext,0);}

Define NumexMsrFrq005a
     [ (Hh {ögst } | {under } | {över })
       [Ins(NumsCommaNums) {±} Ins(NumsCommaNums) | Ins(Nums) {x} Ins(Nums)
          | Ins(Nums) {/} DigitCommas | DigitDashes { } DigitDashes | Ins(NumsSpRange)
          | Num19+ { , } Ins(Nums) | Ins(Nums) | Ins(NumsCommaNums) | Ins(NumsDotNums) | Ins(NumRange)
          | Tt {vå} | Tt {re} | Ff {yra} | Ff {em} | {tusen} | Ff {lera}]
       { } [{gånger} | {ggr}] {/}
       [{day} | {kg/dag} | {kg/day} | {kg/min} | {kg/timme} | {min}
          | {timme} | {dygn} | {vecka} | {dag} | {dagl} | {dagligen} | {mån}
          | {månaden} | {v}]
       ({ i en vecka} | { i } Ins(Word) { veckor} | { sista dygnet}) ] ;
Define NumexMsrFrq005 [ NumexMsrFrq005a   EndTag(NumexMsrFrq) ] ; 82

!R ([Hh]ögst" "|under" "|över" ")?([0-9]+\,[0-9]+±[0-9]+\,[0-9]+|[0-9]+x[0-9]+|[0-9]+\/[0-9\,]+|[0-9\-]+" "[0-9\-]+|[0-9]+" \- "[0-9]+|[1-9]+" \, "[0-9]+|[0-9]+|[0-9]+\,[0-9]+|[0-9]+\.[0-9]+|[0-9]+\-[0-9]+|{NUM}|[Ee]"tt par"|[Ee]"tt fåtal"|tusen|[Ff]lera|[Nn]ågon|En)" "(gånger|ggr|gång|timme|timmar)" per "(minut|min|timme|månad|dygn|vecka|dag|dagligen|år|århundrade)
!A {printFRQ(yytext,0);}

Define NumexMsrFrq006a
     [ (Hh {ögst } | {under } | {över })
       [Ins(NumsCommaNums) {±} Ins(NumsCommaNums) | Ins(Nums) {x} Ins(Nums)
          | Ins(Nums) {/} DigitCommas | DigitDashes { } DigitDashes | Ins(NumsSpRange)
          | Num19+ { , } Ins(Nums) | Ins(Nums) | Ins(NumsCommaNums) | Ins(NumsDotNums) | Ins(NumRange)
          | Ins(NUM) | Ee {tt par} | Ee {tt fåtal} | {tusen} | Ff {lera} | Nn {ågon}
          | {En}]
       { } [{gånger} | {ggr} | {gång} | {timme} | {timmar}] { per }
       [{minut} | {min} | {timme} | {månad} | {dygn} | {vecka} | {dag}
          | {dagligen} | {år} | {århundrade}] ] ;
Define NumexMsrFrq006 [ NumexMsrFrq006a   EndTag(NumexMsrFrq) ] ; 83

!R ([Hh]ögst" "|under" "|över" ")?([0-9]+\,[0-9]+±[0-9]+\,[0-9]+|[0-9]+x[0-9]+|[0-9]+\/[0-9\,]+|[0-9\-]+" "[0-9\-]+|[0-9]+" \- "[0-9]+|[1-9]+" \, "[0-9]+|[0-9]+|[0-9]+\,[0-9]+|[0-9]+\.[0-9]+|[0-9]+\-[0-9]+|{NUM}|{NUM}"\-"{NUM}|{NUM}" till "{NUM}|[Ee]"tt par"|[Ee]"tt fåtal"|tusen|[Ff]lera|[Ee]n" eller två")" "(gånger|ggr|gång)" "("varje natt"|"sista dygnet"|dagligen|om" "dagen|"om året")
!A {printFRQ(yytext,0);}

Define NumexMsrFrq007a
     [ (Hh {ögst } | {under } | {över })
       [Ins(NumsCommaNums) {±} Ins(NumsCommaNums) | Ins(Nums) {x} Ins(Nums)
          | Ins(Nums) {/} DigitCommas | DigitDashes { } DigitDashes | Ins(NumsSpRange)
          | Num19+ { , } Ins(Nums) | Ins(Nums) | Ins(NumsCommaNums) | Ins(NumsDotNums) | Ins(NumRange)
          | Ins(NUM) | Ins(NUM) {-} Ins(NUM) | Ins(NUM) { till } Ins(NUM) | Ee {tt par} | Ee {tt fåtal}
          | {tusen} | Ff {lera} | Ee {n eller två}]
       { } [{gånger} | {ggr} | {gång}] { }
       [{varje natt} | {sista dygnet} | {dagligen} | {om dagen} | {om året}] ] ;
Define NumexMsrFrq007 [ NumexMsrFrq007a   EndTag(NumexMsrFrq) ] ; 84

!R ([Hh]ögst" "|under" "|över" ")?([0-9]+\,[0-9]+±[0-9]+\,[0-9]+|[0-9]+x[0-9]+|[0-9]+\/[0-9\,]+|[0-9\-]+" "[0-9\-]+|[0-9]+" \- "[0-9]+|[1-9]+" \, "[0-9]+|[0-9]+|[0-9]+\,[0-9]+|[0-9]+\.[0-9]+|[0-9]+\-[0-9]+|{NUM}|{NUM}\-{NUM}|tusen|[Ff]lera)" "(gånger|ggr|gång)" i "(sekunden|timmen|dagligen|vecka|veckan|månaden)
!A {printFRQ(yytext,0);}

Define NumexMsrFrq008a
     [ (Hh {ögst } | {under } | {över })
       [Ins(NumsCommaNums) {±} Ins(NumsCommaNums) | Ins(Nums) {x} Ins(Nums)
          | Ins(Nums) {/} DigitCommas | DigitDashes { } DigitDashes | Ins(NumsSpRange)
          | Num19+ { , } Ins(Nums) | Ins(Nums) | Ins(NumsCommaNums) | Ins(NumsDotNums) | Ins(NumRange)
          | Ins(NUM) | Ins(NUM) {-} Ins(NUM) | {tusen} | Ff {lera}]
       { } [{gånger} | {ggr} | {gång}] { i }
       [{sekunden} | {timmen} | {dagligen} | {vecka} | {veckan} | {månaden}] ] ;
Define NumexMsrFrq008 [ NumexMsrFrq008a   EndTag(NumexMsrFrq) ] ; 85

!R ([0-9]+\-)?[0-9]+([km]g|g)"\/d"(ygn)?
!A {printFRQ(yytext,0);}

Define NumexMsrFrq009a
     [ (Ins(Nums) {-}) Ins(Nums) [["k"|"m"] {g} | {g}] {/d} ({ygn}) ] ;
Define NumexMsrFrq009 [ NumexMsrFrq009a   EndTag(NumexMsrFrq) ] ; 86

!R ([Mm]inst" ")?([0-9][+-9\-]*" min")" om dagen"
!A {printFRQ(yytext,0);}

Define NumexMsrFrq010a
     [ (Mm {inst }) Num
       ["+"|","|"-"|"."|"/"|"0"|"1"|"2"|"3"|"4"|"5"|"6"|"7"|"8"|"9"|"-"]*
       { min om dagen} ] ;
Define NumexMsrFrq010 [ NumexMsrFrq010a   EndTag(NumexMsrFrq) ] ; 87

!R [0-9]+" gång\/vecka"
!A {printFRQ(yytext,0);}

Define NumexMsrFrq011a [ Ins(Nums) { gång/vecka} ] ;
Define NumexMsrFrq011 [ NumexMsrFrq011a   EndTag(NumexMsrFrq) ] ; 88

!R (under" "|över" ")?[0-9]+(gång|gånger|ggr)"\/"(day|kg\/dag|kg\/day|kg\/min|kg\/timme|min|timme|dygn|vecka|dag|dagl|dagligen|mån|månaden|månad)
!A {printFRQ(yytext,0);}

Define NumexMsrFrq012a
     [ ({under } | {över }) Ins(Nums) [{gång} | {gånger} | {ggr}] {/}
       [{day} | {kg/dag} | {kg/day} | {kg/min} | {kg/timme} | {min}
          | {timme} | {dygn} | {vecka} | {dag} | {dagl} | {dagligen} | {mån}
          | {månaden} | {månad}] ] ;
Define NumexMsrFrq012 [ NumexMsrFrq012a   EndTag(NumexMsrFrq) ] ; 89

!R [A-ZÅÄÖa-zåäö]+" gånger med "[0-9]\-[0-9]" minuters intervall"
!A {printFRQ(yytext,0);}

Define NumexMsrFrq013a
     [ [UppercaseAlpha|LowercaseAlpha]+ { gånger med } Num {-} Num
       { minuters intervall} ] ;
Define NumexMsrFrq013 [ NumexMsrFrq013a   EndTag(NumexMsrFrq) ] ; 90

!R (1g\/mån|2ggr|1ggr\/V|1g\/v)
!A {printFRQ(yytext,0);}

Define NumexMsrFrq014a [ {1g/mån} | {2ggr} | {1ggr/V} | {1g/v} ] ;
Define NumexMsrFrq014 [ NumexMsrFrq014a   EndTag(NumexMsrFrq) ] ; 91

!R "gäller allt oftare"
!A {printFRQ(yytext,1);}

Define NumexMsrFrq015a [ {allt oftare} ] ;
Define NumexMsrFrq015
     [ NumexMsrFrq015a
       LC({gäller })
       EndTag(NumexMsrFrq) ] ; 92

!R "\, året runt"
!A {printf(", <NUMEX TYPE=\"MSR\" SBT=\"FRQ\">året runt</NUMEX>"); }

Define NumexMsrFrq016 [ {året runt}   LC({, })   EndTag(NumexMsrFrq) ] ; 93

!R {NUM}" dagar i "veckan
!A {printFRQ(yytext,0);}

Define NumexMsrFrq017a [ Ins(NUM) { dagar i veckan} ] ;
Define NumexMsrFrq017 [ NumexMsrFrq017a   EndTag(NumexMsrFrq) ] ; 94

!R {NUM}" och en halv gånger"
!A {printFRQ(yytext,0);}

Define NumexMsrFrq018a [ Ins(NUM) { och en halv gånger} ] ;
Define NumexMsrFrq018 [ NumexMsrFrq018a   EndTag(NumexMsrFrq) ] ; 95

!R [Vv]ar" tredje \, fjärde "(dag|månad)
!A {printFRQ(yytext,0);}

Define NumexMsrFrq019a [ Vv {ar tredje , fjärde } [{dag} | {månad}] ] ;
Define NumexMsrFrq019 [ NumexMsrFrq019a   EndTag(NumexMsrFrq) ] ; 96

!R [Vv]ar" tredje till fjärde "(dag|månad)
!A {printFRQ(yytext,0);}

Define NumexMsrFrq020a [ Vv {ar tredje till fjärde } [{dag} | {månad}] ] ;
Define NumexMsrFrq020 [ NumexMsrFrq020a   EndTag(NumexMsrFrq) ] ; 97

!R [Ff]rekvens" bilat "[0-9]+\/min
!A {printFRQ(yytext,2);}

Define NumexMsrFrq021a [ Ins(Nums) {/min} ] ;
Define NumexMsrFrq021
     [ NumexMsrFrq021a
       LC(Ff {rekvens bilat })
       EndTag(NumexMsrFrq) ] ; 98

!R [Ff]rekvens" "[0-9]+\/min
!A {printFRQ(yytext,1);}

Define NumexMsrFrq022a [ Ins(Nums) {/min} ] ;
Define NumexMsrFrq022
     [ NumexMsrFrq022a
       LC(Ff {rekvens })
       EndTag(NumexMsrFrq) ] ; 99

!R [0-9]+" år i rad"
!A {printFRQ(yytext,0);}

Define NumexMsrFrq023a [ Ins(Nums) { år i rad} ] ;
Define NumexMsrFrq023 [ NumexMsrFrq023a   EndTag(NumexMsrFrq) ] ; 100

!R [Vv]ar" "[1-9]\:?dje" "(år|vecka|månad)
!A {printFRQ(yytext,0);}

Define NumexMsrFrq024a
     [ Vv {ar } Num19 ({:}) {dje } [{år} | {vecka} | {månad}] ] ;
Define NumexMsrFrq024 [ NumexMsrFrq024a   EndTag(NumexMsrFrq) ] ; 101

!R ([Mm]inst" ")?({NUM}|[0-9]+|[0-9]+\-[0-9]+)" "(minuter|timmar|dagar|h)\/(månad|vecka|månaden|veckan)
!A {printFRQ(yytext,0);}

Define NumexMsrFrq025a
     [ (Mm {inst }) [Ins(NUM) | Ins(Nums) | Ins(NumRange)] { }
       [{minuter} | {timmar} | {dagar} | {h}] {/}
       [{månad} | {vecka} | {månaden} | {veckan}] ] ;
Define NumexMsrFrq025 [ NumexMsrFrq025a   EndTag(NumexMsrFrq) ] ; 102

!R [Vv]arannan" "dag" i "[^\n ]+" "dagar
!A {printFRQ(yytext,0);}

Define NumexMsrFrq026a [ Vv {arannan dag i } Ins(Word) { dagar} ] ;
Define NumexMsrFrq026 [ NumexMsrFrq026a   EndTag(NumexMsrFrq) ] ; 103

!R {NUM}" "dagar\/vecka" i "[^\n ]+" "veckor
!A {printFRQ(yytext,0);}

Define NumexMsrFrq027a [ Ins(NUM) { dagar/vecka i } Ins(Word) { veckor} ] ;
Define NumexMsrFrq027 [ NumexMsrFrq027a   EndTag(NumexMsrFrq) ] ; 104

!R {NUM}" "dagar" i "veckan
!A {printFRQ(yytext,0);}

Define NumexMsrFrq028a [ Ins(NUM) { dagar i veckan} ] ;
Define NumexMsrFrq028 [ NumexMsrFrq028a   EndTag(NumexMsrFrq) ] ; 105

!R [Ff]rekvens" "[a-z]+" "[0-9]+\/min
!A {printFRQ(yytext,1);}

Define NumexMsrFrq029a [ Ins(LowerWord) { } Ins(Nums) {/min} ] ;
Define NumexMsrFrq029
     [ NumexMsrFrq029a
       LC(Ff {rekvens })
       EndTag(NumexMsrFrq) ] ; 106

!R [Ff]rekv\.?" "[a-z]+" "[0-9]+(\/min)?
!A {printFRQ(yytext,1);}

Define NumexMsrFrq030a [ Ins(LowerWord) { } Ins(Nums) ({/min}) ] ;
Define NumexMsrFrq030
     [ NumexMsrFrq030a
       LC(Ff {rekv} ({.}) { })
       EndTag(NumexMsrFrq) ] ; 107

!R (Mer" än"|[Hh]ögst|[Uu]nder)" "[^\n< ]+" timmar per "dag
!A {printFRQ(yytext,0);}

Define NumexMsrFrq031a
     [ [{Mer än} | Hh {ögst} | Uu {nder}] { } Ins(Word) { timmar per dag} ] ;
Define NumexMsrFrq031 [ NumexMsrFrq031a   EndTag(NumexMsrFrq) ] ; 108

!R [Ii]" "genomsnitt" "[^\n\t< ]+" "(veckor|dagar|år|månader)
!A {printFRQ(yytext,0);}

Define NumexMsrFrq032a
     [ Ii { genomsnitt } Ins(Word) { } [{veckor} | {dagar} | {år} | {månader}] ] ;
Define NumexMsrFrq032 [ NumexMsrFrq032a   EndTag(NumexMsrFrq) ] ; 109

!R ([Åå]rligen|[Dd]agligen|[Vv]eckovis|[Mm]ånadsvis|[Tt]idvis|[Pp]eriodvis)
!A {printFRQ(yytext,0);}

Define NumexMsrFrq033a
     [ ["Å"|"å"] {rligen} | Dd {agligen} | Vv {eckovis} | Mm {ånadsvis}
       | Tt {idvis} | Pp {eriodvis} ] ;
Define NumexMsrFrq033 [ NumexMsrFrq033a   EndTag(NumexMsrFrq) ] ; 110

!#  Metric surface Unit - MSU 

!R ([Uu]ppemot" "|[Pp]å" "|[Öö]ver" "|[Uu]nder" "|[Mm]"inst "|[Uu]"ngefär "|[Oo]"mkring "|[Dd]"rygt "|[Cc]"irka "|[Dd]ryga" "|[Ff]rån" ")?[0-9]+([\,\.0-9\-\_]+|" "[0-9]+)?" "("miljoner ")?(mikrometer|kvadrat[^\n\t ]*meter|mm2|cm2|hkr|m2|km2|hektar|hektaren|tunnland)
!A {printMSU(yytext,0);}

Define NumexMsrMsu001a
     [ (Uu {ppemot } | Pp {å } | ["Ö"|"ö"] {ver } | Uu {nder } | Mm {inst }
         | Uu {ngefär } | Oo {mkring } | Dd {rygt } | Cc {irka } | Dd {ryga }
         | Ff {rån })
       Ins(Nums) ([Num|","|"."|"-"|"_"]+ | { } Ins(Nums)) { } ({miljoner })
       [{mikrometer} | {kvadrat} NS* {meter} | {mm2} | {cm2} | {hkr} | {m2}
          | {km2} | {hektar} | {hektaren} | {tunnland}] ] ;
Define NumexMsrMsu001 [ NumexMsrMsu001a   EndTag(NumexMsrMsu) ] ; 111

!R ([Uu]ppemot" "|[Pp]å" "|[Öö]ver" "|[Uu]nder" "|[Mm]"inst "|[Uu]"ngefär "|[Oo]"mkring "|[Dd]"rygt "|[Cc]"irka "|"dryga "|[Ff]"rån "){NUM}" "(mikrometer|kvadrat[^\n\t ]*meter|mm2|cm2|hkr|m2|km2|hektar|hektaren|tunnland)
!A {printMSU(yytext,0);}

Define NumexMsrMsu002a
     [Uu {ppemot } | Pp {å } | ["Ö"|"ö"] {ver } | Uu {nder } | Mm {inst }
        | Uu {ngefär } | Oo {mkring } | Dd {rygt } | Cc {irka } | {dryga }
        | Ff {rån }]
     Ins(NUM) { }
     [{mikrometer} | {kvadrat} NS* {meter} | {mm2} | {cm2} | {hkr} | {m2}
        | {km2} | {hektar} | {hektaren} | {tunnland}] ;
Define NumexMsrMsu002 [ NumexMsrMsu002a   EndTag(NumexMsrMsu) ] ; 112

!R båt" på "[0-9]+" fot"
!A {printMSU(yytext,1);}

Define NumexMsrMsu003a [ {på } Ins(Nums) { fot} ] ;
Define NumexMsrMsu003
     [ NumexMsrMsu003a
       LC({båt })
       EndTag(NumexMsrMsu) ] ; 113

!R {NUM}" tomma kvadratmeter"
!A {printMSU(yytext,0);}

Define NumexMsrMsu004a [ Ins(NUM) { tomma kvadratmeter} ] ;
Define NumexMsrMsu004 [ NumexMsrMsu004a   EndTag(NumexMsrMsu) ] ; 114

!R [Jj]ag" är "[12]"\,"[0-9][0-9]
!A {printMSU(yytext,2);}

Define NumexMsrMsu005a [ Num12 {,} Ins(Nums2) ] ;
Define NumexMsrMsu005
     [ NumexMsrMsu005a
       LC(Jj {ag är })
       EndTag(NumexMsrMsu) ] ; 115

!R ([Cc]irka" ")?[0-9]+" "[0-9]+" km²"
!A {printMSU(yytext,0);}

Define NumexMsrMsu006a [ (Cc {irka }) Ins(NumsSpNums) { km²} ] ;
Define NumexMsrMsu006 [ NumexMsrMsu006a   EndTag(NumexMsrMsu) ] ; 116

!R [0-9][x\.][0-9]" "inch(es)?
!A {printMSU(yytext,0);}

Define NumexMsrMsu007a [ Num ["x"|"."] Num { inch} ({es}) ] ;
Define NumexMsrMsu007 [ NumexMsrMsu007a   EndTag(NumexMsrMsu) ] ; 117

!#  

!R "BMI Pop"
!A {ECHO;}

Define Except002 [ {BMI Pop} ] ; 118

!R volym" "[0-9]+(\.[0-9]+)?" "[^\n\t ]L
!A {printVLM(yytext,0);}

Define NumexMsrVlm001a [ {volym } Ins(Nums) ({.} Ins(Nums)) { } NS {L} ] ;
Define NumexMsrVlm001 [ NumexMsrVlm001a   EndTag(NumexMsrVlm) ] ; 119

!R "BMI "[0-9]+[0-9\-\,]*(" eller mer"|" ±"[0-9]+|" kg\/m2")?
!A {printVLM(yytext,0);}

Define NumexMsrVlm002a
     [ {BMI } Ins(Nums) [Num|"-"|","]* ({ eller mer} | { ±} Ins(Nums) | { kg/m2}) ] ;
Define NumexMsrVlm002 [ NumexMsrVlm002a   EndTag(NumexMsrVlm) ] ; 120

!R (vid|på)" "[0-9\-]+" BMI"
!A {printVLM(yytext,1);}

Define NumexMsrVlm003a [ DigitDashes { BMI} ] ;
Define NumexMsrVlm003
     [ NumexMsrVlm003a
       LC([{vid} | {på}] { })
       EndTag(NumexMsrVlm) ] ; 121

!R (BMI|BMI\-värde)" "("\, över"|"\&lt\;"|"\&gt\;"|"mindre än"|över|under|på" "minst)" "[0-9\,]*[0-9](" kg\/m2")?
!A {printVLM(yytext,0);}

Define NumexMsrVlm004a
     [ [{BMI} | {BMI-värde}] { }
       [{, över} | {&lt;} | {&gt;} | {mindre än} | {över} | {under}
          | {på minst}]
       { } DigitComma* Num ({ kg/m2}) ] ;
Define NumexMsrVlm004 [ NumexMsrVlm004a   EndTag(NumexMsrVlm) ] ; 122

!R "BMI mellan "[0-9\,\-]*[0-9]" och "[0-9\,\-]*[0-9]
!A {printVLM(yytext,0);}

Define NumexMsrVlm005a
     [ {BMI mellan } [Num|","|"-"]* Num { och } [Num|","|"-"]* Num ] ;
Define NumexMsrVlm005 [ NumexMsrVlm005a   EndTag(NumexMsrVlm) ] ; 123

!R "BMI "[0-9][0-9\-\,]*(" eller mer"|" ±"[0-9]+|" kg\/m2")?
!A {printVLM(yytext,0);}

Define NumexMsrVlm006a
     [ {BMI } Num [Num|"-"|","]* ({ eller mer} | { ±} Ins(Nums) | { kg/m2}) ] ;
Define NumexMsrVlm006 [ NumexMsrVlm006a   EndTag(NumexMsrVlm) ] ; 124

!R "BMI \( Body Mass Index ) på "[0-9\,\-]+(" eller mer")?
!A {printVLM(yytext,0);}

Define NumexMsrVlm007a
     [ {BMI ( Body Mass Index ) på } [Num|","|"-"]+ ({ eller mer}) ] ;
Define NumexMsrVlm007 [ NumexMsrVlm007a   EndTag(NumexMsrVlm) ] ; 125

!R [1-9]0" BMI"
!A {printVLM(yytext,0);}

Define NumexMsrVlm008a [ Num19 {0 BMI} ] ;
Define NumexMsrVlm008 [ NumexMsrVlm008a   EndTag(NumexMsrVlm) ] ; 126

!R (BMI|[Bb]ody" "[Mm]ass" "[Ii]ndex)" på "[0-9\-\,\/]+(±[1-9])?
!A {printVLM(yytext,0);}

Define NumexMsrVlm009a
     [ [{BMI} | Bb {ody } Mm {ass } Ii {ndex}] { på } [Num|"-"|","|"/"]+
       ({±} Num19) ] ;
Define NumexMsrVlm009 [ NumexMsrVlm009a   EndTag(NumexMsrVlm) ] ; 127

!R ([Mm]edel\-BMI|BMI|[Bb]ody" "[Mm]ass" "[Ii]ndex|[Bb]odymassindex)(et)?
!A {printVLM(yytext,0);}

Define NumexMsrVlm010a
     [ [Mm {edel-BMI} | {BMI} | Bb {ody } Mm {ass } Ii {ndex}
          | Bb {odymassindex}]
       ({et}) ] ;
Define NumexMsrVlm010 [ NumexMsrVlm010a   EndTag(NumexMsrVlm) ] ; 128

!R BMI" "[0-9]+\.[0-9](±[0-9])?
!A {printVLM(yytext,0);}

Define NumexMsrVlm011a [ {BMI } Ins(Nums) {.} Num ({±} Num) ] ;
Define NumexMsrVlm011 [ NumexMsrVlm011a   EndTag(NumexMsrVlm) ] ; 129

!R BMI" "[0-9]+\.[0-9](\-[0-9]+\.[0-9])(" kg\/m2")?
!A {printVLM(yytext,0);}

Define NumexMsrVlm012a
     [ {BMI } Ins(Nums) {.} Num {-} Ins(Nums) {.} Num ({ kg/m2}) ] ;
Define NumexMsrVlm012 [ NumexMsrVlm012a   EndTag(NumexMsrVlm) ] ; 130

!R [Ii]ndex" är "(under|över)" "[0-9][0-9\-\,\/]*
!A {printVLM(yytext,2);}

Define NumexMsrVlm013a [ [{under} | {över}] { } Num [Num|"-"|","|"/"]* ] ;
Define NumexMsrVlm013
     [ NumexMsrVlm013a
       LC(Ii {ndex är })
       EndTag(NumexMsrVlm) ] ; 131

!R \±" "[0-9]+\.[0-9]+" kg\/m2"
!A {printVLM(yytext,0);}

Define NumexMsrVlm014a [ {± } Ins(NumsDotNums) { kg/m2} ] ;
Define NumexMsrVlm014 [ NumexMsrVlm014a   EndTag(NumexMsrVlm) ] ; 132

!R [0-9]+" kg\/m2"
!A {printVLM(yytext,0);}

Define NumexMsrVlm015a [ Ins(Nums) { kg/m2} ] ;
Define NumexMsrVlm015 [ NumexMsrVlm015a   EndTag(NumexMsrVlm) ] ; 133

!R BMI" = "[0-9]+(\/kg\/m2)?
!A {printVLM(yytext,0);}

Define NumexMsrVlm016a [ {BMI = } Ins(Nums) ({/kg/m2}) ] ;
Define NumexMsrVlm016 [ NumexMsrVlm016a   EndTag(NumexMsrVlm) ] ; 134

!R BMI" >"[0-9]+" eller \>= "[0-9]+
!A {printVLM(yytext,0);}

Define NumexMsrVlm017a [ {BMI >} Ins(Nums) { eller >= } Ins(Nums) ] ;
Define NumexMsrVlm017 [ NumexMsrVlm017a   EndTag(NumexMsrVlm) ] ; 135

!R ([Nn]ästan" "|[Mm]inst" "|[Cc]irka" "|[Cc]\:a" "|ca" "|[Ff]rån" "|till" "|[Dd]"rygt "|[Bb]"ara "|[Uu]ngefär" "|[Oo]mkring" "|[Uu]"pp till "|[Pp]"å cirka "|[Pp]å" "|[Uu]"nder ")?([0-9]+" eller "|[0-9]+" till "|[1-9][0-9]+" "|[0-9]" respektive ")?([0-9][0-9\-\,\.\/]*[0-9]+|[0-9]+|[0-9]+" "[0-9]+|[Tt]vå|[Tt]re|[Ff]yra|[Ss]ex|[Ff]em|[Ss]ju|[Åå]tta|[Nn]io|[Tt]io|[Tt]olv|[^\n\t ]*[Hh]undra|[Tt]"vå hundra"|[Tt]"re hundra"|[Ff]"yra hundra"|[Ff]"em hundra"|[Ee]n" halv"|[Nn]"ågra hundra"|[Nn]"ågra få"|flera|"för varje"|[Ee]"tt "[^\n\t ]+tal|miljoner)" "[^\n\t ]*(mil|mils|centimeter|meters|m|meter|[kcmd]m)" "(tjock|bred|brett)(e|a|t)?
!A {printVLM(yytext,0);}

Define NumexMsrVlm018a
     [ (Nn {ästan } | Mm {inst } | Cc {irka } | Cc {:a } | {ca } | Ff {rån }
         | {till } | Dd {rygt } | Bb {ara } | Uu {ngefär } | Oo {mkring }
         | Uu {pp till } | Pp {å cirka } | Pp {å } | Uu {nder })
       (Ins(Nums) { eller } | Ins(Nums) { till } | Num19 Ins(Nums) { } | Num { respektive })
       [Num [Num|"-"|","|"."|"/"]* Ins(Nums) | Ins(Nums) | Ins(NumsSpNums) | Tt {vå}
          | Tt {re} | Ff {yra} | Ss {ex} | Ff {em} | Ss {ju} | ["Å"|"å"] {tta}
          | Nn {io} | Tt {io} | Tt {olv} | NS* Hh {undra} | Tt {vå hundra}
          | Tt {re hundra} | Ff {yra hundra} | Ff {em hundra} | Ee {n halv}
          | Nn {ågra hundra} | Nn {ågra få} | {flera} | {för varje}
          | Ee {tt } Word {tal} | {miljoner}]
       { } NS*
       [{mil} | {mils} | {centimeter} | {meters} | {m} | {meter}
          | ["k"|"c"|"m"|"d"] {m}]
       { } [{tjock} | {bred} | {brett}] ({e} | {a} | {t}) ] ;
Define NumexMsrVlm018 [ NumexMsrVlm018a   EndTag(NumexMsrVlm) ] ; 136

!R ([Nn]ästan" "|[Mm]inst" "|[Cc]irka" "|[Cc]\:a" "|ca" "|[Ff]rån" "|till" "|[Dd]"rygt "|[Bb]"ara "|[Uu]ngefär" "|[Oo]mkring" "|[Uu]"pp till "|[Pp]"å cirka "|[Pp]å" "|[Uu]"nder ")?([0-9]+" eller "|[0-9]+" till "|[1-9][0-9]+" "|[0-9]" respektive ")?([0-9][0-9\-\,\.\/]*[0-9]+|[0-9]+)" cm2\/m2"
!A {printVLM(yytext,0);}

Define NumexMsrVlm019a
     [ (Nn {ästan } | Mm {inst } | Cc {irka } | Cc {:a } | {ca } | Ff {rån }
         | {till } | Dd {rygt } | Bb {ara } | Uu {ngefär } | Oo {mkring }
         | Uu {pp till } | Pp {å cirka } | Pp {å } | Uu {nder })
       (Ins(Nums) { eller } | Ins(Nums) { till } | Num19 Ins(Nums) { } | Num { respektive })
       [Num [Num|"-"|","|"."|"/"]* Ins(Nums) | Ins(Nums)] { cm2/m2} ] ;
Define NumexMsrVlm019 [ NumexMsrVlm019a   EndTag(NumexMsrVlm) ] ; 137

!#  Length Unit - LNU 

!R ([Nn]ästan" "|[Mm]inst" "|[Cc]irka" "|[Cc]\:a" "|ca" "|[Ff]rån" "|till" "|[Dd]"rygt "|[Bb]"ara "|[Uu]ngefär" "|[Oo]mkring" "|[Uu]"pp till "|[Pp]"å cirka "|[Pp]å" "|[Uu]"nder "|[Uu]"pptill ")?([0-9]+" x "|[0-9]+" eller "|[0-9]+" till "|[1-9][0-9]+" "|[0-9]" respektive "|[0-9]" resp "|{NUM}" eller ")?([0-9][0-9\-\,\.\/]*[0-9]+|[0-9]+|[0-9]+" "[0-9]+|[Tt]vå|[Tt]re|[Ff]yra|[Ss]ex|[Ff]em|[Ss]ju|[Åå]tta|[Nn]io|[Tt]io|[Tt]olv|[^\n\t ]*[Hh]undra|[Tt]"vå hundra"|[Tt]"re hundra"|[Ff]"yra hundra"|[Ff]"em hundra"|[Ee]n" halv"|[Nn]"ågra hundra"|[Nn]"ågra få"|flera|"för varje"|[Ee]"tt "[^\n\t ]+tal|miljoner|[^\n\t ]*[Tt]usen)" "[^\n\t ]*(kilometre|mil|mils|centimeter|meters|meters|m|meter|[kcmd]m)" "(stor|lång|hög|djup|höjd|havsdjup|bort|avstånd|håll)(e|a|t)?
!A {printDST(yytext,0);}

Define NumexMsrDst001a
     [ (Nn {ästan } | Mm {inst } | Cc {irka } | Cc {:a } | {ca } | Ff {rån }
         | {till } | Dd {rygt } | Bb {ara } | Uu {ngefär } | Oo {mkring }
         | Uu {pp till } | Pp {å cirka } | Pp {å } | Uu {nder } | Uu {pptill })
       (Ins(Nums) { x } | Ins(Nums) { eller } | Ins(Nums) { till } | Num19 Ins(Nums) { }
         | Num { respektive } | Num { resp } | Ins(NUM) { eller })
       [Num [Num|"-"|","|"."|"/"]* Ins(Nums) | Ins(Nums) | Ins(NumsSpNums) | Tt {vå}
          | Tt {re} | Ff {yra} | Ss {ex} | Ff {em} | Ss {ju} | ["Å"|"å"] {tta}
          | Nn {io} | Tt {io} | Tt {olv} | NS* Hh {undra} | Tt {vå hundra}
          | Tt {re hundra} | Ff {yra hundra} | Ff {em hundra} | Ee {n halv}
          | Nn {ågra hundra} | Nn {ågra få} | {flera} | {för varje}
          | Ee {tt } Word {tal} | {miljoner} | NS* Tt {usen}]
       { } NS*
       [{kilometre} | {mil} | {mils} | {centimeter} | {meters} | {m}
          | {meter} | ["k"|"c"|"m"|"d"] {m}]
       { }
       [{stor} | {lång} | {hög} | {djup} | {höjd} | {havsdjup} | {bort}
          | {avstånd} | {håll}]
       ({e} | {a} | {t}) ] ;
Define NumexMsrDst001 [ NumexMsrDst001a   EndTag(NumexMsrDst) ] ; 138

!R ([Kk]"nappa "|[Nn]ästan" "|[Mm]inst" "|[Cc]irka" "|[Cc]\:a" "|ca" "|[Ff]rån" "|till" "|[Dd]"rygt "|[Bb]"ara "|[Uu]ngefär" "|[Oo]mkring" "|[Uu]"pp till "|[Pp]"å cirka "|[Pp]å" "|"på över "|[Pp]"å ca "|[Uu]"nder "|[Öö]"ver ")?([0-9]+" eller "|[0-9]+" och "|[Mm]ellan" "[0-9]+" och "|[0-9]+" respektive "|[0-9]+" till ")?([1-9][0-9]*" ")?([Nn]ågra|[Tt]vå|[Tt]re|[Ff]yra|[Ss]ex|[Ff]em|[Ss]ju|[Åå]tta|[Nn]io|[Tt]io|[Tt]olv|[0-9]+|[Ee]"tt par hundra"|[Nn]"ågra hundra"|[^\n ]*[Hh]undra|[Ee]n" halv"|[Ee]ttusen|[Ee]tt" par"|[Ee]n" dryg"|"bara en"|[0-9]+\/[0-9]+|[0-9]+" "[0-9]+\/[0-9]+|[0-9]+"x"[0-9]+|[0-9]+" \- "[0-9]+|[0-9][0-9\-\,\.]*[0-9]+|[Ee]"tt "[^\n\t ]+tal|[^\n\t ]+ton)" "("miljoner "|"miljarder ")?([Kkcd]m|kilometer|centimeter|[^\n\t ]*[Mm]eter|[^\n\t ]*meterna|[^\n\t ]*metrarna)(\/t[a-z]*)?
!A {printDST(yytext,0);}

Define NumexMsrDst002a
     [ (Kk {nappa } | Nn {ästan } | Mm {inst } | Cc {irka } | Cc {:a }
         | {ca } | Ff {rån } | {till } | Dd {rygt } | Bb {ara } | Uu {ngefär }
         | Oo {mkring } | Uu {pp till } | Pp {å cirka } | Pp {å } | {på över }
         | Pp {å ca } | Uu {nder } | ["Ö"|"ö"] {ver })
       (Ins(Nums) { eller } | Ins(Nums) { och } | Mm {ellan } Ins(Nums) { och }
         | Ins(Nums) { respektive } | Ins(Nums) { till })
       (Num19 Num* { })
       [Nn {ågra} | Tt {vå} | Tt {re} | Ff {yra} | Ss {ex} | Ff {em}
          | Ss {ju} | ["Å"|"å"] {tta} | Nn {io} | Tt {io} | Tt {olv} | Ins(Nums)
          | Ee {tt par hundra} | Nn {ågra hundra} | NS* Hh {undra} | Ee {n halv}
          | Ee {ttusen} | Ee {tt par} | Ee {n dryg} | {bara en} | Ins(NumsSlashNums)
          | Ins(Nums) { } Ins(NumsSlashNums) | Ins(Nums) {x} Ins(Nums) | Ins(NumsSpRange)
          | Num [Num|"-"|","|"."]* Ins(Nums) | Ee {tt } Word {tal} | Word {ton}]
       { } ({miljoner } | {miljarder })
       [["K"|"k"|"c"|"d"] {m} | {kilometer} | {centimeter} | NS* Mm {eter}
          | NS* {meterna} | NS* {metrarna}]
       ({/t} Az*) ] ;
Define NumexMsrDst002 [ NumexMsrDst002a   EndTag(NumexMsrDst) ] ; 139

!# had to separate the 'mm' cause it was interefering with the mm>hg

!R ([Nn]ästan" "|[Mm]inst" "|[Cc]irka" "|[Cc]\:a" "|ca" "|[Ff]rån" "|till" "|[Dd]"rygt "|[Bb]"ara "|[Uu]ngefär" "|[Oo]mkring" "|[Uu]"pp till "|[Pp]"å cirka "|[Pp]å" "|"på över "|[Pp]"å ca "|[Uu]"nder "|[Öö]"ver ")?([0-9]+" eller "|[0-9]+" och "|[Mm]ellan" "[0-9]+" och "|[0-9]+" respektive "|[0-9]+" till ")?([1-9][0-9]*" ")?([Nn]ågra|[Tt]vå|[Tt]re|[Ff]yra|[Ss]ex|[Ff]em|[Ss]ju|[Åå]tta|[Nn]io|[Tt]io|[Tt]olv|[0-9]+|[Ee]"tt par hundra"|[Nn]"ågra hundra"|[^\n ]*[Hh]undra|[Ee]n" halv"|[Ee]tt" par"|[Ee]n" dryg"|"bara en"|[0-9]+" "[0-9]+\/[0-9]+|[0-9]+"x"[0-9]+|[0-9]+" \- "[0-9]+|[0-9][0-9\-\,\.]*[0-9]+|[Ee]"tt "[^\n\t ]+tal|[^\n\t ]+ton)" "("miljoner "|"miljarder ")?mm(\/t[a-z]*)?" "
!A {int i=0;
!A 	printf("<NUMEX TYPE=\"MSR\" SBT=\"DST\">");
!A 	for(;i<yyleng-1;putchar(yytext[i++])); printf("</NUMEX> "); }

Define NumexMsrDst003a
     [ (Nn {ästan } | Mm {inst } | Cc {irka } | Cc {:a } | {ca } | Ff {rån }
         | {till } | Dd {rygt } | Bb {ara } | Uu {ngefär } | Oo {mkring }
         | Uu {pp till } | Pp {å cirka } | Pp {å } | {på över } | Pp {å ca }
         | Uu {nder } | ["Ö"|"ö"] {ver })
       (Ins(Nums) { eller } | Ins(Nums) { och } | Mm {ellan } Ins(Nums) { och }
         | Ins(Nums) { respektive } | Ins(Nums) { till })
       (Num19 Num* { })
       [Nn {ågra} | Tt {vå} | Tt {re} | Ff {yra} | Ss {ex} | Ff {em}
          | Ss {ju} | ["Å"|"å"] {tta} | Nn {io} | Tt {io} | Tt {olv} | Ins(Nums)
          | Ee {tt par hundra} | Nn {ågra hundra} | NS* Hh {undra} | Ee {n halv}
          | Ee {tt par} | Ee {n dryg} | {bara en} | Ins(Nums) { } Ins(NumsSlashNums)
          | Ins(Nums) {x} Ins(Nums) | Ins(NumsSpRange) | Num [Num|"-"|","|"."]* Ins(Nums)
          | Ee {tt } Word {tal} | Word {ton}]
       { } ({miljoner } | {miljarder }) {mm} ({/t} Az*) ] ;
Define NumexMsrDst003 [ NumexMsrDst003a   RC({ })   EndTag(NumexMsrDst) ] ; 140

!R ([Nn]ästan" "|[Mm]inst" "|[Cc]irka" "|[Cc]\:a" "|ca" "|[Ff]rån" "|till" "|[Dd]"rygt "|[Bb]"ara "|[Uu]ngefär" "|[Oo]mkring" "|[Uu]"pp till "|[Pp]"å cirka "|[Pp]å" "|[Uu]"nder ")?([1-9][0-9]" ")?[0-9][0-9\-\,\.]*[0-9]" "("svenska "|"nautiska ")?[a-zåäö]*mil" "
!A {int i=0; printf("<NUMEX TYPE=\"MSR\" SBT=\"DST\">"); 	for(;i<yyleng-1;putchar(yytext[i++])); printf("</NUMEX>"); putchar(' ');}

Define NumexMsrDst004a
     [ (Nn {ästan } | Mm {inst } | Cc {irka } | Cc {:a } | {ca } | Ff {rån }
         | {till } | Dd {rygt } | Bb {ara } | Uu {ngefär } | Oo {mkring }
         | Uu {pp till } | Pp {å cirka } | Pp {å } | Uu {nder })
       (Num19X { }) Num [Num|"-"|","|"."]* Num { } ({svenska } | {nautiska })
       Lower* {mil} ] ;
Define NumexMsrDst004 [ NumexMsrDst004a   RC({ })   EndTag(NumexMsrDst) ] ; 141

!R (hundratal|[0-9]+" x "[0-9]+)" "[^\n\t ]*meter
!A {printDST(yytext,0);}

Define NumexMsrDst005a
     [ [{hundratal} | Ins(Nums) { x } Ins(Nums)] { } NS* {meter} ] ;
Define NumexMsrDst005 [ NumexMsrDst005a   EndTag(NumexMsrDst) ] ; 142

!R [Pp]å" "[0-9]+" m "
!A { int i=0; printf("<NUMEX TYPE=\"MSR\" SBT=\"DST\">");
!A 	for(;i<yyleng-1;putchar(yytext[i++])); printf("</NUMEX>"); putchar(' ');}

Define NumexMsrDst006a [ Pp {å } Ins(Nums) { m} ] ;
Define NumexMsrDst006 [ NumexMsrDst006a   RC({ })   EndTag(NumexMsrDst) ] ; 143

!R ([Cc]"entimeter för centimeter"|[Dd]en" "knappa" "kilometern|[Nn]ågon" "[^\n\t ]*meter|några" "[^\n\t ]*meter|[Ee]n" halvmil")
!A {printDST(yytext,0);}

Define NumexMsrDst007a
     [ Cc {entimeter för centimeter} | Dd {en knappa kilometern}
       | Nn {ågon } NS* {meter} | {några } NS* {meter} | Ee {n halvmil} ] ;
Define NumexMsrDst007 [ NumexMsrDst007a   EndTag(NumexMsrDst) ] ; 144

!R (två|tre|fyra|fem|sex|sju|åtta|nio|[0-9]+)" "(eller|och)" "(två|tre|fyra|fem|sex|sju|åtta|nio|tio|[0-9]+)" "[^\n\t ]*meters" "[a-zåäö]+
!A {printDST(yytext,0);}

Define NumexMsrDst008a
     [ [{två} | {tre} | {fyra} | {fem} | {sex} | {sju} | {åtta} | {nio}
          | Ins(Nums)]
       { } [{eller} | {och}] { }
       [{två} | {tre} | {fyra} | {fem} | {sex} | {sju} | {åtta} | {nio}
          | {tio} | Ins(Nums)]
       { } NS* {meters } LowerWord ] ;
Define NumexMsrDst008 [ NumexMsrDst008a   EndTag(NumexMsrDst) ] ; 145

!R ([0-9]+|{NUM})" "(miljarder|miljoner)" "ljusår
!A {printDST(yytext,0);}

Define NumexMsrDst009a
     [ [Ins(Nums) | Ins(NUM)] { } [{miljarder} | {miljoner}] { ljusår} ] ;
Define NumexMsrDst009 [ NumexMsrDst009a   EndTag(NumexMsrDst) ] ; 146

!R [0-9]+" "[0-9]+" ljusår"
!A {printDST(yytext,0);}

Define NumexMsrDst010a [ Ins(NumsSpNums) { ljusår} ] ;
Define NumexMsrDst010 [ NumexMsrDst010a   EndTag(NumexMsrDst) ] ; 147

!R [0-9]+" "(engelska" "mil|ljusår|distansminuter)
!A {printDST(yytext,0);}

Define NumexMsrDst011a
     [ Ins(Nums) { } [{engelska mil} | {ljusår} | {distansminuter}] ] ;
Define NumexMsrDst011 [ NumexMsrDst011a   EndTag(NumexMsrDst) ] ; 148

!R ([Kk]"nappt "|[Nn]"ästan "|[Cc]irka" "|[Uu]"pp till "|[Pp]"å knappt "|[Dd]"rygt ")?({NUM}" nautiska"|få" nautiska"|{NUM}|[Hh]undra|[^\n\t ]+tio)" "(sjö)?mil" "
!A {int i=0;
!A 	printf("<NUMEX TYPE=\"MSR\" SBT=\"DST\">");
!A 	for(;i<yyleng-1;putchar(yytext[i++])); printf("</NUMEX> "); }

Define NumexMsrDst012a
     [ (Kk {nappt } | Nn {ästan } | Cc {irka } | Uu {pp till }
         | Pp {å knappt } | Dd {rygt })
       [Ins(NUM) { nautiska} | {få nautiska} | Ins(NUM) | Hh {undra} | Word {tio}] { }
       ({sjö}) {mil} ] ;
Define NumexMsrDst012 [ NumexMsrDst012a   RC({ })   EndTag(NumexMsrDst) ] ; 149

!R ([Cc]irka|[Uu]"pp till"|[Nn]ästan|[Dd]rygt|[Pp]"å knappt"|[Dd]rygt)" "[^\n\t ]+" "(sjö)?mil" "
!A { int i=0;
!A 	printf("<NUMEX TYPE=\"MSR\" SBT=\"DST\">");
!A 	for(;i<yyleng-1;putchar(yytext[i++])); printf("</NUMEX> "); }

Define NumexMsrDst013a
     [ [Cc {irka} | Uu {pp till} | Nn {ästan} | Dd {rygt} | Pp {å knappt}] { }
       Ins(Word) { } ({sjö}) {mil} ] ;
Define NumexMsrDst013 [ NumexMsrDst013a   RC({ })   EndTag(NumexMsrDst) ] ; 150

!R [0-9]+" m ö h"
!A {printDST(yytext,0);}

Define NumexMsrDst014a [ Ins(Nums) { m ö h} ] ;
Define NumexMsrDst014 [ NumexMsrDst014a   EndTag(NumexMsrDst) ] ; 151

!R ([Hh]ögre|[Ll]ägre)" än "[0-9]\,[0-9]+
!A {printDST(yytext,2);}

Define NumexMsrDst015a [ Num {,} Ins(Nums) ] ;
Define NumexMsrDst015
     [ NumexMsrDst015a
       LC([Hh {ögre} | Ll {ägre}] { än })
       EndTag(NumexMsrDst) ] ; 152

!R [^\n\t ]*"hoppet på "[0-9]\,[0-9]+
!A {printDST(yytext,2);}

Define NumexMsrDst016a [ Num {,} Ins(Nums) ] ;
Define NumexMsrDst016
     [ NumexMsrDst016a
       LC({hoppet på })
       EndTag(NumexMsrDst) ] ; 153

!R [^\n\t ]+\-[^\n\t ]+" "sekundenheter
!A {printDST(yytext,0);}

Define NumexMsrDst017a [ Word {-} Ins(Word) { sekundenheter} ] ;
Define NumexMsrDst017 [ NumexMsrDst017a   EndTag(NumexMsrDst) ] ; 154

!R [0-9\,]+("x"[0-9\.\,]+)+" "[cm]m
!A {printDST(yytext,0);}

Define NumexMsrDst018a
     [ DigitCommas [{x} [Num|"."|","]+]+ { } ["c"|"m"] {m} ] ;
Define NumexMsrDst018 [ NumexMsrDst018a   EndTag(NumexMsrDst) ] ; 155

!R [0-9\,]+(" x "[0-9\.\,]+)+" "[cm]m
!A {printDST(yytext,0);}

Define NumexMsrDst019a
     [ DigitCommas [{ x } [Num|"."|","]+]+ { } ["c"|"m"] {m} ] ;
Define NumexMsrDst019 [ NumexMsrDst019a   EndTag(NumexMsrDst) ] ; 156

!R [^\n\t ]*måttet" "[0-9]+" x "[0-9]+" cm"
!A {printDST(yytext,1);}

Define NumexMsrDst020a [ Ins(Nums) { x } Ins(Nums) { cm} ] ;
Define NumexMsrDst020
     [ NumexMsrDst020a
       LC({måttet })
       EndTag(NumexMsrDst) ] ; 157

!R ca" "[0-9]+[cm]m" "
!A {int i=0; printf("<NUMEX TYPE=\"MSR\" SBT=\"DST\">"); 	for(;i<yyleng-1;putchar(yytext[i++])); printf("</NUMEX> "); }

Define NumexMsrDst021a [ {ca } Ins(Nums) ["c"|"m"] {m} ] ;
Define NumexMsrDst021 [ NumexMsrDst021a   RC({ })   EndTag(NumexMsrDst) ] ; 158

!R [Cc]irka" "[0-9]+" milen"
!A {printDST(yytext,0);}

Define NumexMsrDst022a [ Cc {irka } Ins(Nums) { milen} ] ;
Define NumexMsrDst022 [ NumexMsrDst022a   EndTag(NumexMsrDst) ] ; 159

!#  Coordinates - CRD 

!R [Ll]atitud" "[0-9]+" gr "[0-9]+" "min
!A {printCRD(yytext,1);}

Define NumexMsrCrd001a [ Ins(Nums) { gr } Ins(Nums) { min} ] ;
Define NumexMsrCrd001
     [ NumexMsrCrd001a
       LC(Ll {atitud })
       EndTag(NumexMsrCrd) ] ; 160

!R [0-9]+" graders "[^\n\t ]+" "latitud
!A {printCRD(yytext,0);}

Define NumexMsrCrd002a [ Ins(Nums) { graders } Ins(Word) { latitud} ] ;
Define NumexMsrCrd002 [ NumexMsrCrd002a   EndTag(NumexMsrCrd) ] ; 161

!R [Ll]atitud" "[NS]" "[0-9]+" "grader
!A {printCRD(yytext,1);}

Define NumexMsrCrd003a [ ["N"|"S"] { } Ins(Nums) { grader} ] ;
Define NumexMsrCrd003
     [ NumexMsrCrd003a
       LC(Ll {atitud })
       EndTag(NumexMsrCrd) ] ; 162

!R [Ll]ongitud" "[VÖ]" "[0-9]+" "grader
!A {printCRD(yytext,1);}

Define NumexMsrCrd004a [ ["V"|"Ö"] { } Ins(Nums) { grader} ] ;
Define NumexMsrCrd004
     [ NumexMsrCrd004a
       LC(Ll {ongitud })
       EndTag(NumexMsrCrd) ] ; 163

!R latitud" "(norr|ost)" "[0-9]+" "gr" "[0-9]+" "min(uter)?
!A {printCRD(yytext,1);}

Define NumexMsrCrd005a
     [ [{norr} | {ost}] { } Ins(Nums) { gr } Ins(Nums) { min} ({uter}) ] ;
Define NumexMsrCrd005
     [ NumexMsrCrd005a
       LC({latitud })
       EndTag(NumexMsrCrd) ] ; 164

!R (latituden|longituden)" "[0-9]+" "grader" \, "[0-9]+" "min(uter)?
!A {printCRD(yytext,1);}

Define NumexMsrCrd006a [ Ins(Nums) { grader , } Ins(Nums) { min} ({uter}) ] ;
Define NumexMsrCrd006
     [ NumexMsrCrd006a
       LC([{latituden} | {longituden}] { })
       EndTag(NumexMsrCrd) ] ; 165

!R koordinater" "[0-9]+\,[0-9]+\º" "[SNÖV]
!A {printCRD(yytext,1);}

Define NumexMsrCrd007a [ Ins(NumsCommaNums) {º } ["S"|"N"|"Ö"|"V"] ] ;
Define NumexMsrCrd007
     [ NumexMsrCrd007a
       LC({koordinater })
       EndTag(NumexMsrCrd) ] ; 166

!R koordinater" "[0-9]+([\,\.][0-9]+)?" "[SNÖV]
!A {printCRD(yytext,1);}

Define NumexMsrCrd008a [ Ins(Nums) ([","|"."] Ins(Nums)) { } ["S"|"N"|"Ö"|"V"] ] ;
Define NumexMsrCrd008
     [ NumexMsrCrd008a
       LC({koordinater })
       EndTag(NumexMsrCrd) ] ; 167

!R koordinater" "[0-9]+([\,\.][0-9]+)?" "[SNÖV]
!A {printCRD(yytext,1);}

Define NumexMsrCrd009a [ Ins(Nums) ([","|"."] Ins(Nums)) { } ["S"|"N"|"Ö"|"V"] ] ;
Define NumexMsrCrd009
     [ NumexMsrCrd009a
       LC({koordinater })
       EndTag(NumexMsrCrd) ] ; 168

!R [0-9]+\,[0-9]+\º" "[SNÖV]
!A {printCRD(yytext,1);}

Define NumexMsrCrd010a ["S"|"N"|"Ö"|"V"] ;
Define NumexMsrCrd010
     [ NumexMsrCrd010a
       LC(NumsCommaNums {º })
       EndTag(NumexMsrCrd) ] ; 169

!#  DEGREE DGR

!R ([Rr]"unt "|"över "|[Mm]"inus "|"plus "|"upp till "|"under "|"drygt "|[Nn]"ästan ")?(\+\-)?[0-9]+([\,\.\-0-9]+)?" graders "(lutning|vinkel)
!A {printDGR(yytext,0);}

Define NumexMsrDgr001a
     [ (Rr {unt } | {över } | Mm {inus } | {plus } | {upp till } | {under }
         | {drygt } | Nn {ästan })
       ({+-}) Ins(Nums) ([Num|","|"."|"-"]+) { graders } [{lutning} | {vinkel}] ] ;
Define NumexMsrDgr001 [ NumexMsrDgr001a   EndTag(NumexMsrDgr) ] ; 170

!R [^\n\t ]*vinkeln" mellan "[0-9]+" och "[0-9]+" "grader
!A {printDGR(yytext,1);}

Define NumexMsrDgr002a [ {mellan } Ins(Nums) { och } Ins(Nums) { grader} ] ;
Define NumexMsrDgr002
     [ NumexMsrDgr002a
       LC({vinkeln })
       EndTag(NumexMsrDgr) ] ; 171

!R [^\n\t ]*vinkel" "[a-zåäö]+" "[0-9]+("\-"|" \- ")[0-9]+" "grader
!A {printDGR(yytext,1);}

Define NumexMsrDgr003a
     [ Ins(LowerWord) { } Ins(Nums) [{-} | { - }] Ins(Nums) { grader} ] ;
Define NumexMsrDgr003
     [ NumexMsrDgr003a
       LC({vinkel })
       EndTag(NumexMsrDgr) ] ; 172

!R [^\n\t ]*vinkeln" "([0-9]+°|[0-9]+" "°)
!A {printDGR(yytext,1);}

Define NumexMsrDgr004a [ Ins(Nums) {°} | Ins(Nums) { °} ] ;
Define NumexMsrDgr004
     [ NumexMsrDgr004a
       LC({vinkeln })
       EndTag(NumexMsrDgr) ] ; 173

!R "360 grader"
!A {printDGR(yytext,0);}

Define NumexMsrDgr005a [ {360 grader} ] ;
Define NumexMsrDgr005 [ NumexMsrDgr005a   EndTag(NumexMsrDgr) ] ; 174

!R [Rr]otation" "[0-9]+o
!A {printDGR(yytext,1);}

Define NumexMsrDgr006a [ Ins(Nums) {o} ] ;
Define NumexMsrDgr006
     [ NumexMsrDgr006a
       LC(Rr {otation })
       EndTag(NumexMsrDgr) ] ; 175

!R ([Ee]xtension|[Ff]lexion)" "(ca" ")?[0-9\-]+" "grader
!A {printDGR(yytext,1);}

Define NumexMsrDgr007a [ ({ca }) DigitDashes { grader} ] ;
Define NumexMsrDgr007
     [ NumexMsrDgr007a
       LC([Ee {xtension} | Ff {lexion}] { })
       EndTag(NumexMsrDgr) ] ; 176

!R [0-9]+o" "flexion
!A {printDGR(yytext,0);}

Define NumexMsrDgr008a [ Ins(Nums) {o flexion} ] ;
Define NumexMsrDgr008 [ NumexMsrDgr008a   EndTag(NumexMsrDgr) ] ; 177

!R ([1-9]" \, "[0-9]|[1-9]|[1-9]\,[0-9]|fem|sex|åtta|sju|nio|[1-9]\.[0-9])" på "("den öppna ")?[Rr]ichter(\-skalan|skalan)
!A {printDEN(yytext,0);}

Define NumexMsrDns001a
     [Num19 { , } Num | Num19 | Num19 {,} Num | {fem} | {sex} | {åtta}
        | {sju} | {nio} | Num19 {.} Num]
     { på } ({den öppna }) Rr {ichter} [{-skalan} | {skalan}] ;
Define NumexMsrDns001 [ NumexMsrDns001a   EndTag(NumexMsrDns) ] ; 178

!R [Mm]ellan" "[0-9]" och "[0-9]+" dBA"
!A {printDEN(yytext,0);}

Define NumexMsrDns002a [ Mm {ellan } Num { och } Ins(Nums) { dBA} ] ;
Define NumexMsrDns002 [ NumexMsrDns002a   EndTag(NumexMsrDns) ] ; 179

!R ([0-9\-]+" "|[0-9\-]+" resp\. ")?[0-9][0-9\-\,\_]*" "(herz|dB|dBA|dBAHz|kilohertz|[Mm]egahertz|[Hh]ertz|MHz|Beaufort|Hz)
!A {printDEN(yytext,0);}

Define NumexMsrDns003a
     [ (DigitDashes { } | DigitDashes { resp. }) Num [Num|"-"|","|"_"]* { }
       [{herz} | {dB} | {dBA} | {dBAHz} | {kilohertz} | Mm {egahertz}
          | Hh {ertz} | {MHz} | {Beaufort} | {Hz}] ] ;
Define NumexMsrDns003 [ NumexMsrDns003a   EndTag(NumexMsrDns) ] ; 180

!R [Rr]ichtermagnituden" "[1-9](" \, "[0-9]|\,[0-9])?
!A {printDEN(yytext,0);}

Define NumexMsrDns004a
     [ Rr {ichtermagnituden } Num19 ({ , } Num | {,} Num) ] ;
Define NumexMsrDns004 [ NumexMsrDns004a   EndTag(NumexMsrDns) ] ; 181

!R ([0-9\-]+" ")?[0-9\-]+" "(ton" "trotyl|trotyl|ångström)
!A {printDEN(yytext,0);}

Define NumexMsrDns005a
     [ (DigitDashes { }) DigitDashes { }
       [{ton trotyl} | {trotyl} | {ångström}] ] ;
Define NumexMsrDns005 [ NumexMsrDns005a   EndTag(NumexMsrDns) ] ; 182

!R [0-9]+" "(decibel|db)
!A {printDEN(yytext,0);}

Define NumexMsrDns006a [ Ins(Nums) { } [{decibel} | {db}] ] ;
Define NumexMsrDns006 [ NumexMsrDns006a   EndTag(NumexMsrDns) ] ; 183

!R [0-9]+d[Bb]
!A {printDEN(yytext,0);}

Define NumexMsrDns007a [ Ins(Nums) {d} Bb ] ;
Define NumexMsrDns007 [ NumexMsrDns007a   EndTag(NumexMsrDns) ] ; 184

!R [0-9]+" av "[0-9]+" "(decibel|db)
!A {printDEN(yytext,0);}

Define NumexMsrDns008a [ Ins(Nums) { av } Ins(Nums) { } [{decibel} | {db}] ] ;
Define NumexMsrDns008 [ NumexMsrDns008a   EndTag(NumexMsrDns) ] ; 185

!R [0-9]+[Hh]z
!A {printDEN(yytext,0);}

Define NumexMsrDns009a [ Ins(Nums) Hh {z} ] ;
Define NumexMsrDns009 [ NumexMsrDns009a   EndTag(NumexMsrDns) ] ; 186

!#  TEMPERATURE 

!R ([Mm]ellan" ")?[\+\-]?[0-9\_]+(" "[0-9]+)?" "(och|till)" "[\+\-]?[0-9\_]+(" "[0-9]+)?" "grader
!A {printTMP(yytext,0);}

Define NumexMsrTmp001a
     [ (Mm {ellan }) (["+"|"-"]) DigitUscores ({ } Ins(Nums)) { } [{och} | {till}]
       { } (["+"|"-"]) DigitUscores ({ } Ins(Nums)) { grader} ] ;
Define NumexMsrTmp001 [ NumexMsrTmp001a   EndTag(NumexMsrTmp) ] ; 187

!R ([Vv]id" ")?(c\:a|[Kk]ring" "|[Bb]ortåt" "|minst" "|"strax under "|"cirka "|[Rr]"unt "|"över "|[Mm]"inus "|"plus "|"upp till "|"under "|"drygt "|[Nn]"ästan ")?[\+\-]?[0-9]+[\,\.\-0-9]*" grader "(plus|minus|[Cc]elsius|[Ff]ahrenheit|[Kk]elvin|varmt|kallt|C)
!A {printTMP(yytext,0);}

Define NumexMsrTmp002a
     [ (Vv {id })
       ({c:a} | Kk {ring } | Bb {ortåt } | {minst } | {strax under }
         | {cirka } | Rr {unt } | {över } | Mm {inus } | {plus } | {upp till }
         | {under } | {drygt } | Nn {ästan })
       (["+"|"-"]) Ins(Nums) [Num|","|"."|"-"]* { grader }
       [{plus} | {minus} | Cc {elsius} | Ff {ahrenheit} | Kk {elvin}
          | {varmt} | {kallt} | {C}] ] ;
Define NumexMsrTmp002 [ NumexMsrTmp002a   EndTag(NumexMsrTmp) ] ; 188

!R (c\:a|[Kk]ring" "|[Bb]ortåt" "|[Vv]id" "|minst" "|"strax under "|"cirka "|[Rr]"unt "|"över "|[Mm]"inus "|"plus "|"upp till "|"under "|"drygt "|[Nn]"ästan ")?(två|tre|fyra|fem|six|åtta|nio|[a-zå]*tio)" grader "(minus|C|[Cc]elsius|[Ff]ahrenheit|[Kk]elvin|varmt|kallt|plus)
!A {printTMP(yytext,0);}

Define NumexMsrTmp003a
     [ ({c:a} | Kk {ring } | Bb {ortåt } | Vv {id } | {minst }
         | {strax under } | {cirka } | Rr {unt } | {över } | Mm {inus }
         | {plus } | {upp till } | {under } | {drygt } | Nn {ästan })
       [{två} | {tre} | {fyra} | {fem} | {six} | {åtta} | {nio}
          | ["a"|"b"|"c"|"d"|"e"|"f"|"g"|"h"|"i"|"j"|"k"|"l"|"m"|"n"|"o"|"p"|"q"|"r"|"s"|"t"|"u"|"v"|"w"|"x"|"y"|"z"|"å"]*
            {tio}]
       { grader }
       [{minus} | {C} | Cc {elsius} | Ff {ahrenheit} | Kk {elvin} | {varmt}
          | {kallt} | {plus}] ] ;
Define NumexMsrTmp003 [ NumexMsrTmp003a   EndTag(NumexMsrTmp) ] ; 189

!R ([Vv]id" ")?(c\:a|[Kk]ring" "|[Bb]ortåt" "|minst" "|"strax under "|"cirka "|[Rr]"unt "|"över "|[Mm]"inus "|"plus "|"upp till "|"under "|"drygt "|[Nn]"ästan ")?[\+\-]?[0-9]+[\,\.\-0-9]*" grader "\°([Cc]|[Ff]|[Kk]|[Cc]elsius|[Ff]ahrenheit|[Kk]elvin)
!A {printTMP(yytext,0);}

Define NumexMsrTmp004a
     [ (Vv {id })
       ({c:a} | Kk {ring } | Bb {ortåt } | {minst } | {strax under }
         | {cirka } | Rr {unt } | {över } | Mm {inus } | {plus } | {upp till }
         | {under } | {drygt } | Nn {ästan })
       (["+"|"-"]) Ins(Nums) [Num|","|"."|"-"]* { grader °}
       [Cc | Ff | Kk | Cc {elsius} | Ff {ahrenheit} | Kk {elvin}] ] ;
Define NumexMsrTmp004 [ NumexMsrTmp004a   EndTag(NumexMsrTmp) ] ; 190

!R (c\:a|[Kk]ring" "|[Bb]ortåt" "|[Vv]id" "|minst" "|"strax under "|"cirka "|[Rr]"unt "|"över "|[Mm]"inus "|"plus "|"upp till "|"under "|"drygt "|[Nn]"ästan ")?[\+\-]?[0-9]+[\,\.\-0-9]*(\°|\°[Cc]|\°[Ff]|\°[Kk]|" °C"|"\° Celsius")(\.)?
!A {printTMP(yytext,0);}

Define NumexMsrTmp005a
     [ ({c:a} | Kk {ring } | Bb {ortåt } | Vv {id } | {minst }
         | {strax under } | {cirka } | Rr {unt } | {över } | Mm {inus }
         | {plus } | {upp till } | {under } | {drygt } | Nn {ästan })
       (["+"|"-"]) Ins(Nums) [Num|","|"."|"-"]*
       [{°} | {°} Cc | {°} Ff | {°} Kk | { °C} | {° Celsius}] ({.}) ] ;
Define NumexMsrTmp005 [ NumexMsrTmp005a   EndTag(NumexMsrTmp) ] ; 191

!R (c\:a|[Kk]ring" "|[Bb]ortåt" "|[Vv]id" "|minst" "|"strax under "|"cirka "|[Rr]"unt "|"över "|[Mm]"inus "|"plus "|"upp till "|"under "|"drygt "|[Nn]"ästan ")?[\+\-]?[0-9]+[\,\.\-0-9]*\°
!A {printTMP(yytext,0);}

Define NumexMsrTmp006a
     [ ({c:a} | Kk {ring } | Bb {ortåt } | Vv {id } | {minst }
         | {strax under } | {cirka } | Rr {unt } | {över } | Mm {inus }
         | {plus } | {upp till } | {under } | {drygt } | Nn {ästan })
       (["+"|"-"]) Ins(Nums) [Num|","|"."|"-"]* {°} ] ;
Define NumexMsrTmp006 [ NumexMsrTmp006a   EndTag(NumexMsrTmp) ] ; 192

!R (c\:a|[Kk]ring" "|[Bb]ortåt" "|[Vv]id" "|minst" "|"strax under "|"cirka "|[Rr]"unt "|"över "|[Mm]"inus "|"plus "|"upp till "|"under "|"drygt "|[Nn]"ästan "|[Bb]"ara ")?(\+|\-)?[0-9]+[\,\.\-0-9]*" "(grader|graders|minusgrader|plusgrader)
!A {printTMP(yytext,0);}

Define NumexMsrTmp007a
     [ ({c:a} | Kk {ring } | Bb {ortåt } | Vv {id } | {minst }
         | {strax under } | {cirka } | Rr {unt } | {över } | Mm {inus }
         | {plus } | {upp till } | {under } | {drygt } | Nn {ästan } | Bb {ara })
       ({+} | {-}) Ins(Nums) [Num|","|"."|"-"]* { }
       [{grader} | {graders} | {minusgrader} | {plusgrader}] ] ;
Define NumexMsrTmp007 [ NumexMsrTmp007a   EndTag(NumexMsrTmp) ] ; 193

!R [^\n\t ]*emperaturen" från "[a-zåäö]+" "[0-9]+" grader till "[a-zåäö]+" "[0-9]+" "grader
!A {printTMP(yytext,2);}

Define NumexMsrTmp008a
     [ Ins(LowerWord) { } Ins(Nums) { grader till } Ins(LowerWord) { } Ins(Nums) { grader} ] ;
Define NumexMsrTmp008
     [ NumexMsrTmp008a
       LC({emperaturen från })
       EndTag(NumexMsrTmp) ] ; 194

!R ([0-9]+" minus grader"|[0-9\,]+"\-gradiga vattnet"|[0-9\,]+"\-gradiga kylan")
!A {printTMP(yytext,0);}

Define NumexMsrTmp009a
     [ Ins(Nums) { minus grader} | DigitCommas {-gradiga vattnet}
       | DigitCommas {-gradiga kylan} ] ;
Define NumexMsrTmp009 [ NumexMsrTmp009a   EndTag(NumexMsrTmp) ] ; 195

!R ("strax under"|[Oo]mkring|högst|[Kk]ring|[Rr]unt|över|[Mm]inus|[Pp]lus|"upp till"|under|drygt|[Nn]ästan|minst)" "[0-9]+" "[a-z]*grader(" "minus)?
!A {printTMP(yytext,0);}

Define NumexMsrTmp010a
     [ [{strax under} | Oo {mkring} | {högst} | Kk {ring} | Rr {unt}
          | {över} | Mm {inus} | Pp {lus} | {upp till} | {under} | {drygt}
          | Nn {ästan} | {minst}]
       { } Ins(Nums) { } Az* {grader} ({ minus}) ] ;
Define NumexMsrTmp010 [ NumexMsrTmp010a   EndTag(NumexMsrTmp) ] ; 196

!R termometern" på "\-[0-9]+
!A {printTMP(yytext,1);}

Define NumexMsrTmp011a [ {på -} Ins(Nums) ] ;
Define NumexMsrTmp011
     [ NumexMsrTmp011a
       LC({termometern })
       EndTag(NumexMsrTmp) ] ; 197

!R ("strax under "|[Oo]mkring" "|högst" "|[Kk]ring" "|[Rr]unt" "|över" "|[Mm]inus" "|[Pp]lus" "|"upp till "|under" "|drygt" "|[Nn]ästan" "|minst" ")?"noll grader"
!A {printTMP(yytext,0);}

Define NumexMsrTmp012a
     [ ({strax under } | Oo {mkring } | {högst } | Kk {ring } | Rr {unt }
         | {över } | Mm {inus } | Pp {lus } | {upp till } | {under } | {drygt }
         | Nn {ästan } | {minst })
       {noll grader} ] ;
Define NumexMsrTmp012 [ NumexMsrTmp012a   EndTag(NumexMsrTmp) ] ; 198

!R [Ii]" drygt "[0-9]+\-gradig" värme"
!A {printTMP(yytext,0);}

Define NumexMsrTmp013a [ Ii { drygt } Ins(Nums) {-gradig värme} ] ;
Define NumexMsrTmp013 [ NumexMsrTmp013a   EndTag(NumexMsrTmp) ] ; 199

!R [0-9]+\°\-[0-9]+\°[CF]
!A {printTMP(yytext,0);}

Define NumexMsrTmp014a [ Ins(Nums) {°-} Ins(Nums) {°} ["C"|"F"] ] ;
Define NumexMsrTmp014 [ NumexMsrTmp014a   EndTag(NumexMsrTmp) ] ; 200

!R [0-9]+" "[Bb]tu\/min
!A {printTMP(yytext,0);}

Define NumexMsrTmp015a [ Ins(Nums) { } Bb {tu/min} ] ;
Define NumexMsrTmp015 [ NumexMsrTmp015a   EndTag(NumexMsrTmp) ] ; 201

!R "\+\/\- "[0-9]+"\°C"
!A {printTMP(yytext,0);}

Define NumexMsrTmp016a [ {+/- } Ins(Nums) {°C} ] ;
Define NumexMsrTmp016 [ NumexMsrTmp016a   EndTag(NumexMsrTmp) ] ; 202

!R \+[0-9]+" ºC eller "(lägre|högre)
!A {printTMP(yytext,0);}

Define NumexMsrTmp017a [ {+} Ins(Nums) { ºC eller } [{lägre} | {högre}] ] ;
Define NumexMsrTmp017 [ NumexMsrTmp017a   EndTag(NumexMsrTmp) ] ; 203

!R \+[0-9]+ºC
!A {printTMP(yytext,0);}

Define NumexMsrTmp018a [ {+} Ins(Nums) {ºC} ] ;
Define NumexMsrTmp018 [ NumexMsrTmp018a   EndTag(NumexMsrTmp) ] ; 204

!R [0-9]+ºC
!A {printTMP(yytext,0);}

Define NumexMsrTmp019a [ Ins(Nums) {ºC} ] ;
Define NumexMsrTmp019 [ NumexMsrTmp019a   EndTag(NumexMsrTmp) ] ; 205

!R [Tt]"emp \> "[0-9][0-9]\,[0-9]
!A {printTMP(yytext,2);}

Define NumexMsrTmp020a [ Ins(Nums2) {,} Num ] ;
Define NumexMsrTmp020
     [ NumexMsrTmp020a
       LC(Tt {emp > })
       EndTag(NumexMsrTmp) ] ; 206

!R "feber "[0-9][0-9]\,[0-9]
!A {printTMP(yytext,1);}

Define NumexMsrTmp021a [ Ins(Nums2) {,} Num ] ;
Define NumexMsrTmp021
     [ NumexMsrTmp021a
       LC({feber })
       EndTag(NumexMsrTmp) ] ; 207

!R ("c\:a"|[Cc]irka)" "[0-9]+\º
!A {printTMP(yytext,0);}

Define NumexMsrTmp022a [ [{c:a} | Cc {irka}] { } Ins(Nums) {º} ] ;
Define NumexMsrTmp022 [ NumexMsrTmp022a   EndTag(NumexMsrTmp) ] ; 208

!R "över "[0-9]+"\º C"
!A {printTMP(yytext,0);}

Define NumexMsrTmp023a [ {över } Ins(Nums) {º C} ] ;
Define NumexMsrTmp023 [ NumexMsrTmp023a   EndTag(NumexMsrTmp) ] ; 209

!R ([Tt]emp|[Tt]emperatur)" \( "[0-9]+(" \ºC"|" \º"|"\ºC"|"\º")
!A {printTMP(yytext,2);}

Define NumexMsrTmp024a [ Ins(Nums) [{ ºC} | { º} | {ºC} | {º}] ] ;
Define NumexMsrTmp024
     [ NumexMsrTmp024a
       LC([Tt {emp} | Tt {emperatur}] { ( })
       EndTag(NumexMsrTmp) ] ; 210

!R översteg" knappast "[0-9]+" grader"
!A {printTMP(yytext,1);}

Define NumexMsrTmp025a [ {knappast } Ins(Nums) { grader} ] ;
Define NumexMsrTmp025
     [ NumexMsrTmp025a
       LC({översteg })
       EndTag(NumexMsrTmp) ] ; 211

!R [Tt]emp\.?" "[0-9][0-9][\,\.][0-9]
!A {printTMP(yytext,1);}

Define NumexMsrTmp026a [ Ins(Nums2) [","|"."] Num ] ;
Define NumexMsrTmp026
     [ NumexMsrTmp026a
       LC(Tt {emp} ({.}) { })
       EndTag(NumexMsrTmp) ] ; 212

!R [Tt]emperaturen" "[a-zåäö]+" mellan "[0-9]+" och "[0-9]+" grader"
!A {printTMP(yytext,2);}

Define NumexMsrTmp027a [ {mellan } Ins(Nums) { och } Ins(Nums) { grader} ] ;
Define NumexMsrTmp027
     [ NumexMsrTmp027a
       LC(Tt {emperaturen } LowerWord { })
       EndTag(NumexMsrTmp) ] ; 213

!R (Nattemp|Dagstemp)" \: "[0-9][0-9]
!A {printTMP(yytext,2);}

Define NumexMsrTmp028a [ Ins(Nums2) ] ;
Define NumexMsrTmp028
     [ NumexMsrTmp028a
       LC([{Nattemp} | {Dagstemp}] { : })
       EndTag(NumexMsrTmp) ] ; 214

!R ([Tt]emp|[Tt]emperatur)" "[0-9][0-9\,]*(" \ºC"|" \º"|"\ºC"|"\º")
!A {printTMP(yytext,1);}

Define NumexMsrTmp029a [ Num DigitComma* [{ ºC} | { º} | {ºC} | {º}] ] ;
Define NumexMsrTmp029
     [ NumexMsrTmp029a
       LC([Tt {emp} | Tt {emperatur}] { })
       EndTag(NumexMsrTmp) ] ; 215

!#  PROCENT 

!R [Ss]å" många som "[0-9](\-[0-9]+)?" "(procent|\%)
!A {printPRC(yytext,0);}

Define NumexMsrPrc001a
     [ Ss {å många som } Num ({-} Ins(Nums)) { } [{procent} | {%}] ] ;
Define NumexMsrPrc001 [ NumexMsrPrc001a   EndTag(NumexMsrPrc) ] ; 216

!R (På" "|[Uu]"ppemot "|[Yy]"tterligare "|[Ee]"ndast "|[Mm]"inst "|[Nn]"ärmare "|[Kk]"nappt "|[Uu]"ngefär "|[Cc]irka" "|[Cc]a" "|[Bb]ara" "|[Cc]"\:a "|[Oo]mkring" "|[Nn]"ära "|[Öö]"ver "|[Uu]"nder ")?([Mm]inus" "|[Mm]"er än "|[Mm]"indre än "|[Rr]unt" "|[Hh]"ela "|[Dd]rygt" "|[Nn]ästan" "|[Uu]pp" till "|med" upp till "|med" "|[Pp]å" plus\/minus ")?([Cc]"irka ")?[^\n\t ]*([Mm]ellan" en"|[Ee]"ndast en"|[Tt]vå|[Tt]re|[Ff]yra|[Ff]em|[Ss]ex|[Ss]ju|[Åå]tta|[Nn]io|[Tt]io|[Ee]lva|[Tt]olv|retton|[Tt]jugo|jorton|tioen|[0-9]+|[0-9]+\,[0-9]+)" "(eller|till|respektive|och|vs|[Ff]rån" "[0-9]+" ± till"|mot)" "[^\n\t ]*("cirka en"|två|tre|fyra|fem|sex|sju|åtta|nio|tio|[0-9]+|[0-9]+\,[0-9]+)" "proc(enten|ent|\.|entenhet|entenheter)(\/år|" lägre"|" högre"|" respektive "[0-9]+" procent")?
!A {printPRC(yytext,0);}

Define NumexMsrPrc002a
     [ ({På } | Uu {ppemot } | Yy {tterligare } | Ee {ndast } | Mm {inst }
         | Nn {ärmare } | Kk {nappt } | Uu {ngefär } | Cc {irka } | Cc {a }
         | Bb {ara } | Cc {:a } | Oo {mkring } | Nn {ära } | ["Ö"|"ö"] {ver }
         | Uu {nder })
       (Mm {inus } | Mm {er än } | Mm {indre än } | Rr {unt } | Hh {ela }
         | Dd {rygt } | Nn {ästan } | Uu {pp till } | {med upp till } | {med }
         | Pp {å plus/minus })
       (Cc {irka }) NS*
       [Mm {ellan en} | Ee {ndast en} | Tt {vå} | Tt {re} | Ff {yra}
          | Ff {em} | Ss {ex} | Ss {ju} | ["Å"|"å"] {tta} | Nn {io} | Tt {io}
          | Ee {lva} | Tt {olv} | {retton} | Tt {jugo} | {jorton} | {tioen}
          | Ins(Nums) | Ins(NumsCommaNums)]
       { }
       [{eller} | {till} | {respektive} | {och} | {vs}
          | Ff {rån } Ins(Nums) { ± till} | {mot}]
       { } NS*
       [{cirka en} | {två} | {tre} | {fyra} | {fem} | {sex} | {sju} | {åtta}
          | {nio} | {tio} | Ins(Nums) | Ins(NumsCommaNums)]
       { proc} [{enten} | {ent} | {.} | {entenhet} | {entenheter}]
       ({/år} | { lägre} | { högre} | { respektive } Ins(Nums) { procent}) ] ;
Define NumexMsrPrc002 [ NumexMsrPrc002a   EndTag(NumexMsrPrc) ] ; 217

!R ([Uu]"ppemot "|[Yy]"tterligare "|[Ee]"ndast "|[Mm]"inst "|[Nn]"ärmare "|[Kk]"nappt "|[Uu]"ngefär "|[Cc]irka" "|[Cc]a" "|[Bb]ara" "|[Cc]"\:a "|[Oo]mkring" "|[Nn]"ära "|[Öö]"ver "|[Uu]"nder ")?([Mm]"er än "|[Mm]indre" än "|[Rr]unt" "|[Hh]"ela "|[Dd]rygt" "|[Nn]ästan" "|[Uu]pp" till "|[Pp]å" plus\/minus ")?([0-9]+" eller "|[0-9]+" till "|[0-9]+\,[0-9]+" vs "|[0-9]+" vs "|"över "|med" upp till "|med" "|[Ff]rån" "[0-9]+" ± till")?[^\n\t ]*([Tt]vå|[Tt]re|[Ff]yra|[Ff]em|[Ss]ex|[Ss]ju|[Åå]tta|[Nn]io|[Tt]io|tioen|[Ee]lva|[Tt]olv|tretton|fjorton|[0-9]+|[0-9]+\,[0-9]+|"en kvarts"|[Nn]"ågra få"|hundra)" "proc(enten|ent|\.|entenhet|entenheter)?(\/år)?
!A {printPRC(yytext,0);}

Define NumexMsrPrc003a
     [ (Uu {ppemot } | Yy {tterligare } | Ee {ndast } | Mm {inst }
         | Nn {ärmare } | Kk {nappt } | Uu {ngefär } | Cc {irka } | Cc {a }
         | Bb {ara } | Cc {:a } | Oo {mkring } | Nn {ära } | ["Ö"|"ö"] {ver }
         | Uu {nder })
       (Mm {er än } | Mm {indre än } | Rr {unt } | Hh {ela } | Dd {rygt }
         | Nn {ästan } | Uu {pp till } | Pp {å plus/minus })
       (Ins(Nums) { eller } | Ins(Nums) { till } | Ins(NumsCommaNums) { vs } | Ins(Nums) { vs }
         | {över } | {med upp till } | {med } | Ff {rån } Ins(Nums) { ± till})
       NS*
       [Tt {vå} | Tt {re} | Ff {yra} | Ff {em} | Ss {ex} | Ss {ju}
          | ["Å"|"å"] {tta} | Nn {io} | Tt {io} | {tioen} | Ee {lva} | Tt {olv}
          | {tretton} | {fjorton} | Ins(Nums) | Ins(NumsCommaNums) | {en kvarts}
          | Nn {ågra få} | {hundra}]
       { proc} ({enten} | {ent} | {.} | {entenhet} | {entenheter}) ({/år}) ] ;
Define NumexMsrPrc003 [ NumexMsrPrc003a   EndTag(NumexMsrPrc) ] ; 218

!R ([Uu]"ppemot "|[Yy]"tterligare "|[Ee]"ndast "|[Mm]"inst "|[Nn]"ärmare "|[Kk]"nappt "|[Uu]"ngefär "|[Cc]irka" "|[Cc]a" "|[Bb]ara" "|[Cc]"\:a "|[Oo]mkring" "|[Nn]"ära "|[Öö]"ver "|[Uu]"nder ")?([Mm]"er än "|[Mm]"indre än "|[Rr]unt" "|[Hh]"ela "|[Dd]rygt" "|[Nn]ästan" "|[Uu]pp" till "|[Mm]ellan" "[0-9]+" och "|med" upp till "|[0-9]+\%" vs "|[0-9]+" vs "|med" "|med" \> "|med" \< "|[Ff]rån" "[0-9]+" ± till "|[Pp]å" plus\/minus ")?([Cc]"irka ")?([0-9]+"\+"[0-9]+|[0-9]+"±"[0-9]+|[0-9]+[\.\,][0-9]+\-[0-9]+|[0-9]+[\.\,][0-9]+\-[0-9]+[\.\,][0-9]+|[0-9]\-[0-9]+[\.\,\-][0-9]+|[0-9]+[\.\,\-][0-9]+|[0-9]+|[0-9]+" till "[0-9]+)(" \%"|\%)(\-enheter|\/år)?
!A {printPRC(yytext,0);}

Define NumexMsrPrc004a
     [ (Uu {ppemot } | Yy {tterligare } | Ee {ndast } | Mm {inst }
         | Nn {ärmare } | Kk {nappt } | Uu {ngefär } | Cc {irka } | Cc {a }
         | Bb {ara } | Cc {:a } | Oo {mkring } | Nn {ära } | ["Ö"|"ö"] {ver }
         | Uu {nder })
       (Mm {er än } | Mm {indre än } | Rr {unt } | Hh {ela } | Dd {rygt }
         | Nn {ästan } | Uu {pp till } | Mm {ellan } Ins(Nums) { och }
         | {med upp till } | Ins(Nums) {% vs } | Ins(Nums) { vs } | {med } | {med > }
         | {med < } | Ff {rån } Ins(Nums) { ± till } | Pp {å plus/minus })
       (Cc {irka })
       [Ins(Nums) {+} Ins(Nums) | Ins(Nums) {±} Ins(Nums) | Ins(Nums) ["."|","] Ins(NumRange)
          | Ins(Nums) ["."|","] Ins(NumRange) ["."|","] Ins(Nums)
          | Num {-} Ins(Nums) ["."|","|"-"] Ins(Nums) | Ins(Nums) ["."|","|"-"] Ins(Nums) | Ins(Nums)
          | Ins(Nums) { till } Ins(Nums)]
       [{ %} | {%}] ({-enheter} | {/år}) ] ;
Define NumexMsrPrc004 [ NumexMsrPrc004a   EndTag(NumexMsrPrc) ] ; 219

!R ([Uu]"ppemot "|[Yy]"tterligare "|[Ee]"ndast "|[Mm]"inst "|[Nn]"ärmare "|[Kk]"nappt "|[Uu]"ngefär "|[Cc]irka" "|[Cc]a" "|[Bb]ara" "|[Cc]"\:a "|[Oo]mkring" "|[Mm]elln" "[0-9]+" och "|[Nn]"ära "|[Öö]"ver "|[Uu]"nder ")?([Mm]"er än "|[Mm]"indre än "|[Rr]unt" "|[Hh]"ela "|[Dd]rygt" "|[Nn]ästan" "|[Uu]pp" till "|med" upp till "|med" "|[Ff]rån" "[0-9]+" ± till"|[0-9]+" respective ")?([Cc]"irka ")?[0-9]+" \- "[0-9]+(" \%"|\%)(\-enheter|\/år)?
!A {printPRC(yytext,0);}

Define NumexMsrPrc005a
     [ (Uu {ppemot } | Yy {tterligare } | Ee {ndast } | Mm {inst }
         | Nn {ärmare } | Kk {nappt } | Uu {ngefär } | Cc {irka } | Cc {a }
         | Bb {ara } | Cc {:a } | Oo {mkring } | Mm {elln } Ins(Nums) { och }
         | Nn {ära } | ["Ö"|"ö"] {ver } | Uu {nder })
       (Mm {er än } | Mm {indre än } | Rr {unt } | Hh {ela } | Dd {rygt }
         | Nn {ästan } | Uu {pp till } | {med upp till } | {med }
         | Ff {rån } Ins(Nums) { ± till} | Ins(Nums) { respective })
       (Cc {irka }) Ins(NumsSpRange) [{ %} | {%}] ({-enheter} | {/år}) ] ;
Define NumexMsrPrc005 [ NumexMsrPrc005a   EndTag(NumexMsrPrc) ] ; 220

!R (\+|\-)[0-9]\,[0-9]\%(\-enheter|\/år)?
!A {printPRC(yytext,0);}

Define NumexMsrPrc006a
     [ [{+} | {-}] Num {,} Num {%} ({-enheter} | {/år}) ] ;
Define NumexMsrPrc006 [ NumexMsrPrc006a   EndTag(NumexMsrPrc) ] ; 221

!R (sänker|höjer)" med "[0-9]+" punkter"
!A {printPRC(yytext,2);}

Define NumexMsrPrc007a [ Ins(Nums) { punkter} ] ;
Define NumexMsrPrc007
     [ NumexMsrPrc007a
       LC([{sänker} | {höjer}] { med })
       EndTag(NumexMsrPrc) ] ; 222

!R [0-9]+"\:e och "[0-9]+"\:e percentilen"
!A {printPRC(yytext,0);}

Define NumexMsrPrc008a [ Ins(Nums) {:e och } Ins(Nums) {:e percentilen} ] ;
Define NumexMsrPrc008 [ NumexMsrPrc008a   EndTag(NumexMsrPrc) ] ; 223

!R ([Uu]"ppemot "|[Yy]"tterligare "|[Ee]"ndast "|[Mm]"inst "|[Nn]"ärmare "|[Kk]"nappt "|[Uu]"ngefär "|[Cc]irka" "|[Cc]a" "|[Bb]ara" "|[Cc]"\:a "|[Oo]mkring" "|[Nn]"ära "|[Öö]"ver "|[Uu]"nder ")?[0-9]+"\:e percentilen"
!A {printPRC(yytext,0);}

Define NumexMsrPrc009a
     [ (Uu {ppemot } | Yy {tterligare } | Ee {ndast } | Mm {inst }
         | Nn {ärmare } | Kk {nappt } | Uu {ngefär } | Cc {irka } | Cc {a }
         | Bb {ara } | Cc {:a } | Oo {mkring } | Nn {ära } | ["Ö"|"ö"] {ver }
         | Uu {nder })
       Ins(Nums) {:e percentilen} ] ;
Define NumexMsrPrc009 [ NumexMsrPrc009a   EndTag(NumexMsrPrc) ] ; 224

!R [^\n ]*tusentals" procent"
!A {printPRC(yytext,0);}

Define NumexMsrPrc010a [ NS* {tusentals procent} ] ;
Define NumexMsrPrc010 [ NumexMsrPrc010a   EndTag(NumexMsrPrc) ] ; 225

!R [0-9]+[\.\,][0-9]+\-procent
!A {printPRC(yytext,0);}

Define NumexMsrPrc011a [ Ins(Nums) ["."|","] Ins(Nums) {-procent} ] ;
Define NumexMsrPrc011 [ NumexMsrPrc011a   EndTag(NumexMsrPrc) ] ; 226

!R [Mm]"indre än ±"[0-9]+" %"
!A {printPRC(yytext,0);}

Define NumexMsrPrc012a [ Mm {indre än ±} Ins(Nums) { %} ] ;
Define NumexMsrPrc012 [ NumexMsrPrc012a   EndTag(NumexMsrPrc) ] ; 227

!#  CURRENCY 

!R [0-9]+\/[0-9]+" av "[0-9]+" kr"\.?
!A {printCUR(yytext,0);}

Define NumexMsrCur001a [ Ins(NumsSlashNums) { av } Ins(Nums) { kr} ({.}) ] ;
Define NumexMsrCur001 [ NumexMsrCur001a   EndTag(NumexMsrCur) ] ; 228

!R ([Kk]"nappt "|[Uu]"ngefär "|[Uu]ppemot" "|[Rr]unt" "|[Dd]rygt" "|[Mm]"inst "|[Nn]"ärmare "|[Uu]pp" till "|[Oo]"mkring "|[Cc]irka" "|[Öö]ver" "|[Kk]"ring ")?([^\n ]*[Hh]undra|[Ee]tt" par hundra"|[Ee]n|[Ee]n" "halv|flera" "hundra)" "milj(on|ard)(er)?" "([a-zåäö]+ska" ")?(pund|lire|peso|litas|rubler|"schweiz franc"|rupees|rupier|rupiah|yen|[Ee]uro|lira|kronorna|[Kk]ronor|öre|[^\n\t ]*dollar|Dmark|D\-mark|kr\.|kr|[^\n\t ]*franc|yuan|shilling|skillingar|skilling)(s)?
!A {printCUR(yytext,0);}

Define NumexMsrCur002a
     [ (Kk {nappt } | Uu {ngefär } | Uu {ppemot } | Rr {unt } | Dd {rygt }
         | Mm {inst } | Nn {ärmare } | Uu {pp till } | Oo {mkring } | Cc {irka }
         | ["Ö"|"ö"] {ver } | Kk {ring })
       [NS* Hh {undra} | Ee {tt par hundra} | Ee {n} | Ee {n halv}
          | {flera hundra}]
       { milj} [{on} | {ard}] ({er}) { } (LowerWord {ska })
       [{pund} | {lire} | {peso} | {litas} | {rubler} | {schweiz franc}
          | {rupees} | {rupier} | {rupiah} | {yen} | Ee {uro} | {lira}
          | {kronorna} | Kk {ronor} | {öre} | NS* {dollar} | {Dmark} | {D-mark}
          | {kr.} | {kr} | NS* {franc} | {yuan} | {shilling} | {skillingar}
          | {skilling}]
       ({s}) ] ;
Define NumexMsrCur002 [ NumexMsrCur002a   EndTag(NumexMsrCur) ] ; 229

!R ([Kk]"nappa "|[Kk]"nappt "|[Uu]"ngefär "|[Uu]ppemot" "|Runt" "|[Mm]"inst "|[Nn]"ärmare "|[Pp]å" över "|[Öö]ver" "|[Uu]pp" till "|[Oo]"mkring "|[Uu]nder" "|[Cc]irka" "|[Mm]ellan" "[0-9]+"\, "[0-9]+" och "|[Mm]ellan" "[0-9]+" "[0-9]+" och "|[Mm]ellan" "[0-9]+" och "|[Dd]"rygt "|[Ff]rån" "[0-9\,]+" till "|"av "{NUM}" till "|[Ff]rån" "[0-9]+" "[0-9]+" till "|"mot minus "|[Mm]"indre än ")?([Mm]"ånga miljarder "|[Ff]"lera hundra "|[Ee]"tt par hundra "|"tolv "|"elva "|"flera "|[^\n\t ]+ton" "|[^\n\t ]*tio" "|{NUM}\-{NUM}" "|{NUM}" "|[^\n\t ]+tals" "|[0-9]+" eller "[0-9]+" "|[0-9]+" "[0-9]+\-[0-9]+" "[0-9]+" "|[0-9]+[\-\:\,\.\_][0-9]+" "|[0-9]+" "[0-9]+" "[0-9]+" "|[1-9]\-[1-9]\,[1-9]|[0-9]+" "[0-9]+" "|[0-9]+" "|[0-9]+\-[0-9]+" "|[0-9]+\-[0-9]+" "[0-9]+" "|[0-9]+" "\,[0-9]+" "|[0-9]+" \. "[0-9]+" "|[0-9]+\:[0-9]+\-[0-9]+\:[0-9]+" "|\-[0-9]+" "|[^\n\t ]*tusen" "|[Mm]ånga" tusen "|[Hh]undra" ")([^\n\t ]*iljoner" "|[^\n\t ]*illion" "|[^\n\t ]*iljarder" "|[^\n\t ]*iljard" "|[^\n\t ]*iljon" "|milj" "|[^\n\t ]*iljader" "|[^\n\t ]*tusen" "|[^\n\t ]*hundra" ")?([a-zåäö]+ska" ")?(won|spänn|yuan|rupees|cent|kopek|rubel|pund|lire|rand|peso|rubler|lira|"estniska kroon"|"US dollar"|US\-cent|shilling|"schweiz franc"|[Rr]inggit|dirham|rupier|skilling|skillingar|litas|dukater|riksbankdaler|riksdaler|pence|rupiah|[^\n\t ]*dollar|yen|[Mm]kr|Mdkr|krona|Mkr\.|[Ee]uro|kronorna|DKK|SEK|MSEK|EUR|[Kk]ronor|öre|D\-mark|kr\.|kr|centimes|[^\n\t ]*franc|dollars)(s)?(\/[a-zå]+)?(" till "[0-9]+\:[0-9]+" dollar"|" till "[0-9]+\:[0-9]+)?
!A {printCUR(yytext,0);}

Define NumexMsrCur003a
     [ (Kk {nappa } | Kk {nappt } | Uu {ngefär } | Uu {ppemot } | {Runt }
         | Mm {inst } | Nn {ärmare } | Pp {å över } | ["Ö"|"ö"] {ver }
         | Uu {pp till } | Oo {mkring } | Uu {nder } | Cc {irka }
         | Mm {ellan } Ins(Nums) {, } Ins(Nums) { och } | Mm {ellan } Ins(NumsSpNums) { och }
         | Mm {ellan } Ins(Nums) { och } | Dd {rygt }
         | Ff {rån } DigitCommas { till } | {av } Ins(NUM) { till }
         | Ff {rån } Ins(NumsSpNums) { till } | {mot minus } | Mm {indre än })
       [Mm {ånga miljarder } | Ff {lera hundra } | Ee {tt par hundra }
          | {tolv } | {elva } | {flera } | Word {ton } | NS* {tio }
          | Ins(NUM) {-} Ins(NUM) { } | Ins(NUM) { } | Word {tals } | Ins(Nums) { eller } Ins(Nums) { }
          | Ins(NumsSpNums) {-} Ins(NumsSpNums) { } | Ins(Nums) ["-"|":"|","|"."|"_"] Ins(Nums) { }
          | Ins(NumsSpNums) { } Ins(Nums) { } | Num19 {-} Num19 {,} Num19 | Ins(NumsSpNums) { }
          | Ins(Nums) { } | Ins(NumRange) { } | Ins(Nums) {-} Ins(NumsSpNums) { }
          | Ins(Nums) { ,} Ins(Nums) { } | Ins(Nums) { . } Ins(Nums) { }
          | Ins(Nums) {:} Ins(NumRange) {:} Ins(Nums) { } | {-} Ins(Nums) { } | NS* {tusen }
          | Mm {ånga tusen } | Hh {undra }]
       (NS* {iljoner } | NS* {illion } | NS* {iljarder } | NS* {iljard }
         | NS* {iljon } | {milj } | NS* {iljader } | NS* {tusen }
         | NS* {hundra })
       (LowerWord {ska })
       [{won} | {spänn} | {yuan} | {rupees} | {cent} | {kopek} | {rubel}
          | {pund} | {lire} | {rand} | {peso} | {rubler} | {lira}
          | {estniska kroon} | {US dollar} | {US-cent} | {shilling}
          | {schweiz franc} | Rr {inggit} | {dirham} | {rupier} | {skilling}
          | {skillingar} | {litas} | {dukater} | {riksbankdaler} | {riksdaler}
          | {pence} | {rupiah} | NS* {dollar} | {yen} | Mm {kr} | {Mdkr}
          | {krona} | {Mkr.} | Ee {uro} | {kronorna} | {DKK} | {SEK} | {MSEK}
          | {EUR} | Kk {ronor} | {öre} | {D-mark} | {kr.} | {kr} | {centimes}
          | NS* {franc} | {dollars}]
       ({s})
       ({/}
         ["a"|"b"|"c"|"d"|"e"|"f"|"g"|"h"|"i"|"j"|"k"|"l"|"m"|"n"|"o"|"p"|"q"|"r"|"s"|"t"|"u"|"v"|"w"|"x"|"y"|"z"|"å"]+)
       ({ till } Ins(Nums) {:} Ins(Nums) { dollar} | { till } Ins(Nums) {:} Ins(Nums)) ] ;
Define NumexMsrCur003 [ NumexMsrCur003a   EndTag(NumexMsrCur) ] ; 230

!R (cirka|minst)" "(MSEK|MUSD|NOK|SEK|EUR|USD)" "[0-9\-]+(\.[0-9]+|\.[0-9]+\,[0-9]+)?
!A {printCUR(yytext,0);}

Define NumexMsrCur004a
     [ [{cirka} | {minst}] { }
       [{MSEK} | {MUSD} | {NOK} | {SEK} | {EUR} | {USD}] { } DigitDashes
       ({.} Ins(Nums) | {.} Ins(NumsCommaNums)) ] ;
Define NumexMsrCur004 [ NumexMsrCur004a   EndTag(NumexMsrCur) ] ; 231

!R (MSEK|MUSD|SEK|EUR|USD)" "[0-9\-]+([\,\.][0-9]+)?
!A {printCUR(yytext,0);}

Define NumexMsrCur005a
     [ [{MSEK} | {MUSD} | {SEK} | {EUR} | {USD}] { } DigitDashes
       ([","|"."] Ins(Nums)) ] ;
Define NumexMsrCur005 [ NumexMsrCur005a   EndTag(NumexMsrCur) ] ; 232

!R [0-9][0-9\-]*([\,\.][0-9]+)?" "(MSEK|MUSD|SEK|EUR|USD)
!A {printCUR(yytext,0);}

Define NumexMsrCur006a
     [ Num DigitDash* ([","|"."] Ins(Nums)) { }
       [{MSEK} | {MUSD} | {SEK} | {EUR} | {USD}] ] ;
Define NumexMsrCur006 [ NumexMsrCur006a   EndTag(NumexMsrCur) ] ; 233

!#  MOD (Jyrki Niemi): Fixed an apparently incorrect regexp:
!# 	("värderas till"|"lånat ut"|"kapital på"|"förlust på"|"anslag på"|"viditetsbrist på")(" "[0-9]+)?[0-9\,]+" "milj(oner|arder)(" kronor")?
!# 	

!R ("värderas till"|"lånat ut"|"kapital på"|"förlust på"|"anslag på"|"viditetsbrist på")" "[0-9][0-9\,]*" "milj(oner|arder)(" kronor")?
!A {printCUR(yytext,2);}

Define NumexMsrCur007a
     [ Num DigitComma* { milj} [{oner} | {arder}] ({ kronor}) ] ;
Define NumexMsrCur007
     [ NumexMsrCur007a
       LC([{värderas till} | {lånat ut} | {kapital på} | {förlust på}
             | {anslag på} | {viditetsbrist på}]
          { })
       EndTag(NumexMsrCur) ] ; 234

!R [^\n\t ]*(förmögenheten|betala|tjänat|kostade|reserverat)" "([0-9]" "[0-9]+" "[0-9]+|[0-9]+|[0-9]+[\,\. ][0-9]+|[0-9]+" "\,[0-9]+|två)" "milj(oner|arder)(" kronor")?
!A {printCUR(yytext,1);}

Define NumexMsrCur008a
     [ [Num { } Ins(NumsSpNums) | Ins(Nums) | Ins(Nums) [Whitespace|","|"."] Ins(Nums)
          | Ins(Nums) { ,} Ins(Nums) | {två}]
       { milj} [{oner} | {arder}] ({ kronor}) ] ;
Define NumexMsrCur008
     [ NumexMsrCur008a
       LC([{förmögenheten} | {betala} | {tjänat} | {kostade}
             | {reserverat}]
          { })
       EndTag(NumexMsrCur) ] ; 235

!R "miljoner "(dollar|kronor)
!A {printCUR(yytext,0);}

Define NumexMsrCur009a [ {miljoner } [{dollar} | {kronor}] ] ;
Define NumexMsrCur009 [ NumexMsrCur009a   EndTag(NumexMsrCur) ] ; 236

!R "mot kursen "[0-9]\:[0-9][0-9]
!A {printCUR(yytext,2);}

Define NumexMsrCur010a [ Num {:} Ins(Nums2) ] ;
Define NumexMsrCur010
     [ NumexMsrCur010a
       LC({mot kursen })
       EndTag(NumexMsrCur) ] ; 237

!R £[0-9]+(\.[0-9]+)?m
!A {printCUR(yytext,0);}

Define NumexMsrCur011a [ {£} Ins(Nums) ({.} Ins(Nums)) {m} ] ;
Define NumexMsrCur011 [ NumexMsrCur011a   EndTag(NumexMsrCur) ] ; 238

!R \$[0-9]+[\.\,][0-9]+
!A {printCUR(yytext,0);}

Define NumexMsrCur012a [ {$} Ins(Nums) ["."|","] Ins(Nums) ] ;
Define NumexMsrCur012 [ NumexMsrCur012a   EndTag(NumexMsrCur) ] ; 239

!R \$[0-9]+(" "[0-9][0-9]+)?
!A {printCUR(yytext,0);}

Define NumexMsrCur013a [ {$} Ins(Nums) ({ } Num Ins(Nums)) ] ;
Define NumexMsrCur013 [ NumexMsrCur013a   EndTag(NumexMsrCur) ] ; 240

!R [A-Z][^\n\t ]+"dska dukater"(na)?
!A {printCUR(yytext,0);}

Define NumexMsrCur014a [ AZ Word {dska dukater} ({na}) ] ;
Define NumexMsrCur014 [ NumexMsrCur014a   EndTag(NumexMsrCur) ] ; 241

!R [0-9]+" "(NOK|mnkr|R:dr)
!A {printCUR(yytext,0);}

Define NumexMsrCur015a [ Ins(Nums) { } [{NOK} | {mnkr} | {R:dr}] ] ;
Define NumexMsrCur015 [ NumexMsrCur015a   EndTag(NumexMsrCur) ] ; 242

!R [0-9]+" £"
!A {printCUR(yytext,0);}

Define NumexMsrCur016a [ Ins(Nums) { £} ] ;
Define NumexMsrCur016 [ NumexMsrCur016a   EndTag(NumexMsrCur) ] ; 243

!R [^\n\< ]+skillingar
!A {printCUR(yytext,0);}

Define NumexMsrCur017a [ Word {skillingar} ] ;
Define NumexMsrCur017 [ NumexMsrCur017a   EndTag(NumexMsrCur) ] ; 244

!R ({NUM}|[0-9][0-9\,]*)" "(daler|styfver)
!A {printCUR(yytext,0);}

Define NumexMsrCur018a [Ins(NUM) | Num DigitComma*] { } [{daler} | {styfver}] ;
Define NumexMsrCur018 [ NumexMsrCur018a   EndTag(NumexMsrCur) ] ; 245

!R [0-9]+" "(skålpund|alner)
!A {printCUR(yytext,0);}

Define NumexMsrCur019a [ Ins(Nums) { } [{skålpund} | {alner}] ] ;
Define NumexMsrCur019 [ NumexMsrCur019a   EndTag(NumexMsrCur) ] ; 246

!#  TELEPHONE 

!R ([Tt]elefonsvarare|[Tt]lf|[Mm]obil|[Tt]el\.|[Ff][Aa][Xx]|[Tt]fn|Ring|[Tt]el|[Tt]elefon|[Tt]elefax|tln|vxl)" \( "[0-9]+" \) "[0-9]+(" "[0-9\_]+)?
!A {/*Telefon ( 09 ) 47 441*/printTEL(yytext,1);}

!# Telefon ( 09 ) 47 441

Define NumexMsrTel001a [ {( } Ins(Nums) { ) } Ins(Nums) ({ } DigitUscores) ] ;
Define NumexMsrTel001
     [ NumexMsrTel001a
       LC([Tt {elefonsvarare} | Tt {lf} | Mm {obil} | Tt {el.} | Ff Aa Xx
             | Tt {fn} | {Ring} | Tt {el} | Tt {elefon} | Tt {elefax} | {tln}
             | {vxl}]
          { })
       EndTag(NumexMsrTel) ] ; 247

!R ([Tt]elefonsvarare|[Tt]lf|ankn|[Mm]obil|[Tt]el\.|[Ff][Aa][Xx]|[Tt]fn|Ring|[Tt]el|[Tt]elefon|[Tt]elefax|Phone|tln|vxl)" "\+?[0-9][0-9\_]+(\/|\-|" \- "|\-|" ")[0-9\_]+" "[0-9\_]+(" "[0-9\_]+)?
!A {printTEL(yytext,1);}

Define NumexMsrTel002a
     [ ({+}) Num DigitUscores [{/} | {-} | { - } | { }] DigitUscores { }
       DigitUscores ({ } DigitUscores) ] ;
Define NumexMsrTel002
     [ NumexMsrTel002a
       LC([Tt {elefonsvarare} | Tt {lf} | {ankn} | Mm {obil} | Tt {el.}
             | Ff Aa Xx | Tt {fn} | {Ring} | Tt {el} | Tt {elefon}
             | Tt {elefax} | {Phone} | {tln} | {vxl}]
          { })
       EndTag(NumexMsrTel) ] ; 248

!R ([Tt]elefonsvarare|[Tt]lf|ankn|[Mm]obil|[Tt]el\.|[Ff][Aa][Xx]|[Tt]fn|Ring|[Tt]el|[Tt]elefon|[Tt]elefax|Phone|tln|vxl)" "\+?[0-9][0-9\_]+(\/|\-|" \- "|" ")?[0-9\_\-]+(" "[0-9\_]+)*
!A {printTEL(yytext,1);}

Define NumexMsrTel003a
     [ ({+}) Num DigitUscores ({/} | {-} | { - } | { }) [Num|"_"|"-"]+
       [{ } DigitUscores]* ] ;
Define NumexMsrTel003
     [ NumexMsrTel003a
       LC([Tt {elefonsvarare} | Tt {lf} | {ankn} | Mm {obil} | Tt {el.}
             | Ff Aa Xx | Tt {fn} | {Ring} | Tt {el} | Tt {elefon}
             | Tt {elefax} | {Phone} | {tln} | {vxl}]
          { })
       EndTag(NumexMsrTel) ] ; 249

!#  MOD (Jyrki Niemi): Rule was split into two by the number of
!# 	   context words:
!# 	([Tt]elefonsvarare|[Tt]lf|ankn|[Mm]obil|[Tt]el\.|[Ff][Aa][Xx]|[Tt]fn|Ring|[Tt]el|[Tt]elefon|[Tt]elefax|Phone|tln|vxl)(" \."|"\."|":"|" :")" "\+?[0-9][0-9\_]+(" "|\/|\-|" \- "|\-)[0-9\_\-]+" "[0-9\_]+(" "[0-9\_]+)*	{printTEL(yytext,1);}
!# 	

!R ([Tt]elefonsvarare|[Tt]lf|ankn|[Mm]obil|[Tt]el\.|[Ff][Aa][Xx]|[Tt]fn|Ring|[Tt]el|[Tt]elefon|[Tt]elefax|Phone|tln|vxl)("\."|":")" "\+?[0-9][0-9\_]+(" "|\/|\-|" \- "|\-)[0-9\_\-]+" "[0-9\_]+(" "[0-9\_]+)*
!A {printTEL(yytext,1);}

Define NumexMsrTel004a
     [ ({+}) Num DigitUscores [{ } | {/} | {-} | { - }] [Num|"_"|"-"]+ { }
       DigitUscores [{ } DigitUscores]* ] ;
Define NumexMsrTel004
     [ NumexMsrTel004a
       LC([Tt {elefonsvarare} | Tt {lf} | {ankn} | Mm {obil} | Tt {el.}
             | Ff Aa Xx | Tt {fn} | {Ring} | Tt {el} | Tt {elefon}
             | Tt {elefax} | {Phone} | {tln} | {vxl}]
          [{.} | {:}] { })
       EndTag(NumexMsrTel) ] ; 250

!R ([Tt]elefonsvarare|[Tt]lf|ankn|[Mm]obil|[Tt]el\.|[Ff][Aa][Xx]|[Tt]fn|Ring|[Tt]el|[Tt]elefon|[Tt]elefax|Phone|tln|vxl)(" \."|" :")" "\+?[0-9][0-9\_]+(" "|\/|\-|" \- "|\-)[0-9\_\-]+" "[0-9\_]+(" "[0-9\_]+)*
!A {printTEL(yytext,2);}

Define NumexMsrTel005a
     [ ({+}) Num DigitUscores [{ } | {/} | {-} | { - }] [Num|"_"|"-"]+ { }
       DigitUscores [{ } DigitUscores]* ] ;
Define NumexMsrTel005
     [ NumexMsrTel005a
       LC([Tt {elefonsvarare} | Tt {lf} | {ankn} | Mm {obil} | Tt {el.}
             | Ff Aa Xx | Tt {fn} | {Ring} | Tt {el} | Tt {elefon}
             | Tt {elefax} | {Phone} | {tln} | {vxl}]
          [{ .} | { :}] { })
       EndTag(NumexMsrTel) ] ; 251

!#  MOD (Jyrki Niemi): Rule was split into two by the number of
!# 	   context words:
!# 	([Tt]elefonsvarare|[Tt]lf|ankn|[Mm]obil|Tel\.|[Ff][Aa][Xx]|[Tt]fn|Ring|[Tt]el|[Tt]elefon|[Tt]elefax|[Tt]ln|vxl)(" \."|"\."|":"|" :")" "\+?[0-9][0-9\_]+(\/|\-|" \- "|" ")[0-9\_\-]+	{printTEL(yytext,1);}
!# 	

!R ([Tt]elefonsvarare|[Tt]lf|ankn|[Mm]obil|Tel\.|[Ff][Aa][Xx]|[Tt]fn|Ring|[Tt]el|[Tt]elefon|[Tt]elefax|[Tt]ln|vxl)("\."|":")" "\+?[0-9][0-9\_]+(\/|\-|" \- "|" ")[0-9\_\-]+
!A {printTEL(yytext,1);}

Define NumexMsrTel006a
     [ ({+}) Num DigitUscores [{/} | {-} | { - } | { }] [Num|"_"|"-"]+ ] ;
Define NumexMsrTel006
     [ NumexMsrTel006a
       LC([Tt {elefonsvarare} | Tt {lf} | {ankn} | Mm {obil} | {Tel.}
             | Ff Aa Xx | Tt {fn} | {Ring} | Tt {el} | Tt {elefon}
             | Tt {elefax} | Tt {ln} | {vxl}]
          [{.} | {:}] { })
       EndTag(NumexMsrTel) ] ; 252

!R ([Tt]elefonsvarare|[Tt]lf|ankn|[Mm]obil|Tel\.|[Ff][Aa][Xx]|[Tt]fn|Ring|[Tt]el|[Tt]elefon|[Tt]elefax|[Tt]ln|vxl)(" \."|" :")" "\+?[0-9][0-9\_]+(\/|\-|" \- "|" ")[0-9\_\-]+
!A {printTEL(yytext,2);}

Define NumexMsrTel007a
     [ ({+}) Num DigitUscores [{/} | {-} | { - } | { }] [Num|"_"|"-"]+ ] ;
Define NumexMsrTel007
     [ NumexMsrTel007a
       LC([Tt {elefonsvarare} | Tt {lf} | {ankn} | Mm {obil} | {Tel.}
             | Ff Aa Xx | Tt {fn} | {Ring} | Tt {el} | Tt {elefon}
             | Tt {elefax} | Tt {ln} | {vxl}]
          [{ .} | { :}] { })
       EndTag(NumexMsrTel) ] ; 253

!#  MOD (Jyrki Niemi): Rule was split into two by the number of
!# 	   context words:
!# 	([Tt]elefonsvarare|[Tt]lf|[Mm]obil|[Tt]el\.|[Ff][Aa][Xx]|[Tt]fn|Ring|[Tt]el|[Tt]elefon|[Tt]elefax|tln)(": "|" : ")"\( \+"[0-9]+" \) "[0-9\_\-]+(" "[0-9\_]+)*	{printTEL(yytext,1);}
!# 	

!R ([Tt]elefonsvarare|[Tt]lf|[Mm]obil|[Tt]el\.|[Ff][Aa][Xx]|[Tt]fn|Ring|[Tt]el|[Tt]elefon|[Tt]elefax|tln)": \( \+"[0-9]+" \) "[0-9\_\-]+(" "[0-9\_]+)*
!A {printTEL(yytext,1);}

Define NumexMsrTel008a
     [ {( +} Ins(Nums) { ) } [Num|"_"|"-"]+ [{ } DigitUscores]* ] ;
Define NumexMsrTel008
     [ NumexMsrTel008a
       LC([Tt {elefonsvarare} | Tt {lf} | Mm {obil} | Tt {el.} | Ff Aa Xx
             | Tt {fn} | {Ring} | Tt {el} | Tt {elefon} | Tt {elefax} | {tln}]
          {: })
       EndTag(NumexMsrTel) ] ; 254

!R ([Tt]elefonsvarare|[Tt]lf|[Mm]obil|[Tt]el\.|[Ff][Aa][Xx]|[Tt]fn|Ring|[Tt]el|[Tt]elefon|[Tt]elefax|tln)" : \( \+"[0-9]+" \) "[0-9\_\-]+(" "[0-9\_]+)*
!A {printTEL(yytext,2);}

Define NumexMsrTel009a
     [ {( +} Ins(Nums) { ) } [Num|"_"|"-"]+ [{ } DigitUscores]* ] ;
Define NumexMsrTel009
     [ NumexMsrTel009a
       LC([Tt {elefonsvarare} | Tt {lf} | Mm {obil} | Tt {el.} | Ff Aa Xx
             | Tt {fn} | {Ring} | Tt {el} | Tt {elefon} | Tt {elefax} | {tln}]
          { : })
       EndTag(NumexMsrTel) ] ; 255

!R (ringa|nås)" på "\+?[0-9\_]+(\/|\-|\/|" \- ")[0-9\_]+" "[0-9\_]+" "[0-9\_]+
!A {printTEL(yytext,2);}

Define NumexMsrTel010a
     [ ({+}) DigitUscores [{/} | {-} | { - }] DigitUscores { } DigitUscores
       { } DigitUscores ] ;
Define NumexMsrTel010
     [ NumexMsrTel010a
       LC([{ringa} | {nås}] { på })
       EndTag(NumexMsrTel) ] ; 256

!R 0[23][01]\-[0-9\_]+(" "[0-9\_]+)+
!A {printTEL(yytext,0);}

Define NumexMsrTel011a
     [ {0} ["2"|"3"] ["0"|"1"] {-} DigitUscores [{ } DigitUscores]+ ] ;
Define NumexMsrTel011 [ NumexMsrTel011a   EndTag(NumexMsrTel) ] ; 257

!R 0(8|3[0-9]|[74]0|7[0-9][0-9]|18)\-[0-9\_]+(" "[0-9\_]+)+(" eller "[0-9\_]+" "[0-9\_]+" "[0-9\_]+)?
!A {printTEL(yytext,0);}

Define NumexMsrTel012a
     [ {0} [{8} | {3} Num | ["7"|"4"] {0} | {7} Ins(Nums2) | {18}] {-} DigitUscores
       [{ } DigitUscores]+
       ({ eller } DigitUscores { } DigitUscores { } DigitUscores) ] ;
Define NumexMsrTel012 [ NumexMsrTel012a   EndTag(NumexMsrTel) ] ; 258

!R 0(8|[34][0-9]|[74]0|7[0-9][0-9]|18)" "[0-9\_]+(" "[0-9\_]+)+
!A {printTEL(yytext,0);}

Define NumexMsrTel013a
     [ {0} [{8} | ["3"|"4"] Num | ["7"|"4"] {0} | {7} Ins(Nums2) | {18}] { }
       DigitUscores [{ } DigitUscores]+ ] ;
Define NumexMsrTel013 [ NumexMsrTel013a   EndTag(NumexMsrTel) ] ; 259

!R 0(8|[34][0-9]|[74]0|7[0-9][0-9]|18)\-[1-9][0-9][0-9][0-9][0-9][0-9][0-9]?
!A {printTEL(yytext,0);}

Define NumexMsrTel014a
     [ {0} [{8} | ["3"|"4"] Num | ["7"|"4"] {0} | {7} Ins(Nums2) | {18}] {-} Num19
       Nums4 Ins(Nums12) ] ;
Define NumexMsrTel014 [ NumexMsrTel014a   EndTag(NumexMsrTel) ] ; 260

!R 0[0-9]+" \( 0 \)"(" "[0-9]+)+
!A {printTEL(yytext,0);}

Define NumexMsrTel015a [ {0} Ins(Nums) { ( 0 )} [{ } Ins(Nums)]+ ] ;
Define NumexMsrTel015 [ NumexMsrTel015a   EndTag(NumexMsrTel) ] ; 261

!R 0[0-9]+" \( 0 \)"[0-9]+(" "[0-9]+)+
!A {/*without space after parentheses*/     printTEL(yytext,0);}

!# without space after parentheses

Define NumexMsrTel016a [ {0} Ins(Nums) { ( 0 )} Ins(Nums) [{ } Ins(Nums)]+ ] ;
Define NumexMsrTel016 [ NumexMsrTel016a   EndTag(NumexMsrTel) ] ; 262

!R "tel nr "[0-9\_\-]+[0-9]+(" "[0-9\_]+)*
!A {printTEL(yytext,2);}

Define NumexMsrTel017a [ [Num|"_"|"-"]+ Ins(Nums) [{ } DigitUscores]* ] ;
Define NumexMsrTel017
     [ NumexMsrTel017a
       LC({tel nr })
       EndTag(NumexMsrTel) ] ; 263

!R "tel nr "[0-9][0-9\_]+(" "[0-9\_]+)*
!A {printTEL(yytext,2);}

Define NumexMsrTel018a [ Num DigitUscores [{ } DigitUscores]* ] ;
Define NumexMsrTel018
     [ NumexMsrTel018a
       LC({tel nr })
       EndTag(NumexMsrTel) ] ; 264

!R "tel hem : "[0-9][0-9\_]+(" "[0-9\_]+)*
!A {printTEL(yytext,2);}

Define NumexMsrTel019a [ {: } Num DigitUscores [{ } DigitUscores]* ] ;
Define NumexMsrTel019
     [ NumexMsrTel019a
       LC({tel hem })
       EndTag(NumexMsrTel) ] ; 265

!R "tel\. "[0-9][0-9\_]+(" "[0-9\_]+)*
!A {printTEL(yytext,1);}

Define NumexMsrTel020a [ Num DigitUscores [{ } DigitUscores]* ] ;
Define NumexMsrTel020
     [ NumexMsrTel020a
       LC({tel. })
       EndTag(NumexMsrTel) ] ; 266

!R "via vx "[0-9\_]+(" "[0-9\_]+)*
!A {printTEL(yytext,2);}

Define NumexMsrTel021a [ DigitUscores [{ } DigitUscores]* ] ;
Define NumexMsrTel021
     [ NumexMsrTel021a
       LC({via vx })
       EndTag(NumexMsrTel) ] ; 267

!R (tel|tln)" "[0-9][0-9][0-9][0-9][0-9][0-9]
!A {printTEL(yytext,1);}

Define NumexMsrTel022a [ Ins(Nums6) ] ;
Define NumexMsrTel022
     [ NumexMsrTel022a
       LC([{tel} | {tln}] { })
       EndTag(NumexMsrTel) ] ; 268

!R " \+"[0-9][0-9]?" "[0-9]+" "[0-9]+
!A {int i=1; printf(" <NUMEX TYPE=\"MSR\" SBT=\"TEL\">"); 
!A 	for(;i<yyleng;putchar(yytext[i++])); printf("</NUMEX>");}

Define NumexMsrTel023a [ {+} Ins(Nums12) { } Ins(NumsSpNums) ] ;
Define NumexMsrTel023 [ NumexMsrTel023a   LC({ })   EndTag(NumexMsrTel) ] ; 269

!R " tel "[0-9][0-9][0-9][0-9][0-9]+
!A {int i=5; printf(" tel <NUMEX TYPE=\"MSR\" SBT=\"TEL\">"); 
!A 	for(;i<yyleng;putchar(yytext[i++])); printf("</NUMEX>");}

Define NumexMsrTel024a [ Nums4 Ins(Nums) ] ;
Define NumexMsrTel024
     [ NumexMsrTel024a
       LC({ tel })
       EndTag(NumexMsrTel) ] ; 270

!R 0(3[0-9][0-9]|40|19)\-[0-9][0-9]" "[0-9][0-9]" "[0-9][0-9]
!A {printTEL(yytext,0);}

Define NumexMsrTel025a
     [ {0} [{3} Ins(Nums2) | {40} | {19}] {-} Ins(Nums2) { } Ins(Nums2) { } Ins(Nums2) ] ;
Define NumexMsrTel025 [ NumexMsrTel025a   EndTag(NumexMsrTel) ] ; 271

!R ([Tt]lf|[Mm]obil|[Tt]el\.|[Ff][Aa][Xx]|[Tt]fn|Ring|[Tt]el|[Tt]elefon|tln)" \+"(" ")?[0-9]+\-\(0\)[0-9\-]+(" "[0-9]+)*
!A {printTEL(yytext,1);}

Define NumexMsrTel026a [ {+} ({ }) Ins(Nums) {-(0)} DigitDashes [{ } Ins(Nums)]* ] ;
Define NumexMsrTel026
     [ NumexMsrTel026a
       LC([Tt {lf} | Mm {obil} | Tt {el.} | Ff Aa Xx | Tt {fn} | {Ring}
             | Tt {el} | Tt {elefon} | {tln}]
          { })
       EndTag(NumexMsrTel) ] ; 272

!#  LISTOR 

!R [Tt]urneringen" Europa "To(p|pp)" "[0-9]+
!A {ECHO;}

Define Except003 [ Tt {urneringen Europa To} [{p} | {pp}] { } Nums ] ; 273

!R "Fortunes lista"
!A {printLST(yytext,0);}

Define NumexMsrLst001a [ {Fortunes lista} ] ;
Define NumexMsrLst001 [ NumexMsrLst001a   EndTag(NumexMsrLst) ] ; 274

!R ("OM ")?[A-Z][^\n\t ]+börsens" O\-lista"
!A {printLST(yytext,0);}

Define NumexMsrLst002a [ ({OM }) AZ Word {börsens O-lista} ] ;
Define NumexMsrLst002 [ NumexMsrLst002a   EndTag(NumexMsrLst) ] ; 275

!R ("Wall Streets"|Fortunes|Attract|FN\:s)" "([Tt]op" ")?[^\n\t ]+\-lista
!A {printLST(yytext,0);}

Define NumexMsrLst003a
     [ [{Wall Streets} | {Fortunes} | {Attract} | {FN:s}] { } (Tt {op }) Word
       {-lista} ] ;
Define NumexMsrLst003 [ NumexMsrLst003a   EndTag(NumexMsrLst) ] ; 276

!R Europa" "To(p|pp)" "[0-9]+
!A {printLST(yytext,0);}

Define NumexMsrLst004a [ {Europa To} [{p} | {pp}] { } Ins(Nums) ] ;
Define NumexMsrLst004 [ NumexMsrLst004a   EndTag(NumexMsrLst) ] ; 277

!R [A-ZÅÄÖ]+\:s" "[^\n\t ]+" "[0-9]+\-lista
!A {printLST(yytext,0);}

Define NumexMsrLst005a [ UpperWord {:s } Ins(Word) { } Ins(Nums) {-lista} ] ;
Define NumexMsrLst005 [ NumexMsrLst005a   EndTag(NumexMsrLst) ] ; 278

!R [^\n\t ]+\-rankingens" "[0-9]+\-bästa\-lista
!A {printLST(yytext,0);}

Define NumexMsrLst006a [ Word {-rankingens } Ins(Nums) {-bästa-lista} ] ;
Define NumexMsrLst006 [ NumexMsrLst006a   EndTag(NumexMsrLst) ] ; 279

!R "Consumer "[^\n\t ]+" "[^\n\t ]*lista
!A {printLST(yytext,0);}

Define NumexMsrLst007a [ {Consumer } Ins(Word) { } NS* {lista} ] ;
Define NumexMsrLst007 [ NumexMsrLst007a   EndTag(NumexMsrLst) ] ; 280

!R "World "[^\n\t ]+" List"
!A {printLST(yytext,0);}

Define NumexMsrLst008a [ {World } Ins(Word) { List} ] ;
Define NumexMsrLst008 [ NumexMsrLst008a   EndTag(NumexMsrLst) ] ; 281

!R "lista kallad "[A-Z][^\n\t ]+" Criteria"
!A {printLST(yytext,0);}

Define NumexMsrLst009a [ {lista kallad } AZ Ins(Word) { Criteria} ] ;
Define NumexMsrLst009 [ NumexMsrLst009a   EndTag(NumexMsrLst) ] ; 282

!#  AGE 

!R [Ff]rån" "[1-9][0-9]?" till "[1-9][0-9]?" veckors medianålder"
!A {printAGE(yytext,0);}

Define NumexMsrAge001a
     [ Ff {rån } Num19x { till } Num19x { veckors medianålder} ] ;
Define NumexMsrAge001 [ NumexMsrAge001a   EndTag(NumexMsrAge) ] ; 283

!R [Vv]id" "[a-zåäö]+" till "[a-zåäö]+" års ålder"(n)?
!A {printAGE(yytext,1);}

Define NumexMsrAge002a
     [ Ins(LowerWord) { till } Ins(LowerWord) { års ålder} ({n}) ] ;
Define NumexMsrAge002
     [ NumexMsrAge002a
       LC(Vv {id })
       EndTag(NumexMsrAge) ] ; 284

!R [^\nt<>]+" och ett "(halv|halft)" år "gammal
!A {printAGE(yytext,0);}

Define NumexMsrAge003a
     [ [AnyChar - ["\n"|"t"|"<"|">"]]+ { och ett } [{halv} | {halft}]
       { år gammal} ] ;
Define NumexMsrAge003 [ NumexMsrAge003a   EndTag(NumexMsrAge) ] ; 285

!R [Vv]id" "[0-9]+" års och "[0-9]+" års ålder"(n)?
!A {printAGE(yytext,1);}

Define NumexMsrAge004a [ Ins(Nums) { års och } Ins(Nums) { års ålder} ({n}) ] ;
Define NumexMsrAge004
     [ NumexMsrAge004a
       LC(Vv {id })
       EndTag(NumexMsrAge) ] ; 286

!R ([Ff]rån|[Vv]id)" "[^\n\t ]+\-[^\n\t ]+" års ålder"(n)?
!A {printAGE(yytext,1);}

Define NumexMsrAge005a [ Word {-} Ins(Word) { års ålder} ({n}) ] ;
Define NumexMsrAge005
     [ NumexMsrAge005a
       LC([Ff {rån} | Vv {id}] { })
       EndTag(NumexMsrAge) ] ; 287

!#  MOD (Jyrki Niemi): Corrected action: apparently had an extra
!# 	   trailing space in the first marked expression. 

!R [Vv]id" "[1-9][0-9]?" månader och en vid "[1-9][0-9]?(" års ålder"|" årsålder")(n)?
!A {int i=0; printf("<NUMEX TYPE=\"MSR\" SBT=\"AGE\">"); for(;yytext[i]!=' '; putchar(yytext[i++])); putchar(' '); i++; for(;yytext[i]!=' '; putchar(yytext[i++])); putchar(' '); i++; for(;yytext[i]!=' '; putchar(yytext[i++])); printf("</NUMEX> och en <NUMEX TYPE=\"MSR\" SBT=\"AGE\">"); for(;i<yyleng;putchar(yytext[i++])); printf("</NUMEX>");}

Define NumexMsrAge006
     [ Vv {id } Num19x { månader}
         EndTag(NumexMsrAge) ]
     { och en }
     [ {vid } Num19x [{ års ålder} | { årsålder}] ({n})
         EndTag(NumexMsrAge) ] ; 288

!R [Bb]arn" "(från|mellan)" "[^\n ]+" månader "[^\n ]+" "[^\n ]+" års ålder"
!A {printAGE(yytext,1);}

Define NumexMsrAge007a
     [ [{från} | {mellan}] { } Ins(Word) { månader } Ins(Word) { } Ins(Word) { års ålder} ] ;
Define NumexMsrAge007
     [ NumexMsrAge007a
       LC(Bb {arn })
       EndTag(NumexMsrAge) ] ; 289

!R [Bb]arn" "(från|mellan)" "[^\n ]+" månader till "[^\n ]+" "år(s" ålder")?
!A {printAGE(yytext,1);}

Define NumexMsrAge008a
     [ [{från} | {mellan}] { } Ins(Word) { månader till } Ins(Word) { år} ({s ålder}) ] ;
Define NumexMsrAge008
     [ NumexMsrAge008a
       LC(Bb {arn })
       EndTag(NumexMsrAge) ] ; 290

!R [Vv]id" "[0-9]+" \, "[0-9]+" och "[0-9]+" månaders ålder"
!A {printAGE(yytext,0);}

Define NumexMsrAge009a
     [ Vv {id } Ins(Nums) { , } Ins(Nums) { och } Ins(Nums) { månaders ålder} ] ;
Define NumexMsrAge009 [ NumexMsrAge009a   EndTag(NumexMsrAge) ] ; 291

!R ([Tt]"\.o\.m\."|[Uu]"pp till"|[Ss]edan|[Ii]nnan|[Ff]öre|[Vv]id|[Ii]|[Öö]ver|[Ff]rån|[Uu]nder|[Ff]r" o m")" "(omkring" "|cirka" ")?[0-9]+(\-[0-9]|[0-9]+)?(" års ålder"|" månaders ålder"|" årsålder")(n)?
!A {printAGE(yytext,0);}

Define NumexMsrAge010a
     [ [Tt {.o.m.} | Uu {pp till} | Ss {edan} | Ii {nnan} | Ff {öre}
          | Vv {id} | Ii | ["Ö"|"ö"] {ver} | Ff {rån} | Uu {nder} | Ff {r o m}]
       { } ({omkring } | {cirka }) Ins(Nums) ({-} Num | Ins(Nums))
       [{ års ålder} | { månaders ålder} | { årsålder}] ({n}) ] ;
Define NumexMsrAge010 [ NumexMsrAge010a   EndTag(NumexMsrAge) ] ; 292

!R ([Uu]"pp till"|[Ss]edan|[Ii]nnan|[Ff]öre|[Vv]id|[Ii]|[Öö]ver|[Ff]rån|[Ee]fter|[Uu]nder)" "(tjuguett|[0-9]" \- "[0-9]|[^\n\t ]+\-|{NUM})("månaders ålder"|"års ålder"|"årsålder"|" månaders ålder"|" års ålder"|" årsålder")(n)?
!A {printAGE(yytext,0);}

Define NumexMsrAge011a
     [ [Uu {pp till} | Ss {edan} | Ii {nnan} | Ff {öre} | Vv {id} | Ii
          | ["Ö"|"ö"] {ver} | Ff {rån} | Ee {fter} | Uu {nder}]
       { } [{tjuguett} | Num { - } Num | Word {-} | Ins(NUM)]
       [{månaders ålder} | {års ålder} | {årsålder} | { månaders ålder}
          | { års ålder} | { årsålder}]
       ({n}) ] ;
Define NumexMsrAge011 [ NumexMsrAge011a   EndTag(NumexMsrAge) ] ; 293

!R [Ii]" "[1-9][0-9](" \- "|\-)[1-9][0-9](" års ålder"|\-årsålder)(n)?
!A {printAGE(yytext,0);}

Define NumexMsrAge012a
     [ Ii { } Num19X [{ - } | {-}] Num19X [{ års ålder} | {-årsålder}] ({n}) ] ;
Define NumexMsrAge012 [ NumexMsrAge012a   EndTag(NumexMsrAge) ] ; 294

!R [Ii]" "[1-9](" \- "|\-)[1-9][0-9]?(" års ålder"|\-årsålder|\-års" "ålder)(n)?
!A {printAGE(yytext,0);}

Define NumexMsrAge013a
     [ Ii { } Num19 [{ - } | {-}] Num19x
       [{ års ålder} | {-årsålder} | {-års ålder}] ({n}) ] ;
Define NumexMsrAge013 [ NumexMsrAge013a   EndTag(NumexMsrAge) ] ; 295

!R [^\n\t ]*åld(ern|rarna|ersgrupperna|ersgrupper|ersgruppen)" "[^\n\>\<\, ]+" "(och|\-|till)" "[^\n\>\<\, ]+(" år")?
!A {printAGE(yytext,1);}

Define NumexMsrAge014a
     [ NSTagComma+ { } [{och} | {-} | {till}] { } NSTagComma+ ({ år}) ] ;
Define NumexMsrAge014
     [ NumexMsrAge014a
       LC({åld}
          [{ern} | {rarna} | {ersgrupperna} | {ersgrupper} | {ersgruppen}]
          { })
       EndTag(NumexMsrAge) ] ; 296

!R [^\n\t ]*åld(rarna|ersgrupperna|ersgrupper|ersgruppen)" "[^\n\>\<\, ]+" år "(och|till)" "[^\n\>\<\, ]+" år"
!A {printAGE(yytext,1);}

Define NumexMsrAge015a
     [ NSTagComma+ { år } [{och} | {till}] { } NSTagComma+ { år} ] ;
Define NumexMsrAge015
     [ NumexMsrAge015a
       LC({åld} [{rarna} | {ersgrupperna} | {ersgrupper} | {ersgruppen}] { })
       EndTag(NumexMsrAge) ] ; 297

!R [^\n\t ]*åld(rarna|ersgrupperna|ersgrupper|ersgruppen)" "[^\n\>\< ]+" år"
!A {printAGE(yytext,1);}

Define NumexMsrAge016a [ Ins(Word) { år} ] ;
Define NumexMsrAge016
     [ NumexMsrAge016a
       LC({åld} [{rarna} | {ersgrupperna} | {ersgrupper} | {ersgruppen}] { })
       EndTag(NumexMsrAge) ] ; 298

!R [^\n\t ]*"åldern "[1-9][0-9]?" \, "[1-9][0-9]?" och "[1-9][0-9]?" år"(" och äldre")?
!A {printAGE(yytext,1);}

Define NumexMsrAge017a
     [ Num19x { , } Num19x { och } Num19x { år} ({ och äldre}) ] ;
Define NumexMsrAge017
     [ NumexMsrAge017a
       LC({åldern })
       EndTag(NumexMsrAge) ] ; 299

!R (yngre|äldre)" \, "[0-9][0-9]?" år vs "[0-9][0-9]?" "år
!A {printAGE(yytext,2);}

Define NumexMsrAge018a [ Ins(Nums12) { år vs } Ins(Nums12) { år} ] ;
Define NumexMsrAge018
     [ NumexMsrAge018a
       LC([{yngre} | {äldre}] { , })
       EndTag(NumexMsrAge) ] ; 300

!R [^\n\t ]*"åldern mellan "[1-9][0-9]" "(och|\-)" "[1-9][0-9](" år")?
!A {printAGE(yytext,1);}

Define NumexMsrAge019a
     [ {mellan } Num19X { } [{och} | {-}] { } Num19X ({ år}) ] ;
Define NumexMsrAge019
     [ NumexMsrAge019a
       LC({åldern })
       EndTag(NumexMsrAge) ] ; 301

!R [^\n\t ]*ålder(n)?" "\±SD" "[0-9\.\±]+
!A {printAGE(yytext,1);}

Define NumexMsrAge020a [ {±SD } [Num|"."|"±"]+ ] ;
Define NumexMsrAge020
     [ NumexMsrAge020a
       LC({ålder} ({n}) { })
       EndTag(NumexMsrAge) ] ; 302

!R [^\n\t ]*ålder(n)?" "[1-9][0-9](\-[1-9][0-9]" år"|\+|" år")
!A {printAGE(yytext,1);}

Define NumexMsrAge021a [ Num19X [{-} Num19X { år} | {+} | { år}] ] ;
Define NumexMsrAge021
     [ NumexMsrAge021a
       LC({ålder} ({n}) { })
       EndTag(NumexMsrAge) ] ; 303

!R (före|mellan|till)" "[1-9]\-[0-9]" års ålder"(n)?
!A {printAGE(yytext,1);}

Define NumexMsrAge022a [ Num19 {-} Num { års ålder} ({n}) ] ;
Define NumexMsrAge022
     [ NumexMsrAge022a
       LC([{före} | {mellan} | {till}] { })
       EndTag(NumexMsrAge) ] ; 304

!R [Bb]arn" på mellan "[^\n\t ]+" och "[^\n\t ]+" år"(" "gamla)?
!A {printAGE(yytext,1);}

Define NumexMsrAge023a
     [ {på mellan } Ins(Word) { och } Ins(Word) { år} ({ gamla}) ] ;
Define NumexMsrAge023
     [ NumexMsrAge023a
       LC(Bb {arn })
       EndTag(NumexMsrAge) ] ; 305

!R [Bb]arn" upp till "[^\n\t ]+" år"(" "gamla|"s ålder"|"s åldern"|såldern)?
!A {printAGE(yytext,1);}

Define NumexMsrAge024a
     [ {upp till } Ins(Word) { år} ({ gamla} | {s ålder} | {s åldern} | {såldern}) ] ;
Define NumexMsrAge024
     [ NumexMsrAge024a
       LC(Bb {arn })
       EndTag(NumexMsrAge) ] ; 306

!R ([Aa]lla|[Uu]ngdomar|svensk|[Kk]vinnor|[Pp]atienter|[Mm]än|kille|[Bb]arn|patienten|[Pp]atient|[Ss]venskar|[Pp]ersoner)" "(runt|under|över|före|från)" "[^\n\t ]+" år"("s ålder"|"sålder")(n)?
!A {printAGE(yytext,1);}

Define NumexMsrAge025a
     [ [{runt} | {under} | {över} | {före} | {från}] { } Ins(Word) { år}
       [{s ålder} | {sålder}] ({n}) ] ;
Define NumexMsrAge025
     [ NumexMsrAge025a
       LC([Aa {lla} | Uu {ngdomar} | {svensk} | Kk {vinnor}
             | Pp {atienter} | Mm {än} | {kille} | Bb {arn} | {patienten}
             | Pp {atient} | Ss {venskar} | Pp {ersoner}]
          { })
       EndTag(NumexMsrAge) ] ; 307

!R (söner|döttrar|barn|män)" \, "[1-9][0-9]?" "(resp|respektive|och)" "[1-9][0-9]?" år"(" "gamla)?
!A {printAGE(yytext,2);}

Define NumexMsrAge026a
     [ Num19x { } [{resp} | {respektive} | {och}] { } Num19x { år} ({ gamla}) ] ;
Define NumexMsrAge026
     [ NumexMsrAge026a
       LC([{söner} | {döttrar} | {barn} | {män}] { , })
       EndTag(NumexMsrAge) ] ; 308

!R (söner|döttrar|barn|män)" \, "{NUM}" "(resp|respektive|och)" "{NUM}" år"(" "gamla)?
!A {printAGE(yytext,2);}

Define NumexMsrAge027a
     [ Ins(NUM) { } [{resp} | {respektive} | {och}] { } Ins(NUM) { år} ({ gamla}) ] ;
Define NumexMsrAge027
     [ NumexMsrAge027a
       LC([{söner} | {döttrar} | {barn} | {män}] { , })
       EndTag(NumexMsrAge) ] ; 309

!R (söner|döttrar|barn|män)" "[1-9][0-9]?" "(resp|respektive|och)" "[1-9][0-9]?" år"(" "gamla)?
!A {printAGE(yytext,1);}

Define NumexMsrAge028a
     [ Num19x { } [{resp} | {respektive} | {och}] { } Num19x { år} ({ gamla}) ] ;
Define NumexMsrAge028
     [ NumexMsrAge028a
       LC([{söner} | {döttrar} | {barn} | {män}] { })
       EndTag(NumexMsrAge) ] ; 310

!R (söner|döttrar|barn)" \( "[1-9][0-9]?" "(resp|respektive|och)" "[1-9][0-9]?" år \)"
!A {printAGE(yytext,1);}

Define NumexMsrAge029a
     [ {( } Num19x { } [{resp} | {respektive} | {och}] { } Num19x { år )} ] ;
Define NumexMsrAge029
     [ NumexMsrAge029a
       LC([{söner} | {döttrar} | {barn}] { })
       EndTag(NumexMsrAge) ] ; 311

!R ([Vv]uxna|[Bb]arn)" \( "[1-9][0-9]?" år \)"
!A {printAGE(yytext,1);}

Define NumexMsrAge030a [ {( } Num19x { år )} ] ;
Define NumexMsrAge030
     [ NumexMsrAge030a
       LC([Vv {uxna} | Bb {arn}] { })
       EndTag(NumexMsrAge) ] ; 312

!R " ålder på "[1-9][0-9]?" "(resp|respektive)" "[1-9][0-9]?" månader"(" "gamla)?
!A {printAGE(yytext,2);}

Define NumexMsrAge031a
     [ {på } Num19x { } [{resp} | {respektive}] { } Num19x { månader}
       ({ gamla}) ] ;
Define NumexMsrAge031
     [ NumexMsrAge031a
       LC({ ålder })
       EndTag(NumexMsrAge) ] ; 313

!R (barn|män)" \, "[1-9][0-9]"\-"[1-9][0-9]" "(resp|respektive|och)" "[1-9][0-9]?" år"(" "gamla)?
!A {printAGE(yytext,2);}

Define NumexMsrAge032a
     [ Num19X {-} Num19X { } [{resp} | {respektive} | {och}] { } Num19x { år}
       ({ gamla}) ] ;
Define NumexMsrAge032
     [ NumexMsrAge032a
       LC([{barn} | {män}] { , })
       EndTag(NumexMsrAge) ] ; 314

!R (mellan|"upp emot "|[Uu]"ngefär "|"cirka ")?([1-9]+" till "|[1-9]+" och "|[0-9]+" resp "|[0-9]+" respektive "|{NUM}" och "|från" "{NUM}" till "|{NUM}" till ")?([0-9]+" "[0-9]+|[0-9]+\-[0-9]+|[0-9]+|{NUM}" respektive "{NUM}|{NUM}|[0-9]+\.[0-9]+|[0-9]+\,[0-9]+|"en till två")" "(dagar|veckor|månader|år)" "(gammalt|gammal|gamla)
!A {printAGE(yytext,0);}

Define NumexMsrAge033a
     [ ({mellan} | {upp emot } | Uu {ngefär } | {cirka })
       (Num19+ { till } | Num19+ { och } | Ins(Nums) { resp }
         | Ins(Nums) { respektive } | Ins(NUM) { och } | {från } Ins(NUM) { till }
         | Ins(NUM) { till })
       [Ins(NumsSpNums) | Ins(NumRange) | Ins(Nums) | Ins(NUM) { respektive } Ins(NUM) | Ins(NUM)
          | Ins(NumsDotNums) | Ins(NumsCommaNums) | {en till två}]
       { } [{dagar} | {veckor} | {månader} | {år}] { }
       [{gammalt} | {gammal} | {gamla}] ] ;
Define NumexMsrAge033 [ NumexMsrAge033a   EndTag(NumexMsrAge) ] ; 315

!R [^\n\t ]*(flickor|pojkar|[Bb]arn)" på "({NUM}|[1-9][0-9]?)" "(resp|respektive)" "({NUM}|[1-9][0-9]?)" år"
!A {printAGE(yytext,1);}

Define NumexMsrAge034a
     [ {på } [Ins(NUM) | Num19x] { } [{resp} | {respektive}] { } [Ins(NUM) | Num19x]
       { år} ] ;
Define NumexMsrAge034
     [ NumexMsrAge034a
       LC([{flickor} | {pojkar} | Bb {arn}] { })
       EndTag(NumexMsrAge) ] ; 316

!R [^\n\t ]*(gruppen|spelare|flickor|unga|veteraner|kvinna|någon|sångare|kille|pojkar|elever|hion|dansare|anställda|människor|väljare|[Uu]ngdomar|[Kk]vinnor|[Pp]atienter|[Mm]än|[Bb]arn|vandrare|ungdom|atient|person|[Pp]ersoner|alla|[Mm]an|Ålder)" "(runt|under|över|från|på)" "({NUM}|[1-9][0-9]?)" år"(" och uppåt"|"s ålder")?
!A {printAGE(yytext,1);}

Define NumexMsrAge035a
     [ [{runt} | {under} | {över} | {från} | {på}] { } [Ins(NUM) | Num19x] { år}
       ({ och uppåt} | {s ålder}) ] ;
Define NumexMsrAge035
     [ NumexMsrAge035a
       LC([{gruppen} | {spelare} | {flickor} | {unga} | {veteraner}
             | {kvinna} | {någon} | {sångare} | {kille} | {pojkar} | {elever}
             | {hion} | {dansare} | {anställda} | {människor} | {väljare}
             | Uu {ngdomar} | Kk {vinnor} | Pp {atienter} | Mm {än} | Bb {arn}
             | {vandrare} | {ungdom} | {atient} | {person} | Pp {ersoner}
             | {alla} | Mm {an} | {Ålder}]
          { })
       EndTag(NumexMsrAge) ] ; 317

!R ([Uu]nder|över|före)" "[^\n\t ]+" veckor"("s "|s)ålder(n)?
!A {printAGE(yytext,0);}

Define NumexMsrAge036a
     [ [Uu {nder} | {över} | {före}] { } Ins(Word) { veckor} [{s } | {s}] {ålder}
       ({n}) ] ;
Define NumexMsrAge036 [ NumexMsrAge036a   EndTag(NumexMsrAge) ] ; 318

!R ([Uu]nder|över|före)" "[^\n\t ]+" veckors "ålder(n)?
!A {printAGE(yytext,0);}

Define NumexMsrAge037a
     [ [Uu {nder} | {över} | {före}] { } Ins(Word) { veckors ålder} ({n}) ] ;
Define NumexMsrAge037 [ NumexMsrAge037a   EndTag(NumexMsrAge) ] ; 319

!R [Vv]id" "[0-9]+" veckors ålder"(n)?
!A {printAGE(yytext,1);}

Define NumexMsrAge038a [ Ins(Nums) { veckors ålder} ({n}) ] ;
Define NumexMsrAge038
     [ NumexMsrAge038a
       LC(Vv {id })
       EndTag(NumexMsrAge) ] ; 320

!R (kvinnorna|männen|[Hh]an|[Hh]on|patienterna|[Ff]lickan|[Pp]ojken|killen|[Åå]ldern|[Pp]appan|[Bb]arn|[Vv]i)" "(är|var)" "[^\n\t ]+" år"(" eller "äldre)?
!A {printAGE(yytext,2);}

Define NumexMsrAge039a [ Ins(Word) { år} ({ eller äldre}) ] ;
Define NumexMsrAge039
     [ NumexMsrAge039a
       LC([{kvinnorna} | {männen} | Hh {an} | Hh {on} | {patienterna}
             | Ff {lickan} | Pp {ojken} | {killen} | ["Å"|"å"] {ldern}
             | Pp {appan} | Bb {arn} | Vv {i}]
          { } [{är} | {var}] { })
       EndTag(NumexMsrAge) ] ; 321

!R ([Hh]an|[Hh]on|[Ff]lickan|[Pp]ojken)" icke "(är|var)" "[^\n\t ]*tio
!A {printAGE(yytext,3);}

Define NumexMsrAge040a [ NS* {tio} ] ;
Define NumexMsrAge040
     [ NumexMsrAge040a
       LC([Hh {an} | Hh {on} | Ff {lickan} | Pp {ojken}] { icke }
          [{är} | {var}] { })
       EndTag(NumexMsrAge) ] ; 322

!R [Bb]arnet" är över "[^\n\t ]+" "(månader|år)
!A {printAGE(yytext,2);}

Define NumexMsrAge041a [ {över } Ins(Word) { } [{månader} | {år}] ] ;
Define NumexMsrAge041
     [ NumexMsrAge041a
       LC(Bb {arnet är })
       EndTag(NumexMsrAge) ] ; 323

!R [Bb]arnet" är "([0-9]+|[0-9]+\-[0-9]+)" "(månader|år)
!A {printAGE(yytext,2);}

Define NumexMsrAge042a [Ins(Nums) | Ins(NumRange)] { } [{månader} | {år}] ;
Define NumexMsrAge042
     [ NumexMsrAge042a
       LC(Bb {arnet är })
       EndTag(NumexMsrAge) ] ; 324

!R [Bb]arnet" var "[0-9]+" "(månader|år)(" och "[0-9]+" månader")?
!A {printAGE(yytext,2);}

Define NumexMsrAge043a
     [ Ins(Nums) { } [{månader} | {år}] ({ och } Ins(Nums) { månader}) ] ;
Define NumexMsrAge043
     [ NumexMsrAge043a
       LC(Bb {arnet var })
       EndTag(NumexMsrAge) ] ; 325

!R [Bb]arnen" "[1-9]" och "[1-9]" "år
!A {printAGE(yytext,1);}

Define NumexMsrAge044a [ Num19 { och } Num19 { år} ] ;
Define NumexMsrAge044
     [ NumexMsrAge044a
       LC(Bb {arnen })
       EndTag(NumexMsrAge) ] ; 326

!R [Bb]arn" "(under|över)" "[^\n\t ]+" "(månader|[a-zåäö]*år|[a-zåäö]*året)
!A {printAGE(yytext,1);}

Define NumexMsrAge045a
     [{under} | {över}] { } Ins(Word) { }
     [{månader} | Lower* {år} | Lower* {året}] ;
Define NumexMsrAge045
     [ NumexMsrAge045a
       LC(Bb {arn })
       EndTag(NumexMsrAge) ] ; 327

!R [Bb]arn" "[^\n\t ]+\-[^\n\t ]+" "(månader|år)
!A {printAGE(yytext,1);}

Define NumexMsrAge046a [ Word {-} Ins(Word) { } [{månader} | {år}] ] ;
Define NumexMsrAge046
     [ NumexMsrAge046a
       LC(Bb {arn })
       EndTag(NumexMsrAge) ] ; 328

!R (kvinnorna|männen|dem|[Kk]vinnan|[Pp]atienten|[Mm]annen|[Pp]appan|[Bb]arnet|[Pp]ersonen|han|hon|[Bb]arn|[vv]i)" "(var|är)" "(nu|under|över|bara)" "({NUM}|[1-9][0-9]?)" år"(" gammal")?
!A {printAGE(yytext,2);}

Define NumexMsrAge047a
     [ [{nu} | {under} | {över} | {bara}] { } [Ins(NUM) | Num19x] { år} ({ gammal}) ] ;
Define NumexMsrAge047
     [ NumexMsrAge047a
       LC([{kvinnorna} | {männen} | {dem} | Kk {vinnan} | Pp {atienten}
             | Mm {annen} | Pp {appan} | Bb {arnet} | Pp {ersonen} | {han}
             | {hon} | Bb {arn} | ["v"|"v"] {i}]
          { } [{var} | {är}] { })
       EndTag(NumexMsrAge) ] ; 329

!R (var|är)" "(jag|du|han|hon)" "(över" "|snart" ")?[1-9][0-9]?" år"
!A {printAGE(yytext,2);}

Define NumexMsrAge048a [ ({över } | {snart }) Num19x { år} ] ;
Define NumexMsrAge048
     [ NumexMsrAge048a
       LC([{var} | {är}] { } [{jag} | {du} | {han} | {hon}] { })
       EndTag(NumexMsrAge) ] ; 330

!R ([Kk]vinna|[Mm]an)" \, "[0-9]+" år"
!A {printAGE(yytext,2);}

Define NumexMsrAge049a [ Ins(Nums) { år} ] ;
Define NumexMsrAge049
     [ NumexMsrAge049a
       LC([Kk {vinna} | Mm {an}] { , })
       EndTag(NumexMsrAge) ] ; 331

!R fyll(da|a|de|t|er)" "[0-9]+" , "[0-9]+" år"
!A {printAGE(yytext,1);}

Define NumexMsrAge050a [ Ins(Nums) { , } Ins(Nums) { år} ] ;
Define NumexMsrAge050
     [ NumexMsrAge050a
       LC({fyll} [{da} | {a} | {de} | {t} | {er}] { })
       EndTag(NumexMsrAge) ] ; 332

!R fyll(da|a|de|t|er)" "[^\n\t ]+" "[^\n\t ]+" "[0-9]+" år"
!A {printAGE(yytext,3);}

Define NumexMsrAge051a [ Ins(Nums) { år} ] ;
Define NumexMsrAge051
     [ NumexMsrAge051a
       LC({fyll} [{da} | {a} | {de} | {t} | {er}] { } Word { } Word { })
       EndTag(NumexMsrAge) ] ; 333

!R fyll(da|a|de|t|er)" "[^\n\t ]+" "[0-9]+" år"
!A {printAGE(yytext,2);}

Define NumexMsrAge052a [ Ins(Nums) { år} ] ;
Define NumexMsrAge052
     [ NumexMsrAge052a
       LC({fyll} [{da} | {a} | {de} | {t} | {er}] { } Word { })
       EndTag(NumexMsrAge) ] ; 334

!R fyll(da|a|de|t|er)" "[0-9]+" år"
!A {printAGE(yytext,1);}

Define NumexMsrAge053a [ Ins(Nums) { år} ] ;
Define NumexMsrAge053
     [ NumexMsrAge053a
       LC({fyll} [{da} | {a} | {de} | {t} | {er}] { })
       EndTag(NumexMsrAge) ] ; 335

!R "fyllda "[1-9][0-9]?(" år")?
!A {printAGE(yytext,1);}

Define NumexMsrAge054a [ Num19x ({ år}) ] ;
Define NumexMsrAge054
     [ NumexMsrAge054a
       LC({fyllda })
       EndTag(NumexMsrAge) ] ; 336

!R [Vv]id" fyllda "[a-zåäö]+" år"
!A {printAGE(yytext,2);}

Define NumexMsrAge055a [ Ins(LowerWord) { år} ] ;
Define NumexMsrAge055
     [ NumexMsrAge055a
       LC(Vv {id fyllda })
       EndTag(NumexMsrAge) ] ; 337

!R ([Hh]an|[Hh]on)" fyllde "[0-9]+(" år")?
!A {printAGE(yytext,2);}

Define NumexMsrAge056a [ Ins(Nums) ({ år}) ] ;
Define NumexMsrAge056
     [ NumexMsrAge056a
       LC([Hh {an} | Hh {on}] { fyllde })
       EndTag(NumexMsrAge) ] ; 338

!R (yngre|äldre)" än "[1-9][0-9]?(\-[1-9][0-9])?(" "månader|" "veckor|" "år)?
!A {printAGE(yytext,0);}

Define NumexMsrAge057a
     [ [{yngre} | {äldre}] { än } Num19x ({-} Num19X)
       ({ månader} | { veckor} | { år}) ] ;
Define NumexMsrAge057 [ NumexMsrAge057a   EndTag(NumexMsrAge) ] ; 339

!R ([1-9][0-9]|[1-9][0-9]?\-[1-9][0-9]?)" års"(ålder|" ålder")(n)?
!A {printAGE(yytext,0);}

Define NumexMsrAge058a
     [ [Num19X | Num19x {-} Num19x] { års} [{ålder} | { ålder}] ({n}) ] ;
Define NumexMsrAge058 [ NumexMsrAge058a   EndTag(NumexMsrAge) ] ; 340

!R [^\n\t ]*(spelare|flickor|unga|pojkar|elever|människor|[Uu]ngdomar|[Kk]vinnor|[Pp]atienter|[Mm]än|[Bb]arn|vandrare)" "[1-9][0-9]?" till "[1-9][0-9]?" år"(sålder|såldern|s" "åldern)?
!A {printAGE(yytext,1);}

Define NumexMsrAge059a
     [ Num19x { till } Num19x { år} ({sålder} | {såldern} | {s åldern}) ] ;
Define NumexMsrAge059
     [ NumexMsrAge059a
       LC([{spelare} | {flickor} | {unga} | {pojkar} | {elever}
             | {människor} | Uu {ngdomar} | Kk {vinnor} | Pp {atienter}
             | Mm {än} | Bb {arn} | {vandrare}]
          { })
       EndTag(NumexMsrAge) ] ; 341

!R [Tt]ill" "[1-9][0-9]?\-[1-9][0-9]?" år"(sålder|såldern|s" "åldern)?
!A {printAGE(yytext,1);}

Define NumexMsrAge060a
     [ Num19x {-} Num19x { år} ({sålder} | {såldern} | {s åldern}) ] ;
Define NumexMsrAge060
     [ NumexMsrAge060a
       LC(Tt {ill })
       EndTag(NumexMsrAge) ] ; 342

!R [^\n\t ]*(spelare|flickor|unga|pojkar|elever|människor|[Uu]ngdomar|[Kk]vinnor|[Pp]atienter|[Mm]än|[Bb]arn|vandrare)" upp "(till|mot)" "[1-9][0-9]?(" år"|\-år)(sålder|såldern|"s åldern")
!A {printAGE(yytext,1);}

Define NumexMsrAge061a
     [ {upp } [{till} | {mot}] { } Num19x [{ år} | {-år}]
       [{sålder} | {såldern} | {s åldern}] ] ;
Define NumexMsrAge061
     [ NumexMsrAge061a
       LC([{spelare} | {flickor} | {unga} | {pojkar} | {elever}
             | {människor} | Uu {ngdomar} | Kk {vinnor} | Pp {atienter}
             | Mm {än} | Bb {arn} | {vandrare}]
          { })
       EndTag(NumexMsrAge) ] ; 343

!R [^\n\t ]*(spelare|lickor|unga|kvinna|någon|sångare|pojkar|hion|dansare|anställda|människor|väljare|ngdomar|[Kk]vinnor|atienter|[Mm]än|[Bb]arn|vandrare|ungdom|juksköterskor|[Ee]lever)" mellan "([1-9][0-9]?|[0-9]\/[0-9])" "(till|och)" "[1-9][0-9]?" år"
!A {printAGE(yytext,2);}

Define NumexMsrAge062a
     [ [Num19x | Num {/} Num] { } [{till} | {och}] { } Num19x { år} ] ;
Define NumexMsrAge062
     [ NumexMsrAge062a
       LC([{spelare} | {lickor} | {unga} | {kvinna} | {någon} | {sångare}
             | {pojkar} | {hion} | {dansare} | {anställda} | {människor}
             | {väljare} | {ngdomar} | Kk {vinnor} | {atienter} | Mm {än}
             | Bb {arn} | {vandrare} | {ungdom} | {juksköterskor} | Ee {lever}]
          { mellan })
       EndTag(NumexMsrAge) ] ; 344

!R [^\n\t ]*(lickor|[Pp]ojkar|[Kk]vinnor|[Mm]än|[Bb]arn)" "(emellan|mellan)" "[^\n ]+ton" "(till|och)" "[^\n ]+ton" år"
!A {printAGE(yytext,2);}

Define NumexMsrAge063a [ Word {ton } [{till} | {och}] { } Word {ton år} ] ;
Define NumexMsrAge063
     [ NumexMsrAge063a
       LC([{lickor} | Pp {ojkar} | Kk {vinnor} | Mm {än} | Bb {arn}] { }
          [{emellan} | {mellan}] { })
       EndTag(NumexMsrAge) ] ; 345

!R "mellan "[1-9][0-9]?" och "[1-9][0-9]?" år"("s "|s)ålder(n)?
!A {printAGE(yytext,0);}

Define NumexMsrAge064a
     [ {mellan } Num19x { och } Num19x { år} [{s } | {s}] {ålder} ({n}) ] ;
Define NumexMsrAge064 [ NumexMsrAge064a   EndTag(NumexMsrAge) ] ; 346

!R "ålder över "[0-9]+" år"
!A {printAGE(yytext,1);}

Define NumexMsrAge065a [ {över } Ins(Nums) { år} ] ;
Define NumexMsrAge065
     [ NumexMsrAge065a
       LC({ålder })
       EndTag(NumexMsrAge) ] ; 347

!R [Åå]"ldrarna "[1-9][0-9]?\-[1-9][0-9]?(" år")?
!A {printAGE(yytext,1);}

Define NumexMsrAge066a [ Num19x {-} Num19x ({ år}) ] ;
Define NumexMsrAge066
     [ NumexMsrAge066a
       LC(["Å"|"å"] {ldrarna })
       EndTag(NumexMsrAge) ] ; 348

!R [Åå]"ldrarna "[1-9][0-9]?" månader upp till "[1-9][0-9]?" år"
!A {printAGE(yytext,1);}

Define NumexMsrAge067a [ Num19x { månader upp till } Num19x { år} ] ;
Define NumexMsrAge067
     [ NumexMsrAge067a
       LC(["Å"|"å"] {ldrarna })
       EndTag(NumexMsrAge) ] ; 349

!R "ålder av "[1-9][0-9]+" år"
!A {printAGE(yytext,1);}

Define NumexMsrAge068a [ {av } Num19 Ins(Nums) { år} ] ;
Define NumexMsrAge068
     [ NumexMsrAge068a
       LC({ålder })
       EndTag(NumexMsrAge) ] ; 350

!R [1-9][0-9]+" år eller yngre"
!A {printAGE(yytext,0);}

Define NumexMsrAge069a [ Num19 Ins(Nums) { år eller yngre} ] ;
Define NumexMsrAge069 [ NumexMsrAge069a   EndTag(NumexMsrAge) ] ; 351

!R (till|[Rr]unt)" "[0-9\-]+årsåldern
!A {printAGE(yytext,0);}

Define NumexMsrAge070a
     [ [{till} | Rr {unt}] { } DigitDashes {årsåldern} ] ;
Define NumexMsrAge070 [ NumexMsrAge070a   EndTag(NumexMsrAge) ] ; 352

!R [Ii]" "[^\n\t ]+\-" \, "[^\n\t ]+årsålder(n)?
!A {printAGE(yytext,0);}

Define NumexMsrAge071a [ Ii { } Word {- , } Word {årsålder} ({n}) ] ;
Define NumexMsrAge071 [ NumexMsrAge071a   EndTag(NumexMsrAge) ] ; 353

!R (är|var|blev)" "(runt|under|över|ungefär)" "({NUM}|[1-9][0-9]?)" år"
!A {printAGE(yytext,1);}

Define NumexMsrAge072a
     [ [{runt} | {under} | {över} | {ungefär}] { } [Ins(NUM) | Num19x] { år} ] ;
Define NumexMsrAge072
     [ NumexMsrAge072a
       LC([{är} | {var} | {blev}] { })
       EndTag(NumexMsrAge) ] ; 354

!R "deltagarna i genomsnitt "[1-9][0-9]+" år"
!A {printAGE(yytext,1);}

Define NumexMsrAge073a [ {i genomsnitt } Num19 Ins(Nums) { år} ] ;
Define NumexMsrAge073
     [ NumexMsrAge073a
       LC({deltagarna })
       EndTag(NumexMsrAge) ] ; 355

!R "\, "[1-9][0-9]?" år"
!A {printAGE(yytext,1);}

Define NumexMsrAge074a [ Num19x { år} ] ;
Define NumexMsrAge074
     [ NumexMsrAge074a
       LC({, })
       EndTag(NumexMsrAge) ] ; 356

!R "de under "[^\n\t ]+" "år
!A {printAGE(yytext,0);}

Define NumexMsrAge075a [ {de under } Ins(Word) { år} ] ;
Define NumexMsrAge075 [ NumexMsrAge075a   EndTag(NumexMsrAge) ] ; 357

!R [Tt]illåten" från "[^\n\t ]+" år"
!A {printAGE(yytext,1);}

Define NumexMsrAge076a [ {från } Ins(Word) { år} ] ;
Define NumexMsrAge076
     [ NumexMsrAge076a
       LC(Tt {illåten })
       EndTag(NumexMsrAge) ] ; 358

!R vara" "{NUM}" eller "{NUM}" år"
!A {printAGE(yytext,1);}

Define NumexMsrAge077a [ Ins(NUM) { eller } Ins(NUM) { år} ] ;
Define NumexMsrAge077
     [ NumexMsrAge077a
       LC({vara })
       EndTag(NumexMsrAge) ] ; 359

!R (man|du|han|hon|jag)" "(är|fyller)" "(tjugu|[1-9][0-9]?)" år"
!A {printAGE(yytext,2);}

Define NumexMsrAge078a [ [{tjugu} | Num19x] { år} ] ;
Define NumexMsrAge078
     [ NumexMsrAge078a
       LC([{man} | {du} | {han} | {hon} | {jag}] { } [{är} | {fyller}] { })
       EndTag(NumexMsrAge) ] ; 360

!R ([Hh]an|[Hh]on)" fyller sina "[a-zåäö]+" år"
!A {printAGE(yytext,3);}

Define NumexMsrAge079a [ Ins(LowerWord) { år} ] ;
Define NumexMsrAge079
     [ NumexMsrAge079a
       LC([Hh {an} | Hh {on}] { fyller sina })
       EndTag(NumexMsrAge) ] ; 361

!R fyllt" mitt tjugonde "år
!A {printAGE(yytext,2);}

Define NumexMsrAge080a [ {tjugonde år} ] ;
Define NumexMsrAge080
     [ NumexMsrAge080a
       LC({fyllt mitt })
       EndTag(NumexMsrAge) ] ; 362

!R "måste vara "(under" "|över" ")?[1-9][0-9]?" år"
!A {printAGE(yytext,2);}

Define NumexMsrAge081a [ ({under } | {över }) Num19x { år} ] ;
Define NumexMsrAge081
     [ NumexMsrAge081a
       LC({måste vara })
       EndTag(NumexMsrAge) ] ; 363

!R (blev|Är)" "[1-9][0-9]?" år"
!A {printAGE(yytext,1);}

Define NumexMsrAge082a [ Num19x { år} ] ;
Define NumexMsrAge082
     [ NumexMsrAge082a
       LC([{blev} | {Är}] { })
       EndTag(NumexMsrAge) ] ; 364

!R Å[Ll][Dd][Ee][Rr]" \: "[1-9][0-9]?\+?(" år")?
!A {printAGE(yytext,2);}

Define NumexMsrAge083a [ Num19x ({+}) ({ år}) ] ;
Define NumexMsrAge083
     [ NumexMsrAge083a
       LC({Å} Ll Dd Ee Rr { : })
       EndTag(NumexMsrAge) ] ; 365

!R "vid "[^\n\t ]+" ung ålder"
!A {printAGE(yytext,0);}

Define NumexMsrAge084a [ {vid } Ins(Word) { ung ålder} ] ;
Define NumexMsrAge084 [ NumexMsrAge084a   EndTag(NumexMsrAge) ] ; 366

!R ([Jj]ag" var"|"åldern var"|"yngsta är"|"män är"|"yngsta var"|"äldsta är"|"äldsta var"|"är ju")(" "bara)?" "([0-9]+|{NUM})" "(månader|år)
!A {printAGE(yytext,2);}

Define NumexMsrAge085a
     [ ({bara }) [Ins(Nums) | Ins(NUM)] { } [{månade} | {å}] {r} ] ;
Define NumexMsrAge085
     [ NumexMsrAge085a
       LC([Jj {ag var} | {åldern var} | {yngsta är} | {män är}
             | {yngsta var} | {äldsta är} | {äldsta var} | {är ju}]
          { })
       EndTag(NumexMsrAge) ] ; 367

!R ([Jj]ag" var"|"åldern var"|"yngsta är"|"män är"|"yngsta var"|"äldsta är"|"äldsta var"|"är ju")(" "bara)?" "[0-9]+år
!A {printAGE(yytext,2);}

Define NumexMsrAge086a [ ({bara }) Ins(Nums) {år} ] ;
Define NumexMsrAge086
     [ NumexMsrAge086a
       LC([Jj {ag var} | {åldern var} | {yngsta är} | {män är}
             | {yngsta var} | {äldsta är} | {äldsta var} | {är ju}]
          { })
       EndTag(NumexMsrAge) ] ; 368

!R "är "[^\n\t ]+" år äldre"
!A {printAGE(yytext,1);}

Define NumexMsrAge087a [ Ins(Word) { år äldre} ] ;
Define NumexMsrAge087
     [ NumexMsrAge087a
       LC({är })
       EndTag(NumexMsrAge) ] ; 369

!R "fall under "[1-9][0-9]" "år
!A {printAGE(yytext,1);}

Define NumexMsrAge088a [ {under } Num19X { år} ] ;
Define NumexMsrAge088
     [ NumexMsrAge088a
       LC({fall })
       EndTag(NumexMsrAge) ] ; 370

!R ([Rr]edan" ")?([Vv]id" cirka "|[Vv]id" "|[Ff]"rån noll till cirka ")?ett" "(halvt" ")?års" "ålder
!A {printAGE(yytext,0);}

Define NumexMsrAge089a
     [ (Rr {edan }) (Vv {id cirka } | Vv {id } | Ff {rån noll till cirka })
       {ett } ({halvt }) {års ålder} ] ;
Define NumexMsrAge089 [ NumexMsrAge089a   EndTag(NumexMsrAge) ] ; 371

!R "till "[^\n\t ]+" års ålder"
!A {printAGE(yytext,1);}

Define NumexMsrAge090a [ Ins(Word) { års ålder} ] ;
Define NumexMsrAge090
     [ NumexMsrAge090a
       LC({till })
       EndTag(NumexMsrAge) ] ; 372

!R [Åå]ldermässigt" är de mellan "[^\n\t ]+" och "[^\n\t ]+" år"
!A {printAGE(yytext,3);}

Define NumexMsrAge091a [ {mellan } Ins(Word) { och } Ins(Word) { år} ] ;
Define NumexMsrAge091
     [ NumexMsrAge091a
       LC(["Å"|"å"] {ldermässigt är de })
       EndTag(NumexMsrAge) ] ; 373

!R [^\n\t ]*(kvinna|[Bb]arn|människa|son|dotter|man)" \, bara "[1-9][0-9]?" år"
!A {printAGE(yytext,2);}

Define NumexMsrAge092a [ {bara } Num19x { år} ] ;
Define NumexMsrAge092
     [ NumexMsrAge092a
       LC([{kvinna} | Bb {arn} | {människa} | {son} | {dotter} | {man}]
          { , })
       EndTag(NumexMsrAge) ] ; 374

!R [Yy]ngre" åldersgrupper \( \< "[0-9][0-9]" år"
!A {printAGE(yytext,4);}

Define NumexMsrAge093a [ Ins(Nums2) { år} ] ;
Define NumexMsrAge093
     [ NumexMsrAge093a
       LC(Yy {ngre åldersgrupper ( < })
       EndTag(NumexMsrAge) ] ; 375

!R [^\n\t ]*(kvinna|[Bb]arn|människa|son|dotter|man|vinnor)" \, "[1-9][0-9\-]*" år"
!A {printAGE(yytext,2);}

Define NumexMsrAge094a [ Num19 DigitDash* { år} ] ;
Define NumexMsrAge094
     [ NumexMsrAge094a
       LC([{kvinna} | Bb {arn} | {människa} | {son} | {dotter} | {man}
             | {vinnor}]
          { , })
       EndTag(NumexMsrAge) ] ; 376

!R [^\n\t ]*([Bb]arn|[Mm]än|[Kk]vinnor)" "(\&lt\;|\&gt\;|\<|\>)" "[1-9][0-9\-]*" år"
!A {printAGE(yytext,2);}

Define NumexMsrAge095a [ Num19 DigitDash* { år} ] ;
Define NumexMsrAge095
     [ NumexMsrAge095a
       LC([Bb {arn} | Mm {än} | Kk {vinnor}] { }
          [{&lt;} | {&gt;} | {<} | {>}] { })
       EndTag(NumexMsrAge) ] ; 377

!R [^\n\t ]*([Bb]arn|människor|män|vinnor)" "[1-9][0-9\-]*" år"
!A {printAGE(yytext,1);}

Define NumexMsrAge096a [ Num19 DigitDash* { år} ] ;
Define NumexMsrAge096
     [ NumexMsrAge096a
       LC([Bb {arn} | {människor} | {män} | {vinnor}] { })
       EndTag(NumexMsrAge) ] ; 378

!R [^\n\t ]*([Bb]arn|änniskor|vinnor|atienter|ngdomar)" \( "[1-9][0-9]?\-[1-9][0-9]?" år \)"
!A {printAGE(yytext,1);}

Define NumexMsrAge097a [ {( } Num19x {-} Num19x { år )} ] ;
Define NumexMsrAge097
     [ NumexMsrAge097a
       LC([Bb {arn} | {änniskor} | {vinnor} | {atienter} | {ngdomar}] { })
       EndTag(NumexMsrAge) ] ; 379

!R ([Jj]ag|[Hh]an|[Hh]on|atienten)" var "[a-z]*ton(" år")?
!A {printAGE(yytext,2);}

Define NumexMsrAge098a [ Az* {ton} ({ år}) ] ;
Define NumexMsrAge098
     [ NumexMsrAge098a
       LC([Jj {ag} | Hh {an} | Hh {on} | {atienten}] { var })
       EndTag(NumexMsrAge) ] ; 380

!R ([Hh]an|[Hh]on)" var "[0-9]+" "dagar
!A {printAGE(yytext,2);}

Define NumexMsrAge099a [ Ins(Nums) { dagar} ] ;
Define NumexMsrAge099
     [ NumexMsrAge099a
       LC([Hh {an} | Hh {on}] { var })
       EndTag(NumexMsrAge) ] ; 381

!R ([Jj]ag|[Hh]an|[Hh]on)" var ca "[1-9][0-9]?(" år")?
!A {printAGE(yytext,2);}

Define NumexMsrAge100a [ {ca } Num19x ({ år}) ] ;
Define NumexMsrAge100
     [ NumexMsrAge100a
       LC([Jj {ag} | Hh {an} | Hh {on}] { var })
       EndTag(NumexMsrAge) ] ; 382

!R ([Jj]ag|[Hh]an|[Hh]on)" är "[1-9][0-9]?" år"
!A {printAGE(yytext,2);}

Define NumexMsrAge101a [ Num19x { år} ] ;
Define NumexMsrAge101
     [ NumexMsrAge101a
       LC([Jj {ag} | Hh {an} | Hh {on}] { är })
       EndTag(NumexMsrAge) ] ; 383

!R ([Jj]ag|[Hh]an|[Hh]on)" är bara "[^\n\t ]+" år"
!A {printAGE(yytext,2);}

Define NumexMsrAge102a [ {bara } Ins(Word) { år} ] ;
Define NumexMsrAge102
     [ NumexMsrAge102a
       LC([Jj {ag} | Hh {an} | Hh {on}] { är })
       EndTag(NumexMsrAge) ] ; 384

!R ([Pp]atienten|[Mm]edelåldern)" var "([0-9]+" ± "[0-9]+" år"|[0-9]+±[0-9])
!A {printAGE(yytext,2);}

Define NumexMsrAge103a [ Ins(Nums) { ± } Ins(Nums) { år} | Ins(Nums) {±} Num ] ;
Define NumexMsrAge103
     [ NumexMsrAge103a
       LC([Pp {atienten} | Mm {edelåldern}] { var })
       EndTag(NumexMsrAge) ] ; 385

!R ([Jj]ag|[Hh]an|[Hh]on)" var "[^\n\t ]+" och ett "[^\n ]+" år gammal"
!A {printAGE(yytext,2);}

Define NumexMsrAge104a [ Ins(Word) { och ett } Ins(Word) { år gammal} ] ;
Define NumexMsrAge104
     [ NumexMsrAge104a
       LC([Jj {ag} | Hh {an} | Hh {on}] { var })
       EndTag(NumexMsrAge) ] ; 386

!R [Bb]arn" är "[1-9]" år och ett "[0-9]+" månader"
!A {printAGE(yytext,2);}

Define NumexMsrAge105a [ Num19 { år och ett } Ins(Nums) { månader} ] ;
Define NumexMsrAge105
     [ NumexMsrAge105a
       LC(Bb {arn är })
       EndTag(NumexMsrAge) ] ; 387

!R [^\n\t ]*ålder(n)?" bland dessa var "[0-9]+" "år
!A {printAGE(yytext,4);}

Define NumexMsrAge106a [ Ins(Nums) { år} ] ;
Define NumexMsrAge106
     [ NumexMsrAge106a
       LC({ålder} ({n}) { bland dessa var })
       EndTag(NumexMsrAge) ] ; 388

!R [^\n\t ]*ålder(n)?" på "[0-9]+(\,[0-9])?" "år
!A {printAGE(yytext,2);}

Define NumexMsrAge107a [ Ins(Nums) ({,} Num) { år} ] ;
Define NumexMsrAge107
     [ NumexMsrAge107a
       LC({ålder} ({n}) { på })
       EndTag(NumexMsrAge) ] ; 389

!R [^\n\t ]*ålder(n)?" "[0-9]+\.[0-9]+" "år
!A {printAGE(yytext,1);}

Define NumexMsrAge108a [ Ins(NumsDotNums) { år} ] ;
Define NumexMsrAge108
     [ NumexMsrAge108a
       LC({ålder} ({n}) { })
       EndTag(NumexMsrAge) ] ; 390

!R [Bb]land" dem "(över|under)" "[1-9][0-9]" år"
!A {printAGE(yytext,2);}

Define NumexMsrAge109a [ [{över} | {under}] { } Num19X { år} ] ;
Define NumexMsrAge109
     [ NumexMsrAge109a
       LC(Bb {land dem })
       EndTag(NumexMsrAge) ] ; 391

!R [Pp]atienterna" var i genomsnitt "[1-9][0-9]" år"
!A {printAGE(yytext,2);}

Define NumexMsrAge110a [ {i genomsnitt } Num19X { år} ] ;
Define NumexMsrAge110
     [ NumexMsrAge110a
       LC(Pp {atienterna var })
       EndTag(NumexMsrAge) ] ; 392

!R (kvinnor|männen|[Pp]atienter|[Bb]arn|[Pp]ersoner)(na)?" "[0-9]+" år"(" eller "äldre)?
!A {printAGE(yytext,1);}

Define NumexMsrAge111a [ Ins(Nums) { år} ({ eller äldre}) ] ;
Define NumexMsrAge111
     [ NumexMsrAge111a
       LC([{kvinnor} | {männen} | Pp {atienter} | Bb {arn} | Pp {ersoner}]
          ({na}) { })
       EndTag(NumexMsrAge) ] ; 393

!R "som idag är "[0-9]+" år"
!A {printAGE(yytext,3);}

Define NumexMsrAge112a [ Ins(Nums) { år} ] ;
Define NumexMsrAge112
     [ NumexMsrAge112a
       LC({som idag är })
       EndTag(NumexMsrAge) ] ; 394

!R "män under "[1-9][0-9]" \."
!A {int i=4; printf("män <NUMEX TYPE=\"MSR\" SBT=\"AGE\">"); for(;yytext[i]!=' '; putchar(yytext[i++])); putchar(' '); i++; for(;yytext[i]!=' '; putchar(yytext[i++])); printf("</NUMEX> .");}

Define NumexMsrAge113
     [ {under } Num19X
       LC({män })
       RC({ .})
       EndTag(NumexMsrAge) ] ; 395

!R [1-9][0-9]?" år äldre"
!A {int i=0; printf("<NUMEX TYPE=\"MSR\" SBT=\"AGE\">"); for(;yytext[i]!=' '; putchar(yytext[i++])); putchar(' '); i++; for(;yytext[i]!=' '; putchar(yytext[i++])); printf("</NUMEX> äldre");}

Define NumexMsrAge114
     [ Num19x { år}
       RC({ äldre})
       EndTag(NumexMsrAge) ] ; 396

!R [Uu]nder" sina första "[^\n\t ]+" dagar i livet"
!A {int i=0; printf("<NUMEX TYPE=\"MSR\" SBT=\"AGE\">"); for(;yytext[i]!=' '; putchar(yytext[i++])); putchar(' '); i++; for(;yytext[i]!=' '; putchar(yytext[i++])); putchar(' '); i++; for(;yytext[i]!=' '; putchar(yytext[i++])); putchar(' '); i++; for(;yytext[i]!=' '; putchar(yytext[i++])); putchar(' '); i++;for(;yytext[i]!=' '; putchar(yytext[i++])); printf("</NUMEX>"); for(;i<yyleng;putchar(yytext[i++]));}

Define NumexMsrAge115
     [ Uu {nder sina första } Word { dagar}
       RC({ i livet})
       EndTag(NumexMsrAge) ] ; 397

!R ([Pp]nr" "|[Pp]ersonnummer" ")?[0-9][0-9][0-9][0-9][0-9][0-9]\-[0-9][0-9][0-9][0-9]
!A {printAGE(yytext,0);}

Define NumexMsrAge116a [ (Pp {nr } | Pp {ersonnummer }) Ins(Nums6) {-} Ins(Nums4) ] ;
Define NumexMsrAge116 [ NumexMsrAge116a   EndTag(NumexMsrAge) ] ; 398

!R [Ff]"rån "[1-9][0-9]?" år och uppåt"
!A {printAGE(yytext,0);}

Define NumexMsrAge117a [ Ff {rån } Num19x { år och uppåt} ] ;
Define NumexMsrAge117 [ NumexMsrAge117a   EndTag(NumexMsrAge) ] ; 399

!R [1-9][0-9]?" år och äldre"
!A {printAGE(yytext,0);}

Define NumexMsrAge118a [ Num19x { år och äldre} ] ;
Define NumexMsrAge118 [ NumexMsrAge118a   EndTag(NumexMsrAge) ] ; 400

!R [Ll]"ivet efter "[^\n\t ]+tio
!A {printAGE(yytext,2);}

Define NumexMsrAge119a [ Word {tio} ] ;
Define NumexMsrAge119
     [ NumexMsrAge119a
       LC(Ll {ivet efter })
       EndTag(NumexMsrAge) ] ; 401

!R [1-9][0-9]?\-[1-9][0-9]?"\-år gammal"
!A {printAGE(yytext,0);}

Define NumexMsrAge120a [ Num19x {-} Num19x {-år gammal} ] ;
Define NumexMsrAge120 [ NumexMsrAge120a   EndTag(NumexMsrAge) ] ; 402

!R [^\n\t ]*"ldersgruppen "[0-9]+\-[0-9]+(\-år|" år")?
!A {printAGE(yytext,0);}

Define NumexMsrAge121a [ NS* {ldersgruppen } Ins(NumRange) ({-år} | { år}) ] ;
Define NumexMsrAge121 [ NumexMsrAge121a   EndTag(NumexMsrAge) ] ; 403

!R [^\n\t ]*"ldersgruppen "[0-9]+" månader till "[0-9]+" år"
!A {printAGE(yytext,0);}

Define NumexMsrAge122a
     [ NS* {ldersgruppen } Ins(Nums) { månader till } Ins(Nums) { år} ] ;
Define NumexMsrAge122 [ NumexMsrAge122a   EndTag(NumexMsrAge) ] ; 404

!R [^\n\t ]*ålder(n)?" "[0-9]+" \( "[0-9]+\-[0-9]+" \) år"
!A {printAGE(yytext,0);}

Define NumexMsrAge123a
     [ NS* {ålder} ({n}) { } Ins(Nums) { ( } Ins(NumRange) { ) år} ] ;
Define NumexMsrAge123 [ NumexMsrAge123a   EndTag(NumexMsrAge) ] ; 405

!R [^\n\t ]*(vuxna|åldern|efolkningen)" "[0-9]"\-"[0-9]+" år"
!A {printAGE(yytext,1);}

Define NumexMsrAge124a [ Num {-} Ins(Nums) { år} ] ;
Define NumexMsrAge124
     [ NumexMsrAge124a
       LC([{vuxna} | {åldern} | {efolkningen}] { })
       EndTag(NumexMsrAge) ] ; 406

!R efolkning" är "[1-9][0-9]" år eller mer"
!A {printAGE(yytext,2);}

Define NumexMsrAge125a [ Num19X { år eller mer} ] ;
Define NumexMsrAge125
     [ NumexMsrAge125a
       LC({efolkning är })
       EndTag(NumexMsrAge) ] ; 407

!R [^\n\t ]*"åldern är "[0-9]+\.[0-9]+
!A {printAGE(yytext,2);}

Define NumexMsrAge126a [ Ins(NumsDotNums) ] ;
Define NumexMsrAge126
     [ NumexMsrAge126a
       LC({åldern är })
       EndTag(NumexMsrAge) ] ; 408

!R [^\n\t ]*(lickor|ojkar|änniskor|ngdomar|vinnor|atienter|[Mm]än|[Bb]arn)" \( "[0-9]+\-[0-9]+" \) år"
!A {printAGE(yytext,1);}

Define NumexMsrAge127a [ {( } Ins(NumRange) { ) år} ] ;
Define NumexMsrAge127
     [ NumexMsrAge127a
       LC([{lickor} | {ojkar} | {änniskor} | {ngdomar} | {vinnor}
             | {atienter} | Mm {än} | Bb {arn}]
          { })
       EndTag(NumexMsrAge) ] ; 409

!R [^\n\t ]*(lickor|ojkar|änniskor|ngdomar|[Kk]vinnor|[Pp]atienter|[Mm]än|[Bb]arn)" \, "[0-9]+\-[0-9]+" år"
!A {printAGE(yytext,2);}

Define NumexMsrAge128a [ Ins(NumRange) { år} ] ;
Define NumexMsrAge128
     [ NumexMsrAge128a
       LC([{lickor} | {ojkar} | {änniskor} | {ngdomar} | Kk {vinnor}
             | Pp {atienter} | Mm {än} | Bb {arn}]
          { , })
       EndTag(NumexMsrAge) ] ; 410

!R [^\n\t ]*ersoner" mellan "[0-9]+" och "[0-9]+(" "år)?
!A {printAGE(yytext,1);}

Define NumexMsrAge129a [ {mellan } Ins(Nums) { och } Ins(Nums) ({ år}) ] ;
Define NumexMsrAge129
     [ NumexMsrAge129a
       LC({ersoner })
       EndTag(NumexMsrAge) ] ; 411

!R [Bb]"arn mellan "[^\n ]+" månader och "[0-9]+" "år
!A {printAGE(yytext,1);}

Define NumexMsrAge130a [ {mellan } Ins(Word) { månader och } Ins(Nums) { år} ] ;
Define NumexMsrAge130
     [ NumexMsrAge130a
       LC(Bb {arn })
       EndTag(NumexMsrAge) ] ; 412

!R [Ll]ivslängd" \: "[0-9]+\.[0-9]+" år"
!A {printAGE(yytext,2);}

Define NumexMsrAge131a [ Ins(NumsDotNums) { år} ] ;
Define NumexMsrAge131
     [ NumexMsrAge131a
       LC(Ll {ivslängd : })
       EndTag(NumexMsrAge) ] ; 413

!R "De var mellan "[0-9]+" och "[0-9]+" år"
!A {printAGE(yytext,2);}

Define NumexMsrAge132a [ {mellan } Ins(Nums) { och } Ins(Nums) { år} ] ;
Define NumexMsrAge132
     [ NumexMsrAge132a
       LC({De var })
       EndTag(NumexMsrAge) ] ; 414

!R [Bb]arn" "[^\n\t ]+" och "[^\n\t ]+" "(månader|år)
!A {printAGE(yytext,1);}

Define NumexMsrAge133a [ Ins(Word) { och } Ins(Word) { } [{månader} | {år}] ] ;
Define NumexMsrAge133
     [ NumexMsrAge133a
       LC(Bb {arn })
       EndTag(NumexMsrAge) ] ; 415

!R [1-9][0-9]?" years old"
!A {printAGE(yytext,0);}

Define NumexMsrAge134a [ Num19x { years old} ] ;
Define NumexMsrAge134 [ NumexMsrAge134a   EndTag(NumexMsrAge) ] ; 416

!R (dotter|son|tjej|syster|bror)" som är "([0-9][0-9]?|tre|fyra|fem)" år"
!A {printAGE(yytext,3);}

Define NumexMsrAge135a [ [Ins(Nums12) | {tre} | {fyra} | {fem}] { år} ] ;
Define NumexMsrAge135
     [ NumexMsrAge135a
       LC([{dotter} | {son} | {tjej} | {syster} | {bror}] { som är })
       EndTag(NumexMsrAge) ] ; 417

!R (flicka|pojke|tjej|kille)" på "[0-9][0-9]?" år"
!A {printAGE(yytext,2);}

Define NumexMsrAge136a [ Ins(Nums12) { år} ] ;
Define NumexMsrAge136
     [ NumexMsrAge136a
       LC([{flicka} | {pojke} | {tjej} | {kille}] { på })
       EndTag(NumexMsrAge) ] ; 418

!R [Pp]ersoner" \( "[0-9][0-9]" år"
!A {printAGE(yytext,2);}

Define NumexMsrAge137a [ Ins(Nums2) { år} ] ;
Define NumexMsrAge137
     [ NumexMsrAge137a
       LC(Pp {ersoner ( })
       EndTag(NumexMsrAge) ] ; 419

!R [Pp]ersoner" \> "[0-9][0-9]" år"
!A {printAGE(yytext,2);}

Define NumexMsrAge138a [ Ins(Nums2) { år} ] ;
Define NumexMsrAge138
     [ NumexMsrAge138a
       LC(Pp {ersoner > })
       EndTag(NumexMsrAge) ] ; 420

!R "nu är "[0-9][0-9]" år"
!A {printAGE(yytext,2);}

Define NumexMsrAge139a [ Ins(Nums2) { år} ] ;
Define NumexMsrAge139
     [ NumexMsrAge139a
       LC({nu är })
       EndTag(NumexMsrAge) ] ; 421

!R "med sina "[0-9][0-9]" "(år|månader)
!A {printAGE(yytext,2);}

Define NumexMsrAge140a [ Ins(Nums2) { } [{år} | {månader}] ] ;
Define NumexMsrAge140
     [ NumexMsrAge140a
       LC({med sina })
       EndTag(NumexMsrAge) ] ; 422

!R [^\n\t ]+" och ett halvt årsålder"(n)?
!A {printAGE(yytext,0);}

Define NumexMsrAge141a [ Ins(Word) { och ett halvt årsålder} ({n}) ] ;
Define NumexMsrAge141 [ NumexMsrAge141a   EndTag(NumexMsrAge) ] ; 423

!R [0-9]\-[0-9]" årsåldern"
!A {printAGE(yytext,0);}

Define NumexMsrAge142a [ Num {-} Num { årsåldern} ] ;
Define NumexMsrAge142 [ NumexMsrAge142a   EndTag(NumexMsrAge) ] ; 424

!R [Ii]" "([a-zåäö]*tio|tre|fem|sex|sju|åtta|nio|två)årsålder(n)?
!A {printAGE(yytext,0);}

Define NumexMsrAge143a
     [ Ii { }
       [Lower* {tio} | {tre} | {fem} | {sex} | {sju} | {åtta} | {nio}
          | {två}]
       {årsålder} ({n}) ] ;
Define NumexMsrAge143 [ NumexMsrAge143a   EndTag(NumexMsrAge) ] ; 425

!R [0-9]+\-"års\-åldern"
!A {printAGE(yytext,0);}

Define NumexMsrAge144a [ Ins(Nums) {-års-åldern} ] ;
Define NumexMsrAge144 [ NumexMsrAge144a   EndTag(NumexMsrAge) ] ; 426

!R [^\n ]+" och ett halvt respektive drygt "[^\n ]+" år"
!A {printAGE(yytext,0);}

Define NumexMsrAge145a
     [ Ins(Word) { och ett halvt respektive drygt } Ins(Word) { år} ] ;
Define NumexMsrAge145 [ NumexMsrAge145a   EndTag(NumexMsrAge) ] ; 427

!R (kvinnor|män)" som "[a-zåäö]+" är "[1-9][0-9]" "år
!A {printAGE(yytext,4);}

Define NumexMsrAge146a [ Num19X { år} ] ;
Define NumexMsrAge146
     [ NumexMsrAge146a
       LC([{kvinnor} | {män}] { som } LowerWord { är })
       EndTag(NumexMsrAge) ] ; 428

!R [^\n ]+"ldern ligger på "[0-9][0-9]" år"
!A {printAGE(yytext,3);}

Define NumexMsrAge147a [ Ins(Nums2) { år} ] ;
Define NumexMsrAge147
     [ NumexMsrAge147a
       LC(Word {ldern ligger på })
       EndTag(NumexMsrAge) ] ; 429

!R [^\n ]+"lder varierade från "[0-9][0-9]?" till "[0-9][0-9]?" år"
!A {printAGE(yytext,2);}

Define NumexMsrAge148a [ {från } Ins(Nums12) { till } Ins(Nums12) { år} ] ;
Define NumexMsrAge148
     [ NumexMsrAge148a
       LC(Word {lder varierade })
       EndTag(NumexMsrAge) ] ; 430

!R [SsRr]edan" "[0-9]+års" "ålder(n)?
!A {printAGE(yytext,0);}

Define NumexMsrAge149a
     [ ["S"|"s"|"R"|"r"] {edan } Ins(Nums) {års ålder} ({n}) ] ;
Define NumexMsrAge149 [ NumexMsrAge149a   EndTag(NumexMsrAge) ] ; 431

!R [Vv]ar" "[a-zåäö]+e" svensk över "[1-9][0-9]
!A {printAGE(yytext,3);}

Define NumexMsrAge150a [ {över } Num19X ] ;
Define NumexMsrAge150
     [ NumexMsrAge150a
       LC(Vv {ar } LowerWord%_e { svensk })
       EndTag(NumexMsrAge) ] ; 432

!R (barn|baby)" som är några månader"(" gammal")?
!A {printAGE(yytext,3);}

Define NumexMsrAge151a [ {några månader} ({ gammal}) ] ;
Define NumexMsrAge151
     [ NumexMsrAge151a
       LC([{barn} | {baby}] { som är })
       EndTag(NumexMsrAge) ] ; 433

!R [Bb]arnets" första "[a-zåäö]+" månader"
!A {printAGE(yytext,1);}

Define NumexMsrAge152a [ {första } Ins(LowerWord) { månader} ] ;
Define NumexMsrAge152
     [ NumexMsrAge152a
       LC(Bb {arnets })
       EndTag(NumexMsrAge) ] ; 434

!R [Bb]arn" under "[1-9][0-9]?" månaders ålder"
!A {printAGE(yytext,1);}

Define NumexMsrAge153a [ {under } Num19x { månaders ålder} ] ;
Define NumexMsrAge153
     [ NumexMsrAge153a
       LC(Bb {arn })
       EndTag(NumexMsrAge) ] ; 435

!R "gruppen "[1-9][0-9]?" \- "[1-9][0-9]?" år"
!A {printAGE(yytext,1);}

Define NumexMsrAge154a [ Num19x { - } Num19x { år} ] ;
Define NumexMsrAge154
     [ NumexMsrAge154a
       LC({gruppen })
       EndTag(NumexMsrAge) ] ; 436

!R "gruppen "[1-9][0-9]?"\-"[1-9][0-9]?" år"
!A {printAGE(yytext,1);}

Define NumexMsrAge155a [ Num19x {-} Num19x { år} ] ;
Define NumexMsrAge155
     [ NumexMsrAge155a
       LC({gruppen })
       EndTag(NumexMsrAge) ] ; 437

!R "är "[1-9][0-9]år
!A {printAGE(yytext,1);}

Define NumexMsrAge156a [ Num19X {år} ] ;
Define NumexMsrAge156
     [ NumexMsrAge156a
       LC({är })
       EndTag(NumexMsrAge) ] ; 438

!R [Åå]lder" "[1-9][0-9]?" och däröver"
!A {printAGE(yytext,1);}

Define NumexMsrAge157a [ Num19x { och däröver} ] ;
Define NumexMsrAge157
     [ NumexMsrAge157a
       LC(["Å"|"å"] {lder })
       EndTag(NumexMsrAge) ] ; 439

!R [Vv]id" "[a-zåäa0-9]+" dagars "ålder
!A {printAGE(yytext,0);}

Define NumexMsrAge158a
     [ Vv {id }
       ["a"|"b"|"c"|"d"|"e"|"f"|"g"|"h"|"i"|"j"|"k"|"l"|"m"|"n"|"o"|"p"|"q"|"r"|"s"|"t"|"u"|"v"|"w"|"x"|"y"|"z"|Num|"å"|"ä"|"a"]+
       { dagars ålder} ] ;
Define NumexMsrAge158 [ NumexMsrAge158a   EndTag(NumexMsrAge) ] ; 440

!R "för männen "[1-9][0-9]?" år"
!A {printAGE(yytext,2);}

Define NumexMsrAge159a [ Num19x { år} ] ;
Define NumexMsrAge159
     [ NumexMsrAge159a
       LC({för männen })
       EndTag(NumexMsrAge) ] ; 441

!R [Uu]nder" livets första "[^\n ]+" månader"
!A {printAGE(yytext,0);}

Define NumexMsrAge160a [ Uu {nder livets första } Ins(Word) { månader} ] ;
Define NumexMsrAge160 [ NumexMsrAge160a   EndTag(NumexMsrAge) ] ; 442

!R [Kk]vinnor" "(under|över)" "[2-8][0-9]
!A {printAGE(yytext,1);}

Define NumexMsrAge161a
     [ [{under} | {över}] { } ["2"|"3"|"4"|"5"|"6"|"7"|"8"] Num ] ;
Define NumexMsrAge161
     [ NumexMsrAge161a
       LC(Kk {vinnor })
       EndTag(NumexMsrAge) ] ; 443

!R [^\n\t ]*(lickor|ojkar|elever|ngdomar|[Kk]vinnor|atienter|[Mm]än|[Bb]arn)" "[1-9][0-9]?" och "[1-9][0-9]?" år"
!A {printAGE(yytext,1);}

Define NumexMsrAge162a [ Num19x { och } Num19x { år} ] ;
Define NumexMsrAge162
     [ NumexMsrAge162a
       LC([{lickor} | {ojkar} | {elever} | {ngdomar} | Kk {vinnor}
             | {atienter} | Mm {än} | Bb {arn}]
          { })
       EndTag(NumexMsrAge) ] ; 444

!R [Bb]arn" mindre än ungefär "[1-9]" år"
!A {printAGE(yytext,1);}

Define NumexMsrAge163a [ {mindre än ungefär } Num19 { år} ] ;
Define NumexMsrAge163
     [ NumexMsrAge163a
       LC(Bb {arn })
       EndTag(NumexMsrAge) ] ; 445

!R [Mm]edianålder" "[1-9]" år"
!A {printAGE(yytext,1);}

Define NumexMsrAge164a [ Num19 { år} ] ;
Define NumexMsrAge164
     [ NumexMsrAge164a
       LC(Mm {edianålder })
       EndTag(NumexMsrAge) ] ; 446

!R [Uu]nder" det "[^\n ]+[ae]" levnadsåret"
!A {printAGE(yytext,0);}

Define NumexMsrAge165a [ Uu {nder det } Word ["a"|"e"] { levnadsåret} ] ;
Define NumexMsrAge165 [ NumexMsrAge165a   EndTag(NumexMsrAge) ] ; 447

!R [Bb]arn" ( < "[1-9]" år"
!A {printAGE(yytext,3);}

Define NumexMsrAge166a [ Num19 { år} ] ;
Define NumexMsrAge166
     [ NumexMsrAge166a
       LC(Bb {arn ( < })
       EndTag(NumexMsrAge) ] ; 448

!R [Ss]ina" "{NUM}" år"
!A {printAGE(yytext,1);}

Define NumexMsrAge167a [ Ins(NUM) { år} ] ;
Define NumexMsrAge167
     [ NumexMsrAge167a
       LC(Ss {ina })
       EndTag(NumexMsrAge) ] ; 449

!R ([Jj]ag|[Hh]an|[Hh]on)" var då "{NUM}" år"
!A {printAGE(yytext,3);}

Define NumexMsrAge168a [ Ins(NUM) { år} ] ;
Define NumexMsrAge168
     [ NumexMsrAge168a
       LC([Jj {ag} | Hh {an} | Hh {on}] { var då })
       EndTag(NumexMsrAge) ] ; 450

!#  MOD (Jyrki Niemi): Fixed regexp:
!# 	([Jj]ag|[Hh]an|[Hh]on)(" är ju "blott|" endast")" "(tjugu|{NUM})" år"	{printAGE(yytext,3);}
!# 	

!R ([Jj]ag|[Hh]an|[Hh]on)" är ju "(blott|endast)" "(tjugu|{NUM})" år"
!A {printAGE(yytext,3);}

Define NumexMsrAge169a [ [{blott} | {endast}] { } [{tjugu} | Ins(NUM)] { år} ] ;
Define NumexMsrAge169
     [ NumexMsrAge169a
       LC([Jj {ag} | Hh {an} | Hh {on}] { är ju })
       EndTag(NumexMsrAge) ] ; 451

!R ([Jj]ag|[Hh]an|[Hh]on[Uu]ngen)" var redan nära "[^\n ]*tio" "år
!A {printAGE(yytext,3);}

Define NumexMsrAge170a [ {nära } NS* {tio år} ] ;
Define NumexMsrAge170
     [ NumexMsrAge170a
       LC([Jj {ag} | Hh {an} | Hh {on} Uu {ngen}] { var redan })
       EndTag(NumexMsrAge) ] ; 452

!R "vilja vara "[a-zåäö]+(två|tre|fyra|fem|sex|sju|åtta|nio|ett)" "år
!A {printAGE(yytext,2);}

Define NumexMsrAge171a
     [ LowerWord
       [{två} | {tre} | {fyra} | {fem} | {sex} | {sju} | {åtta} | {nio}
          | {ett}]
       { år} ] ;
Define NumexMsrAge171
     [ NumexMsrAge171a
       LC({vilja vara })
       EndTag(NumexMsrAge) ] ; 453

!R (mamma|pappa|mormor|farmor)" som är "[1-9][0-9]
!A {printAGE(yytext,3);}

Define NumexMsrAge172a [ Num19X ] ;
Define NumexMsrAge172
     [ NumexMsrAge172a
       LC([{mamma} | {pappa} | {mormor} | {farmor}] { som är })
       EndTag(NumexMsrAge) ] ; 454

!R [Rr]edan" i "[a-zåäö]+årsåldern
!A {printAGE(yytext,0);}

Define NumexMsrAge173a [ Rr {edan i } LowerWord {årsåldern} ] ;
Define NumexMsrAge173 [ NumexMsrAge173a   EndTag(NumexMsrAge) ] ; 455

!R [Uu]nder" "[^\n ]*ungdomstiden
!A {printAGE(yytext,0);}

Define NumexMsrAge174a [ Uu {nder } NS* {ungdomstiden} ] ;
Define NumexMsrAge174 [ NumexMsrAge174a   EndTag(NumexMsrAge) ] ; 456

!R [Uu]nder" "[^\n ]*ungdomsåren
!A {printAGE(yytext,0);}

Define NumexMsrAge175a [ Uu {nder } NS* {ungdomsåren} ] ;
Define NumexMsrAge175 [ NumexMsrAge175a   EndTag(NumexMsrAge) ] ; 457

!R [Ii]" "[0-9]+\-" till "[0-9]+"\-årsålder"(n)?
!A {printAGE(yytext,0);}

Define NumexMsrAge176a [ Ii { } Ins(Nums) {- till } Ins(Nums) {-årsålder} ({n}) ] ;
Define NumexMsrAge176 [ NumexMsrAge176a   EndTag(NumexMsrAge) ] ; 458

!R [Mm]ellan" sen tonårsperiod och "[0-9]+"\-års ålder"(n)?
!A {printAGE(yytext,0);}

Define NumexMsrAge177a
     [ Mm {ellan sen tonårsperiod och } Ins(Nums) {-års ålder} ({n}) ] ;
Define NumexMsrAge177 [ NumexMsrAge177a   EndTag(NumexMsrAge) ] ; 459

!R [Ii]" åldersintervallen över "[0-9]+" år"
!A {printAGE(yytext,2);}

Define NumexMsrAge178a [ {över } Ins(Nums) { år} ] ;
Define NumexMsrAge178
     [ NumexMsrAge178a
       LC(Ii { åldersintervallen })
       EndTag(NumexMsrAge) ] ; 460

!R [Bb]arn" \< "[0-9]+" år"
!A {printAGE(yytext,2);}

Define NumexMsrAge179a [ Ins(Nums) { år} ] ;
Define NumexMsrAge179
     [ NumexMsrAge179a
       LC(Bb {arn < })
       EndTag(NumexMsrAge) ] ; 461

!R [Bb]arn" "[0-9]+" \- "[0-9]+" år"
!A {printAGE(yytext,1);}

Define NumexMsrAge180a [ Ins(NumsSpRange) { år} ] ;
Define NumexMsrAge180
     [ NumexMsrAge180a
       LC(Bb {arn })
       EndTag(NumexMsrAge) ] ; 462

!R [Yy]ngre" än "(tre|fyra|fem|två)" "år
!A {printAGE(yytext,0);}

Define NumexMsrAge181a
     [ Yy {ngre än } [{tre} | {fyra} | {fem} | {två}] { år} ] ;
Define NumexMsrAge181 [ NumexMsrAge181a   EndTag(NumexMsrAge) ] ; 463

!R [Åå]ldersfördelning" var "[0-9]+\-[0-9]+" "år
!A {printAGE(yytext,2);}

Define NumexMsrAge182a [ Ins(NumRange) { år} ] ;
Define NumexMsrAge182
     [ NumexMsrAge182a
       LC(["Å"|"å"] {ldersfördelning var })
       EndTag(NumexMsrAge) ] ; 464

!R [Åå]ldersfördelning" "[0-9]+\-[0-9]+" "år
!A {printAGE(yytext,1);}

Define NumexMsrAge183a [ Ins(NumRange) { år} ] ;
Define NumexMsrAge183
     [ NumexMsrAge183a
       LC(["Å"|"å"] {ldersfördelning })
       EndTag(NumexMsrAge) ] ; 465

!R [Dd]u" över "[0-9][0-9]
!A {printAGE(yytext,1);}

Define NumexMsrAge184a [ {över } Ins(Nums2) ] ;
Define NumexMsrAge184
     [ NumexMsrAge184a
       LC(Dd {u })
       EndTag(NumexMsrAge) ] ; 466

!R [Ii]" åldrarna under "[0-9][0-9]" år"
!A {printAGE(yytext,2);}

Define NumexMsrAge185a [ {under } Ins(Nums2) { år} ] ;
Define NumexMsrAge185
     [ NumexMsrAge185a
       LC(Ii { åldrarna })
       EndTag(NumexMsrAge) ] ; 467

!R [Ii]" "[a-zåäö]+\-" och "[^\n\< ]+åldern
!A {printAGE(yytext,0);}

Define NumexMsrAge186a [ Ii { } LowerWord {- och } Word {åldern} ] ;
Define NumexMsrAge186 [ NumexMsrAge186a   EndTag(NumexMsrAge) ] ; 468

!R [0-9]+\-dagar" gammal"t?
!A {printAGE(yytext,0);}

Define NumexMsrAge187a [ Ins(Nums) {-dagar gammal} ({t}) ] ;
Define NumexMsrAge187 [ NumexMsrAge187a   EndTag(NumexMsrAge) ] ; 469

!R [Uu]ngefär" "[^\n ]+" dagar gammal"t?
!A {printAGE(yytext,0);}

Define NumexMsrAge188a [ Uu {ngefär } Ins(Word) { dagar gammal} ({t}) ] ;
Define NumexMsrAge188 [ NumexMsrAge188a   EndTag(NumexMsrAge) ] ; 470

!R [Åå]ldersklasserna" "[0-9]+" - "[0-9]+" år"
!A {printAGE(yytext,1);}

Define NumexMsrAge189a [ Ins(NumsSpRange) { år} ] ;
Define NumexMsrAge189
     [ NumexMsrAge189a
       LC(["Å"|"å"] {ldersklasserna })
       EndTag(NumexMsrAge) ] ; 471

!R "vid sin död "{NUM}" år"
!A {printAGE(yytext,3);}

Define NumexMsrAge190a [ Ins(NUM) { år} ] ;
Define NumexMsrAge190
     [ NumexMsrAge190a
       LC({vid sin död })
       EndTag(NumexMsrAge) ] ; 472

!R [Ff]rån" "[^\n ]+årsåldern
!A {printAGE(yytext,0);}

Define NumexMsrAge191a [ Ff {rån } Word {årsåldern} ] ;
Define NumexMsrAge191 [ NumexMsrAge191a   EndTag(NumexMsrAge) ] ; 473

!R [Mm]edianåldern" "(är|var)" "[0-9][0-9]
!A {printAGE(yytext,2);}

Define NumexMsrAge192a [ Ins(Nums2) ] ;
Define NumexMsrAge192
     [ NumexMsrAge192a
       LC(Mm {edianåldern } [{är} | {var}] { })
       EndTag(NumexMsrAge) ] ; 474

!R "ett är "[0-9][0-9]?" månader"
!A {printAGE(yytext,2);}

Define NumexMsrAge193a [ Ins(Nums12) { månader} ] ;
Define NumexMsrAge193
     [ NumexMsrAge193a
       LC({ett är })
       EndTag(NumexMsrAge) ] ; 475

!#  WEB 

!R (mms|http|ftp|https)\:\/\/[^\n\.\, ]+\.[^\n\t ]+
!A {printWEB(yytext,0);}

Define NumexMsrWeb001a
     [ [{mms} | {http} | {ftp} | {https}] {://} [NS - ["."|","]]+ {.} Word ] ;
Define NumexMsrWeb001 [ NumexMsrWeb001a   EndTag(NumexMsrWeb) ] ; 476

!R (www[1-4]|www)\.[^\n\.\, ]+\.[^\n\t ]+
!A {printWEB(yytext,0);}

Define NumexMsrWeb002a
     [ [{www} ["1"|"2"|"3"|"4"] | {www}] {.} [NS - ["."|","]]+ {.} Word ] ;
Define NumexMsrWeb002 [ NumexMsrWeb002a   EndTag(NumexMsrWeb) ] ; 477

!#  (http\:\/\/|ftp\:\/\/)?www\.[a-z0-9\-]+(\.[a-z0-9\-\/\?]+)*\.[a-z][a-z][a-z]?[a-z]?	{printWEB(yytext,0);}

!R [a-zA-Z0-9\-]+\.[a-zA-Z0-9\-\_]+\.[a-zA-Z0-9\-]+\@[a-zA-Z0-9]+\.[a-zA-Z0-9]+(\.[a-zA-Z0-9]+)*
!A {printWEB(yytext,0);}

Define NumexMsrWeb003a
     [ AlphaDigitDash+ {.} AlphaDigitDashUnder+ {.} AlphaDigitDash+ {@}
       AlphaDigit+ {.} AlphaDigit+ [{.} AlphaDigit+]* ] ;
Define NumexMsrWeb003 [ NumexMsrWeb003a   EndTag(NumexMsrWeb) ] ; 478

!R [a-zA-Z0-9\-]+\.[a-zA-Z0-9\-\_]+\@[a-zA-Z0-9\-]+\.[a-zA-Z0-9]+(\.[a-zA-Z0-9]+)*
!A {printWEB(yytext,0);}

Define NumexMsrWeb004a
     [ AlphaDigitDash+ {.} AlphaDigitDashUnder+ {@} AlphaDigitDash+ {.}
       AlphaDigit+ [{.} AlphaDigit+]* ] ;
Define NumexMsrWeb004 [ NumexMsrWeb004a   EndTag(NumexMsrWeb) ] ; 479

!R [a-zA-Z0-9][a-zA-Z0-9\-\_]+\@[a-zA-Z0-9][a-zA-Z0-9\-]+\.[a-zA-Z][a-zA-Z0-9]+(\.[a-zA-Z0-9]+)*
!A {printWEB(yytext,0);}

Define NumexMsrWeb005a
     [ AlphaDigit AlphaDigitDashUnder+ {@} AlphaDigit AlphaDigitDash+ {.}
       AsciiAlpha AlphaDigit+ [{.} AlphaDigit+]* ] ;
Define NumexMsrWeb005 [ NumexMsrWeb005a   EndTag(NumexMsrWeb) ] ; 480

!R [^\n\.\,\<\> ][^\n\.\,\<\> ]+\.(com|se|org|net|info)
!A {printWEB(yytext,0);}

Define NumexMsrWeb006a
     [NS - ["."|","|"<"|">"]] [NS - ["."|","|"<"|">"]]+ {.}
     [{com} | {se} | {org} | {net} | {info}] ;
Define NumexMsrWeb006 [ NumexMsrWeb006a   EndTag(NumexMsrWeb) ] ; 481

!R [a-zA-Z0-9\-]+\.[a-zA-Z0-9\-\_]+\(at\)[a-zA-Z0-9\-]+\.[a-zA-Z0-9]+(\.[a-zA-Z0-9]+)*
!A {printWEB(yytext,0);}

Define NumexMsrWeb007a
     [ AlphaDigitDash+ {.} AlphaDigitDashUnder+ {(at)} AlphaDigitDash+ {.}
       AlphaDigit+ [{.} AlphaDigit+]* ] ;
Define NumexMsrWeb007 [ NumexMsrWeb007a   EndTag(NumexMsrWeb) ] ; 482

!#  Capacity and Volume Unit - CVU 
!# ? after the ml/? 

!R [0-9]+(\,[0-9])?" "kvadrat\-cm
!A {printCVU(yytext,0);}

Define NumexMsrCvu001a [ Ins(Nums) ({,} Num) { kvadrat-cm} ] ;
Define NumexMsrCvu001 [ NumexMsrCvu001a   EndTag(NumexMsrCvu) ] ; 483

!R ([Mm]inst" "|[Uu]ngefär" "|[Oo]mkring" "|[Dd]rygt" "|[Cc]irka" "|dryga" ")?[0-9]+([\,\.0-9\_]+|" "[0-9]+)?(" "miljoner|" "miljarder)?" "(mm3|cm3|m3|km3|kubik[^\n\t ]*meter|[^\n\t ]g\/m3|g\/m3|[^\n\t ]g\/[cm]m3|g\/[cm]m3)
!A {printCVU(yytext,0);}

Define NumexMsrCvu002a
     [ (Mm {inst } | Uu {ngefär } | Oo {mkring } | Dd {rygt } | Cc {irka }
         | {dryga })
       Ins(Nums) ([Num|","|"."|"_"]+ | { } Ins(Nums)) ({ miljoner} | { miljarder}) { }
       [{mm3} | {cm3} | {m3} | {km3} | {kubik} NS* {meter} | NS {g/m3}
          | {g/m3} | NS {g/} ["c"|"m"] {m3} | {g/} ["c"|"m"] {m3}] ] ;
Define NumexMsrCvu002 [ NumexMsrCvu002a   EndTag(NumexMsrCvu) ] ; 484

!R ([Uu]"ngefär "|[Oo]"mkring "|[Dd]"rygt "|[Mm]er" än "|[Cc]irka" "|[Mm]inst" "|från" ")?([Nn]"ågra få"|[Ee]n" "kvarts|[Ee]tt" "halvt|[Ee]tt" "halv|[Dd]"rygt en"|[Tt]vå|[Tt]re|[Ff]yra|[Ff]em|[Ss]ex|sju|åtta|nio|tio|tolv|[0-9]*½|[0-9]+|[0-9]+\-tals|[0-9]+" "[0-9]+\/[0-9]+|[0-9]+\/[0-9]+|[0-9]+\-[0-9]+\,[0-9]+|[0-9]+\.[0-9]+|[0-9]+\,[0-9]+"\-"[0-9]+\,[0-9]+|[0-9]+\,[0-9]+" till "[0-9]+\,[0-9]+|[0-9]+\,[0-9]+|[0-9]+\-[0-9]+|[0-9]+" "[0-9]+|[0-9]+\,[0-9]+\-[0-9]+|{NUM}" till "{NUM})" "(miljon" "|miljoner" "|miljarder" ")?([^\n\t ]+[^\n l]liter|liter)
!A {printCVU(yytext,0);}

Define NumexMsrCvu003a
     [ (Uu {ngefär } | Oo {mkring } | Dd {rygt } | Mm {er än } | Cc {irka }
         | Mm {inst } | {från })
       [Nn {ågra få} | Ee {n kvarts} | Ee {tt halvt} | Ee {tt halv}
          | Dd {rygt en} | Tt {vå} | Tt {re} | Ff {yra} | Ff {em} | Ss {ex}
          | {sju} | {åtta} | {nio} | {tio} | {tolv} | Num* {½} | Ins(Nums)
          | Ins(Nums) {-tals} | Ins(Nums) { } Ins(NumsSlashNums) | Ins(NumsSlashNums)
          | Ins(Nums) {-} Ins(NumsCommaNums) | Ins(NumsDotNums)
          | Ins(NumsCommaNums) {-} Ins(NumsCommaNums)
          | Ins(NumsCommaNums) { till } Ins(NumsCommaNums) | Ins(NumsCommaNums) | Ins(NumRange)
          | Ins(NumsSpNums) | Ins(NumsCommaNums) {-} Ins(Nums) | Ins(NUM) { till } Ins(NUM)]
       { } ({miljon } | {miljoner } | {miljarder })
       [Word [NS - {l}] {liter} | {liter}] ] ;
Define NumexMsrCvu003 [ NumexMsrCvu003a   EndTag(NumexMsrCvu) ] ; 485

!R ([Mm]inst" "|[Uu]ngefär" "|[Oo]mkring" "|[Dd]rygt" "|[Cc]irka" "|dryga" "|[Mm]indre" än ")en" "("halv ")?liter
!A {printCVU(yytext,0);}

Define NumexMsrCvu004a
     [ [Mm {inst } | Uu {ngefär } | Oo {mkring } | Dd {rygt } | Cc {irka }
          | {dryga } | Mm {indre än }]
       {en } ({halv }) {liter} ] ;
Define NumexMsrCvu004 [ NumexMsrCvu004a   EndTag(NumexMsrCvu) ] ; 486

!R ([0-9]+\-[0-9]+|[0-9]+\/[0-9]+|[0-9]+|[1-9]+" \, "[0-9]+|[1-9]+\,[0-9]+)" "(msk|krm)
!A {printCVU(yytext,0);}

Define NumexMsrCvu005a
     [Ins(NumRange) | Ins(NumsSlashNums) | Ins(Nums) | Num19+ { , } Ins(Nums)
        | Num19+ {,} Ins(Nums)]
     { } [{msk} | {krm}] ;
Define NumexMsrCvu005 [ NumexMsrCvu005a   EndTag(NumexMsrCvu) ] ; 487

!R ([Mm]ellan" "[0-9]+" och"|[Mm]er" än "|[Cc]irka" "|[Mm]inst" ")?([Nn]"ågra få"|[Ee]n" "kvarts|[Ee]tt" "halvt|[Ee]tt" "halv|[Dd]"rygt en"|[Tt]vå|[Tt]re|[Ff]yra|[Ff]em|[Ss]ex|sju|åtta|nio|tio|tolv|[0-9]*½|[0-9]+|[0-9]+\-tals|[0-9]+" "[0-9]+\/[0-9]+|[0-9]+\/[0-9]+|[0-9]+" "[0-9]+\/[0-9\-]+|[0-9]+\,[0-9]+"\-"[0-9]+\,[0-9]+|[0-9]+\.[0-9]+|[0-9]+\,[0-9]+|[0-9]+\-[0-9]+|[0-9]+" "[0-9]+)" "(miljon" "|miljoner" "|miljarder" ")?(m[Ll]|dl|cl|promille)
!A {printCVU(yytext,0);}

Define NumexMsrCvu006a
     [ (Mm {ellan } Ins(Nums) { och} | Mm {er än } | Cc {irka } | Mm {inst })
       [Nn {ågra få} | Ee {n kvarts} | Ee {tt halvt} | Ee {tt halv}
          | Dd {rygt en} | Tt {vå} | Tt {re} | Ff {yra} | Ff {em} | Ss {ex}
          | {sju} | {åtta} | {nio} | {tio} | {tolv} | Num* {½} | Ins(Nums)
          | Ins(Nums) {-tals} | Ins(Nums) { } Ins(NumsSlashNums) | Ins(NumsSlashNums)
          | Ins(NumsSpNums) {/} DigitDashes | Ins(NumsCommaNums) {-} Ins(NumsCommaNums)
          | Ins(NumsDotNums) | Ins(NumsCommaNums) | Ins(NumRange) | Ins(NumsSpNums)]
       { } ({miljon } | {miljoner } | {miljarder })
       [{m} Ll | {dl} | {cl} | {promille}] ] ;
Define NumexMsrCvu006 [ NumexMsrCvu006a   EndTag(NumexMsrCvu) ] ; 488

!R [0-9]+\,[0-9]+" \( "[0-9\,]+\-[0-9\,]+" \) g\/l"
!A {printCVU(yytext,0);}

Define NumexMsrCvu007a
     [ Ins(NumsCommaNums) { ( } DigitCommas {-} DigitCommas { ) g/l} ] ;
Define NumexMsrCvu007 [ NumexMsrCvu007a   EndTag(NumexMsrCvu) ] ; 489

!R [0-9]\,[0-9]l" "
!A {printf("<NUMEX TYPE=\"MSR\" SBT=\"CVU\">"); putchar(yytext[0]); putchar(yytext[1]); putchar(yytext[2]); printf("l</NUMEX> ");}

Define NumexMsrCvu008 [ Num {,} Num {l}   RC({ })   EndTag(NumexMsrCvu) ] ; 490

!R [0-9]\,[0-9]" lit "
!A {printf("<NUMEX TYPE=\"MSR\" SBT=\"CVU\">"); putchar(yytext[0]); putchar(yytext[1]); putchar(yytext[2]); printf(" lit</NUMEX> ");}

Define NumexMsrCvu009
     [ Num {,} Num { lit}
       RC({ })
       EndTag(NumexMsrCvu) ] ; 491

!R ([Uu]"nder "|[Öö]"ver "|"\< "[0-9]|[0-9]\,[0-9]+" till "|[0-9]" till "|[0-9]+\,[0-9\-]+" respektive "|\-)?([0-9][0-9\,\-]+[0-9]+|[0-9\-]+" "[0-9\-]+|[1-9]" \, "[0-9]|[0-9]+|[0-9]+\,[0-9\-]+|[0-9]+\.[0-9]+|{NUM})" "mg\/mmol
!A {printCVU(yytext,0);}

Define NumexMsrCvu010a
     [ (Uu {nder } | ["Ö"|"ö"] {ver } | {< } Num | Num {,} Ins(Nums) { till }
         | Num { till } | Ins(Nums) {,} DigitDashes { respektive } | {-})
       [Num [Num|","|"-"]+ Ins(Nums) | DigitDashes { } DigitDashes
          | Num19 { , } Num | Ins(Nums) | Ins(Nums) {,} DigitDashes | Ins(NumsDotNums) | Ins(NUM)]
       { mg/mmol} ] ;
Define NumexMsrCvu010 [ NumexMsrCvu010a   EndTag(NumexMsrCvu) ] ; 492

!R ([Gg]enomsnitt" ")?([Uu]nder" "|[Öö]"ver "|"\< "[0-9]|[0-9]\,[0-9]+" till "|[0-9]" till "|[Mm]"ellan "[0-9]+" och "|[Mm]"ellan "[0-9]+\,[0-9\-]+" och "|[0-9]+\,[0-9\-]+" respektive "|\-)?([0-9][0-9\,\-]+[0-9]+|[0-9]+" \- "[0-9]+|[0-9\-]+" "[0-9\-]+|[1-9]" \, "[0-9]|[0-9]+|[0-9]+\,[0-9\-]+|[0-9]+\.[0-9]+|{NUM}|[0-9]+\?[0-9]+)" "(umol|nmol|pmol|milimol|millimol|mikromol|pmol|mmol|lmol|µmol|g|nanogram)(\/[Ss]|\/m[Ll]|\/d[Ll]|\/[Ll]|\/[Ll]iter|" per liter"|" per milliliter")
!A {printCVU(yytext,0);}

Define NumexMsrCvu011a
     [ (Gg {enomsnitt })
       (Uu {nder } | ["Ö"|"ö"] {ver } | {< } Num | Num {,} Ins(Nums) { till }
         | Num { till } | Mm {ellan } Ins(Nums) { och }
         | Mm {ellan } Ins(Nums) {,} DigitDashes { och }
         | Ins(Nums) {,} DigitDashes { respektive } | {-})
       [Num [Num|","|"-"]+ Ins(Nums) | Ins(NumsSpRange) | DigitDashes { } DigitDashes
          | Num19 { , } Num | Ins(Nums) | Ins(Nums) {,} DigitDashes | Ins(NumsDotNums) | Ins(NUM)
          | Ins(Nums) {?} Ins(Nums)]
       { }
       [{umol} | {nmol} | {pmol} | {milimol} | {millimol} | {mikromol}
          | {mmol} | {lmol} | {µmol} | {g} | {nanogram}]
       [{/} Ss | {/m} Ll | {/d} Ll | {/} Ll | {/} Ll {iter} | { per liter}
          | { per milliliter}] ] ;
Define NumexMsrCvu011 [ NumexMsrCvu011a   EndTag(NumexMsrCvu) ] ; 493

!R ([Gg]enomsnitt" ")?([Uu]nder" "|[Öö]"ver "|"\< "[0-9]|[0-9]\,[0-9]+" till "|[0-9]" till "|[Mm]"ellan "[0-9]+" och "|[Mm]"ellan "[0-9]+\,[0-9\-]+" och "|[0-9]+\,[0-9\-]+" respektive "|\-)?([0-9][0-9\,\-]+[0-9]+|[0-9\-]+" "[0-9\-]+|[1-9]" \, "[0-9]|[0-9]+|[0-9]+\,[0-9\-]+|[0-9]+\.[0-9]+|[0-9]+|{NUM}|[0-9]+\?[0-9]+)(umol|nmol|pmol|milimol|millimol|mikromol|pmol|mmol|lmol|µmol|g|nanogram)(\/[Ss]|\/m[Ll]|\/d[Ll]|\/[Ll]|\/[Ll]iter)
!A {printCVU(yytext,0);}

Define NumexMsrCvu012a
     [ (Gg {enomsnitt })
       (Uu {nder } | ["Ö"|"ö"] {ver } | {< } Num | Num {,} Ins(Nums) { till }
         | Num { till } | Mm {ellan } Ins(Nums) { och }
         | Mm {ellan } Ins(Nums) {,} DigitDashes { och }
         | Ins(Nums) {,} DigitDashes { respektive } | {-})
       [Num [Num|","|"-"]+ Ins(Nums) | DigitDashes { } DigitDashes
          | Num19 { , } Num | Ins(Nums) | Ins(Nums) {,} DigitDashes | Ins(NumsDotNums) | Ins(NUM)
          | Ins(Nums) {?} Ins(Nums)]
       [{umol} | {nmol} | {pmol} | {milimol} | {millimol} | {mikromol}
          | {mmol} | {lmol} | {µmol} | {g} | {nanogram}]
       [{/} Ss | {/m} Ll | {/d} Ll | {/} Ll | {/} Ll {iter}] ] ;
Define NumexMsrCvu012 [ NumexMsrCvu012a   EndTag(NumexMsrCvu) ] ; 494

!R (under" "|över" "|[0-9]+\,[0-9]+" till "|[0-9]+" till ")?([0-9]+x[0-9]+|[0-9]+\/[0-9\,]+|[0-9\-]+" "[0-9\-]+|[0-9]+" \- "[0-9]+|[1-9]+" \, "[0-9]+|[0-9]+|[0-9]+\,[0-9]+|[0-9]+\-[0-9]+|[0-9]+\,[0-9]+" \- "[0-9]+\,[0-9\-]+)" "(mg|IU|mikrog|µg|m[Ll]|mikrogram|ggr|gram)(\/g|\/mg|\/m[Ll]|\/L|\/liter|" per liter"|" per kg")
!A {printCVU(yytext,0);}

Define NumexMsrCvu013a
     [ ({under } | {över } | Ins(NumsCommaNums) { till } | Ins(Nums) { till })
       [Ins(Nums) {x} Ins(Nums) | Ins(Nums) {/} DigitCommas | DigitDashes { } DigitDashes
          | Ins(NumsSpRange) | Num19+ { , } Ins(Nums) | Ins(Nums) | Ins(NumsCommaNums) | Ins(NumRange)
          | Ins(NumsCommaNums) { - } Ins(Nums) {,} DigitDashes]
       { }
       [{mg} | {IU} | {mikrog} | {µg} | {m} Ll | {mikrogram} | {ggr}
          | {gram}]
       [{/g} | {/mg} | {/m} Ll | {/L} | {/liter} | { per liter} | { per kg}] ] ;
Define NumexMsrCvu013 [ NumexMsrCvu013a   EndTag(NumexMsrCvu) ] ; 495

!R " 1g "
!A {printf(" <NUMEX TYPE=\"MSR\" SBT=\"CVU\">1g</NUMEX> ");}

Define NumexMsrCvu014a [ {1g} ] ;
Define NumexMsrCvu014
     [ NumexMsrCvu014a
       LC({ })
       RC({ })
       EndTag(NumexMsrCvu) ] ; 496

!R ([Uu]"nder "|[Öö]"ver "|"\< ")?([0-9]+\,[0-9]+" \- "[0-9]+\,[0-9\-]+|[0-9]+\,[0-9]+\-[0-9]+\,[0-9\-]+|[0-9\-]+" "[0-9\-]+|[1-9]" \, "[0-9]|[0-9]+|[0-9]+\,[0-9\-]+|[0-9]+\.[0-9]+|[0-9]+\,[0-9\-]+" respektive "[0-9]+\,[0-9\-]+)" "(milimol|millimol|mikromol|mmol|lmol|nanogram)(\/m[Ll]|\/d[Ll]|\/[Ll]|\/[Ll]iter|" per liter"|" per milliliter")?
!A {printCVU(yytext,0);}

Define NumexMsrCvu015a
     [ (Uu {nder } | ["Ö"|"ö"] {ver } | {< })
       [Ins(NumsCommaNums) { - } Ins(Nums) {,} DigitDashes
          | Ins(NumsCommaNums) {-} Ins(Nums) {,} DigitDashes | DigitDashes { } DigitDashes
          | Num19 { , } Num | Ins(Nums) | Ins(Nums) {,} DigitDashes | Ins(NumsDotNums)
          | Ins(Nums) {,} DigitDashes { respektive } Ins(Nums) {,} DigitDashes]
       { }
       [{milimol} | {millimol} | {mikromol} | {mmol} | {lmol} | {nanogram}]
       ({/m} Ll | {/d} Ll | {/} Ll | {/} Ll {iter} | { per liter}
         | { per milliliter}) ] ;
Define NumexMsrCvu015 [ NumexMsrCvu015a   EndTag(NumexMsrCvu) ] ; 497

!R ([0-9]+" ")?[0-9]+" fat "
!A {int i=0; printf("<NUMEX TYPE=\"MSR\" SBT=\"CVU\">"); 
!A 	for(;i<yyleng-1;putchar(yytext[i++])); printf("</NUMEX> ");}

Define NumexMsrCvu016a [ (Ins(Nums) { }) Ins(Nums) { fat} ] ;
Define NumexMsrCvu016 [ NumexMsrCvu016a   RC({ })   EndTag(NumexMsrCvu) ] ; 498

!R " 1g "
!A {printf(" <NUMEX TYPE=\"MSR\" SBT=\"CVU\">1g</NUMEX> ");}

Define NumexMsrCvu017a [ {1g} ] ;
Define NumexMsrCvu017
     [ NumexMsrCvu017a
       LC({ })
       RC({ })
       EndTag(NumexMsrCvu) ] ; 499

!R [0-9]+\,[0-9]+ml
!A {printCVU(yytext,0);}

Define NumexMsrCvu018a [ Ins(NumsCommaNums) {ml} ] ;
Define NumexMsrCvu018 [ NumexMsrCvu018a   EndTag(NumexMsrCvu) ] ; 500

!R [0-9]+\,[0-9]+" m g\/l"
!A {printCVU(yytext,0);}

Define NumexMsrCvu019a [ Ins(NumsCommaNums) { m g/l} ] ;
Define NumexMsrCvu019 [ NumexMsrCvu019a   EndTag(NumexMsrCvu) ] ; 501

!R [0-9]+" m g\/l"
!A {printCVU(yytext,0);}

Define NumexMsrCvu020a [ Ins(Nums) { m g/l} ] ;
Define NumexMsrCvu020 [ NumexMsrCvu020a   EndTag(NumexMsrCvu) ] ; 502

!#  Weight and Mass Unit - WMU 

!R vikt" "[0-9\,]+" g\."
!A {int i=5; printf("vikt <NUMEX TYPE=\"MSR\" SBT=\"WMU\">"); 
!A 	for(;i<yyleng;putchar(yytext[i++])); printf("</NUMEX>");}

Define NumexMsrWmu001a [ DigitCommas { g.} ] ;
Define NumexMsrWmu001
     [ NumexMsrWmu001a
       LC({vikt })
       EndTag(NumexMsrWmu) ] ; 503

!R vägande" "[0-9\,]+" g\."
!A {int i=8; printf("vägande <NUMEX TYPE=\"MSR\" SBT=\"WMU\">"); 
!A 	for(;i<yyleng;putchar(yytext[i++])); printf("</NUMEX>");}

Define NumexMsrWmu002a [ DigitCommas { g.} ] ;
Define NumexMsrWmu002
     [ NumexMsrWmu002a
       LC({vägande })
       EndTag(NumexMsrWmu) ] ; 504

!R ([Mm]er" än "|[Cc]irka" "|[Mm]inst" ")?([Nn]"ärmare "|[Ff]"rån "{NUM}" till "[^\n\t ]+|[Nn]"ågra få"|[Ee]n" "kvarts|[Ee]tt" "halvt|[Ee]tt" "halv|Ett|[Dd]"rygt en"|[Tt]vå|[Tt]re|[Ff]yra|[Ff]em|[Ss]ex|sju|åtta|nio|[^\n\t ]*tio|tolv|[0-9]*½|[0-9]+|[0-9]+\-tals|[0-9]+" "[0-9]+\/[0-9]+|[0-9]+\/[0-9]+|[0-9]+\.[0-9]+|[0-9]+\,[0-9]+" och "[0-9]+\,[0-9]+|[0-9]+\,[0-9]+|[0-9]+\-[0-9]+|[Mm]"ellan "[0-9]+" och "[0-9]+|[0-9]+" respektive "[0-9]+|[0-9]+" eller "[0-9]+|[0-9]+\,[0-9]+\-[0-9]+|[0-9]+\/[0-9]+\/[0-9]+|[0-9]+" "[0-9]+|[0-9]+\.[0-9]+" eller "[0-9]+\.[0-9]+|[0-9]+" till "[0-9]+)" "(miljon" "|miljoner" "|miljarder" ")?(pounds|kilona|kilo|[Kk]ilogram|mikrog|mikrogram|gram|[tm]sk|kryddmått|milligram|[Kk]g|kg\+|ton|mg|mikrog|µg|µl)
!A {printWMU(yytext,0);}

Define NumexMsrWmu003a
     [ (Mm {er än } | Cc {irka } | Mm {inst })
       [Nn {ärmare } | Ff {rån } Ins(NUM) { till } Ins(Word) | Nn {ågra få}
          | Ee {n kvarts} | Ee {tt halvt} | Ee {tt halv} | {Ett} | Dd {rygt en}
          | Tt {vå} | Tt {re} | Ff {yra} | Ff {em} | Ss {ex} | {sju} | {åtta}
          | {nio} | NS* {tio} | {tolv} | Num* {½} | Ins(Nums) | Ins(Nums) {-tals}
          | Ins(Nums) { } Ins(NumsSlashNums) | Ins(NumsSlashNums) | Ins(NumsDotNums)
          | Ins(NumsCommaNums) { och } Ins(NumsCommaNums) | Ins(NumsCommaNums) | Ins(NumRange)
          | Mm {ellan } Ins(Nums) { och } Ins(Nums) | Ins(Nums) { respektive } Ins(Nums)
          | Ins(Nums) { eller } Ins(Nums) | Ins(NumsCommaNums) {-} Ins(Nums)
          | Ins(NumsSlashNums) {/} Ins(Nums) | Ins(NumsSpNums)
          | Ins(NumsDotNums) { eller } Ins(NumsDotNums) | Ins(Nums) { till } Ins(Nums)]
       { } ({miljon } | {miljoner } | {miljarder })
       [{pounds} | {kilona} | {kilo} | Kk {ilogram} | {mikrog} | {mikrogram}
          | {gram} | ["t"|"m"] {sk} | {kryddmått} | {milligram} | Kk {g} | {kg+}
          | {ton} | {mg} | {µg} | {µl}] ] ;
Define NumexMsrWmu003 [ NumexMsrWmu003a   EndTag(NumexMsrWmu) ] ; 505

!R ([Mm]er" än "|[Cc]irka" "|[Mm]inst" "|ca" "|[Nn]"ärmare ")?([Ee]tt" "halvt|[Ee]tt" "halv|två|tre|fyra|fem|sex|sju|åtta|nio|[^\n\t ]*tio|tolv|[0-9]+|[0-9]+\/[0-9]+|[0-9]+\.[0-9]+|[0-9]+\,[0-9]+|[0-9]+\-[0-9]+)" "(miljoner" "|miljarder" "|miljondels" ")?gram
!A {printWMU(yytext,0);}

Define NumexMsrWmu004a
     [ (Mm {er än } | Cc {irka } | Mm {inst } | {ca } | Nn {ärmare })
       [Ee {tt halvt} | Ee {tt halv} | {två} | {tre} | {fyra} | {fem}
          | {sex} | {sju} | {åtta} | {nio} | NS* {tio} | {tolv} | Ins(Nums)
          | Ins(NumsSlashNums) | Ins(NumsDotNums) | Ins(NumsCommaNums) | Ins(NumRange)]
       { } ({miljoner } | {miljarder } | {miljondels }) {gram} ] ;
Define NumexMsrWmu004 [ NumexMsrWmu004a   EndTag(NumexMsrWmu) ] ; 506

!R ([Mm]er" än "|[Cc]irka" "|[Mm]inst" ")?([Nn]"ågra få"|[Ee]n" "kvarts|[Ee]tt" "halvt|[Ee]tt" "halv|[Dd]"rygt en"|[Tt]vå|[Tt]re|[Ff]yra|[Ff]em|[Ss]ex|sju|åtta|nio|tio|tolv|[0-9]*½|[0-9]+|[0-9]+\-tals|[0-9]+" "[0-9]+\/[0-9]+|[0-9]+\/[0-9]+|[0-9]+\.[0-9]+|[0-9]+\,[0-9]+|[0-9]+\-[0-9]+|[0-9]+" "[0-9]+)" "(miljon" "|miljoner" "|miljarder" ")?g" "
!A {int i=0;printf("<NUMEX TYPE=\"MSR\" SBT=\"WMU\">"); for(;i<yyleng-1;putchar(yytext[i++])); printf("</NUMEX> "); }

Define NumexMsrWmu005a
     [ (Mm {er än } | Cc {irka } | Mm {inst })
       [Nn {ågra få} | Ee {n kvarts} | Ee {tt halvt} | Ee {tt halv}
          | Dd {rygt en} | Tt {vå} | Tt {re} | Ff {yra} | Ff {em} | Ss {ex}
          | {sju} | {åtta} | {nio} | {tio} | {tolv} | Num* {½} | Ins(Nums)
          | Ins(Nums) {-tals} | Ins(Nums) { } Ins(NumsSlashNums) | Ins(NumsSlashNums) | Ins(NumsDotNums)
          | Ins(NumsCommaNums) | Ins(NumRange) | Ins(NumsSpNums)]
       { } ({miljon } | {miljoner } | {miljarder }) {g} ] ;
Define NumexMsrWmu005 [ NumexMsrWmu005a   RC({ })   EndTag(NumexMsrWmu) ] ; 507

!R [0-9]+[0-9\_\,\-]+g" "
!A {int i=0; printf("<NUMEX TYPE=\"MSR\" SBT=\"WMU\">"); for(;i<yyleng-1;putchar(yytext[i++])); printf("</NUMEX> "); }

Define NumexMsrWmu006a [ Ins(Nums) [Num|"_"|","|"-"]+ {g} ] ;
Define NumexMsrWmu006 [ NumexMsrWmu006a   RC({ })   EndTag(NumexMsrWmu) ] ; 508

!R [0-9\_]+g" "
!A {int i=0; printf("<NUMEX TYPE=\"MSR\" SBT=\"WMU\">"); for(;i<yyleng-1;putchar(yytext[i++])); printf("</NUMEX> "); }

Define NumexMsrWmu007a [ DigitUscores {g} ] ;
Define NumexMsrWmu007 [ NumexMsrWmu007a   RC({ })   EndTag(NumexMsrWmu) ] ; 509

!R ([0-9]+"\,"|[0-9]+\,[0-9]+\-)?[0-9]+([km]g|g|gram)
!A {printWMU(yytext,0);}

Define NumexMsrWmu008a
     [ (Ins(Nums) {,} | Ins(NumsCommaNums) {-}) Ins(Nums) [["k"|"m"] {g} | {g} | {gram}] ] ;
Define NumexMsrWmu008 [ NumexMsrWmu008a   EndTag(NumexMsrWmu) ] ; 510

!R ([0-9]+\.[0-9]+|[0-9]+)\-([0-9]+\.[0-9]+|[0-9]+)mg
!A {printWMU(yytext,0);}

Define NumexMsrWmu009a
     [ [Ins(NumsDotNums) | Ins(Nums)] {-} [Ins(NumsDotNums) | Ins(Nums)] {mg} ] ;
Define NumexMsrWmu009 [ NumexMsrWmu009a   EndTag(NumexMsrWmu) ] ; 511

!R ([0-9]+\-)?[0-9]+[km]g\/(kg|i)
!A {printXXX(yytext,0);}

Define NumexMsrXxx015a [ (Ins(Nums) {-}) Ins(Nums) ["k"|"m"] {g/} [{kg} | {i}] ] ;
Define NumexMsrXxx015 [ NumexMsrXxx015a   EndTag(NumexMsrXxx) ] ; 512

!R (under" "|över" "|[0-9]\,[0-9]" vs ")?([0-9]+x[0-9]+|[0-9]+\/[0-9\,]+|[0-9\-]+" "[0-9\-]+|[0-9]+" \- "[0-9]+|[1-9]+" \, "[0-9]+|[0-9]+|[0-9]+\,[0-9]+|[0-9]+\-[0-9]+)" "(mg|IE|IU|mikrog|µg|m[lL]|mikrogram|ggr)(\/minut|\/min|\/m2|" "[Hh][Gg])?
!A {printXXX(yytext,0);}

Define NumexMsrXxx016a
     [ ({under } | {över } | Num {,} Num { vs })
       [Ins(Nums) {x} Ins(Nums) | Ins(Nums) {/} DigitCommas | DigitDashes { } DigitDashes
          | Ins(NumsSpRange) | Num19+ { , } Ins(Nums) | Ins(Nums) | Ins(NumsCommaNums) | Ins(NumRange)]
       { }
       [{mg} | {IE} | {IU} | {mikrog} | {µg} | {m} ["l"|"L"] | {mikrogram}
          | {ggr}]
       ({/minut} | {/min} | {/m2} | { } Hh Gg) ] ;
Define NumexMsrXxx016 [ NumexMsrXxx016a   EndTag(NumexMsrXxx) ] ; 513

!R [0-9]+[pm][lg](\/timme|\/ml|\/mL|\/dos|\/m2|\/dagl|\/dygn|\/L)?
!A {printXXX(yytext,0);}

Define NumexMsrXxx017a
     [ Ins(Nums) ["p"|"m"] ["l"|"g"]
       ({/timme} | {/ml} | {/mL} | {/dos} | {/m2} | {/dagl} | {/dygn} | {/L}) ] ;
Define NumexMsrXxx017 [ NumexMsrXxx017a   EndTag(NumexMsrXxx) ] ; 514

!R pH(\-värde)?" "(omkring|under|över|på)" "[0-9]+([\-\,0-9]+)?
!A {printXXX(yytext,1);}

Define NumexMsrXxx018a
     [ [{omkring} | {under} | {över} | {på}] { } Ins(Nums) ([Num|"-"|","]+) ] ;
Define NumexMsrXxx018
     [ NumexMsrXxx018a
       LC({pH} ({-värde}) { })
       EndTag(NumexMsrXxx) ] ; 515

!R pH" "[0-9]+(\.[0-9])?
!A {printXXX(yytext,1);}

Define NumexMsrXxx019a [ Ins(Nums) ({.} Num) ] ;
Define NumexMsrXxx019
     [ NumexMsrXxx019a
       LC({pH })
       EndTag(NumexMsrXxx) ] ; 516

!R [0-9]+" \( mg \) ml\/l"
!A {printXXX(yytext,0);}

Define NumexMsrXxx020a [ Ins(Nums) { ( mg ) ml/l} ] ;
Define NumexMsrXxx020 [ NumexMsrXxx020a   EndTag(NumexMsrXxx) ] ; 517

!R (ISBN|ISSN)" "("\: ")?[0-9][0-9]*" "[0-9]+" "[0-9]+" "[0-9]+
!A {printXXX(yytext,0);}

Define NumexMsrXxx021a
     [ [{ISBN} | {ISSN}] { } ({: }) Num Num* { } Ins(NumsSpNums) { } Ins(Nums) ] ;
Define NumexMsrXxx021 [ NumexMsrXxx021a   EndTag(NumexMsrXxx) ] ; 518

!R (ISBN|ISSN)" "("\: ")?[0-9][0-9](\-[0-9\-\/]+)+(\-X)?(" \- "[0-9]+)?
!A {printXXX(yytext,0);}

Define NumexMsrXxx022a
     [ [{ISBN} | {ISSN}] { } ({: }) Ins(Nums2) [{-} [Num|"-"|"/"]+]+ ({-X})
       ({ - } Ins(Nums)) ] ;
Define NumexMsrXxx022 [ NumexMsrXxx022a   EndTag(NumexMsrXxx) ] ; 519

!R (ISBN|ISSN)" "("\: ")?[0-9][0-9]*"\-"[0-9\-]+
!A {printXXX(yytext,0);}

Define NumexMsrXxx023a
     [ [{ISBN} | {ISSN}] { } ({: }) Num Num* {-} DigitDashes ] ;
Define NumexMsrXxx023 [ NumexMsrXxx023a   EndTag(NumexMsrXxx) ] ; 520

!R ("P\.O\."|"P\. O\.")" Box "[0-9]+
!A {printXXX(yytext,0);}

Define NumexMsrXxx024a [ [{P.O.} | {P. O.}] { Box } Ins(Nums) ] ;
Define NumexMsrXxx024 [ NumexMsrXxx024a   EndTag(NumexMsrXxx) ] ; 521

!R \n
!A {ECHO;}
!I Ignored exception rule

!R .
!A {ECHO;}
!I Ignored exception rule

!= ======================
!= Pmatch top definitions
!= ======================

Define TOP
     [ IgnoreTagged | Except001 | NumexMsrXxx001 | NumexMsrXxx002
       | NumexMsrXxx003 | NumexMsrXxx004 | NumexMsrXxx005 | NumexMsrXxx006
       | NumexMsrXxx007 | NumexMsrXxx008 | NumexMsrCmu001 | NumexMsrCmu002
       | NumexMsrCmu003 | NumexMsrCmu004 | NumexMsrCmu005 | NumexMsrCmu006
       | NumexMsrCmu007 | NumexMsrSpd001 | NumexMsrSpd002 | NumexMsrSpd003
       | NumexMsrSpd004 | NumexMsrSpd005 | NumexMsrSpd006 | NumexMsrSpd007
       | NumexMsrSpd008 | NumexMsrPss001 | NumexMsrPss002 | NumexMsrPss003
       | NumexMsrPss004 | NumexMsrPss005 | NumexMsrPss006 | NumexMsrPss007
       | NumexMsrPss008 | NumexMsrPss009 | NumexMsrPss010 | NumexMsrPss011
       | NumexMsrPss012 | NumexMsrPss013 | NumexMsrPss014 | NumexMsrPss015
       | NumexMsrPss016 | NumexMsrPss017 | NumexMsrPss018 | NumexMsrPss019
       | NumexMsrPss020 | NumexMsrPss021 | NumexMsrPss022 | NumexMsrPss023
       | NumexMsrPss024 | NumexMsrPss025 | NumexMsrPss026 | NumexMsrPss027
       | NumexMsrXxx009 | NumexMsrXxx010 | NumexMsrPss028 | NumexMsrPss029
       | NumexMsrPss030 | NumexMsrPss031 | NumexMsrPss032 | NumexMsrPss033
       | NumexMsrPss034 | NumexMsrPss035 | NumexMsrXxx011 | NumexMsrXxx012
       | NumexMsrXxx013 | NumexMsrXxx014 | NumexMsrElu001 | NumexMsrElu002
       | NumexMsrElu003 | NumexMsrElu004 | NumexMsrElu005 | NumexMsrElu006
       | NumexMsrElu007 | NumexMsrElu008 | NumexMsrElu009 | NumexMsrElu010
       | NumexMsrElu011 | NumexMsrElu012 | NumexMsrFrq001 | NumexMsrFrq002
       | NumexMsrFrq003 | NumexMsrFrq004 | NumexMsrFrq005 | NumexMsrFrq006
       | NumexMsrFrq007 | NumexMsrFrq008 | NumexMsrFrq009 | NumexMsrFrq010
       | NumexMsrFrq011 | NumexMsrFrq012 | NumexMsrFrq013 | NumexMsrFrq014
       | NumexMsrFrq015 | NumexMsrFrq016 | NumexMsrFrq017 | NumexMsrFrq018
       | NumexMsrFrq019 | NumexMsrFrq020 | NumexMsrFrq021 | NumexMsrFrq022
       | NumexMsrFrq023 | NumexMsrFrq024 | NumexMsrFrq025 | NumexMsrFrq026
       | NumexMsrFrq027 | NumexMsrFrq028 | NumexMsrFrq029 | NumexMsrFrq030
       | NumexMsrFrq031 | NumexMsrFrq032 | NumexMsrFrq033 | NumexMsrMsu001
       | NumexMsrMsu002 | NumexMsrMsu003 | NumexMsrMsu004 | NumexMsrMsu005
       | NumexMsrMsu006 | NumexMsrMsu007 | Except002 | NumexMsrVlm001
       | NumexMsrVlm002 | NumexMsrVlm003 | NumexMsrVlm004 | NumexMsrVlm005
       | NumexMsrVlm006 | NumexMsrVlm007 | NumexMsrVlm008 | NumexMsrVlm009
       | NumexMsrVlm010 | NumexMsrVlm011 | NumexMsrVlm012 | NumexMsrVlm013
       | NumexMsrVlm014 | NumexMsrVlm015 | NumexMsrVlm016 | NumexMsrVlm017
       | NumexMsrVlm018 | NumexMsrVlm019 | NumexMsrDst001 | NumexMsrDst002
       | NumexMsrDst003 | NumexMsrDst004 | NumexMsrDst005 | NumexMsrDst006
       | NumexMsrDst007 | NumexMsrDst008 | NumexMsrDst009 | NumexMsrDst010
       | NumexMsrDst011 | NumexMsrDst012 | NumexMsrDst013 | NumexMsrDst014
       | NumexMsrDst015 | NumexMsrDst016 | NumexMsrDst017 | NumexMsrDst018
       | NumexMsrDst019 | NumexMsrDst020 | NumexMsrDst021 | NumexMsrDst022
       | NumexMsrCrd001 | NumexMsrCrd002 | NumexMsrCrd003 | NumexMsrCrd004
       | NumexMsrCrd005 | NumexMsrCrd006 | NumexMsrCrd007 | NumexMsrCrd008
       | NumexMsrCrd009 | NumexMsrCrd010 | NumexMsrDgr001 | NumexMsrDgr002
       | NumexMsrDgr003 | NumexMsrDgr004 | NumexMsrDgr005 | NumexMsrDgr006
       | NumexMsrDgr007 | NumexMsrDgr008 | NumexMsrDns001 | NumexMsrDns002
       | NumexMsrDns003 | NumexMsrDns004 | NumexMsrDns005 | NumexMsrDns006
       | NumexMsrDns007 | NumexMsrDns008 | NumexMsrDns009 | NumexMsrTmp001
       | NumexMsrTmp002 | NumexMsrTmp003 | NumexMsrTmp004 | NumexMsrTmp005
       | NumexMsrTmp006 | NumexMsrTmp007 | NumexMsrTmp008 | NumexMsrTmp009
       | NumexMsrTmp010 | NumexMsrTmp011 | NumexMsrTmp012 | NumexMsrTmp013
       | NumexMsrTmp014 | NumexMsrTmp015 | NumexMsrTmp016 | NumexMsrTmp017
       | NumexMsrTmp018 | NumexMsrTmp019 | NumexMsrTmp020 | NumexMsrTmp021
       | NumexMsrTmp022 | NumexMsrTmp023 | NumexMsrTmp024 | NumexMsrTmp025
       | NumexMsrTmp026 | NumexMsrTmp027 | NumexMsrTmp028 | NumexMsrTmp029
       | NumexMsrPrc001 | NumexMsrPrc002 | NumexMsrPrc003 | NumexMsrPrc004
       | NumexMsrPrc005 | NumexMsrPrc006 | NumexMsrPrc007 | NumexMsrPrc008
       | NumexMsrPrc009 | NumexMsrPrc010 | NumexMsrPrc011 | NumexMsrPrc012
       | NumexMsrCur001 | NumexMsrCur002 | NumexMsrCur003 | NumexMsrCur004
       | NumexMsrCur005 | NumexMsrCur006 | NumexMsrCur007 | NumexMsrCur008
       | NumexMsrCur009 | NumexMsrCur010 | NumexMsrCur011 | NumexMsrCur012
       | NumexMsrCur013 | NumexMsrCur014 | NumexMsrCur015 | NumexMsrCur016
       | NumexMsrCur017 | NumexMsrCur018 | NumexMsrCur019 | NumexMsrTel001
       | NumexMsrTel002 | NumexMsrTel003 | NumexMsrTel004 | NumexMsrTel005
       | NumexMsrTel006 | NumexMsrTel007 | NumexMsrTel008 | NumexMsrTel009
       | NumexMsrTel010 | NumexMsrTel011 | NumexMsrTel012 | NumexMsrTel013
       | NumexMsrTel014 | NumexMsrTel015 | NumexMsrTel016 | NumexMsrTel017
       | NumexMsrTel018 | NumexMsrTel019 | NumexMsrTel020 | NumexMsrTel021
       | NumexMsrTel022 | NumexMsrTel023 | NumexMsrTel024 | NumexMsrTel025
       | NumexMsrTel026 | Except003 | NumexMsrLst001 | NumexMsrLst002
       | NumexMsrLst003 | NumexMsrLst004 | NumexMsrLst005 | NumexMsrLst006
       | NumexMsrLst007 | NumexMsrLst008 | NumexMsrLst009 | NumexMsrAge001
       | NumexMsrAge002 | NumexMsrAge003 | NumexMsrAge004 | NumexMsrAge005
       | NumexMsrAge006 | NumexMsrAge007 | NumexMsrAge008 | NumexMsrAge009
       | NumexMsrAge010 | NumexMsrAge011 | NumexMsrAge012 | NumexMsrAge013
       | NumexMsrAge014 | NumexMsrAge015 | NumexMsrAge016 | NumexMsrAge017
       | NumexMsrAge018 | NumexMsrAge019 | NumexMsrAge020 | NumexMsrAge021
       | NumexMsrAge022 | NumexMsrAge023 | NumexMsrAge024 | NumexMsrAge025
       | NumexMsrAge026 | NumexMsrAge027 | NumexMsrAge028 | NumexMsrAge029
       | NumexMsrAge030 | NumexMsrAge031 | NumexMsrAge032 | NumexMsrAge033
       | NumexMsrAge034 | NumexMsrAge035 | NumexMsrAge036 | NumexMsrAge037
       | NumexMsrAge038 | NumexMsrAge039 | NumexMsrAge040 | NumexMsrAge041
       | NumexMsrAge042 | NumexMsrAge043 | NumexMsrAge044 | NumexMsrAge045
       | NumexMsrAge046 | NumexMsrAge047 | NumexMsrAge048 | NumexMsrAge049
       | NumexMsrAge050 | NumexMsrAge051 | NumexMsrAge052 | NumexMsrAge053
       | NumexMsrAge054 | NumexMsrAge055 | NumexMsrAge056 | NumexMsrAge057
       | NumexMsrAge058 | NumexMsrAge059 | NumexMsrAge060 | NumexMsrAge061
       | NumexMsrAge062 | NumexMsrAge063 | NumexMsrAge064 | NumexMsrAge065
       | NumexMsrAge066 | NumexMsrAge067 | NumexMsrAge068 | NumexMsrAge069
       | NumexMsrAge070 | NumexMsrAge071 | NumexMsrAge072 | NumexMsrAge073
       | NumexMsrAge074 | NumexMsrAge075 | NumexMsrAge076 | NumexMsrAge077
       | NumexMsrAge078 | NumexMsrAge079 | NumexMsrAge080 | NumexMsrAge081
       | NumexMsrAge082 | NumexMsrAge083 | NumexMsrAge084 | NumexMsrAge085
       | NumexMsrAge086 | NumexMsrAge087 | NumexMsrAge088 | NumexMsrAge089
       | NumexMsrAge090 | NumexMsrAge091 | NumexMsrAge092 | NumexMsrAge093
       | NumexMsrAge094 | NumexMsrAge095 | NumexMsrAge096 | NumexMsrAge097
       | NumexMsrAge098 | NumexMsrAge099 | NumexMsrAge100 | NumexMsrAge101
       | NumexMsrAge102 | NumexMsrAge103 | NumexMsrAge104 | NumexMsrAge105
       | NumexMsrAge106 | NumexMsrAge107 | NumexMsrAge108 | NumexMsrAge109
       | NumexMsrAge110 | NumexMsrAge111 | NumexMsrAge112 | NumexMsrAge113
       | NumexMsrAge114 | NumexMsrAge115 | NumexMsrAge116 | NumexMsrAge117
       | NumexMsrAge118 | NumexMsrAge119 | NumexMsrAge120 | NumexMsrAge121
       | NumexMsrAge122 | NumexMsrAge123 | NumexMsrAge124 | NumexMsrAge125
       | NumexMsrAge126 | NumexMsrAge127 | NumexMsrAge128 | NumexMsrAge129
       | NumexMsrAge130 | NumexMsrAge131 | NumexMsrAge132 | NumexMsrAge133
       | NumexMsrAge134 | NumexMsrAge135 | NumexMsrAge136 | NumexMsrAge137
       | NumexMsrAge138 | NumexMsrAge139 | NumexMsrAge140 | NumexMsrAge141
       | NumexMsrAge142 | NumexMsrAge143 | NumexMsrAge144 | NumexMsrAge145
       | NumexMsrAge146 | NumexMsrAge147 | NumexMsrAge148 | NumexMsrAge149
       | NumexMsrAge150 | NumexMsrAge151 | NumexMsrAge152 | NumexMsrAge153
       | NumexMsrAge154 | NumexMsrAge155 | NumexMsrAge156 | NumexMsrAge157
       | NumexMsrAge158 | NumexMsrAge159 | NumexMsrAge160 | NumexMsrAge161
       | NumexMsrAge162 | NumexMsrAge163 | NumexMsrAge164 | NumexMsrAge165
       | NumexMsrAge166 | NumexMsrAge167 | NumexMsrAge168 | NumexMsrAge169
       | NumexMsrAge170 | NumexMsrAge171 | NumexMsrAge172 | NumexMsrAge173
       | NumexMsrAge174 | NumexMsrAge175 | NumexMsrAge176 | NumexMsrAge177
       | NumexMsrAge178 | NumexMsrAge179 | NumexMsrAge180 | NumexMsrAge181
       | NumexMsrAge182 | NumexMsrAge183 | NumexMsrAge184 | NumexMsrAge185
       | NumexMsrAge186 | NumexMsrAge187 | NumexMsrAge188 | NumexMsrAge189
       | NumexMsrAge190 | NumexMsrAge191 | NumexMsrAge192 | NumexMsrAge193
       | NumexMsrWeb001 | NumexMsrWeb002 | NumexMsrWeb003 | NumexMsrWeb004
       | NumexMsrWeb005 | NumexMsrWeb006 | NumexMsrWeb007 | NumexMsrCvu001
       | NumexMsrCvu002 | NumexMsrCvu003 | NumexMsrCvu004 | NumexMsrCvu005
       | NumexMsrCvu006 | NumexMsrCvu007 | NumexMsrCvu008 | NumexMsrCvu009
       | NumexMsrCvu010 | NumexMsrCvu011 | NumexMsrCvu012 | NumexMsrCvu013
       | NumexMsrCvu014 | NumexMsrCvu015 | NumexMsrCvu016 | NumexMsrCvu017
       | NumexMsrCvu018 | NumexMsrCvu019 | NumexMsrCvu020 | NumexMsrWmu001
       | NumexMsrWmu002 | NumexMsrWmu003 | NumexMsrWmu004 | NumexMsrWmu005
       | NumexMsrWmu006 | NumexMsrWmu007 | NumexMsrWmu008 | NumexMsrWmu009
       | NumexMsrXxx015 | NumexMsrXxx016 | NumexMsrXxx017 | NumexMsrXxx018
       | NumexMsrXxx019 | NumexMsrXxx020 | NumexMsrXxx021 | NumexMsrXxx022
       | NumexMsrXxx023 | NumexMsrXxx024
       LC(WordBoundary) ] ;
