Index: src/test/org/tartarus/snowball/ext/TestSwedish2Stemmer.java =================================================================== --- src/test/org/tartarus/snowball/ext/TestSwedish2Stemmer.java (revision 0) +++ src/test/org/tartarus/snowball/ext/TestSwedish2Stemmer.java (revision 0) @@ -0,0 +1,1744 @@ +package org.tartarus.snowball.ext; + +import junit.framework.TestCase; + +/** + * User: kalle + * Date: 2009-jan-08 + * Time: 19:18:57 + */ +public class TestSwedish2Stemmer extends TestCase { + + public void test() { + + assertEquals("klock", stem("klocka")); + assertEquals("klock", stem("klockan")); + assertEquals("klock", stem("klockans")); + assertEquals("klock", stem("klockor")); + assertEquals("klock", stem("klockorna")); + assertEquals("klock", stem("klockornas")); + + // -an and -ans + + // the two single words 'an' and 'ans' should not be stemmed + assertEquals("an", stem("an")); + assertEquals("ans", stem("ans")); + + + // composite word suffix stripping exceptions + + assertEquals("sommardans", stem("sommardans")); + assertEquals("sommardans", stem("sommardansen")); + assertEquals("sommardans", stem("sommardanserna")); + + assertEquals("fotbollsfan", stem("fotbollsfan")); + assertEquals("fotbollsfan", stem("fotbollsfans")); + assertEquals("fotbollsfan", stem("fotbollsfansen")); + assertEquals("fotbollsfan", stem("fotbollsfansens")); + + assertEquals("aktiefinans", stem("aktiefinans")); + assertEquals("aktiefinans", stem("aktiefinansen")); + assertEquals("aktiefinans", stem("aktiefinansens")); + assertEquals("aktiefinans", stem("aktiefinanser")); + assertEquals("aktiefinans", stem("aktiefinanserna")); + assertEquals("aktiefinans", stem("aktiefinansernas")); + + assertEquals("ögonfrans", stem("ögonfrans")); + assertEquals("ögonfrans", stem("ögonfransen")); + assertEquals("ögonfrans", stem("ögonfransens")); + + assertEquals("midsommarkrans", stem("midsommarkrans")); + assertEquals("midsommarkrans", stem("midsommarkransen")); + assertEquals("midsommarkrans", stem("midsommarkransens")); + assertEquals("midsommarkrans", stem("midsommarkransar")); + assertEquals("midsommarkrans", stem("midsommarkransarna")); + assertEquals("midsommarkrans", stem("midsommarkransarnas")); + + assertEquals("vattenkran", stem("vattenkran")); + assertEquals("vattenkran", stem("vattenkranar")); + assertEquals("vattenkran", stem("vattenkranarna")); + assertEquals("vattenkran", stem("vattenkranarnas")); + + assertEquals("pocketroman", stem("pocketroman")); + assertEquals("pocketroman", stem("pocketromanen")); + assertEquals("pocketroman", stem("pocketromanens")); + assertEquals("pocketroman", stem("pocketromaner")); + assertEquals("pocketroman", stem("pocketromanerna")); + assertEquals("pocketroman", stem("pocketromanernas")); + + assertEquals("sommarromans", stem("sommarromans")); + assertEquals("sommarromans", stem("sommarromansen")); + assertEquals("sommarromans", stem("sommarromansens")); + assertEquals("sommarromans", stem("sommarromanser")); + assertEquals("sommarromans", stem("sommarromanserna")); + assertEquals("sommarromans", stem("sommarromansernas")); + + assertEquals("varumärkesslogan", stem("varumärkesslogan")); + assertEquals("varumärkesslogan", stem("varumärkesslogans")); + + assertEquals("vintersv", stem("vintersvan")); + + assertEquals("kattsvans", stem("kattsvans")); + assertEquals("kattsvans", stem("kattsvansen")); + assertEquals("kattsvans", stem("kattsvansens")); + assertEquals("kattsvans", stem("kattsvansar")); + assertEquals("kattsvans", stem("kattsvansarna")); + assertEquals("kattsvans", stem("kattsvansarnas")); + + + assertEquals("ökensultan", stem("ökensultan")); + assertEquals("ökensultan", stem("ökensultanen")); + assertEquals("ökensultan", stem("ökensultanens")); + assertEquals("ökensultan", stem("ökensultaner")); + assertEquals("ökensultan", stem("ökensultanerna")); + assertEquals("ökensultan", stem("ökensultanernas")); + + assertEquals("meditiationstrans", stem("meditiationstrans")); + assertEquals("meditiationstrans", stem("meditiationstransen")); + assertEquals("meditiationstrans", stem("meditiationstransens")); + + + // -an and -ans suffix stripping exceptions + + assertEquals("banan", stem("banan")); + assertEquals("banan", stem("bananen")); + assertEquals("banan", stem("bananens")); + assertEquals("banan", stem("bananerna")); + assertEquals("banan", stem("bananernas")); + + assertEquals("finans", stem("finans")); + assertEquals("finans", stem("finansen")); + assertEquals("finans", stem("finansens")); + assertEquals("finans", stem("finanser")); + assertEquals("finans", stem("finanserna")); + assertEquals("finans", stem("finansernas")); + + + + + assertEquals("sedan", stem("sedan")); + + + // words in SAOL ending with an or ans + + assertEquals("abortfråg", stem("abortfrågan")); + assertEquals("abundans", stem("abundans")); + assertEquals("accept", stem("acceptans")); + assertEquals("adekv", stem("adekvans")); + assertEquals("adelsm", stem("adelsman")); + assertEquals("admit", stem("admittans")); + assertEquals("adoptionsansök", stem("adoptionsansökan")); + assertEquals("aeropl", stem("aeroplan")); + assertEquals("affärsm", stem("affärsman")); + assertEquals("afgh", stem("afghan")); + assertEquals("afrikaans", stem("afrikaans")); + assertEquals("afrik", stem("afrikan")); + assertEquals("afroamerik", stem("afroamerikan")); + assertEquals("agentroman", stem("agentroman")); + assertEquals("akademihemm", stem("akademihemman")); + assertEquals("alb", stem("alban")); + assertEquals("allared", stem("allaredan")); + assertEquals("allesamm", stem("allesamman")); + assertEquals("allesamm", stem("allesammans")); + assertEquals("alli", stem("allians")); + assertEquals("allroundidrottsm", stem("allroundidrottsman")); + assertEquals("allsvensk", stem("allsvenskan")); + assertEquals("alltmed", stem("alltmedan")); + assertEquals("alltsamm", stem("alltsamman")); + assertEquals("alltsamm", stem("alltsammans")); + assertEquals("alltsed", stem("alltsedan")); + assertEquals("allvarsm", stem("allvarsman")); + assertEquals("alt", stem("altan")); + assertEquals("amatöridrottsm", stem("amatöridrottsman")); + assertEquals("ambassadtjänstem", stem("ambassadtjänsteman")); + assertEquals("ambul", stem("ambulans")); + assertEquals("ambulansm", stem("ambulansman")); + assertEquals("amerik", stem("amerikan")); + assertEquals("amfibieflygpl", stem("amfibieflygplan")); + assertEquals("amorteringspl", stem("amorteringsplan")); + assertEquals("amtm", stem("amtman")); + + assertEquals("andningsorg", stem("andningsorgan")); + assertEquals("andorr", stem("andorran")); + assertEquals("andrestyrm", stem("andrestyrman")); + assertEquals("anfordr", stem("anfordran")); + assertEquals("angloamerik", stem("angloamerikan")); + assertEquals("anglom", stem("angloman")); + assertEquals("angol", stem("angolan")); + assertEquals("angreppspl", stem("angreppsplan")); + assertEquals("anhåll", stem("anhållan")); + assertEquals("ankarkran", stem("ankarkran")); + assertEquals("anmod", stem("anmodan")); + assertEquals("anmäl", stem("anmälan")); + assertEquals("ann", stem("annan")); + assertEquals("annanst", stem("annanstans")); + assertEquals("annonsorg", stem("annonsorgan")); + assertEquals("anstift", stem("anstiftan")); + assertEquals("ansök", stem("ansökan")); + assertEquals("antigu", stem("antiguan")); + assertEquals("antimongl", stem("antimonglans")); + assertEquals("antyd", stem("antydan")); + assertEquals("apachedans", stem("apachedans")); + assertEquals("arbetsgivarsid", stem("arbetsgivarsidan")); + assertEquals("arbetsnarkom", stem("arbetsnarkoman")); + assertEquals("arbetspl", stem("arbetsplan")); + assertEquals("arbetsvägr", stem("arbetsvägran")); + assertEquals("argusfas", stem("argusfasan")); + assertEquals("arrendehemm", stem("arrendehemman")); + assertEquals("arrog", stem("arrogans")); + assertEquals("artikulationsorg", stem("artikulationsorgan")); + assertEquals("asalär", stem("asaläran")); + assertEquals("assist", stem("assistans")); + assertEquals("asson", stem("assonans")); + assertEquals("assur", stem("assurans")); + assertEquals("astrak", stem("astrakan")); + assertEquals("asylansök", stem("asylansökan")); + assertEquals("attackflygpl", stem("attackflygplan")); + assertEquals("attackpl", stem("attackplan")); + assertEquals("attan", stem("attan")); + assertEquals("attentatsm", stem("attentatsman")); + assertEquals("avanmäl", stem("avanmälan")); + assertEquals("avans", stem("avans")); + assertEquals("avbetalningspl", stem("avbetalningsplan")); + assertEquals("avbid", stem("avbidan")); + assertEquals("avfordr", stem("avfordran")); + assertEquals("avgl", stem("avglans")); + assertEquals("avgudadyrk", stem("avgudadyrkan")); + assertEquals("avråd", stem("avrådan")); + assertEquals("avskedsansök", stem("avskedsansökan")); + assertEquals("avstyrk", stem("avstyrkan")); + assertEquals("avståndsverk", stem("avståndsverkan")); + assertEquals("avsöndringsorg", stem("avsöndringsorgan")); + assertEquals("avundsm", stem("avundsman")); + assertEquals("avvak", stem("avvaktan")); + assertEquals("avvecklingspl", stem("avvecklingsplan")); + assertEquals("azerbajdzj", stem("azerbajdzjan")); + assertEquals("babbl", stem("babblan")); + assertEquals("babi", stem("babian")); + assertEquals("backtimj", stem("backtimjan")); + assertEquals("badlak", stem("badlakan")); + assertEquals("baham", stem("bahaman")); + assertEquals("bajadärdans", stem("bajadärdans")); + assertEquals("balans", stem("balans")); + assertEquals("balansorg", stem("balansorgan")); + assertEquals("ban", stem("ban")); + assertEquals("banan", stem("banan")); + assertEquals("bandyallsvensk", stem("bandyallsvenskan")); + assertEquals("banem", stem("baneman")); + assertEquals("banj", stem("banjan")); + assertEquals("bankm", stem("bankman")); + assertEquals("banktjänstem", stem("banktjänsteman")); + assertEquals("bany", stem("banyan")); + assertEquals("bardis", stem("bardisan")); + assertEquals("barnombudsm", stem("barnombudsman")); + assertEquals("barnuppfostr", stem("barnuppfostran")); + assertEquals("baspl", stem("basplan")); + assertEquals("befallningsm", stem("befallningsman")); + assertEquals("befordr", stem("befordran")); + assertEquals("befrämj", stem("befrämjan")); + assertEquals("begravningskrans", stem("begravningskrans")); + assertEquals("begrund", stem("begrundan")); + assertEquals("begär", stem("begäran")); + assertEquals("behandlingspl", stem("behandlingsplan")); + assertEquals("beivr", stem("beivran")); + assertEquals("bekännelseroman", stem("bekännelseroman")); + assertEquals("bemanningspl", stem("bemanningsplan")); + assertEquals("benrangelsm", stem("benrangelsman")); + assertEquals("benådningsansök", stem("benådningsansökan")); + assertEquals("beredningsorg", stem("beredningsorgan")); + assertEquals("beredskapspl", stem("beredskapsplan")); + assertEquals("bergsm", stem("bergsman")); + assertEquals("bergspredik", stem("bergspredikan")); + assertEquals("besiktningsm", stem("besiktningsman")); + assertEquals("beskåd", stem("beskådan")); + assertEquals("beslutsorg", stem("beslutsorgan")); + assertEquals("besm", stem("besman")); + assertEquals("besvärsinst", stem("besvärsinstans")); + assertEquals("besättningsm", stem("besättningsman")); + assertEquals("betalningsbalans", stem("betalningsbalans")); + assertEquals("betalningspl", stem("betalningsplan")); + assertEquals("betydelseny", stem("betydelsenyans")); + assertEquals("beundr", stem("beundran")); + assertEquals("bevarandepl", stem("bevarandeplan")); + assertEquals("bevaringspl", stem("bevaringsplan")); + assertEquals("bibelkonkordans", stem("bibelkonkordans")); + assertEquals("bibliom", stem("biblioman")); + assertEquals("bibliotekstjänstem", stem("bibliotekstjänsteman")); + assertEquals("bid", stem("bidan")); + assertEquals("bidragsansök", stem("bidragsansökan")); + assertEquals("bilddyrk", stem("bilddyrkan")); + assertEquals("bildningsroman", stem("bildningsroman")); + assertEquals("bilkarav", stem("bilkaravan")); + assertEquals("biståndsorg", stem("biståndsorgan")); + assertEquals("biverk", stem("biverkan")); + assertEquals("bjällerkrans", stem("bjällerkrans")); + assertEquals("blandningskran", stem("blandningskran")); + assertEquals("blodspill", stem("blodspillan")); + assertEquals("blodsspill", stem("blodsspillan")); + assertEquals("blomsterkrans", stem("blomsterkrans")); + assertEquals("blygl", stem("blyglans")); + assertEquals("blågr", stem("blågran")); + assertEquals("blåje", stem("blåjeans")); + assertEquals("bokanmäl", stem("bokanmälan")); + assertEquals("bolagsm", stem("bolagsman")); + assertEquals("bolivi", stem("bolivian")); + assertEquals("bollpl", stem("bollplan")); + assertEquals("bombpl", stem("bombplan")); + assertEquals("bondehemm", stem("bondehemman")); + assertEquals("bonderoman", stem("bonderoman")); + assertEquals("bondhemm", stem("bondhemman")); + assertEquals("bondvisch", stem("bondvischan")); + assertEquals("borddans", stem("borddans")); + assertEquals("borgensm", stem("borgensman")); + assertEquals("borgesm", stem("borgesman")); + assertEquals("bortapl", stem("bortaplan")); + assertEquals("bottenpl", stem("bottenplan")); + assertEquals("boutredningsm", stem("boutredningsman")); + assertEquals("brahm", stem("brahman")); + assertEquals("bram", stem("braman")); + assertEquals("brandm", stem("brandman")); + assertEquals("branschorg", stem("branschorgan")); + assertEquals("brasili", stem("brasilian")); + assertEquals("breakdans", stem("breakdans")); + assertEquals("brevbefordr", stem("brevbefordran")); + assertEquals("brevroman", stem("brevroman")); + assertEquals("brilj", stem("briljans")); + assertEquals("bris", stem("brisans")); + assertEquals("bryggdans", stem("bryggdans")); + assertEquals("budgetbalans", stem("budgetbalans")); + assertEquals("buffertverk", stem("buffertverkan")); + assertEquals("buld", stem("buldan")); + assertEquals("bulv", stem("bulvan")); + assertEquals("burm", stem("burman")); + assertEquals("bushm", stem("bushman")); + assertEquals("but", stem("butan")); + assertEquals("byggnadspl", stem("byggnadsplan")); + assertEquals("byggpl", stem("byggplan")); + assertEquals("bytesbalans", stem("bytesbalans")); + assertEquals("bärpl", stem("bärplan")); + assertEquals("bästem", stem("bästeman")); + assertEquals("bäv", stem("bävan")); + assertEquals("båtsm", stem("båtsman")); + assertEquals("bönem", stem("böneman")); + assertEquals("börj", stem("början")); + assertEquals("canc", stem("cancan")); + assertEquals("cardigan", stem("cardigan")); + assertEquals("cellmembr", stem("cellmembran")); + assertEquals("cellofan", stem("cellofan")); + assertEquals("centerm", stem("centerman")); + assertEquals("centerriksdagsm", stem("centerriksdagsman")); + assertEquals("centralafrik", stem("centralafrikan")); + assertEquals("centralorg", stem("centralorgan")); + assertEquals("chan", stem("chans")); + assertEquals("charlat", stem("charlatan")); + assertEquals("charterpl", stem("charterplan")); + assertEquals("chefsrådm", stem("chefsrådman")); + assertEquals("chefstjänstem", stem("chefstjänsteman")); + assertEquals("chik", stem("chikan")); + assertEquals("chockverk", stem("chockverkan")); + assertEquals("colombi", stem("colombian")); + assertEquals("costaric", stem("costarican")); + assertEquals("cricketpl", stem("cricketplan")); + assertEquals("cyan", stem("cyan")); + assertEquals("dagting", stem("dagtingan")); + assertEquals("daldans", stem("daldans")); + assertEquals("dan", stem("dan")); + assertEquals("dandyeleg", stem("dandyelegans")); + assertEquals("dannem", stem("danneman")); + assertEquals("dans", stem("dans")); + assertEquals("datam", stem("dataman")); + assertEquals("debutroman", stem("debutroman")); + assertEquals("dekadans", stem("dekadans")); + + assertEquals("dek", stem("dekan")); + assertEquals("dek", stem("dekanen")); + assertEquals("dek", stem("dekanens")); + assertEquals("dek", stem("dekanerna")); + assertEquals("dek", stem("dekanerna")); + assertEquals("dek", stem("dekanernas")); + + assertEquals("demissionsansök", stem("demissionsansökan")); + assertEquals("denimje", stem("denimjeans")); + assertEquals("dervischdans", stem("dervischdans")); + assertEquals("dessemell", stem("dessemellan")); + assertEquals("dessförin", stem("dessförinnan")); + assertEquals("dessförut", stem("dessförutan")); + assertEquals("detaljpl", stem("detaljplan")); + assertEquals("detektivroman", stem("detektivroman")); + assertEquals("dextr", stem("dextran")); + assertEquals("diagonalpl", stem("diagonalplan")); + assertEquals("diametralpl", stem("diametralplan")); + assertEquals("dikt", stem("diktan")); + assertEquals("dipsom", stem("dipsoman")); + assertEquals("diskodans", stem("diskodans")); + assertEquals("diskordans", stem("diskordans")); + assertEquals("diskrep", stem("diskrepans")); + assertEquals("diskrimineringsombudsm", stem("diskrimineringsombudsman")); + assertEquals("dispensansök", stem("dispensansökan")); + assertEquals("dispositionspl", stem("dispositionsplan")); + assertEquals("disson", stem("dissonans")); + assertEquals("dist", stem("distans")); + assertEquals("div", stem("divan")); + assertEquals("djupverk", stem("djupverkan")); + assertEquals("djävulsdyrk", stem("djävulsdyrkan")); + assertEquals("dokumentärroman", stem("dokumentärroman")); + assertEquals("domaredans", stem("domaredans")); + assertEquals("domedagspredik", stem("domedagspredikan")); + assertEquals("domin", stem("dominans")); + assertEquals("dominik", stem("dominikan")); + assertEquals("domkyrkosysslem", stem("domkyrkosyssleman")); + assertEquals("donju", stem("donjuan")); + assertEquals("donkeym", stem("donkeyman")); + assertEquals("doppared", stem("dopparedan")); + assertEquals("dragom", stem("dragoman")); + assertEquals("dressyrtävl", stem("dressyrtävlan")); + assertEquals("driftvärnsm", stem("driftvärnsman")); + assertEquals("duman", stem("duman")); + assertEquals("dussinroman", stem("dussinroman")); + assertEquals("dymmelveck", stem("dymmelveckan")); + assertEquals("dyrk", stem("dyrkan")); + assertEquals("däd", stem("dädan")); + assertEquals("där", stem("däran")); + assertEquals("däremell", stem("däremellan")); + assertEquals("därförin", stem("därförinnan")); + assertEquals("därförut", stem("därförutan")); + assertEquals("därutin", stem("därutinnan")); + assertEquals("dödm", stem("dödman")); + assertEquals("dödsdans", stem("dödsdans")); + assertEquals("dödsfruk", stem("dödsfruktan")); + assertEquals("dödsläng", stem("dödslängtan")); + assertEquals("ecuadori", stem("ecuadorian")); + assertEquals("edsvägr", stem("edsvägran")); + assertEquals("efteranmäl", stem("efteranmälan")); + assertEquals("efterfråg", stem("efterfrågan")); + assertEquals("efterfrågesid", stem("efterfrågesidan")); + assertEquals("eftergl", stem("efterglans")); + assertEquals("efterlever", stem("efterleverans")); + assertEquals("efterverk", stem("efterverkan")); + assertEquals("eklövskrans", stem("eklövskrans")); + assertEquals("ekoverk", stem("ekoverkan")); + assertEquals("ekvatorialguine", stem("ekvatorialguinean")); + assertEquals("ekvidist", stem("ekvidistans")); + assertEquals("eldverk", stem("eldverkan")); + assertEquals("eleg", stem("elegans")); + assertEquals("elitidrottsm", stem("elitidrottsman")); + assertEquals("ellever", stem("elleverans")); + assertEquals("emed", stem("emedan")); + assertEquals("emell", stem("emellan")); + assertEquals("engelsm", stem("engelsman")); + assertEquals("engångslak", stem("engångslakan")); + assertEquals("enhetsflygpl", stem("enhetsflygplan")); + assertEquals("enm", stem("enmans")); + assertEquals("enpl", stem("enplans")); + assertEquals("entrépl", stem("entréplan")); + assertEquals("epålettfrans", stem("epålettfrans")); + assertEquals("eran", stem("eran")); + assertEquals("erbjud", stem("erbjudan")); + assertEquals("erinr", stem("erinran")); + assertEquals("eritre", stem("eritrean")); + assertEquals("erotom", stem("erotoman")); + assertEquals("eternellkrans", stem("eternellkrans")); + assertEquals("evakueringspl", stem("evakueringsplan")); + assertEquals("evighetsläng", stem("evighetslängtan")); + assertEquals("expansionspl", stem("expansionsplan")); + assertEquals("exploateringspl", stem("exploateringsplan")); + assertEquals("expressbefordr", stem("expressbefordran")); + assertEquals("extravag", stem("extravagans")); + assertEquals("fackeldans", stem("fackeldans")); + assertEquals("fackföreningsm", stem("fackföreningsman")); + assertEquals("fackm", stem("fackman")); + assertEquals("fackorg", stem("fackorgan")); + assertEquals("faderull", stem("faderullan")); + assertEquals("faj", stem("fajans")); + assertEquals("fan", stem("fan")); + assertEquals("farssid", stem("farssidan")); + assertEquals("fasan", stem("fasan")); + assertEquals("felanmäl", stem("felanmälan")); + assertEquals("femårspl", stem("femårsplan")); + assertEquals("fetischdyrk", stem("fetischdyrkan")); + assertEquals("fiendesid", stem("fiendesidan")); + assertEquals("fiji", stem("fijian")); + assertEquals("filigr", stem("filigran")); + assertEquals("finans", stem("finans")); + assertEquals("finansieringspl", stem("finansieringsplan")); + assertEquals("finansm", stem("finansman")); + assertEquals("finanspl", stem("finansplan")); + assertEquals("fiskeritillsyningsm", stem("fiskeritillsyningsman")); + assertEquals("fjällv", stem("fjällvan")); + assertEquals("fjärdem", stem("fjärdeman")); + assertEquals("fjärdingsm", stem("fjärdingsman")); + assertEquals("fjärr", stem("fjärran")); + assertEquals("fjärrverk", stem("fjärrverkan")); + assertEquals("flaggm", stem("flaggman")); + assertEquals("flaggstyrm", stem("flaggstyrman")); + assertEquals("flamencodans", stem("flamencodans")); + assertEquals("flerårspl", stem("flerårsplan")); + assertEquals("flottkrans", stem("flottkrans")); + assertEquals("flygpl", stem("flygplan")); + assertEquals("flygstyrm", stem("flygstyrman")); + assertEquals("flygveter", stem("flygveteran")); + assertEquals("flyktpl", stem("flyktplan")); + assertEquals("flyttningsanmäl", stem("flyttningsanmälan")); + assertEquals("flödespl", stem("flödesplan")); + assertEquals("fogsvans", stem("fogsvans")); + assertEquals("fokaldist", stem("fokaldistans")); + assertEquals("fokalpl", stem("fokalplan")); + assertEquals("folkdans", stem("folkdans")); + assertEquals("folkuppfostr", stem("folkuppfostran")); + assertEquals("fordr", stem("fordran")); + assertEquals("fornkyrk", stem("fornkyrkan")); + assertEquals("fortplantningsorg", stem("fortplantningsorgan")); + assertEquals("fostr", stem("fostran")); + assertEquals("fotbollspl", stem("fotbollsplan")); + assertEquals("framhjärn", stem("framhjärnan")); + assertEquals("framställ", stem("framställan")); + assertEquals("framtidsm", stem("framtidsman")); + assertEquals("framtidspl", stem("framtidsplan")); + assertEquals("francisk", stem("franciskan")); + assertEquals("frans", stem("frans")); + assertEquals("fransm", stem("fransman")); + assertEquals("fredspl", stem("fredsplan")); + assertEquals("frihetsläng", stem("frihetslängtan")); + assertEquals("fril", stem("frilans")); + assertEquals("frontm", stem("frontman")); + assertEquals("frontveter", stem("frontveteran")); + assertEquals("frukt", stem("fruktan")); + assertEquals("fruntimmersveck", stem("fruntimmersveckan")); + assertEquals("frälsarkrans", stem("frälsarkrans")); + assertEquals("frälsehemm", stem("frälsehemman")); + assertEquals("frälsem", stem("frälseman")); + assertEquals("frälserm", stem("frälserman")); + assertEquals("fullbord", stem("fullbordan")); + assertEquals("fullgörelsetal", stem("fullgörelsetalan")); + assertEquals("fyraårspl", stem("fyraårsplan")); + assertEquals("fältm", stem("fältman")); + assertEquals("fälttävl", stem("fälttävlan")); + assertEquals("fälttågspl", stem("fälttågsplan")); + assertEquals("färdpl", stem("färdplan")); + assertEquals("färggl", stem("färgglans")); + assertEquals("färgny", stem("färgnyans")); + assertEquals("färgverk", stem("färgverkan")); + assertEquals("fästm", stem("fästman")); + assertEquals("fångesm", stem("fångesman")); + assertEquals("fångstm", stem("fångstman")); + assertEquals("följdverk", stem("följdverkan")); + assertEquals("föranmäl", stem("föranmälan")); + assertEquals("föranstalt", stem("föranstaltan")); + assertEquals("förbid", stem("förbidan")); + assertEquals("förbindelsem", stem("förbindelseman")); + assertEquals("fördelningspl", stem("fördelningsplan")); + assertEquals("föregångsm", stem("föregångsman")); + assertEquals("förfråg", stem("förfrågan")); + assertEquals("förfädersdyrk", stem("förfädersdyrkan")); + assertEquals("förfär", stem("förfäran")); + assertEquals("förgrundsm", stem("förgrundsman")); + assertEquals("förhandsanmäl", stem("förhandsanmälan")); + assertEquals("förintelseläng", stem("förintelselängtan")); + assertEquals("förkovr", stem("förkovran")); + assertEquals("förlikningsm", stem("förlikningsman")); + assertEquals("förlit", stem("förlitan")); + assertEquals("förm", stem("förman")); + assertEquals("förmedlingsorg", stem("förmedlingsorgan")); + assertEquals("förmod", stem("förmodan")); + assertEquals("förrättningsm", stem("förrättningsman")); + assertEquals("förskyll", stem("förskyllan")); + assertEquals("förstestyrm", stem("förstestyrman")); + assertEquals("försvarsalli", stem("försvarsallians")); + assertEquals("försvarshögskol", stem("försvarshögskolan")); + assertEquals("försäkr", stem("försäkran")); + assertEquals("försäkringsm", stem("försäkringsman")); + assertEquals("försäkringstjänstem", stem("försäkringstjänsteman")); + assertEquals("försörjningsbalans", stem("försörjningsbalans")); + assertEquals("förtroendem", stem("förtroendeman")); + assertEquals("förtröst", stem("förtröstan")); + assertEquals("förtvivl", stem("förtvivlan")); + assertEquals("förundr", stem("förundran")); + assertEquals("förutan", stem("förutan")); + assertEquals("förvaltningsorg", stem("förvaltningsorgan")); + assertEquals("förvänt", stem("förväntan")); + assertEquals("förvåll", stem("förvållan")); + assertEquals("gammaldans", stem("gammaldans")); + assertEquals("gamm", stem("gamman")); + assertEquals("gammeldans", stem("gammeldans")); + assertEquals("gan", stem("gan")); + assertEquals("gans", stem("gans")); + assertEquals("garnnyst", stem("garnnystan")); + assertEquals("gaskran", stem("gaskran")); + assertEquals("gaslever", stem("gasleverans")); + assertEquals("gasvulk", stem("gasvulkan")); + assertEquals("gatupl", stem("gatuplan")); + assertEquals("gen", stem("genans")); + assertEquals("generalpl", stem("generalplan")); + assertEquals("generationsroman", stem("generationsroman")); + assertEquals("genitalorg", stem("genitalorgan")); + assertEquals("gentlem", stem("gentleman")); + assertEquals("gerillam", stem("gerillaman")); + assertEquals("germ", stem("german")); + assertEquals("ghan", stem("ghanan")); + assertEquals("giftom", stem("giftoman")); + assertEquals("giftverk", stem("giftverkan")); + assertEquals("gissl", stem("gisslan")); + assertEquals("glan", stem("glan")); + assertEquals("glans", stem("glans")); + assertEquals("glidflygpl", stem("glidflygplan")); + assertEquals("glutenintoler", stem("glutenintolerans")); + assertEquals("godsbefordr", stem("godsbefordran")); + assertEquals("gossopr", stem("gossopran")); + assertEquals("gran", stem("gran")); + assertEquals("granskningsm", stem("granskningsman")); + assertEquals("granskningsorg", stem("granskningsorgan")); + assertEquals("gratisch", stem("gratischans")); + assertEquals("griporg", stem("griporgan")); + assertEquals("gripsvans", stem("gripsvans")); + assertEquals("grobi", stem("grobian")); + assertEquals("grodm", stem("grodman")); + assertEquals("grundpl", stem("grundplan")); + assertEquals("gruspl", stem("grusplan")); + assertEquals("gränsuppsyningsm", stem("gränsuppsyningsman")); + assertEquals("gräspl", stem("gräsplan")); + assertEquals("gråhårsm", stem("gråhårsman")); + assertEquals("guatemal", stem("guatemalan")); + assertEquals("gudsdyrk", stem("gudsdyrkan")); + assertEquals("gudsfruk", stem("gudsfruktan")); + assertEquals("gudsförtröst", stem("gudsförtröstan")); + assertEquals("gudsm", stem("gudsman")); + assertEquals("guine", stem("guinean")); + assertEquals("guldch", stem("guldchans")); + assertEquals("guldfas", stem("guldfasan")); + assertEquals("guldgl", stem("guldglans")); + assertEquals("gustavi", stem("gustavian")); + assertEquals("guyan", stem("guyanan")); + assertEquals("gärningsm", stem("gärningsman")); + assertEquals("gårdspl", stem("gårdsplan")); + assertEquals("hallåm", stem("hallåman")); + assertEquals("halvan", stem("halvannan")); + assertEquals("halvdan", stem("halvdan")); + assertEquals("halvdist", stem("halvdistans")); + assertEquals("han", stem("han")); + assertEquals("handelsbalans", stem("handelsbalans")); + assertEquals("handelsm", stem("handelsman")); + assertEquals("handikappombudsm", stem("handikappombudsman")); + assertEquals("handst", stem("handstans")); + assertEquals("hans", stem("hans")); + assertEquals("harvärj", stem("harvärjan")); + assertEquals("havstulp", stem("havstulpan")); + assertEquals("hawaii", stem("hawaiian")); + assertEquals("hedersm", stem("hedersman")); + assertEquals("hegeli", stem("hegelian")); + assertEquals("hej", stem("hejans")); + assertEquals("hejs", stem("hejsan")); + assertEquals("helgondyrk", stem("helgondyrkan")); + assertEquals("helgongl", stem("helgonglans")); + assertEquals("helhetsverk", stem("helhetsverkan")); + assertEquals("helikopterambul", stem("helikopterambulans")); + assertEquals("helvetespredik", stem("helvetespredikan")); + assertEquals("hemlockgr", stem("hemlockgran")); + assertEquals("hemlocksgr", stem("hemlocksgran")); + assertEquals("hemläng", stem("hemlängtan")); + assertEquals("hemmam", stem("hemmaman")); + assertEquals("hemm", stem("hemman")); + assertEquals("hemmapl", stem("hemmaplan")); + assertEquals("hemmav", stem("hemmavan")); + assertEquals("hemställ", stem("hemställan")); + assertEquals("hemulsm", stem("hemulsman")); + assertEquals("hemv", stem("hemvan")); + assertEquals("hemvärnsm", stem("hemvärnsman")); + assertEquals("herderoman", stem("herderoman")); + assertEquals("herran", stem("herran")); + assertEquals("herrem", stem("herreman")); + assertEquals("herrgårdsroman", stem("herrgårdsroman")); + assertEquals("hetm", stem("hetman")); + assertEquals("hinsid", stem("hinsidan")); + assertEquals("hirdm", stem("hirdman")); + assertEquals("historieroman", stem("historieroman")); + assertEquals("hjälporg", stem("hjälporgan")); + assertEquals("hjältedyrk", stem("hjältedyrkan")); + assertEquals("hjärnsubst", stem("hjärnsubstans")); + assertEquals("hockeyallsvensk", stem("hockeyallsvenskan")); + assertEquals("hockeypl", stem("hockeyplan")); + assertEquals("hondur", stem("honduran")); + assertEquals("hopps", stem("hoppsan")); + assertEquals("horisontalpl", stem("horisontalplan")); + assertEquals("hormonbalans", stem("hormonbalans")); + assertEquals("hovm", stem("hovman")); + assertEquals("hovrättslagm", stem("hovrättslagman")); + assertEquals("hugsval", stem("hugsvalan")); + assertEquals("hul", stem("huligan")); + assertEquals("hum", stem("human")); + assertEquals("hund", stem("hundan")); + assertEquals("hundstjärn", stem("hundstjärnan")); + assertEquals("hurd", stem("hurdan")); + assertEquals("hurud", stem("hurudan")); + assertEquals("hushållningspl", stem("hushållningsplan")); + assertEquals("husm", stem("husman")); + assertEquals("husorg", stem("husorgan")); + assertEquals("husrannsak", stem("husrannsakan")); + assertEquals("hustavl", stem("hustavlan")); + assertEquals("huvudm", stem("huvudman")); + assertEquals("huvudorg", stem("huvudorgan")); + assertEquals("hydropl", stem("hydroplan")); + assertEquals("hyllpl", stem("hyllplan")); + assertEquals("häckgr", stem("häckgran")); + assertEquals("häd", stem("hädan")); + assertEquals("häntyd", stem("häntydan")); + assertEquals("häremell", stem("häremellan")); + assertEquals("häromd", stem("häromdan")); + assertEquals("häromveck", stem("häromveckan")); + assertEquals("härutin", stem("härutinnan")); + assertEquals("hästm", stem("hästman")); + assertEquals("hästsvans", stem("hästsvans")); + assertEquals("häxdans", stem("häxdans")); + assertEquals("hålst", stem("hålstans")); + assertEquals("hårm", stem("hårman")); + assertEquals("högbåtsm", stem("högbåtsman")); + assertEquals("högerm", stem("högerman")); + assertEquals("höggl", stem("högglans")); + assertEquals("högr", stem("högran")); + assertEquals("högrenäss", stem("högrenässans")); + assertEquals("hörselorg", stem("hörselorgan")); + assertEquals("höv", stem("hövan")); + assertEquals("hövitsm", stem("hövitsman")); + assertEquals("idegr", stem("idegran")); + assertEquals("idoldyrk", stem("idoldyrkan")); + assertEquals("idrottsm", stem("idrottsman")); + assertEquals("idrottspl", stem("idrottsplan")); + assertEquals("idéroman", stem("idéroman")); + assertEquals("ignor", stem("ignorans")); + assertEquals("ilbefordr", stem("ilbefordran")); + assertEquals("ilexkrans", stem("ilexkrans")); + assertEquals("illgärningsm", stem("illgärningsman")); + assertEquals("impedans", stem("impedans")); + assertEquals("inbjud", stem("inbjudan")); + assertEquals("indi", stem("indian")); + assertEquals("indiandans", stem("indiandans")); + assertEquals("indogerm", stem("indogerman")); + assertEquals("indrivningsm", stem("indrivningsman")); + assertEquals("induk", stem("induktans")); + assertEquals("industrim", stem("industriman")); + assertEquals("industritjänstem", stem("industritjänsteman")); + assertEquals("infallspl", stem("infallsplan")); + assertEquals("ingenst", stem("ingenstans")); + assertEquals("inhum", stem("inhuman")); + assertEquals("inkaindi", stem("inkaindian")); + assertEquals("inkur", stem("inkurans")); + assertEquals("inn", stem("innan")); + assertEquals("innem", stem("inneman")); + assertEquals("innerpl", stem("innerplan")); + assertEquals("inråd", stem("inrådan")); + assertEquals("inst", stem("instans")); + assertEquals("insöndringsorg", stem("insöndringsorgan")); + assertEquals("intal", stem("intalan")); + assertEquals("interurb", stem("interurban")); + assertEquals("intoler", stem("intolerans")); + assertEquals("intresseanmäl", stem("intresseanmälan")); + assertEquals("inventeringsm", stem("inventeringsman")); + assertEquals("inverk", stem("inverkan")); + assertEquals("investeringspl", stem("investeringsplan")); + assertEquals("irrelev", stem("irrelevans")); + assertEquals("isbrytarassist", stem("isbrytarassistans")); + assertEquals("isdans", stem("isdans")); + assertEquals("ivori", stem("ivorian")); + assertEquals("ivr", stem("ivran")); + assertEquals("jagroman", stem("jagroman")); + assertEquals("jajamäns", stem("jajamänsan")); + assertEquals("jaktflygpl", stem("jaktflygplan")); + assertEquals("jaktpl", stem("jaktplan")); + assertEquals("jamaic", stem("jamaican")); + assertEquals("jan", stem("jan")); + assertEquals("jap", stem("japan")); + assertEquals("jazzdans", stem("jazzdans")); + assertEquals("jean", stem("jeans")); + assertEquals("jetbombpl", stem("jetbombplan")); + assertEquals("jetflygpl", stem("jetflygplan")); + assertEquals("jetpl", stem("jetplan")); + assertEquals("jojomäns", stem("jojomänsan")); + assertEquals("judefråg", stem("judefrågan")); + assertEquals("julgr", stem("julgran")); + assertEquals("julpredik", stem("julpredikan")); + assertEquals("jumbopl", stem("jumboplan")); + assertEquals("jungfrudans", stem("jungfrudans")); + assertEquals("jungm", stem("jungman")); + assertEquals("justeringsm", stem("justeringsman")); + assertEquals("justitieombudsm", stem("justitieombudsman")); + assertEquals("jädr", stem("jädrans")); + assertEquals("jämn", stem("jämnan")); + assertEquals("jämställdhetsombudsm", stem("jämställdhetsombudsman")); + assertEquals("jämställdhetspl", stem("jämställdhetsplan")); + assertEquals("jämviktsorg", stem("jämviktsorgan")); + assertEquals("järngl", stem("järnglans")); + assertEquals("järnvägsm", stem("järnvägsman")); + assertEquals("järnvägstjänstem", stem("järnvägstjänsteman")); + assertEquals("jättech", stem("jättechans")); + assertEquals("jättekatamar", stem("jättekatamaran")); + assertEquals("kaft", stem("kaftan")); + assertEquals("kajm", stem("kajman")); + assertEquals("kallvattenkran", stem("kallvattenkran")); + assertEquals("kallvattenskran", stem("kallvattenskran")); + assertEquals("kalvdans", stem("kalvdans")); + assertEquals("kambodj", stem("kambodjan")); + assertEquals("kamelkarav", stem("kamelkaravan")); + assertEquals("kameram", stem("kameraman")); + assertEquals("kammarrättslagm", stem("kammarrättslagman")); + assertEquals("kampuche", stem("kampuchean")); + assertEquals("kan", stem("kan")); + assertEquals("kapacit", stem("kapacitans")); + assertEquals("kapellkrans", stem("kapellkrans")); + assertEquals("kapl", stem("kaplan")); + assertEquals("karav", stem("karavan")); + assertEquals("kard", stem("kardan")); + assertEquals("kardu", stem("karduan")); + assertEquals("kartusi", stem("kartusian")); + assertEquals("kastell", stem("kastellan")); + assertEquals("kastili", stem("kastilian")); + assertEquals("katal", stem("katalan")); + assertEquals("katamar", stem("katamaran")); + assertEquals("katastrofpl", stem("katastrofplan")); + assertEquals("kattsvans", stem("kattsvans")); + assertEquals("kedjekrans", stem("kedjekrans")); + assertEquals("keny", stem("kenyan")); + assertEquals("kikkran", stem("kikkran")); + assertEquals("klag", stem("klagan")); + assertEquals("klagoinst", stem("klagoinstans")); + assertEquals("klan", stem("klan")); + assertEquals("klangverk", stem("klangverkan")); + assertEquals("kleptom", stem("kleptoman")); + assertEquals("klädeleg", stem("klädelegans")); + assertEquals("klärvoaj", stem("klärvoajans")); + assertEquals("knölsv", stem("knölsvan")); + assertEquals("koboltgl", stem("koboltglans")); + assertEquals("kollektivroman", stem("kollektivroman")); + assertEquals("koloratursopr", stem("koloratursopran")); + assertEquals("kolportageroman", stem("kolportageroman")); + assertEquals("kometsvans", stem("kometsvans")); + assertEquals("kommunalm", stem("kommunalman")); + assertEquals("kommunaltjänstem", stem("kommunaltjänsteman")); + assertEquals("kommunistorg", stem("kommunistorgan")); + assertEquals("koncessionsansök", stem("koncessionsansökan")); + assertEquals("koncili", stem("koncilians")); + assertEquals("kondole", stem("kondoleans")); + assertEquals("kongressm", stem("kongressman")); + assertEquals("konjakskrans", stem("konjakskrans")); + assertEquals("konkordans", stem("konkordans")); + assertEquals("konkurrensombudsm", stem("konkurrensombudsman")); + assertEquals("konkursansök", stem("konkursansökan")); + assertEquals("konnäss", stem("konnässans")); + assertEquals("konsili", stem("konsilians")); + assertEquals("konsolideringspl", stem("konsolideringsplan")); + assertEquals("konson", stem("konsonans")); + assertEquals("konspirationspl", stem("konspirationsplan")); + assertEquals("konst", stem("konstans")); + assertEquals("konsulatstjänstem", stem("konsulatstjänsteman")); + assertEquals("konsulattjänstem", stem("konsulattjänsteman")); + assertEquals("konsumentombudsm", stem("konsumentombudsman")); + assertEquals("kontaktm", stem("kontaktman")); + assertEquals("kontaktorg", stem("kontaktorgan")); + assertEquals("konten", stem("kontenans")); + assertEquals("kontorsm", stem("kontorsman")); + assertEquals("kontradans", stem("kontradans")); + assertEquals("kontrastverk", stem("kontrastverkan")); + assertEquals("kontringsch", stem("kontringschans")); + assertEquals("kontrollorg", stem("kontrollorgan")); + assertEquals("konungaförsäkran", stem("konungaförsäkran")); + assertEquals("konven", stem("konvenans")); + assertEquals("koordinatpl", stem("koordinatplan")); + assertEquals("koppargl", stem("kopparglans")); + assertEquals("koppelv", stem("koppelvan")); + assertEquals("koran", stem("koran")); + assertEquals("kore", stem("korean")); + assertEquals("kormor", stem("kormoran")); + assertEquals("korsik", stem("korsikan")); + assertEquals("kortdist", stem("kortdistans")); + assertEquals("kosackdans", stem("kosackdans")); + assertEquals("kosvans", stem("kosvans")); + assertEquals("kraftlever", stem("kraftleverans")); + assertEquals("kran", stem("kran")); + assertEquals("krans", stem("krans")); + assertEquals("krasch", stem("kraschan")); + assertEquals("krigsdans", stem("krigsdans")); + assertEquals("krigsm", stem("krigsman")); + assertEquals("krigspl", stem("krigsplan")); + assertEquals("krigsv", stem("krigsvan")); + assertEquals("krigsveter", stem("krigsveteran")); + assertEquals("kriminalroman", stem("kriminalroman")); + assertEquals("krispl", stem("krisplan")); + assertEquals("krocketpl", stem("krocketplan")); + assertEquals("krogdans", stem("krogdans")); + assertEquals("krogv", stem("krogvan")); + assertEquals("krok", stem("krokan")); + assertEquals("kronohemm", stem("kronohemman")); + assertEquals("kronolänsm", stem("kronolänsman")); + assertEquals("kuba", stem("kuban")); + assertEquals("kulturorg", stem("kulturorgan")); + assertEquals("kump", stem("kumpan")); + assertEquals("kungaförsäkran", stem("kungaförsäkran")); + assertEquals("kuppl", stem("kupplan")); + assertEquals("kurspl", stem("kursplan")); + assertEquals("kurtis", stem("kurtisan")); + assertEquals("kvadrupelalli", stem("kvadrupelallians")); + assertEquals("kverul", stem("kverulans")); + assertEquals("kvid", stem("kvidan")); + assertEquals("kvinnosid", stem("kvinnosidan")); + assertEquals("kvittningsm", stem("kvittningsman")); + assertEquals("källarpl", stem("källarplan")); + assertEquals("känselorg", stem("känselorgan")); + assertEquals("kärandesid", stem("kärandesidan")); + assertEquals("kärleksroman", stem("kärleksroman")); + assertEquals("könsorg", stem("könsorgan")); + assertEquals("köpm", stem("köpman")); + assertEquals("köpslag", stem("köpslagan")); + assertEquals("ladugårdsförm", stem("ladugårdsförman")); + assertEquals("ladugårdspl", stem("ladugårdsplan")); + assertEquals("lagerförm", stem("lagerförman")); + assertEquals("lagerkrans", stem("lagerkrans")); + assertEquals("lagm", stem("lagman")); + assertEquals("lajb", stem("lajban")); + assertEquals("lajb", stem("lajbans")); + assertEquals("lak", stem("lakan")); + assertEquals("laktovegetari", stem("laktovegetarian")); + assertEquals("lan", stem("lan")); + assertEquals("landsm", stem("landsman")); + assertEquals("landstingsm", stem("landstingsman")); + assertEquals("lans", stem("lans")); + assertEquals("lant", stem("lantan")); + assertEquals("lantm", stem("lantman")); + assertEquals("lastkran", stem("lastkran")); + assertEquals("latsid", stem("latsidan")); + assertEquals("lebem", stem("lebeman")); + assertEquals("legu", stem("leguan")); + assertEquals("lejonm", stem("lejonman")); + assertEquals("lekm", stem("lekman")); + assertEquals("lekmannapredik", stem("lekmannapredikan")); + assertEquals("lever", stem("leverans")); + assertEquals("leveransvägr", stem("leveransvägran")); + assertEquals("levertr", stem("levertran")); + assertEquals("lian", stem("lian")); + assertEquals("liberi", stem("liberian")); + assertEquals("likad", stem("likadan")); + assertEquals("likpredik", stem("likpredikan")); + assertEquals("lill", stem("lillan")); + assertEquals("lillhjärn", stem("lillhjärnan")); + assertEquals("lindans", stem("lindans")); + assertEquals("linjem", stem("linjeman")); + assertEquals("linnelak", stem("linnelakan")); + assertEquals("litteraturanmäl", stem("litteraturanmälan")); + assertEquals("livsdyrk", stem("livsdyrkan")); + assertEquals("lodpl", stem("lodplan")); + assertEquals("logdans", stem("logdans")); + assertEquals("lokalpl", stem("lokalplan")); + assertEquals("lor", stem("loran")); + assertEquals("luktorg", stem("luktorgan")); + assertEquals("lumin", stem("luminans")); + assertEquals("luther", stem("lutheran")); + assertEquals("lyckönsk", stem("lyckönskan")); + assertEquals("lyftkran", stem("lyftkran")); + assertEquals("längesed", stem("längesedan")); + assertEquals("läng", stem("längtan")); + assertEquals("länsm", stem("länsman")); + assertEquals("läppgl", stem("läppglans")); + assertEquals("läropl", stem("läroplan")); + assertEquals("låneansök", stem("låneansökan")); + assertEquals("långdans", stem("långdans")); + assertEquals("långdist", stem("långdistans")); + assertEquals("læstadi", stem("læstadian")); + assertEquals("löjtnantshjärt", stem("löjtnantshjärtan")); + assertEquals("lönepl", stem("löneplan")); + assertEquals("lötkrans", stem("lötkrans")); + assertEquals("magdans", stem("magdans")); + assertEquals("majstångskrans", stem("majstångskrans")); + assertEquals("makraméfrans", stem("makraméfrans")); + assertEquals("maktbalans", stem("maktbalans")); + assertEquals("maktsträv", stem("maktsträvan")); + assertEquals("mammonsdyrk", stem("mammonsdyrkan")); + assertEquals("man", stem("man")); + assertEquals("manchesterje", stem("manchesterjeans")); + assertEquals("mang", stem("mangan")); + assertEquals("manspill", stem("manspillan")); + assertEquals("manssid", stem("manssidan")); + assertEquals("manöverorg", stem("manöverorgan")); + assertEquals("margr", stem("margran")); + assertEquals("marock", stem("marockan")); + assertEquals("marsi", stem("marsian")); + assertEquals("marsip", stem("marsipan")); + assertEquals("maserverk", stem("maserverkan")); + assertEquals("massverk", stem("massverkan")); + assertEquals("matvägr", stem("matvägran")); + assertEquals("medan", stem("medan")); + assertEquals("medeldist", stem("medeldistans")); + assertEquals("medi", stem("median")); + assertEquals("medicinm", stem("medicinman")); + assertEquals("mediterr", stem("mediterran")); + assertEquals("medverk", stem("medverkan")); + assertEquals("medömk", stem("medömkan")); + assertEquals("mell", stem("mellan")); + assertEquals("membr", stem("membran")); + assertEquals("meridi", stem("meridian")); + assertEquals("mesalli", stem("mesallians")); + assertEquals("mesan", stem("mesan")); + assertEquals("metallgl", stem("metallglans")); + assertEquals("metan", stem("metan")); + assertEquals("meteorsvans", stem("meteorsvans")); + assertEquals("mexik", stem("mexikan")); + assertEquals("mezzosopr", stem("mezzosopran")); + assertEquals("midsommardans", stem("midsommardans")); + assertEquals("militärflygpl", stem("militärflygplan")); + assertEquals("militärpl", stem("militärplan")); + assertEquals("miljöpåverk", stem("miljöpåverkan")); + assertEquals("missgärningsm", stem("missgärningsman")); + assertEquals("missroman", stem("missroman")); + assertEquals("misströst", stem("misströstan")); + assertEquals("mittemell", stem("mittemellan")); + assertEquals("mittensamverk", stem("mittensamverkan")); + assertEquals("mittsamverk", stem("mittsamverkan")); + assertEquals("mobilkran", stem("mobilkran")); + assertEquals("modedans", stem("modedans")); + assertEquals("modellflygpl", stem("modellflygplan")); + assertEquals("modellpl", stem("modellplan")); + assertEquals("mogendans", stem("mogendans")); + assertEquals("mohik", stem("mohikan")); + assertEquals("molybdengl", stem("molybdenglans")); + assertEquals("moment", stem("momentan")); + assertEquals("monom", stem("monoman")); + assertEquals("monstrans", stem("monstrans")); + assertEquals("moralpredik", stem("moralpredikan")); + assertEquals("morgonkul", stem("morgonkulan")); + assertEquals("morgonsid", stem("morgonsidan")); + assertEquals("mori", stem("morian")); + assertEquals("morsgumm", stem("morsgumman")); + assertEquals("morssid", stem("morssidan")); + assertEquals("motinst", stem("motinstans")); + assertEquals("motorm", stem("motorman")); + assertEquals("motståndsm", stem("motståndsman")); + assertEquals("motverk", stem("motverkan")); + assertEquals("muhammed", stem("muhammedan")); + assertEquals("museim", stem("museiman")); + assertEquals("muselm", stem("muselman")); + assertEquals("myggdans", stem("myggdans")); + assertEquals("myrtenkrans", stem("myrtenkrans")); + assertEquals("mytom", stem("mytoman")); + assertEquals("märkesje", stem("märkesjeans")); + assertEquals("märkesm", stem("märkesman")); + assertEquals("mässingskran", stem("mässingskran")); + assertEquals("mästerm", stem("mästerman")); + assertEquals("målch", stem("målchans")); + assertEquals("målm", stem("målman")); + assertEquals("målsm", stem("målsman")); + assertEquals("månggudadyrk", stem("månggudadyrkan")); + assertEquals("mörkm", stem("mörkman")); + assertEquals("nadirdist", stem("nadirdistans")); + assertEquals("narkom", stem("narkoman")); + assertEquals("nattkul", stem("nattkulan")); + assertEquals("naturvetenskapsm", stem("naturvetenskapsman")); + assertEquals("ned", stem("nedan")); + assertEquals("nestori", stem("nestorian")); + assertEquals("nettofordr", stem("nettofordran")); + assertEquals("nicaragu", stem("nicaraguan")); + assertEquals("nietzsche", stem("nietzschean")); + assertEquals("nigardans", stem("nigardans")); + assertEquals("nigdans", stem("nigdans")); + assertEquals("nigeri", stem("nigerian")); + assertEquals("nippr", stem("nippran")); + assertEquals("nitälsk", stem("nitälskan")); + assertEquals("nivelleringssträv", stem("nivelleringssträvan")); + assertEquals("nollmeridi", stem("nollmeridian")); + assertEquals("nonchal", stem("nonchalans")); + assertEquals("nordafrik", stem("nordafrikan")); + assertEquals("nordamerik", stem("nordamerikan")); + assertEquals("nord", stem("nordan")); + assertEquals("nordkore", stem("nordkorean")); + assertEquals("nordm", stem("nordman")); + assertEquals("norrm", stem("norrman")); + assertEquals("nyans", stem("nyans")); + assertEquals("nybyggnadspl", stem("nybyggnadsplan")); + assertEquals("nyckelm", stem("nyckelman")); + assertEquals("nyckelroman", stem("nyckelroman")); + assertEquals("nymfom", stem("nymfoman")); + assertEquals("nyst", stem("nystan")); + assertEquals("nämndem", stem("nämndeman")); + assertEquals("näringsanmäl", stem("näringsanmälan")); + assertEquals("näringsombudsm", stem("näringsombudsman")); + assertEquals("nästan", stem("nästan")); + assertEquals("nådeansök", stem("nådeansökan")); + assertEquals("någonst", stem("någonstans")); + assertEquals("nånst", stem("nånstans")); + assertEquals("obalans", stem("obalans")); + assertEquals("observ", stem("observans")); + assertEquals("obsidi", stem("obsidian")); + assertEquals("oce", stem("ocean")); + assertEquals("odaliskdans", stem("odaliskdans")); + assertEquals("odalm", stem("odalman")); + assertEquals("ogärningsm", stem("ogärningsman")); + assertEquals("oherr", stem("oherrans")); + assertEquals("okt", stem("oktan")); + assertEquals("oljelever", stem("oljeleverans")); + assertEquals("ombudsm", stem("ombudsman")); + assertEquals("ombyggnadspl", stem("ombyggnadsplan")); + assertEquals("omhuld", stem("omhuldan")); + assertEquals("områdespl", stem("områdesplan")); + assertEquals("omstörtningspl", stem("omstörtningsplan")); + assertEquals("onöd", stem("onödan")); + assertEquals("ordningsm", stem("ordningsman")); + assertEquals("ordon", stem("ordonnans")); + assertEquals("org", stem("organ")); + assertEquals("organisationspl", stem("organisationsplan")); + assertEquals("ork", stem("orkan")); + assertEquals("ormgr", stem("ormgran")); + assertEquals("ortspl", stem("ortsplan")); + assertEquals("oskari", stem("oskarian")); + assertEquals("osm", stem("osman")); + assertEquals("ost", stem("ostan")); + assertEquals("ottom", stem("ottoman")); + assertEquals("ovan", stem("ovan")); + assertEquals("oxdans", stem("oxdans")); + assertEquals("oxsvans", stem("oxsvans")); + assertEquals("pallkrans", stem("pallkrans")); + assertEquals("pampasindi", stem("pampasindian")); + assertEquals("panam", stem("panaman")); + assertEquals("pantomimdans", stem("pantomimdans")); + assertEquals("papegojtulp", stem("papegojtulpan")); + assertEquals("papperslak", stem("papperslakan")); + assertEquals("papu", stem("papuan")); + assertEquals("paraguay", stem("paraguayan")); + assertEquals("parav", stem("paravan")); + assertEquals("pardans", stem("pardans")); + assertEquals("pari", stem("parian")); + assertEquals("parmes", stem("parmesan")); + assertEquals("partim", stem("partiman")); + assertEquals("partiorg", stem("partiorgan")); + assertEquals("partis", stem("partisan")); + assertEquals("passagerarpl", stem("passagerarplan")); + assertEquals("patentansök", stem("patentansökan")); + assertEquals("patientombudsm", stem("patientombudsman")); + assertEquals("pelik", stem("pelikan")); + assertEquals("pemmik", stem("pemmikan")); + assertEquals("penningdyrk", stem("penningdyrkan")); + assertEquals("pensionsansök", stem("pensionsansökan")); + assertEquals("perform", stem("performans")); + assertEquals("perkut", stem("perkutan")); + assertEquals("permissionsansök", stem("permissionsansökan")); + assertEquals("persi", stem("persian")); + assertEquals("personalsid", stem("personalsidan")); + assertEquals("personbefordr", stem("personbefordran")); + assertEquals("personpl", stem("personplan")); + assertEquals("perspektivpl", stem("perspektivplan")); + assertEquals("peru", stem("peruan")); + assertEquals("pigroman", stem("pigroman")); + assertEquals("pikareskroman", stem("pikareskroman")); + assertEquals("pilotpl", stem("pilotplan")); + assertEquals("pjäxdans", stem("pjäxdans")); + assertEquals("plan", stem("plan")); + assertEquals("plat", stem("platan")); + assertEquals("platsanmäl", stem("platsanmälan")); + assertEquals("polisanmäl", stem("polisanmälan")); + assertEquals("polism", stem("polisman")); + assertEquals("polistjänstem", stem("polistjänsteman")); + assertEquals("polstjärn", stem("polstjärnan")); + assertEquals("polyuret", stem("polyuretan")); + assertEquals("pomer", stem("pomerans")); + assertEquals("pontonkran", stem("pontonkran")); + assertEquals("populärroman", stem("populärroman")); + assertEquals("portalkran", stem("portalkran")); + assertEquals("postbefordr", stem("postbefordran")); + assertEquals("postm", stem("postman")); + assertEquals("posttjänstem", stem("posttjänsteman")); + assertEquals("predik", stem("predikan")); + assertEquals("pregn", stem("pregnans")); + assertEquals("presbyteri", stem("presbyterian")); + assertEquals("pressm", stem("pressman")); + assertEquals("pressombudsm", stem("pressombudsman")); + assertEquals("pressorg", stem("pressorgan")); + assertEquals("presstalesm", stem("presstalesman")); + assertEquals("pretori", stem("pretorian")); + assertEquals("princippl", stem("principplan")); + assertEquals("pristävl", stem("pristävlan")); + assertEquals("privatflygpl", stem("privatflygplan")); + assertEquals("privatm", stem("privatman")); + assertEquals("prodek", stem("prodekan")); + assertEquals("produktionspl", stem("produktionsplan")); + assertEquals("profan", stem("profan")); + assertEquals("programpl", stem("programplan")); + assertEquals("projektansök", stem("projektansökan")); + assertEquals("projektpl", stem("projektplan")); + assertEquals("proletärroman", stem("proletärroman")); + assertEquals("prop", stem("propan")); + assertEquals("propellerpl", stem("propellerplan")); + assertEquals("protuber", stem("protuberans")); + assertEquals("provlever", stem("provleverans")); + assertEquals("provpredik", stem("provpredikan")); + assertEquals("prästm", stem("prästman")); + assertEquals("publik", stem("publikan")); + assertEquals("puertoric", stem("puertorican")); + assertEquals("purit", stem("puritan")); + assertEquals("pyroman", stem("pyroman")); + assertEquals("pyskran", stem("pyskran")); + assertEquals("pytts", stem("pyttsan")); + assertEquals("pärlemorgl", stem("pärlemorglans")); + assertEquals("påfordr", stem("påfordran")); + assertEquals("pålkran", stem("pålkran")); + assertEquals("påpek", stem("påpekan")); + assertEquals("påslak", stem("påslakan")); + assertEquals("påtal", stem("påtalan")); + assertEquals("påverk", stem("påverkan")); + assertEquals("påyrk", stem("påyrkan")); + assertEquals("radi", stem("radian")); + assertEquals("radiom", stem("radioman")); + assertEquals("ragl", stem("raglan")); + assertEquals("raketflygpl", stem("raketflygplan")); + assertEquals("ralj", stem("raljans")); + assertEquals("ramad", stem("ramadan")); + assertEquals("rannsak", stem("rannsakan")); + assertEquals("rationaliseringspl", stem("rationaliseringsplan")); + assertEquals("reaktorprop", stem("reaktorpropan")); + assertEquals("reapl", stem("reaplan")); + assertEquals("reassur", stem("reassurans")); + assertEquals("redan", stem("redan")); + assertEquals("redundans", stem("redundans")); + assertEquals("reformsträv", stem("reformsträvan")); + assertEquals("regeringsorg", stem("regeringsorgan")); + assertEquals("regeringstalesm", stem("regeringstalesman")); + assertEquals("regeringstjänstem", stem("regeringstjänsteman")); + assertEquals("regionpl", stem("regionplan")); + assertEquals("regleringspl", stem("regleringsplan")); + assertEquals("reklamm", stem("reklamman")); + assertEquals("rekonstruktionspl", stem("rekonstruktionsplan")); + assertEquals("rekonventionstal", stem("rekonventionstalan")); + assertEquals("relev", stem("relevans")); + assertEquals("reliefverk", stem("reliefverkan")); + assertEquals("remissinst", stem("remissinstans")); + assertEquals("remissorg", stem("remissorgan")); + assertEquals("renlevnadsm", stem("renlevnadsman")); + assertEquals("renäss", stem("renässans")); + assertEquals("reptilhjärn", stem("reptilhjärnan")); + assertEquals("republik", stem("republikan")); + assertEquals("resebyråm", stem("resebyråman")); + assertEquals("resist", stem("resistans")); + assertEquals("resningsansök", stem("resningsansökan")); + assertEquals("reson", stem("resonans")); + assertEquals("respl", stem("resplan")); + assertEquals("resv", stem("resvan")); + assertEquals("revisionsorg", stem("revisionsorgan")); + assertEquals("revolutionspl", stem("revolutionsplan")); + assertEquals("revolverm", stem("revolverman")); + assertEquals("riddarroman", stem("riddarroman")); + assertEquals("riddersm", stem("riddersman")); + assertEquals("rikem", stem("rikeman")); + assertEquals("riksdagsm", stem("riksdagsman")); + assertEquals("rikspl", stem("riksplan")); + assertEquals("riksspelm", stem("riksspelman")); + assertEquals("ringdans", stem("ringdans")); + assertEquals("roman", stem("roman")); + assertEquals("romans", stem("romans")); + assertEquals("rorsm", stem("rorsman")); + assertEquals("rosenkrans", stem("rosenkrans")); + assertEquals("rotari", stem("rotarian")); + assertEquals("rymdorg", stem("rymdorgan")); + assertEquals("rymdverk", stem("rymdverkan")); + assertEquals("rymningspl", stem("rymningsplan")); + assertEquals("rätoroman", stem("rätoroman")); + assertEquals("rättarkrans", stem("rättarkrans")); + assertEquals("rättfärdighetsläng", stem("rättfärdighetslängtan")); + assertEquals("rättsinst", stem("rättsinstans")); + assertEquals("rättsverk", stem("rättsverkan")); + assertEquals("rävsvans", stem("rävsvans")); + assertEquals("rådm", stem("rådman")); + assertEquals("råttsvans", stem("råttsvans")); + assertEquals("rölak", stem("rölakan")); + assertEquals("röllak", stem("röllakan")); + assertEquals("rövarch", stem("rövarchans")); + assertEquals("rövarroman", stem("rövarroman")); + assertEquals("saffi", stem("saffian")); + assertEquals("saffr", stem("saffran")); + assertEquals("sagesm", stem("sagesman")); + assertEquals("salvador", stem("salvadoran")); + assertEquals("samarbetsm", stem("samarbetsman")); + assertEquals("samarbetsorg", stem("samarbetsorgan")); + assertEquals("samhällsorg", stem("samhällsorgan")); + assertEquals("samman", stem("samman")); + assertEquals("samo", stem("samoan")); + assertEquals("samordningsorg", stem("samordningsorgan")); + assertEquals("samp", stem("sampan")); + assertEquals("samrådsorg", stem("samrådsorgan")); + assertEquals("samtidsroman", stem("samtidsroman")); + assertEquals("samverk", stem("samverkan")); + assertEquals("samverkansorg", stem("samverkansorgan")); + assertEquals("sandpl", stem("sandplan")); + assertEquals("sandwichm", stem("sandwichman")); + assertEquals("saneringspl", stem("saneringsplan")); + assertEquals("sanningsförsäkran", stem("sanningsförsäkran")); + assertEquals("sans", stem("sans")); + assertEquals("sarafan", stem("sarafan")); + assertEquals("satan", stem("satan")); + assertEquals("scham", stem("schaman")); + assertEquals("scharlak", stem("scharlakan")); + assertEquals("schartau", stem("schartauan")); + assertEquals("schimp", stem("schimpans")); + assertEquals("seans", stem("seans")); + assertEquals("sedan", stem("sedan")); + assertEquals("segelflygpl", stem("segelflygplan")); + assertEquals("segelpl", stem("segelplan")); + assertEquals("segerch", stem("segerchans")); + assertEquals("segerdans", stem("segerdans")); + assertEquals("segerkrans", stem("segerkrans")); + assertEquals("segerv", stem("segervan")); + assertEquals("sejdm", stem("sejdman")); + assertEquals("sekretionsorg", stem("sekretionsorgan")); + assertEquals("sektorsorg", stem("sektorsorgan")); + assertEquals("sekundärverk", stem("sekundärverkan")); + assertEquals("senrenäss", stem("senrenässans")); + assertEquals("servicem", stem("serviceman")); + assertEquals("serviceorg", stem("serviceorgan")); + assertEquals("sham", stem("shaman")); + assertEquals("sidengl", stem("sidenglans")); + assertEquals("sidensvans", stem("sidensvans")); + assertEquals("signalsubst", stem("signalsubstans")); + assertEquals("signifik", stem("signifikans")); + assertEquals("silkesgl", stem("silkesglans")); + assertEquals("silverfas", stem("silverfasan")); + assertEquals("silvergl", stem("silverglans")); + assertEquals("silvergr", stem("silvergran")); + assertEquals("simult", stem("simultan")); + assertEquals("singapori", stem("singaporian")); + assertEquals("sinnesorg", stem("sinnesorgan")); + assertEquals("sinsemell", stem("sinsemellan")); + assertEquals("siouxindi", stem("siouxindian")); + assertEquals("situationspl", stem("situationsplan")); + assertEquals("sjukanmäl", stem("sjukanmälan")); + assertEquals("sjukvårdshuvudm", stem("sjukvårdshuvudman")); + assertEquals("sjutus", stem("sjutusan")); + assertEquals("självförtröst", stem("självförtröstan")); + assertEquals("självmordspl", stem("självmordsplan")); + assertEquals("självrannsak", stem("självrannsakan")); + assertEquals("självständighetssträv", stem("självständighetssträvan")); + assertEquals("självuppfostr", stem("självuppfostran")); + assertEquals("självömk", stem("självömkan")); + assertEquals("sjöflygpl", stem("sjöflygplan")); + assertEquals("sjöm", stem("sjöman")); + assertEquals("sjöv", stem("sjövan")); + assertEquals("skadeanmäl", stem("skadeanmälan")); + assertEquals("skadeverk", stem("skadeverkan")); + assertEquals("skan", stem("skans")); + assertEquals("skepparkrans", stem("skepparkrans")); + assertEquals("skiftesm", stem("skiftesman")); + assertEquals("skiljem", stem("skiljeman")); + assertEquals("skogsm", stem("skogsman")); + assertEquals("skoldans", stem("skoldans")); + assertEquals("skolflygpl", stem("skolflygplan")); + assertEquals("skolm", stem("skolman")); + assertEquals("skorstenskrans", stem("skorstenskrans")); + assertEquals("skrymt", stem("skrymtan")); + assertEquals("skräckroman", stem("skräckroman")); + assertEquals("skräproman", stem("skräproman")); + assertEquals("skyldighetsdans", stem("skyldighetsdans")); + assertEquals("skymund", stem("skymundan")); + assertEquals("skälmroman", stem("skälmroman")); + assertEquals("skälv", stem("skälvan")); + assertEquals("skämt", stem("skämtan")); + assertEquals("skärskåd", stem("skärskådan")); + assertEquals("skönhetsdyrk", stem("skönhetsdyrkan")); + assertEquals("skönhetsläng", stem("skönhetslängtan")); + assertEquals("skötselpl", stem("skötselplan")); + assertEquals("slagrutem", stem("slagruteman")); + assertEquals("slamvulk", stem("slamvulkan")); + assertEquals("slentri", stem("slentrian")); + assertEquals("slogan", stem("slogan")); + assertEquals("slokgr", stem("slokgran")); + assertEquals("slutänd", stem("slutändan")); + assertEquals("slöjdans", stem("slöjdans")); + assertEquals("smakorg", stem("smakorgan")); + assertEquals("smäkt", stem("smäktan")); + assertEquals("smörjkran", stem("smörjkran")); + assertEquals("snattr", stem("snattran")); + assertEquals("snisk", stem("sniskan")); + assertEquals("snyftkran", stem("snyftkran")); + assertEquals("snörnyst", stem("snörnystan")); + assertEquals("soldyrk", stem("soldyrkan")); + assertEquals("solochvårm", stem("solochvårman")); + assertEquals("solodans", stem("solodans")); + assertEquals("sopr", stem("sopran")); + assertEquals("spaningsflygpl", stem("spaningsflygplan")); + assertEquals("spaningspl", stem("spaningsplan")); + assertEquals("sparlak", stem("sparlakan")); + assertEquals("sparpl", stem("sparplan")); + assertEquals("spart", stem("spartan")); + assertEquals("specialdist", stem("specialdistans")); + assertEquals("spelem", stem("speleman")); + assertEquals("spelm", stem("spelman")); + assertEquals("spelpl", stem("spelplan")); + assertEquals("spetsgl", stem("spetsglans")); + assertEquals("spetslak", stem("spetslakan")); + assertEquals("spinnsid", stem("spinnsidan")); + assertEquals("spiselkrans", stem("spiselkrans")); + assertEquals("spont", stem("spontan")); + assertEquals("sportflygpl", stem("sportflygplan")); + assertEquals("sportpl", stem("sportplan")); + assertEquals("sportsm", stem("sportsman")); + assertEquals("sprill", stem("sprillans")); + assertEquals("sprinterdist", stem("sprinterdistans")); + assertEquals("spritskrans", stem("spritskrans")); + assertEquals("sprutnarkom", stem("sprutnarkoman")); + assertEquals("sprängj", stem("sprängjan")); + assertEquals("sprängverk", stem("sprängverkan")); + assertEquals("språkm", stem("språkman")); + assertEquals("språkvetenskapsm", stem("språkvetenskapsman")); + assertEquals("spåm", stem("spåman")); + assertEquals("squaredans", stem("squaredans")); + assertEquals("stadsombudsm", stem("stadsombudsman")); + assertEquals("stadspl", stem("stadsplan")); + assertEquals("stannpl", stem("stannplan")); + assertEquals("stans", stem("stans")); + assertEquals("startm", stem("startman")); + assertEquals("statsm", stem("statsman")); + assertEquals("statstjänstem", stem("statstjänsteman")); + assertEquals("statsvetenskapsm", stem("statsvetenskapsman")); + assertEquals("steppdans", stem("steppdans")); + assertEquals("stigm", stem("stigman")); + assertEquals("stimul", stem("stimulans")); + assertEquals("stipendieansök", stem("stipendieansökan")); + assertEquals("stjärngl", stem("stjärnglans")); + assertEquals("stoffverk", stem("stoffverkan")); + assertEquals("storhjärn", stem("storhjärnan")); + assertEquals("storm", stem("storman")); + assertEquals("straffpredik", stem("straffpredikan")); + assertEquals("stridsflygpl", stem("stridsflygplan")); + assertEquals("stridsm", stem("stridsman")); + assertEquals("stridspl", stem("stridsplan")); + assertEquals("strukturpl", stem("strukturplan")); + assertEquals("sträv", stem("strävan")); + assertEquals("strålgl", stem("strålglans")); + assertEquals("strålkrans", stem("strålkrans")); + assertEquals("strömlever", stem("strömleverans")); + assertEquals("stubbsvans", stem("stubbsvans")); + assertEquals("studiepl", stem("studieplan")); + assertEquals("studiom", stem("studioman")); + assertEquals("stuntm", stem("stuntman")); + assertEquals("styresm", stem("styresman")); + assertEquals("styrkebalans", stem("styrkebalans")); + assertEquals("styrm", stem("styrman")); + assertEquals("stämningsansök", stem("stämningsansökan")); + assertEquals("stämningsm", stem("stämningsman")); + assertEquals("stålm", stem("stålman")); + assertEquals("ståndm", stem("ståndman")); + assertEquals("stödorg", stem("stödorgan")); + assertEquals("stöldanmäl", stem("stöldanmälan")); + assertEquals("subkut", stem("subkutan")); + assertEquals("subskriptionsinbjud", stem("subskriptionsinbjudan")); + assertEquals("subst", stem("substans")); + assertEquals("succéroman", stem("succéroman")); + assertEquals("suck", stem("suckan")); + assertEquals("suffis", stem("suffisans")); + assertEquals("sultan", stem("sultan")); + assertEquals("sunn", stem("sunnan")); + assertEquals("sut", stem("sutan")); + assertEquals("svan", stem("svan")); + assertEquals("svans", stem("svans")); + assertEquals("svarandesid", stem("svarandesidan")); + assertEquals("svartfotsindi", stem("svartfotsindian")); + assertEquals("svekom", stem("svekoman")); + assertEquals("svenskamerik", stem("svenskamerikan")); + assertEquals("svärdsdans", stem("svärdsdans")); + assertEquals("svärdssid", stem("svärdssidan")); + assertEquals("swedenborgi", stem("swedenborgian")); + assertEquals("sydafrik", stem("sydafrikan")); + assertEquals("sydamerik", stem("sydamerikan")); + assertEquals("sydkore", stem("sydkorean")); + assertEquals("symmetripl", stem("symmetriplan")); + assertEquals("synem", stem("syneman")); + assertEquals("syri", stem("syrian")); + assertEquals("sysselsättningspl", stem("sysselsättningsplan")); + assertEquals("sysslom", stem("syssloman")); + assertEquals("systemm", stem("systemman")); + assertEquals("säkerhetsm", stem("säkerhetsman")); + assertEquals("säkerhetsorg", stem("säkerhetsorgan")); + assertEquals("säll", stem("sällan")); + assertEquals("sällskapsdans", stem("sällskapsdans")); + assertEquals("såd", stem("sådan")); + assertEquals("sångsv", stem("sångsvan")); + assertEquals("såningsm", stem("såningsman")); + assertEquals("takalt", stem("takaltan")); + assertEquals("tal", stem("talan")); + assertEquals("talesm", stem("talesman")); + assertEquals("talism", stem("talisman")); + assertEquals("talm", stem("talman")); + assertEquals("talorg", stem("talorgan")); + assertEquals("tandagnissl", stem("tandagnisslan")); + assertEquals("tangentpl", stem("tangentplan")); + assertEquals("tappkran", stem("tappkran")); + assertEquals("tappningskran", stem("tappningskran")); + assertEquals("tart", stem("tartan")); + assertEquals("teaterm", stem("teaterman")); + assertEquals("teb", stem("teban")); + assertEquals("tegelstensroman", stem("tegelstensroman")); + assertEquals("telefonförfråg", stem("telefonförfrågan")); + assertEquals("tempeldans", stem("tempeldans")); + assertEquals("tendensroman", stem("tendensroman")); + assertEquals("tennispl", stem("tennisplan")); + assertEquals("tentakelkrans", stem("tentakelkrans")); + assertEquals("terrorbalans", stem("terrorbalans")); + assertEquals("tibet", stem("tibetan")); + assertEquals("tidningsm", stem("tidningsman")); + assertEquals("tidpl", stem("tidplan")); + assertEquals("tidspill", stem("tidspillan")); + assertEquals("tidspl", stem("tidsplan")); + assertEquals("tidsspill", stem("tidsspillan")); + assertEquals("tidsstudiem", stem("tidsstudieman")); + assertEquals("tigre", stem("tigrean")); + assertEquals("tillbedj", stem("tillbedjan")); + assertEquals("tillfråg", stem("tillfrågan")); + assertEquals("tillförsäkran", stem("tillförsäkran")); + assertEquals("tillråd", stem("tillrådan")); + assertEquals("tillsamm", stem("tillsamman")); + assertEquals("tillsamm", stem("tillsammans")); + assertEquals("tillskynd", stem("tillskyndan")); + assertEquals("tillstyrk", stem("tillstyrkan")); + assertEquals("tillstädj", stem("tillstädjan")); + assertEquals("tillståndsansök", stem("tillståndsansökan")); + assertEquals("tillsyningsm", stem("tillsyningsman")); + assertEquals("tillsynsm", stem("tillsynsman")); + assertEquals("tillsynsorg", stem("tillsynsorgan")); + assertEquals("tillägn", stem("tillägnan")); + assertEquals("tillönsk", stem("tillönskan")); + assertEquals("timj", stem("timjan")); + assertEquals("timmergr", stem("timmergran")); + assertEquals("timmerm", stem("timmerman")); + assertEquals("timmersvans", stem("timmersvans")); + assertEquals("timpl", stem("timplan")); + assertEquals("tingspredik", stem("tingspredikan")); + assertEquals("tit", stem("titan")); + assertEquals("tjurgr", stem("tjurgran")); + assertEquals("tjuvdans", stem("tjuvdans")); + assertEquals("tjänstem", stem("tjänsteman")); + assertEquals("tjänstledighetsansök", stem("tjänstledighetsansökan")); + assertEquals("toler", stem("tolerans")); + assertEquals("tolvm", stem("tolvman")); + assertEquals("tong", stem("tongan")); + assertEquals("toppm", stem("toppman")); + assertEquals("torrsubst", stem("torrsubstans")); + assertEquals("totalverk", stem("totalverkan")); + assertEquals("trafikpl", stem("trafikplan")); + assertEquals("trakt", stem("traktan")); + assertEquals("tran", stem("tran")); + assertEquals("trandans", stem("trandans")); + assertEquals("tranedans", stem("tranedans")); + assertEquals("trans", stem("trans")); + assertEquals("transoce", stem("transocean")); + assertEquals("transpirationsorg", stem("transpirationsorgan")); + assertEquals("transportflygpl", stem("transportflygplan")); + assertEquals("transportpl", stem("transportplan")); + assertEquals("transur", stem("transuran")); + assertEquals("traseleg", stem("traselegans")); + assertEquals("traverskran", stem("traverskran")); + assertEquals("tredjem", stem("tredjeman")); + assertEquals("trevorg", stem("trevorgan")); + assertEquals("trevägskran", stem("trevägskran")); + assertEquals("trimar", stem("trimaran")); + assertEquals("trippelalli", stem("trippelallians")); + assertEquals("trivialroman", stem("trivialroman")); + assertEquals("troj", stem("trojan")); + assertEquals("trollgl", stem("trollglans")); + assertEquals("trygghetsnarkom", stem("trygghetsnarkoman")); + assertEquals("träffverk", stem("träffverkan")); + assertEquals("träng", stem("trängtan")); + assertEquals("träskodans", stem("träskodans")); + assertEquals("tuk", stem("tukan")); + assertEquals("tukt", stem("tuktan")); + assertEquals("tullm", stem("tullman")); + assertEquals("tulltjänstem", stem("tulltjänsteman")); + assertEquals("tulp", stem("tulpan")); + assertEquals("turb", stem("turban")); + assertEquals("turboproppl", stem("turbopropplan")); + assertEquals("tus", stem("tusan")); + assertEquals("tuvalu", stem("tuvaluan")); + assertEquals("tvek", stem("tvekan")); + assertEquals("tvetal", stem("tvetalan")); + assertEquals("tvivelsut", stem("tvivelsutan")); + assertEquals("tvåm", stem("tvåmans")); + assertEquals("tätm", stem("tätman")); + assertEquals("tävl", stem("tävlan")); + assertEquals("tävlingsv", stem("tävlingsvan")); + assertEquals("tömningskran", stem("tömningskran")); + assertEquals("törnekrans", stem("törnekrans")); + assertEquals("töv", stem("tövan")); + assertEquals("ulan", stem("ulan")); + assertEquals("und", stem("undan")); + assertEquals("underinst", stem("underinstans")); + assertEquals("underlak", stem("underlakan")); + assertEquals("underljudspl", stem("underljudsplan")); + assertEquals("underm", stem("underman")); + assertEquals("underrättelseorg", stem("underrättelseorgan")); + assertEquals("undervisningspl", stem("undervisningsplan")); + assertEquals("undr", stem("undran")); + assertEquals("undskyll", stem("undskyllan")); + assertEquals("ungdomsroman", stem("ungdomsroman")); + assertEquals("ungrenäss", stem("ungrenässans")); + assertEquals("uniformeringssträv", stem("uniformeringssträvan")); + assertEquals("uniformitetssträv", stem("uniformitetssträvan")); + assertEquals("uppbördsm", stem("uppbördsman")); + assertEquals("uppfordr", stem("uppfordran")); + assertEquals("uppfostr", stem("uppfostran")); + assertEquals("upphovsm", stem("upphovsman")); + assertEquals("uppmuntr", stem("uppmuntran")); + assertEquals("upprorsm", stem("upprorsman")); + assertEquals("upprustningspl", stem("upprustningsplan")); + assertEquals("uppskovsanhåll", stem("uppskovsanhållan")); + assertEquals("uppsyningsm", stem("uppsyningsman")); + assertEquals("uran", stem("uran")); + assertEquals("urb", stem("urban")); + assertEquals("uret", stem("uretan")); + assertEquals("urinorg", stem("urinorgan")); + assertEquals("urkyrk", stem("urkyrkan")); + assertEquals("urogenitalorg", stem("urogenitalorgan")); + assertEquals("urskuld", stem("urskuldan")); + assertEquals("uruguay", stem("uruguayan")); + assertEquals("usans", stem("usans")); + assertEquals("utan", stem("utan")); + assertEquals("utbildningsch", stem("utbildningschans")); + assertEquals("utbildningspl", stem("utbildningsplan")); + assertEquals("utbyggnadspl", stem("utbyggnadsplan")); + assertEquals("utem", stem("uteman")); + assertEquals("utmätningsm", stem("utmätningsman")); + assertEquals("utredningsm", stem("utredningsman")); + assertEquals("utrikesbalans", stem("utrikesbalans")); + assertEquals("utrymningspl", stem("utrymningsplan")); + assertEquals("utsöndringsorg", stem("utsöndringsorgan")); + assertEquals("utvecklingspl", stem("utvecklingsplan")); + assertEquals("utvidgningspl", stem("utvidgningsplan")); + assertEquals("vacklan", stem("vacklan")); + assertEquals("vad", stem("vadan")); + assertEquals("vadeanmäl", stem("vadeanmälan")); + assertEquals("vadetal", stem("vadetalan")); + assertEquals("vagabondroman", stem("vagabondroman")); + assertEquals("vakans", stem("vakans")); + assertEquals("vaktm", stem("vaktman")); + assertEquals("valalli", stem("valallians")); + assertEquals("van", stem("van")); + assertEquals("vandringsm", stem("vandringsman")); + assertEquals("vapenlever", stem("vapenleverans")); + assertEquals("vapenvägr", stem("vapenvägran")); + assertEquals("var", stem("varan")); + assertEquals("varan", stem("varannan")); + assertEquals("varemell", stem("varemellan")); + assertEquals("varförin", stem("varförinnan")); + assertEquals("varförut", stem("varförutan")); + assertEquals("vari", stem("varians")); + assertEquals("varmvattenkran", stem("varmvattenkran")); + assertEquals("varmvattenskran", stem("varmvattenskran")); + assertEquals("varst", stem("varstans")); + assertEquals("varutin", stem("varutinnan")); + assertEquals("vattenbalans", stem("vattenbalans")); + assertEquals("vattenkran", stem("vattenkran")); + assertEquals("vattum", stem("vattuman")); + assertEquals("vederdelom", stem("vederdeloman")); + assertEquals("vegetari", stem("vegetarian")); + assertEquals("veklag", stem("veklagan")); + assertEquals("veneti", stem("venetian")); + assertEquals("venezol", stem("venezolan")); + assertEquals("venezuel", stem("venezuelan")); + assertEquals("verk", stem("verkan")); + assertEquals("vertikalpl", stem("vertikalplan")); + assertEquals("vetebrödskrans", stem("vetebrödskrans")); + assertEquals("vetekrans", stem("vetekrans")); + assertEquals("vetenskapsm", stem("vetenskapsman")); + assertEquals("veter", stem("veteran")); + assertEquals("vidarebefordr", stem("vidarebefordran")); + assertEquals("vigil", stem("vigilans")); + assertEquals("vigselvägr", stem("vigselvägran")); + assertEquals("viktori", stem("viktorian")); + assertEquals("vildm", stem("vildman")); + assertEquals("vingåkersdans", stem("vingåkersdans")); + assertEquals("vinlövskrans", stem("vinlövskrans")); + assertEquals("vinstch", stem("vinstchans")); + assertEquals("vinstpl", stem("vinstplan")); + assertEquals("virveldans", stem("virveldans")); + assertEquals("visch", stem("vischan")); + assertEquals("vism", stem("visman")); + assertEquals("vismutgl", stem("vismutglans")); + assertEquals("visumansök", stem("visumansökan")); + assertEquals("vulk", stem("vulkan")); + assertEquals("väderspåm", stem("väderspåman")); + assertEquals("vädj", stem("vädjan")); + assertEquals("vägr", stem("vägran")); + assertEquals("välan", stem("välan")); + assertEquals("väldans", stem("väldans")); + assertEquals("välgångsönsk", stem("välgångsönskan")); + assertEquals("vällevnadsm", stem("vällevnadsman")); + assertEquals("välönsk", stem("välönskan")); + assertEquals("vändpl", stem("vändplan")); + assertEquals("vänsterm", stem("vänsterman")); + assertEquals("vänstr", stem("vänstran")); + assertEquals("vänt", stem("väntan")); + assertEquals("värderingsm", stem("värderingsman")); + assertEquals("världsm", stem("världsman")); + assertEquals("världsv", stem("världsvan")); + assertEquals("värnpliktsvägr", stem("värnpliktsvägran")); + assertEquals("västalli", stem("västallians")); + assertEquals("väst", stem("västan")); + assertEquals("vätskebalans", stem("vätskebalans")); + assertEquals("växelverk", stem("växelverkan")); + assertEquals("vågpl", stem("vågplan")); + assertEquals("våldsm", stem("våldsman")); + assertEquals("våldtäktsm", stem("våldtäktsman")); + assertEquals("våningspl", stem("våningsplan")); + assertEquals("vår", stem("våran")); + assertEquals("vårsid", stem("vårsidan")); + assertEquals("wienerkrans", stem("wienerkrans")); + assertEquals("ynk", stem("ynkan")); + assertEquals("yrk", stem("yrkan")); + assertEquals("yrkesm", stem("yrkesman")); + assertEquals("yrkesv", stem("yrkesvan")); + assertEquals("ytbefordr", stem("ytbefordran")); + assertEquals("ytverk", stem("ytverkan")); + assertEquals("zenitdist", stem("zenitdistans")); + assertEquals("ädelfas", stem("ädelfasan")); + assertEquals("ädelgr", stem("ädelgran")); + assertEquals("älvadans", stem("älvadans")); + assertEquals("älvdans", stem("älvdans")); + assertEquals("ämbetsm", stem("ämbetsman")); + assertEquals("ängsl", stem("ängslan")); + assertEquals("änkem", stem("änkeman")); + assertEquals("äventyrsroman", stem("äventyrsroman")); + assertEquals("ävl", stem("ävlan")); + assertEquals("åkall", stem("åkallan")); + assertEquals("åklagarsid", stem("åklagarsidan")); + assertEquals("ålderm", stem("ålderman")); + assertEquals("åskåd", stem("åskådan")); + assertEquals("åstund", stem("åstundan")); + assertEquals("återgl", stem("återglans")); + assertEquals("återverk", stem("återverkan")); + assertEquals("åverk", stem("åverkan")); + assertEquals("élan", stem("élan")); + assertEquals("ödehemm", stem("ödehemman")); + assertEquals("ögonfrans", stem("ögonfrans")); + assertEquals("ömk", stem("ömkan")); + assertEquals("önsk", stem("önskan")); + assertEquals("örlogsm", stem("örlogsman")); + assertEquals("öst", stem("östan")); + assertEquals("överbalans", stem("överbalans")); + assertEquals("överefterfråg", stem("överefterfrågan")); + assertEquals("överhöv", stem("överhövan")); + assertEquals("överinst", stem("överinstans")); + assertEquals("överlak", stem("överlakan")); + assertEquals("överljudspl", stem("överljudsplan")); + assertEquals("överm", stem("överman")); + assertEquals("övermåt", stem("övermåttan")); + assertEquals("översiktspl", stem("översiktsplan")); + assertEquals("överstyrm", stem("överstyrman")); + assertEquals("överuppsyningsm", stem("överuppsyningsman")); + assertEquals("övervakningsorg", stem("övervakningsorgan")); + + // non SAOL + + assertEquals("innerst", stem("innerstan")); + assertEquals("pappersst", stem("pappersstans")); + assertEquals("ingenst", stem("ingenstans")); + + + } + + private static Swedish2Stemmer stemmer = new Swedish2Stemmer(); + + private String stem(String in) { + stemmer.setCurrent(in); + stemmer.stem(); + return stemmer.getCurrent(); + } + +} Index: src/java/org/tartarus/snowball/ext/Swedish2_ISO_8859_1.sbl =================================================================== --- src/java/org/tartarus/snowball/ext/Swedish2_ISO_8859_1.sbl (revision 0) +++ src/java/org/tartarus/snowball/ext/Swedish2_ISO_8859_1.sbl (revision 0) @@ -0,0 +1,472 @@ +/* + + problematic stems: + + dans/dans (dan's/dance) + dyrk/dyrkan (lockpick/idolize) + eran/era/er (yours or historical age/your or historical age/your) + frukt/fruktan (fruit/fear) + gen/genans (gene/awkward) + jean/jeans + lake/lakan (burbot/sheet) + ost/ostan (cheese/eastern) + var/varan/varannan (was/"retail goods" or "komodo dragon"/"every other") + + short -an and -ans words as lian is not stemmed. thus not stemmed same as lianerna, et c. + why is that? + +*/ + +routines ( + mark_regions + main_suffix + consonant_pair + other_suffix + exception1 + exception2 +) + +externals ( stem ) + +integers ( p1 x ) + +groupings ( v s_ending ) + +stringescapes {} + +/* special characters (in ISO Latin I) */ + +stringdef a" hex 'E4' +stringdef ao hex 'E5' +stringdef o" hex 'F6' + +define v 'aeiouy{a"}{ao}{o"}' + +define s_ending 'bcdfghjklmnoprtvy' + +define mark_regions as ( + + $p1 = limit + test ( hop 3 setmark x ) + goto v gopast non-v setmark p1 + try ( $p1 < x $p1 = x ) +) + +backwardmode ( + + /* special -AN and -ANS cases for composite words, e.g. gammeldansen */ + define exception2 as ( + [substring] among ( + + 'balans' (<-'balans') + 'balansen' (<-'balans') + 'balansens' (<-'balans') + 'balanser' (<-'balans') + 'balanserna' (<-'balans') + 'balansernas' (<-'balans') + 'balansera' (<-'balans') + 'balanseras' (<-'balans') + 'balanserar' (<-'balans') + 'balanserara' (<-'balans') + + 'dansen' (<-'dans') + 'danserna' (<-'dans') + 'dans' (<-'dans') + + 'fan' (<-'fan') + 'fans' (<-'fan') + 'fansen' (<-'fan') + 'fansens' (<-'fan') + + 'finans' (<-'finans') + 'finansen' (<-'finans') + 'finansens' (<-'finans') + 'finanser' (<-'finans') + 'finanserna' (<-'finans') + 'finansernas' (<-'finans') + + 'frans' (<-'frans') + 'fransen' (<-'frans') + 'fransens' (<-'frans') + + 'krans' (<-'krans') + 'kransen' (<-'krans') + 'kransens' (<-'krans') + 'kransar' (<-'krans') + 'kransarna' (<-'krans') + 'kransarnas' (<-'krans') + + 'kran' (<-'kran') + 'kranar' (<-'kran') + 'kranarna' (<-'kran') + 'kranarnas' (<-'kran') + + 'roman' (<-'roman') + 'romanen' (<-'roman') + 'romanens' (<-'roman') + 'romaner' (<-'roman') + 'romanerna' (<-'roman') + 'romanernas' (<-'roman') + + 'romans' (<-'romans') + 'romansen' (<-'romans') + 'romansens' (<-'romans') + 'romanser' (<-'romans') + 'romanserna' (<-'romans') + 'romansernas' (<-'romans') + + 'slogan' (<-'slogan') + 'slogans' (<-'slogan') + +// 'svan' (<-'svan') + + 'svans' (<-'svans') + 'svansen' (<-'svans') + 'svansens' (<-'svans') + 'svansar' (<-'svans') + 'svansarna' (<-'svans') + 'svansarnas' (<-'svans') + +// 'stan' (<-'stan') +// 'stans' (<-'stans') + + 'sultan' (<-'sultan') + 'sultanen' (<-'sultan') + 'sultanens' (<-'sultan') + 'sultaner' (<-'sultan') + 'sultanerna' (<-'sultan') + 'sultanernas' (<-'sultan') + + 'trans' (<-'trans') + 'transen' (<-'trans') + 'transens' (<-'trans') + ) + ) + + define main_suffix as ( + setlimit tomark p1 for ([substring]) + among( + 'a' 'arna' 'erna' 'heterna' 'orna' 'ad' 'e' 'ade' 'ande' 'arne' + 'are' 'aste' 'en' 'anden' 'aren' 'heten' 'ern' 'ar' 'er' 'heter' + 'or' 'as' 'arnas' 'ernas' 'ornas' 'es' 'ades' 'andes' 'ens' 'arens' + 'hetens' 'erns' 'at' 'andet' 'het' 'ast' + 'era' 'erar' 'erarna' 'erarnas' + 'an' 'anen' 'anens' 'anare' 'aner' 'anerna' 'anernas' + 'ans' 'ansen' 'ansens' 'anser' 'ansera' 'anserar' 'anserna' 'ansernas' + 'iera' + (delete) + + 's' + (s_ending delete) + ) + ) + + define consonant_pair as setlimit tomark p1 for ( + among('dd' 'gd' 'nn' 'dt' 'gt' 'kt' 'tt') + and ([next] delete) + ) + + define other_suffix as setlimit tomark p1 for ( + [substring] among( + 'lig' 'ig' 'els' (delete) + 'l{o"}st' (<-'l{o"}s') + 'fullt' (<-'full') + ) + ) +) + +/* special -AN and -ANS cases */ +define exception1 as ( + +// todo ansigt + + [substring] atlimit among ( + + 'afrikaans' (<-'afrikaans') + + 'avans' (<-'avans') + 'avansen' (<-'avans') + 'avansens' (<-'avans') + 'avanser' (<-'avans') + 'avanserna' (<-'avans') + 'avansernas' (<-'avans') + + 'attan' (<-'attan') + 'attans' (<-'attan') + + 'balans' (<-'balans') + 'balansen' (<-'balans') + 'balansens' (<-'balans') + 'balanser' (<-'balans') + 'balanserna' (<-'balans') + 'balansernas' (<-'balans') + 'balansera' (<-'balans') + 'balanseras' (<-'balans') + 'balanserar' (<-'balans') + 'balanserara' (<-'balans') + + 'banan' (<-'banan') // | bana (trail/path) + 'bananen' (<-'banan') + 'bananens' (<-'banan') + 'bananer' (<-'banan') + 'bananerna' (<-'banan') + 'bananernas' (<-'banan') + + 'cardigan' (<-'cardigan') + 'cardigans' (<-'cardigan') + +// 'chans' (<-'chans') +// 'chansa' (<-'chans') +// 'chansar' (<-'chans') +// 'chansen' (<-'chans') +// 'chansens' (<-'chans') + + 'dans' (<-'dans') // | dan (the name) + 'dansen' (<-'dans') + 'dansens' (<-'dans') + 'danser' (<-'dans') + 'danserna' (<-'dans') + 'dansernas' (<-'dans') + + 'dan' (<-'dan') + 'danen' (<-'dan') + 'danens' (<-'dan') + 'daner' (<-'dan') + 'danerna' (<-'dan') + 'danernas' (<-'dan') + + 'duman' (<-'duman') + 'dumans' (<-'duman') + + 'fan' (<-'fan') + + 'fans' (<-'fans') + + 'fasan' (<-'fasan') + 'fasanen' (<-'fasan') + 'fasanens' (<-'fasan') + 'fasaner' (<-'fasan') + 'fasanerna' (<-'fasan') + 'fasanernas' (<-'fasan') + + + 'finans' (<-'finans') + 'finansen' (<-'finans') + 'finansens' (<-'finans') + 'finanser' (<-'finans') + 'finanserna' (<-'finans') + 'finansernas' (<-'finans') + + 'frans' (<-'frans') + 'fransen' (<-'frans') + 'fransens' (<-'frans') + 'fransarna' (<-'frans') + 'fransarnas' (<-'frans') + + 'f{o"}rutan' (<-'f{o"}rutan') + + 'f{o"}rs{a"}kran' (<-'f{o"}rs{a"}kr') + + 'glan' (<-'glan') + 'glanare' (<-'glan') + + 'glans' (<-'glans') + 'glansen' (<-'glans') + 'glansens' (<-'glans') + 'glansernas' (<-'glans') + + 'gan' (<-'gan') + 'ganen' (<-'gan') + 'ganens' (<-'gan') + 'ganernas' (<-'gan') + + 'gans' (<-'gans') + 'gansen' (<-'gans') + 'gansens' (<-'gans') + 'gansernas' (<-'gans') + + 'han' (<-'han') + 'hans' (<-'hans') + + 'halvdan' (<-'halvdan') + 'halvdans' (<-'halvdan') + + 'herran' (<-'herran') + 'herrans' (<-'herran') + + 'jan' (<-'jan') + 'jans' (<-'jan') + + 'kan' (<-'kan') + + 'krans' (<-'krans') + 'kransen' (<-'krans') + 'kransens' (<-'krans') + 'kransarna' (<-'krans') + 'kransarnas' (<-'krans') + + + 'kran' (<-'kran') + 'kranen' (<-'kran') + 'kranens' (<-'kran') + 'kranarna' (<-'kran') + 'kranarnas' (<-'kran') + + + 'koran' (<-'koran') + 'koranen' (<-'koran') + 'koranens' (<-'koran') + 'koranerna' (<-'koran') + 'koranernas' (<-'koran') + + 'kuba' (<-'kuba') + 'kuban' (<-'kuba') + 'kubanen' (<-'kuba') + 'kubanens' (<-'kuba') + 'kubaner' (<-'kuba') + 'kubanerna' (<-'kuba') + 'kubanernas' (<-'kuba') + + 'lan' (<-'lan') + + 'lans' (<-'lans') + 'lanser' (<-'lans') + 'lanserna' (<-'lans') + 'lansernas' (<-'lans') + + 'man' (<-'man') + + 'medan' (<-'medan') + 'medans' (<-'medan') + + 'mesan' (<-'mesan') + + 'metan' (<-'metan') + + 'nyans' (<-'nyans') + 'nyanser' (<-'nyans') + 'nyansera' (<-'nyans') + 'nyanseras' (<-'nyans') + 'nyanserar' (<-'nyans') + 'nyanserna' (<-'nyans') + 'nyansernas' (<-'nyans') + + 'n{a"}stan' (<-'n{a"}stan') + + 'ovan' (<-'ovan') + + 'redan' (<-'redan') + + 'roman' (<-'roman') + 'romanen' (<-'roman') + 'romanens' (<-'roman') + 'romaner' (<-'roman') + 'romanerna' (<-'roman') + 'romanernas' (<-'roman') + + 'romans' (<-'romans') + 'romansen' (<-'romans') + 'romansens' (<-'romans') + 'romanser' (<-'romans') + 'romanserna' (<-'romans') + 'romansernas' (<-'romans') + + 'samman' (<-'samman') + + 'sans' (<-'sans') + + 'satan' (<-'satan') + 'satans' (<-'satan') + + 'seans' (<-'seans') + 'seansen' (<-'seans') + 'seansens' (<-'seans') + 'seanser' (<-'seans') + 'seanserna' (<-'seans') + 'seansernas' (<-'seans') + + 'sedan' (<-'sedan') + +// 'skans' (<-'skans') + + 'slogan' (<-'slogan') + + 'svan' (<-'svan') + 'svanen' (<-'svan') + 'svanens' (<-'svan') + 'svanarna' (<-'svan') + 'svanarnas' (<-'svan') + + 'svans' (<-'svans') + 'svansen' (<-'svans') + 'svansens' (<-'svans') + 'svansarna' (<-'svans') + 'svansarnas' (<-'svans') + + 'stan' (<-'stan') + 'stans' (<-'stans') + + 'sultan' (<-'sultan') + 'sultanen' (<-'sultan') + 'sultanens' (<-'sultan') + 'sultaner' (<-'sultan') + 'sultanerna' (<-'sultan') + 'sultanernas' (<-'sultan') + + +// 'titan' (<-'titan') + + 'tran' (<-'tran') + 'tranen' (<-'tran') + 'tranens' (<-'tran') + 'tranerna' (<-'tran') + 'tranernas' (<-'tran') + + 'trans' (<-'trans') + 'transen' (<-'trans') + 'transens' (<-'trans') + 'transer' (<-'trans') + 'transerna' (<-'trans') + 'transernas' (<-'trans') + + 'usans' (<-'usans') + 'usansen' (<-'usans') + 'usansens' (<-'usans') + 'usanser' (<-'usans') + 'usanserna' (<-'usans') + 'usansernas' (<-'usans') + + 'utan' (<-'utan') + + 'van' (<-'van') + + 'vacklan' (<-'vacklan') + + 'vakans' (<-'vakans') + 'vakansen' (<-'vakans') + 'vakansens' (<-'vakans') + 'vakanser' (<-'vakans') + 'vakanserna' (<-'vakans') + 'vakansernas' (<-'vakans') + + 'v{a"}lan' (<-'v{a"}lan') + + ) +) + + +define stem as ( + + + exception1 + or ( + do mark_regions + backwards ( + exception2 or ( + do main_suffix + do consonant_pair + do other_suffix + ) + ) + ) +) Index: src/java/org/tartarus/snowball/ext/Swedish2Stemmer.java =================================================================== --- src/java/org/tartarus/snowball/ext/Swedish2Stemmer.java (revision 0) +++ src/java/org/tartarus/snowball/ext/Swedish2Stemmer.java (revision 0) @@ -0,0 +1,2020 @@ +// This file was generated automatically by the Snowball to Java compiler + +package org.tartarus.snowball.ext; + +import org.tartarus.snowball.Among; + +/** + * This class was automatically generated by a Snowball to Java compiler + * It implements the stemming algorithm defined by a snowball script. + */ + +public class Swedish2Stemmer extends org.tartarus.snowball.SnowballProgram { + + private static final long serialVersionUID = 1L; + + private final static Swedish2Stemmer methodObject = new Swedish2Stemmer(); + + private final static Among a_0[] = { + new Among("kranarna", -1, 35, "", methodObject), + new Among("kransarna", -1, 31, "", methodObject), + new Among("svansarna", -1, 55, "", methodObject), + new Among("romanerna", -1, 41, "", methodObject), + new Among("sultanerna", -1, 61, "", methodObject), + new Among("danserna", -1, 12, "", methodObject), + new Among("balanserna", -1, 5, "", methodObject), + new Among("romanserna", -1, 47, "", methodObject), + new Among("finanserna", -1, 22, "", methodObject), + new Among("balanserara", -1, 10, "", methodObject), + new Among("balansera", -1, 7, "", methodObject), + new Among("fan", -1, 14, "", methodObject), + new Among("slogan", -1, 49, "", methodObject), + new Among("roman", -1, 37, "", methodObject), + new Among("kran", -1, 33, "", methodObject), + new Among("sultan", -1, 57, "", methodObject), + new Among("romanen", -1, 38, "", methodObject), + new Among("sultanen", -1, 58, "", methodObject), + new Among("dansen", -1, 11, "", methodObject), + new Among("fansen", -1, 16, "", methodObject), + new Among("balansen", -1, 2, "", methodObject), + new Among("romansen", -1, 44, "", methodObject), + new Among("finansen", -1, 19, "", methodObject), + new Among("fransen", -1, 25, "", methodObject), + new Among("kransen", -1, 28, "", methodObject), + new Among("transen", -1, 64, "", methodObject), + new Among("svansen", -1, 52, "", methodObject), + new Among("kranar", -1, 34, "", methodObject), + new Among("balanserar", -1, 9, "", methodObject), + new Among("kransar", -1, 30, "", methodObject), + new Among("svansar", -1, 54, "", methodObject), + new Among("romaner", -1, 40, "", methodObject), + new Among("sultaner", -1, 60, "", methodObject), + new Among("balanser", -1, 4, "", methodObject), + new Among("romanser", -1, 46, "", methodObject), + new Among("finanser", -1, 21, "", methodObject), + new Among("kranarnas", -1, 36, "", methodObject), + new Among("kransarnas", -1, 32, "", methodObject), + new Among("svansarnas", -1, 56, "", methodObject), + new Among("romanernas", -1, 42, "", methodObject), + new Among("sultanernas", -1, 62, "", methodObject), + new Among("balansernas", -1, 6, "", methodObject), + new Among("romansernas", -1, 48, "", methodObject), + new Among("finansernas", -1, 23, "", methodObject), + new Among("balanseras", -1, 8, "", methodObject), + new Among("dans", -1, 13, "", methodObject), + new Among("fans", -1, 15, "", methodObject), + new Among("slogans", -1, 50, "", methodObject), + new Among("balans", -1, 1, "", methodObject), + new Among("romans", -1, 43, "", methodObject), + new Among("finans", -1, 18, "", methodObject), + new Among("frans", -1, 24, "", methodObject), + new Among("krans", -1, 27, "", methodObject), + new Among("trans", -1, 63, "", methodObject), + new Among("svans", -1, 51, "", methodObject), + new Among("romanens", -1, 39, "", methodObject), + new Among("sultanens", -1, 59, "", methodObject), + new Among("fansens", -1, 17, "", methodObject), + new Among("balansens", -1, 3, "", methodObject), + new Among("romansens", -1, 45, "", methodObject), + new Among("finansens", -1, 20, "", methodObject), + new Among("fransens", -1, 26, "", methodObject), + new Among("kransens", -1, 29, "", methodObject), + new Among("transens", -1, 65, "", methodObject), + new Among("svansens", -1, 53, "", methodObject) + }; + + private final static Among a_1[] = { + new Among("a", -1, 1, "", methodObject), + new Among("arna", 0, 1, "", methodObject), + new Among("erarna", 1, 1, "", methodObject), + new Among("erna", 0, 1, "", methodObject), + new Among("anerna", 3, 1, "", methodObject), + new Among("anserna", 3, 1, "", methodObject), + new Among("heterna", 3, 1, "", methodObject), + new Among("orna", 0, 1, "", methodObject), + new Among("era", 0, 1, "", methodObject), + new Among("iera", 8, 1, "", methodObject), + new Among("ansera", 8, 1, "", methodObject), + new Among("ad", -1, 1, "", methodObject), + new Among("e", -1, 1, "", methodObject), + new Among("ade", 12, 1, "", methodObject), + new Among("ande", 12, 1, "", methodObject), + new Among("arne", 12, 1, "", methodObject), + new Among("are", 12, 1, "", methodObject), + new Among("anare", 16, 1, "", methodObject), + new Among("aste", 12, 1, "", methodObject), + new Among("an", -1, 1, "", methodObject), + new Among("en", -1, 1, "", methodObject), + new Among("anden", 20, 1, "", methodObject), + new Among("anen", 20, 1, "", methodObject), + new Among("aren", 20, 1, "", methodObject), + new Among("ansen", 20, 1, "", methodObject), + new Among("heten", 20, 1, "", methodObject), + new Among("ern", -1, 1, "", methodObject), + new Among("ar", -1, 1, "", methodObject), + new Among("erar", 27, 1, "", methodObject), + new Among("anserar", 28, 1, "", methodObject), + new Among("er", -1, 1, "", methodObject), + new Among("aner", 30, 1, "", methodObject), + new Among("anser", 30, 1, "", methodObject), + new Among("heter", 30, 1, "", methodObject), + new Among("or", -1, 1, "", methodObject), + new Among("s", -1, 2, "", methodObject), + new Among("as", 35, 1, "", methodObject), + new Among("arnas", 36, 1, "", methodObject), + new Among("erarnas", 37, 1, "", methodObject), + new Among("ernas", 36, 1, "", methodObject), + new Among("anernas", 39, 1, "", methodObject), + new Among("ansernas", 39, 1, "", methodObject), + new Among("ornas", 36, 1, "", methodObject), + new Among("es", 35, 1, "", methodObject), + new Among("ades", 43, 1, "", methodObject), + new Among("andes", 43, 1, "", methodObject), + new Among("ans", 35, 1, "", methodObject), + new Among("ens", 35, 1, "", methodObject), + new Among("anens", 47, 1, "", methodObject), + new Among("arens", 47, 1, "", methodObject), + new Among("ansens", 47, 1, "", methodObject), + new Among("hetens", 47, 1, "", methodObject), + new Among("erns", 35, 1, "", methodObject), + new Among("at", -1, 1, "", methodObject), + new Among("andet", -1, 1, "", methodObject), + new Among("het", -1, 1, "", methodObject), + new Among("ast", -1, 1, "", methodObject) + }; + + private final static Among a_2[] = { + new Among("dd", -1, -1, "", methodObject), + new Among("gd", -1, -1, "", methodObject), + new Among("nn", -1, -1, "", methodObject), + new Among("dt", -1, -1, "", methodObject), + new Among("gt", -1, -1, "", methodObject), + new Among("kt", -1, -1, "", methodObject), + new Among("tt", -1, -1, "", methodObject) + }; + + private final static Among a_3[] = { + new Among("ig", -1, 1, "", methodObject), + new Among("lig", 0, 1, "", methodObject), + new Among("els", -1, 1, "", methodObject), + new Among("fullt", -1, 3, "", methodObject), + new Among("l\u00F6st", -1, 2, "", methodObject) + }; + + private final static Among a_4[] = { + new Among("afrikaans", -1, 1, "", methodObject), + new Among("attan", -1, 8, "", methodObject), + new Among("attans", 1, 9, "", methodObject), + new Among("avans", -1, 2, "", methodObject), + new Among("avansen", 3, 3, "", methodObject), + new Among("avansens", 4, 4, "", methodObject), + new Among("avanser", 3, 5, "", methodObject), + new Among("avanserna", 6, 6, "", methodObject), + new Among("avansernas", 7, 7, "", methodObject), + new Among("balans", -1, 10, "", methodObject), + new Among("balansen", 9, 11, "", methodObject), + new Among("balansens", 10, 12, "", methodObject), + new Among("balanser", 9, 13, "", methodObject), + new Among("balansera", 12, 16, "", methodObject), + new Among("balanserar", 13, 18, "", methodObject), + new Among("balanserara", 14, 19, "", methodObject), + new Among("balanseras", 13, 17, "", methodObject), + new Among("balanserna", 12, 14, "", methodObject), + new Among("balansernas", 17, 15, "", methodObject), + new Among("banan", -1, 20, "", methodObject), + new Among("bananen", 19, 21, "", methodObject), + new Among("bananens", 20, 22, "", methodObject), + new Among("bananer", 19, 23, "", methodObject), + new Among("bananerna", 22, 24, "", methodObject), + new Among("bananernas", 23, 25, "", methodObject), + new Among("cardigan", -1, 26, "", methodObject), + new Among("cardigans", 25, 27, "", methodObject), + new Among("dan", -1, 34, "", methodObject), + new Among("danen", 27, 35, "", methodObject), + new Among("danens", 28, 36, "", methodObject), + new Among("daner", 27, 37, "", methodObject), + new Among("danerna", 30, 38, "", methodObject), + new Among("danernas", 31, 39, "", methodObject), + new Among("dans", 27, 28, "", methodObject), + new Among("dansen", 33, 29, "", methodObject), + new Among("dansens", 34, 30, "", methodObject), + new Among("danser", 33, 31, "", methodObject), + new Among("danserna", 36, 32, "", methodObject), + new Among("dansernas", 37, 33, "", methodObject), + new Among("duman", -1, 40, "", methodObject), + new Among("dumans", 39, 41, "", methodObject), + new Among("fan", -1, 42, "", methodObject), + new Among("fans", 41, 43, "", methodObject), + new Among("fasan", -1, 44, "", methodObject), + new Among("fasanen", 43, 45, "", methodObject), + new Among("fasanens", 44, 46, "", methodObject), + new Among("fasaner", 43, 47, "", methodObject), + new Among("fasanerna", 46, 48, "", methodObject), + new Among("fasanernas", 47, 49, "", methodObject), + new Among("finans", -1, 50, "", methodObject), + new Among("finansen", 49, 51, "", methodObject), + new Among("finansens", 50, 52, "", methodObject), + new Among("finanser", 49, 53, "", methodObject), + new Among("finanserna", 52, 54, "", methodObject), + new Among("finansernas", 53, 55, "", methodObject), + new Among("frans", -1, 56, "", methodObject), + new Among("fransarna", 55, 59, "", methodObject), + new Among("fransarnas", 56, 60, "", methodObject), + new Among("fransen", 55, 57, "", methodObject), + new Among("fransens", 58, 58, "", methodObject), + new Among("f\u00F6rs\u00E4kran", -1, 62, "", methodObject), + new Among("f\u00F6rutan", -1, 61, "", methodObject), + new Among("gan", -1, 69, "", methodObject), + new Among("ganen", 62, 70, "", methodObject), + new Among("ganens", 63, 71, "", methodObject), + new Among("ganernas", 62, 72, "", methodObject), + new Among("gans", 62, 73, "", methodObject), + new Among("gansen", 66, 74, "", methodObject), + new Among("gansens", 67, 75, "", methodObject), + new Among("gansernas", 66, 76, "", methodObject), + new Among("glan", -1, 63, "", methodObject), + new Among("glanare", 70, 64, "", methodObject), + new Among("glans", 70, 65, "", methodObject), + new Among("glansen", 72, 66, "", methodObject), + new Among("glansens", 73, 67, "", methodObject), + new Among("glansernas", 72, 68, "", methodObject), + new Among("halvdan", -1, 79, "", methodObject), + new Among("halvdans", 76, 80, "", methodObject), + new Among("han", -1, 77, "", methodObject), + new Among("hans", 78, 78, "", methodObject), + new Among("herran", -1, 81, "", methodObject), + new Among("herrans", 80, 82, "", methodObject), + new Among("jan", -1, 83, "", methodObject), + new Among("jans", 82, 84, "", methodObject), + new Among("kan", -1, 85, "", methodObject), + new Among("koran", -1, 96, "", methodObject), + new Among("koranen", 85, 97, "", methodObject), + new Among("koranens", 86, 98, "", methodObject), + new Among("koranerna", 85, 99, "", methodObject), + new Among("koranernas", 88, 100, "", methodObject), + new Among("kran", -1, 91, "", methodObject), + new Among("kranarna", 90, 94, "", methodObject), + new Among("kranarnas", 91, 95, "", methodObject), + new Among("kranen", 90, 92, "", methodObject), + new Among("kranens", 93, 93, "", methodObject), + new Among("krans", 90, 86, "", methodObject), + new Among("kransarna", 95, 89, "", methodObject), + new Among("kransarnas", 96, 90, "", methodObject), + new Among("kransen", 95, 87, "", methodObject), + new Among("kransens", 98, 88, "", methodObject), + new Among("kuba", -1, 101, "", methodObject), + new Among("kuban", 100, 102, "", methodObject), + new Among("kubanen", 101, 103, "", methodObject), + new Among("kubanens", 102, 104, "", methodObject), + new Among("kubaner", 101, 105, "", methodObject), + new Among("kubanerna", 104, 106, "", methodObject), + new Among("kubanernas", 105, 107, "", methodObject), + new Among("lan", -1, 108, "", methodObject), + new Among("lans", 107, 109, "", methodObject), + new Among("lanser", 108, 110, "", methodObject), + new Among("lanserna", 109, 111, "", methodObject), + new Among("lansernas", 110, 112, "", methodObject), + new Among("man", -1, 113, "", methodObject), + new Among("medan", -1, 114, "", methodObject), + new Among("medans", 113, 115, "", methodObject), + new Among("mesan", -1, 116, "", methodObject), + new Among("metan", -1, 117, "", methodObject), + new Among("nyans", -1, 118, "", methodObject), + new Among("nyanser", 117, 119, "", methodObject), + new Among("nyansera", 118, 120, "", methodObject), + new Among("nyanserar", 119, 122, "", methodObject), + new Among("nyanseras", 119, 121, "", methodObject), + new Among("nyanserna", 118, 123, "", methodObject), + new Among("nyansernas", 122, 124, "", methodObject), + new Among("n\u00E4stan", -1, 125, "", methodObject), + new Among("ovan", -1, 126, "", methodObject), + new Among("redan", -1, 127, "", methodObject), + new Among("roman", -1, 128, "", methodObject), + new Among("romanen", 127, 129, "", methodObject), + new Among("romanens", 128, 130, "", methodObject), + new Among("romaner", 127, 131, "", methodObject), + new Among("romanerna", 130, 132, "", methodObject), + new Among("romanernas", 131, 133, "", methodObject), + new Among("romans", 127, 134, "", methodObject), + new Among("romansen", 133, 135, "", methodObject), + new Among("romansens", 134, 136, "", methodObject), + new Among("romanser", 133, 137, "", methodObject), + new Among("romanserna", 136, 138, "", methodObject), + new Among("romansernas", 137, 139, "", methodObject), + new Among("samman", -1, 140, "", methodObject), + new Among("sans", -1, 141, "", methodObject), + new Among("satan", -1, 142, "", methodObject), + new Among("satans", 141, 143, "", methodObject), + new Among("seans", -1, 144, "", methodObject), + new Among("seansen", 143, 145, "", methodObject), + new Among("seansens", 144, 146, "", methodObject), + new Among("seanser", 143, 147, "", methodObject), + new Among("seanserna", 146, 148, "", methodObject), + new Among("seansernas", 147, 149, "", methodObject), + new Among("sedan", -1, 150, "", methodObject), + new Among("slogan", -1, 151, "", methodObject), + new Among("stan", -1, 162, "", methodObject), + new Among("stans", 151, 163, "", methodObject), + new Among("sultan", -1, 164, "", methodObject), + new Among("sultanen", 153, 165, "", methodObject), + new Among("sultanens", 154, 166, "", methodObject), + new Among("sultaner", 153, 167, "", methodObject), + new Among("sultanerna", 156, 168, "", methodObject), + new Among("sultanernas", 157, 169, "", methodObject), + new Among("svan", -1, 152, "", methodObject), + new Among("svanarna", 159, 155, "", methodObject), + new Among("svanarnas", 160, 156, "", methodObject), + new Among("svanen", 159, 153, "", methodObject), + new Among("svanens", 162, 154, "", methodObject), + new Among("svans", 159, 157, "", methodObject), + new Among("svansarna", 164, 160, "", methodObject), + new Among("svansarnas", 165, 161, "", methodObject), + new Among("svansen", 164, 158, "", methodObject), + new Among("svansens", 167, 159, "", methodObject), + new Among("tran", -1, 170, "", methodObject), + new Among("tranen", 169, 171, "", methodObject), + new Among("tranens", 170, 172, "", methodObject), + new Among("tranerna", 169, 173, "", methodObject), + new Among("tranernas", 172, 174, "", methodObject), + new Among("trans", 169, 175, "", methodObject), + new Among("transen", 174, 176, "", methodObject), + new Among("transens", 175, 177, "", methodObject), + new Among("transer", 174, 178, "", methodObject), + new Among("transerna", 177, 179, "", methodObject), + new Among("transernas", 178, 180, "", methodObject), + new Among("usans", -1, 181, "", methodObject), + new Among("usansen", 180, 182, "", methodObject), + new Among("usansens", 181, 183, "", methodObject), + new Among("usanser", 180, 184, "", methodObject), + new Among("usanserna", 183, 185, "", methodObject), + new Among("usansernas", 184, 186, "", methodObject), + new Among("utan", -1, 187, "", methodObject), + new Among("vacklan", -1, 189, "", methodObject), + new Among("vakans", -1, 190, "", methodObject), + new Among("vakansen", 188, 191, "", methodObject), + new Among("vakansens", 189, 192, "", methodObject), + new Among("vakanser", 188, 193, "", methodObject), + new Among("vakanserna", 191, 194, "", methodObject), + new Among("vakansernas", 192, 195, "", methodObject), + new Among("van", -1, 188, "", methodObject), + new Among("v\u00E4lan", -1, 196, "", methodObject) + }; + + private static final char g_v[] = {17, 65, 16, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 24, 0, 32}; + + private static final char g_s_ending[] = {119, 127, 149}; + + private int I_x; + private int I_p1; + + private void copy_from(Swedish2Stemmer other) { + I_x = other.I_x; + I_p1 = other.I_p1; + super.copy_from(other); + } + + private boolean r_mark_regions() { + int v_1; + int v_2; + // (, line 47 + I_p1 = limit; + // test, line 50 + v_1 = cursor; + // (, line 50 + // hop, line 50 + { + int c = cursor + 3; + if (0 > c || c > limit) { + return false; + } + cursor = c; + } + // setmark x, line 50 + I_x = cursor; + cursor = v_1; + // goto, line 51 + golab0: + while (true) { + v_2 = cursor; + lab1: + do { + if (!(in_grouping(g_v, 97, 246))) { + break lab1; + } + cursor = v_2; + break golab0; + } while (false); + cursor = v_2; + if (cursor >= limit) { + return false; + } + cursor++; + } + // gopast, line 51 + golab2: + while (true) { + lab3: + do { + if (!(out_grouping(g_v, 97, 246))) { + break lab3; + } + break golab2; + } while (false); + if (cursor >= limit) { + return false; + } + cursor++; + } + // setmark p1, line 51 + I_p1 = cursor; + // try, line 52 + lab4: + do { + // (, line 52 + if (!(I_p1 < I_x)) { + break lab4; + } + I_p1 = I_x; + } while (false); + return true; + } + + private boolean r_exception2() { + int among_var; + // (, line 58 + // [, line 59 + ket = cursor; + // substring, line 59 + among_var = find_among_b(a_0, 65); + if (among_var == 0) { + return false; + } + // ], line 59 + bra = cursor; + switch (among_var) { + case 0: + return false; + case 1: + // (, line 61 + // <-, line 61 + slice_from("balans"); + break; + case 2: + // (, line 62 + // <-, line 62 + slice_from("balans"); + break; + case 3: + // (, line 63 + // <-, line 63 + slice_from("balans"); + break; + case 4: + // (, line 64 + // <-, line 64 + slice_from("balans"); + break; + case 5: + // (, line 65 + // <-, line 65 + slice_from("balans"); + break; + case 6: + // (, line 66 + // <-, line 66 + slice_from("balans"); + break; + case 7: + // (, line 67 + // <-, line 67 + slice_from("balans"); + break; + case 8: + // (, line 68 + // <-, line 68 + slice_from("balans"); + break; + case 9: + // (, line 69 + // <-, line 69 + slice_from("balans"); + break; + case 10: + // (, line 70 + // <-, line 70 + slice_from("balans"); + break; + case 11: + // (, line 72 + // <-, line 72 + slice_from("dans"); + break; + case 12: + // (, line 73 + // <-, line 73 + slice_from("dans"); + break; + case 13: + // (, line 74 + // <-, line 74 + slice_from("dans"); + break; + case 14: + // (, line 76 + // <-, line 76 + slice_from("fan"); + break; + case 15: + // (, line 77 + // <-, line 77 + slice_from("fan"); + break; + case 16: + // (, line 78 + // <-, line 78 + slice_from("fan"); + break; + case 17: + // (, line 79 + // <-, line 79 + slice_from("fan"); + break; + case 18: + // (, line 81 + // <-, line 81 + slice_from("finans"); + break; + case 19: + // (, line 82 + // <-, line 82 + slice_from("finans"); + break; + case 20: + // (, line 83 + // <-, line 83 + slice_from("finans"); + break; + case 21: + // (, line 84 + // <-, line 84 + slice_from("finans"); + break; + case 22: + // (, line 85 + // <-, line 85 + slice_from("finans"); + break; + case 23: + // (, line 86 + // <-, line 86 + slice_from("finans"); + break; + case 24: + // (, line 88 + // <-, line 88 + slice_from("frans"); + break; + case 25: + // (, line 89 + // <-, line 89 + slice_from("frans"); + break; + case 26: + // (, line 90 + // <-, line 90 + slice_from("frans"); + break; + case 27: + // (, line 92 + // <-, line 92 + slice_from("krans"); + break; + case 28: + // (, line 93 + // <-, line 93 + slice_from("krans"); + break; + case 29: + // (, line 94 + // <-, line 94 + slice_from("krans"); + break; + case 30: + // (, line 95 + // <-, line 95 + slice_from("krans"); + break; + case 31: + // (, line 96 + // <-, line 96 + slice_from("krans"); + break; + case 32: + // (, line 97 + // <-, line 97 + slice_from("krans"); + break; + case 33: + // (, line 99 + // <-, line 99 + slice_from("kran"); + break; + case 34: + // (, line 100 + // <-, line 100 + slice_from("kran"); + break; + case 35: + // (, line 101 + // <-, line 101 + slice_from("kran"); + break; + case 36: + // (, line 102 + // <-, line 102 + slice_from("kran"); + break; + case 37: + // (, line 104 + // <-, line 104 + slice_from("roman"); + break; + case 38: + // (, line 105 + // <-, line 105 + slice_from("roman"); + break; + case 39: + // (, line 106 + // <-, line 106 + slice_from("roman"); + break; + case 40: + // (, line 107 + // <-, line 107 + slice_from("roman"); + break; + case 41: + // (, line 108 + // <-, line 108 + slice_from("roman"); + break; + case 42: + // (, line 109 + // <-, line 109 + slice_from("roman"); + break; + case 43: + // (, line 111 + // <-, line 111 + slice_from("romans"); + break; + case 44: + // (, line 112 + // <-, line 112 + slice_from("romans"); + break; + case 45: + // (, line 113 + // <-, line 113 + slice_from("romans"); + break; + case 46: + // (, line 114 + // <-, line 114 + slice_from("romans"); + break; + case 47: + // (, line 115 + // <-, line 115 + slice_from("romans"); + break; + case 48: + // (, line 116 + // <-, line 116 + slice_from("romans"); + break; + case 49: + // (, line 118 + // <-, line 118 + slice_from("slogan"); + break; + case 50: + // (, line 119 + // <-, line 119 + slice_from("slogan"); + break; + case 51: + // (, line 123 + // <-, line 123 + slice_from("svans"); + break; + case 52: + // (, line 124 + // <-, line 124 + slice_from("svans"); + break; + case 53: + // (, line 125 + // <-, line 125 + slice_from("svans"); + break; + case 54: + // (, line 126 + // <-, line 126 + slice_from("svans"); + break; + case 55: + // (, line 127 + // <-, line 127 + slice_from("svans"); + break; + case 56: + // (, line 128 + // <-, line 128 + slice_from("svans"); + break; + case 57: + // (, line 133 + // <-, line 133 + slice_from("sultan"); + break; + case 58: + // (, line 134 + // <-, line 134 + slice_from("sultan"); + break; + case 59: + // (, line 135 + // <-, line 135 + slice_from("sultan"); + break; + case 60: + // (, line 136 + // <-, line 136 + slice_from("sultan"); + break; + case 61: + // (, line 137 + // <-, line 137 + slice_from("sultan"); + break; + case 62: + // (, line 138 + // <-, line 138 + slice_from("sultan"); + break; + case 63: + // (, line 140 + // <-, line 140 + slice_from("trans"); + break; + case 64: + // (, line 141 + // <-, line 141 + slice_from("trans"); + break; + case 65: + // (, line 142 + // <-, line 142 + slice_from("trans"); + break; + } + return true; + } + + private boolean r_main_suffix() { + int among_var; + int v_1; + int v_2; + // (, line 146 + // setlimit, line 147 + v_1 = limit - cursor; + // tomark, line 147 + if (cursor < I_p1) { + return false; + } + cursor = I_p1; + v_2 = limit_backward; + limit_backward = cursor; + cursor = limit - v_1; + // (, line 147 + // [, line 147 + ket = cursor; + // substring, line 147 + among_var = find_among_b(a_1, 57); + if (among_var == 0) { + limit_backward = v_2; + return false; + } + // ], line 147 + bra = cursor; + limit_backward = v_2; + switch (among_var) { + case 0: + return false; + case 1: + // (, line 157 + // delete, line 157 + slice_del(); + break; + case 2: + // (, line 160 + if (!(in_grouping_b(g_s_ending, 98, 121))) { + return false; + } + // delete, line 160 + slice_del(); + break; + } + return true; + } + + private boolean r_consonant_pair() { + int v_1; + int v_2; + int v_3; + // setlimit, line 164 + v_1 = limit - cursor; + // tomark, line 164 + if (cursor < I_p1) { + return false; + } + cursor = I_p1; + v_2 = limit_backward; + limit_backward = cursor; + cursor = limit - v_1; + // (, line 164 + // and, line 166 + v_3 = limit - cursor; + // among, line 165 + if (find_among_b(a_2, 7) == 0) { + limit_backward = v_2; + return false; + } + cursor = limit - v_3; + // (, line 166 + // [, line 166 + ket = cursor; + // next, line 166 + if (cursor <= limit_backward) { + limit_backward = v_2; + return false; + } + cursor--; + // ], line 166 + bra = cursor; + // delete, line 166 + slice_del(); + limit_backward = v_2; + return true; + } + + private boolean r_other_suffix() { + int among_var; + int v_1; + int v_2; + // setlimit, line 169 + v_1 = limit - cursor; + // tomark, line 169 + if (cursor < I_p1) { + return false; + } + cursor = I_p1; + v_2 = limit_backward; + limit_backward = cursor; + cursor = limit - v_1; + // (, line 169 + // [, line 170 + ket = cursor; + // substring, line 170 + among_var = find_among_b(a_3, 5); + if (among_var == 0) { + limit_backward = v_2; + return false; + } + // ], line 170 + bra = cursor; + switch (among_var) { + case 0: + limit_backward = v_2; + return false; + case 1: + // (, line 171 + // delete, line 171 + slice_del(); + break; + case 2: + // (, line 172 + // <-, line 172 + slice_from("l\u00F6s"); + break; + case 3: + // (, line 173 + // <-, line 173 + slice_from("full"); + break; + } + limit_backward = v_2; + return true; + } + + private boolean r_exception1() { + int among_var; + // (, line 179 + // [, line 183 + bra = cursor; + // substring, line 183 + among_var = find_among(a_4, 196); + if (among_var == 0) { + return false; + } + // ], line 183 + ket = cursor; + // atlimit, line 183 + if (cursor < limit) { + return false; + } + switch (among_var) { + case 0: + return false; + case 1: + // (, line 185 + // <-, line 185 + slice_from("afrikaans"); + break; + case 2: + // (, line 187 + // <-, line 187 + slice_from("avans"); + break; + case 3: + // (, line 188 + // <-, line 188 + slice_from("avans"); + break; + case 4: + // (, line 189 + // <-, line 189 + slice_from("avans"); + break; + case 5: + // (, line 190 + // <-, line 190 + slice_from("avans"); + break; + case 6: + // (, line 191 + // <-, line 191 + slice_from("avans"); + break; + case 7: + // (, line 192 + // <-, line 192 + slice_from("avans"); + break; + case 8: + // (, line 194 + // <-, line 194 + slice_from("attan"); + break; + case 9: + // (, line 195 + // <-, line 195 + slice_from("attan"); + break; + case 10: + // (, line 197 + // <-, line 197 + slice_from("balans"); + break; + case 11: + // (, line 198 + // <-, line 198 + slice_from("balans"); + break; + case 12: + // (, line 199 + // <-, line 199 + slice_from("balans"); + break; + case 13: + // (, line 200 + // <-, line 200 + slice_from("balans"); + break; + case 14: + // (, line 201 + // <-, line 201 + slice_from("balans"); + break; + case 15: + // (, line 202 + // <-, line 202 + slice_from("balans"); + break; + case 16: + // (, line 203 + // <-, line 203 + slice_from("balans"); + break; + case 17: + // (, line 204 + // <-, line 204 + slice_from("balans"); + break; + case 18: + // (, line 205 + // <-, line 205 + slice_from("balans"); + break; + case 19: + // (, line 206 + // <-, line 206 + slice_from("balans"); + break; + case 20: + // (, line 208 + // <-, line 208 + slice_from("banan"); + break; + case 21: + // (, line 209 + // <-, line 209 + slice_from("banan"); + break; + case 22: + // (, line 210 + // <-, line 210 + slice_from("banan"); + break; + case 23: + // (, line 211 + // <-, line 211 + slice_from("banan"); + break; + case 24: + // (, line 212 + // <-, line 212 + slice_from("banan"); + break; + case 25: + // (, line 213 + // <-, line 213 + slice_from("banan"); + break; + case 26: + // (, line 215 + // <-, line 215 + slice_from("cardigan"); + break; + case 27: + // (, line 216 + // <-, line 216 + slice_from("cardigan"); + break; + case 28: + // (, line 224 + // <-, line 224 + slice_from("dans"); + break; + case 29: + // (, line 225 + // <-, line 225 + slice_from("dans"); + break; + case 30: + // (, line 226 + // <-, line 226 + slice_from("dans"); + break; + case 31: + // (, line 227 + // <-, line 227 + slice_from("dans"); + break; + case 32: + // (, line 228 + // <-, line 228 + slice_from("dans"); + break; + case 33: + // (, line 229 + // <-, line 229 + slice_from("dans"); + break; + case 34: + // (, line 231 + // <-, line 231 + slice_from("dan"); + break; + case 35: + // (, line 232 + // <-, line 232 + slice_from("dan"); + break; + case 36: + // (, line 233 + // <-, line 233 + slice_from("dan"); + break; + case 37: + // (, line 234 + // <-, line 234 + slice_from("dan"); + break; + case 38: + // (, line 235 + // <-, line 235 + slice_from("dan"); + break; + case 39: + // (, line 236 + // <-, line 236 + slice_from("dan"); + break; + case 40: + // (, line 238 + // <-, line 238 + slice_from("duman"); + break; + case 41: + // (, line 239 + // <-, line 239 + slice_from("duman"); + break; + case 42: + // (, line 241 + // <-, line 241 + slice_from("fan"); + break; + case 43: + // (, line 243 + // <-, line 243 + slice_from("fans"); + break; + case 44: + // (, line 245 + // <-, line 245 + slice_from("fasan"); + break; + case 45: + // (, line 246 + // <-, line 246 + slice_from("fasan"); + break; + case 46: + // (, line 247 + // <-, line 247 + slice_from("fasan"); + break; + case 47: + // (, line 248 + // <-, line 248 + slice_from("fasan"); + break; + case 48: + // (, line 249 + // <-, line 249 + slice_from("fasan"); + break; + case 49: + // (, line 250 + // <-, line 250 + slice_from("fasan"); + break; + case 50: + // (, line 253 + // <-, line 253 + slice_from("finans"); + break; + case 51: + // (, line 254 + // <-, line 254 + slice_from("finans"); + break; + case 52: + // (, line 255 + // <-, line 255 + slice_from("finans"); + break; + case 53: + // (, line 256 + // <-, line 256 + slice_from("finans"); + break; + case 54: + // (, line 257 + // <-, line 257 + slice_from("finans"); + break; + case 55: + // (, line 258 + // <-, line 258 + slice_from("finans"); + break; + case 56: + // (, line 260 + // <-, line 260 + slice_from("frans"); + break; + case 57: + // (, line 261 + // <-, line 261 + slice_from("frans"); + break; + case 58: + // (, line 262 + // <-, line 262 + slice_from("frans"); + break; + case 59: + // (, line 263 + // <-, line 263 + slice_from("frans"); + break; + case 60: + // (, line 264 + // <-, line 264 + slice_from("frans"); + break; + case 61: + // (, line 266 + // <-, line 266 + slice_from("f\u00F6rutan"); + break; + case 62: + // (, line 268 + // <-, line 268 + slice_from("f\u00F6rs\u00E4kr"); + break; + case 63: + // (, line 270 + // <-, line 270 + slice_from("glan"); + break; + case 64: + // (, line 271 + // <-, line 271 + slice_from("glan"); + break; + case 65: + // (, line 273 + // <-, line 273 + slice_from("glans"); + break; + case 66: + // (, line 274 + // <-, line 274 + slice_from("glans"); + break; + case 67: + // (, line 275 + // <-, line 275 + slice_from("glans"); + break; + case 68: + // (, line 276 + // <-, line 276 + slice_from("glans"); + break; + case 69: + // (, line 278 + // <-, line 278 + slice_from("gan"); + break; + case 70: + // (, line 279 + // <-, line 279 + slice_from("gan"); + break; + case 71: + // (, line 280 + // <-, line 280 + slice_from("gan"); + break; + case 72: + // (, line 281 + // <-, line 281 + slice_from("gan"); + break; + case 73: + // (, line 283 + // <-, line 283 + slice_from("gans"); + break; + case 74: + // (, line 284 + // <-, line 284 + slice_from("gans"); + break; + case 75: + // (, line 285 + // <-, line 285 + slice_from("gans"); + break; + case 76: + // (, line 286 + // <-, line 286 + slice_from("gans"); + break; + case 77: + // (, line 288 + // <-, line 288 + slice_from("han"); + break; + case 78: + // (, line 289 + // <-, line 289 + slice_from("hans"); + break; + case 79: + // (, line 291 + // <-, line 291 + slice_from("halvdan"); + break; + case 80: + // (, line 292 + // <-, line 292 + slice_from("halvdan"); + break; + case 81: + // (, line 294 + // <-, line 294 + slice_from("herran"); + break; + case 82: + // (, line 295 + // <-, line 295 + slice_from("herran"); + break; + case 83: + // (, line 297 + // <-, line 297 + slice_from("jan"); + break; + case 84: + // (, line 298 + // <-, line 298 + slice_from("jan"); + break; + case 85: + // (, line 300 + // <-, line 300 + slice_from("kan"); + break; + case 86: + // (, line 302 + // <-, line 302 + slice_from("krans"); + break; + case 87: + // (, line 303 + // <-, line 303 + slice_from("krans"); + break; + case 88: + // (, line 304 + // <-, line 304 + slice_from("krans"); + break; + case 89: + // (, line 305 + // <-, line 305 + slice_from("krans"); + break; + case 90: + // (, line 306 + // <-, line 306 + slice_from("krans"); + break; + case 91: + // (, line 309 + // <-, line 309 + slice_from("kran"); + break; + case 92: + // (, line 310 + // <-, line 310 + slice_from("kran"); + break; + case 93: + // (, line 311 + // <-, line 311 + slice_from("kran"); + break; + case 94: + // (, line 312 + // <-, line 312 + slice_from("kran"); + break; + case 95: + // (, line 313 + // <-, line 313 + slice_from("kran"); + break; + case 96: + // (, line 316 + // <-, line 316 + slice_from("koran"); + break; + case 97: + // (, line 317 + // <-, line 317 + slice_from("koran"); + break; + case 98: + // (, line 318 + // <-, line 318 + slice_from("koran"); + break; + case 99: + // (, line 319 + // <-, line 319 + slice_from("koran"); + break; + case 100: + // (, line 320 + // <-, line 320 + slice_from("koran"); + break; + case 101: + // (, line 322 + // <-, line 322 + slice_from("kuba"); + break; + case 102: + // (, line 323 + // <-, line 323 + slice_from("kuba"); + break; + case 103: + // (, line 324 + // <-, line 324 + slice_from("kuba"); + break; + case 104: + // (, line 325 + // <-, line 325 + slice_from("kuba"); + break; + case 105: + // (, line 326 + // <-, line 326 + slice_from("kuba"); + break; + case 106: + // (, line 327 + // <-, line 327 + slice_from("kuba"); + break; + case 107: + // (, line 328 + // <-, line 328 + slice_from("kuba"); + break; + case 108: + // (, line 330 + // <-, line 330 + slice_from("lan"); + break; + case 109: + // (, line 332 + // <-, line 332 + slice_from("lans"); + break; + case 110: + // (, line 333 + // <-, line 333 + slice_from("lans"); + break; + case 111: + // (, line 334 + // <-, line 334 + slice_from("lans"); + break; + case 112: + // (, line 335 + // <-, line 335 + slice_from("lans"); + break; + case 113: + // (, line 337 + // <-, line 337 + slice_from("man"); + break; + case 114: + // (, line 339 + // <-, line 339 + slice_from("medan"); + break; + case 115: + // (, line 340 + // <-, line 340 + slice_from("medan"); + break; + case 116: + // (, line 342 + // <-, line 342 + slice_from("mesan"); + break; + case 117: + // (, line 344 + // <-, line 344 + slice_from("metan"); + break; + case 118: + // (, line 346 + // <-, line 346 + slice_from("nyans"); + break; + case 119: + // (, line 347 + // <-, line 347 + slice_from("nyans"); + break; + case 120: + // (, line 348 + // <-, line 348 + slice_from("nyans"); + break; + case 121: + // (, line 349 + // <-, line 349 + slice_from("nyans"); + break; + case 122: + // (, line 350 + // <-, line 350 + slice_from("nyans"); + break; + case 123: + // (, line 351 + // <-, line 351 + slice_from("nyans"); + break; + case 124: + // (, line 352 + // <-, line 352 + slice_from("nyans"); + break; + case 125: + // (, line 354 + // <-, line 354 + slice_from("n\u00E4stan"); + break; + case 126: + // (, line 356 + // <-, line 356 + slice_from("ovan"); + break; + case 127: + // (, line 358 + // <-, line 358 + slice_from("redan"); + break; + case 128: + // (, line 360 + // <-, line 360 + slice_from("roman"); + break; + case 129: + // (, line 361 + // <-, line 361 + slice_from("roman"); + break; + case 130: + // (, line 362 + // <-, line 362 + slice_from("roman"); + break; + case 131: + // (, line 363 + // <-, line 363 + slice_from("roman"); + break; + case 132: + // (, line 364 + // <-, line 364 + slice_from("roman"); + break; + case 133: + // (, line 365 + // <-, line 365 + slice_from("roman"); + break; + case 134: + // (, line 367 + // <-, line 367 + slice_from("romans"); + break; + case 135: + // (, line 368 + // <-, line 368 + slice_from("romans"); + break; + case 136: + // (, line 369 + // <-, line 369 + slice_from("romans"); + break; + case 137: + // (, line 370 + // <-, line 370 + slice_from("romans"); + break; + case 138: + // (, line 371 + // <-, line 371 + slice_from("romans"); + break; + case 139: + // (, line 372 + // <-, line 372 + slice_from("romans"); + break; + case 140: + // (, line 374 + // <-, line 374 + slice_from("samman"); + break; + case 141: + // (, line 376 + // <-, line 376 + slice_from("sans"); + break; + case 142: + // (, line 378 + // <-, line 378 + slice_from("satan"); + break; + case 143: + // (, line 379 + // <-, line 379 + slice_from("satan"); + break; + case 144: + // (, line 381 + // <-, line 381 + slice_from("seans"); + break; + case 145: + // (, line 382 + // <-, line 382 + slice_from("seans"); + break; + case 146: + // (, line 383 + // <-, line 383 + slice_from("seans"); + break; + case 147: + // (, line 384 + // <-, line 384 + slice_from("seans"); + break; + case 148: + // (, line 385 + // <-, line 385 + slice_from("seans"); + break; + case 149: + // (, line 386 + // <-, line 386 + slice_from("seans"); + break; + case 150: + // (, line 388 + // <-, line 388 + slice_from("sedan"); + break; + case 151: + // (, line 392 + // <-, line 392 + slice_from("slogan"); + break; + case 152: + // (, line 394 + // <-, line 394 + slice_from("svan"); + break; + case 153: + // (, line 395 + // <-, line 395 + slice_from("svan"); + break; + case 154: + // (, line 396 + // <-, line 396 + slice_from("svan"); + break; + case 155: + // (, line 397 + // <-, line 397 + slice_from("svan"); + break; + case 156: + // (, line 398 + // <-, line 398 + slice_from("svan"); + break; + case 157: + // (, line 400 + // <-, line 400 + slice_from("svans"); + break; + case 158: + // (, line 401 + // <-, line 401 + slice_from("svans"); + break; + case 159: + // (, line 402 + // <-, line 402 + slice_from("svans"); + break; + case 160: + // (, line 403 + // <-, line 403 + slice_from("svans"); + break; + case 161: + // (, line 404 + // <-, line 404 + slice_from("svans"); + break; + case 162: + // (, line 406 + // <-, line 406 + slice_from("stan"); + break; + case 163: + // (, line 407 + // <-, line 407 + slice_from("stans"); + break; + case 164: + // (, line 409 + // <-, line 409 + slice_from("sultan"); + break; + case 165: + // (, line 410 + // <-, line 410 + slice_from("sultan"); + break; + case 166: + // (, line 411 + // <-, line 411 + slice_from("sultan"); + break; + case 167: + // (, line 412 + // <-, line 412 + slice_from("sultan"); + break; + case 168: + // (, line 413 + // <-, line 413 + slice_from("sultan"); + break; + case 169: + // (, line 414 + // <-, line 414 + slice_from("sultan"); + break; + case 170: + // (, line 419 + // <-, line 419 + slice_from("tran"); + break; + case 171: + // (, line 420 + // <-, line 420 + slice_from("tran"); + break; + case 172: + // (, line 421 + // <-, line 421 + slice_from("tran"); + break; + case 173: + // (, line 422 + // <-, line 422 + slice_from("tran"); + break; + case 174: + // (, line 423 + // <-, line 423 + slice_from("tran"); + break; + case 175: + // (, line 425 + // <-, line 425 + slice_from("trans"); + break; + case 176: + // (, line 426 + // <-, line 426 + slice_from("trans"); + break; + case 177: + // (, line 427 + // <-, line 427 + slice_from("trans"); + break; + case 178: + // (, line 428 + // <-, line 428 + slice_from("trans"); + break; + case 179: + // (, line 429 + // <-, line 429 + slice_from("trans"); + break; + case 180: + // (, line 430 + // <-, line 430 + slice_from("trans"); + break; + case 181: + // (, line 432 + // <-, line 432 + slice_from("usans"); + break; + case 182: + // (, line 433 + // <-, line 433 + slice_from("usans"); + break; + case 183: + // (, line 434 + // <-, line 434 + slice_from("usans"); + break; + case 184: + // (, line 435 + // <-, line 435 + slice_from("usans"); + break; + case 185: + // (, line 436 + // <-, line 436 + slice_from("usans"); + break; + case 186: + // (, line 437 + // <-, line 437 + slice_from("usans"); + break; + case 187: + // (, line 439 + // <-, line 439 + slice_from("utan"); + break; + case 188: + // (, line 441 + // <-, line 441 + slice_from("van"); + break; + case 189: + // (, line 443 + // <-, line 443 + slice_from("vacklan"); + break; + case 190: + // (, line 445 + // <-, line 445 + slice_from("vakans"); + break; + case 191: + // (, line 446 + // <-, line 446 + slice_from("vakans"); + break; + case 192: + // (, line 447 + // <-, line 447 + slice_from("vakans"); + break; + case 193: + // (, line 448 + // <-, line 448 + slice_from("vakans"); + break; + case 194: + // (, line 449 + // <-, line 449 + slice_from("vakans"); + break; + case 195: + // (, line 450 + // <-, line 450 + slice_from("vakans"); + break; + case 196: + // (, line 452 + // <-, line 452 + slice_from("v\u00E4lan"); + break; + } + return true; + } + + public boolean stem() { + int v_1; + int v_2; + int v_3; + int v_4; + int v_5; + int v_6; + // (, line 458 + // or, line 462 + lab0: + do { + v_1 = cursor; + lab1: + do { + // call exception1, line 461 + if (!r_exception1()) { + break lab1; + } + break lab0; + } while (false); + cursor = v_1; + // (, line 462 + // do, line 463 + v_2 = cursor; + lab2: + do { + // call mark_regions, line 463 + if (!r_mark_regions()) { + break lab2; + } + } while (false); + cursor = v_2; + // backwards, line 464 + limit_backward = cursor; + cursor = limit; + // (, line 464 + // or, line 465 + lab3: + do { + v_3 = limit - cursor; + lab4: + do { + // call exception2, line 465 + if (!r_exception2()) { + break lab4; + } + break lab3; + } while (false); + cursor = limit - v_3; + // (, line 465 + // do, line 466 + v_4 = limit - cursor; + lab5: + do { + // call main_suffix, line 466 + if (!r_main_suffix()) { + break lab5; + } + } while (false); + cursor = limit - v_4; + // do, line 467 + v_5 = limit - cursor; + lab6: + do { + // call consonant_pair, line 467 + if (!r_consonant_pair()) { + break lab6; + } + } while (false); + cursor = limit - v_5; + // do, line 468 + v_6 = limit - cursor; + lab7: + do { + // call other_suffix, line 468 + if (!r_other_suffix()) { + break lab7; + } + } while (false); + cursor = limit - v_6; + } while (false); + cursor = limit_backward; + } while (false); + return true; + } + + public boolean equals(Object o) { + return o instanceof Swedish2Stemmer; + } + + public int hashCode() { + return Swedish2Stemmer.class.getName().hashCode(); + } + + +} \ No newline at end of file