forked from GitHub/gf-rgl
(Por) add Dict module, improve Irreg module
* Dict
- Dict only contains nouns and adjectives using the full-form
paradigms^1 (for stability and because generating the minimal ones
would take longer)
- verbs can be found in Irreg, using bescherelle paradigms -- the
full-form ones would make the file too big!
- adverbs are just {s : Str}, so if you know their names you can make
them yourself, no need to include them (but I can if it's best)
^1: adjectives actually use the almost full-form paradigm, but they
should be correct except for a couple of cases
* Irreg
- renamed IrregBesch to Irreg
- added more verbs (there are still quite a few missing)
This commit is contained in:
odanoburu
+549
-4
@@ -1,9 +1,554 @@
|
||||
--# -path=.:../romance:../abstract:../common:../prelude
|
||||
--# -path=.:../romance:../common:../abstract:../prelude
|
||||
|
||||
concrete IrregPor of IrregPorAbs = CatPor **
|
||||
open ParadigmsPor, BeschPor in {
|
||||
|
||||
flags optimize=values ;
|
||||
coding=utf8 ;
|
||||
flags optimize=noexpand ;
|
||||
coding=utf8 ;
|
||||
|
||||
}
|
||||
-- machine-generated file: do not edit directly! see
|
||||
-- https://gitlab.com/odanoburu/gf-pt
|
||||
|
||||
-- look up your verb here. if you don't find it, see if
|
||||
-- if you can find out what is its paradigm and then add it!
|
||||
|
||||
lin acontecer_V = mkV (acontecer_Besch "acontecer") ;
|
||||
lin conhecer_V = mkV (acontecer_Besch "conhecer") ;
|
||||
lin coalescer_V = mkV (acontecer_Besch "coalescer") ;
|
||||
lin comparecer_V = mkV (acontecer_Besch "comparecer") ;
|
||||
lin compadecer_V = mkV (acontecer_Besch "compadecer") ;
|
||||
lin contorcer_V = mkV (acontecer_Besch "contorcer") ;
|
||||
lin convalescer_V = mkV (acontecer_Besch "convalescer") ;
|
||||
lin convencer_V = mkV (acontecer_Besch "convencer") ;
|
||||
lin acudir_V = mkV (acudir_Besch "acudir") ;
|
||||
lin bulir_V = mkV (acudir_Besch "bulir") ;
|
||||
lin cuspir_V = mkV (acudir_Besch "cuspir") ;
|
||||
lin sacudir_V = mkV (acudir_Besch "sacudir") ;
|
||||
lin subir_V = mkV (acudir_Besch "subir") ;
|
||||
lin sumir_V = mkV (acudir_Besch "sumir") ;
|
||||
lin consumir_V = mkV (acudir_Besch "consumir") ;
|
||||
lin adequar_V = mkV (adequar_Besch "adequar") ;
|
||||
lin agredir_V = mkV (agredir_Besch "agredir") ;
|
||||
lin denegrir_V = mkV (agredir_Besch "denegrir") ;
|
||||
lin prevenir_V = mkV (agredir_Besch "prevenir") ;
|
||||
lin progredir_V = mkV (agredir_Besch "progredir") ;
|
||||
lin transgredir_V = mkV (agredir_Besch "transgredir") ;
|
||||
lin anunciar_V = mkV (anunciar_Besch "anunciar") ;
|
||||
lin abreviar_V = mkV (anunciar_Besch "abreviar") ;
|
||||
lin acariciar_V = mkV (anunciar_Besch "acariciar") ;
|
||||
lin afiar_V = mkV (anunciar_Besch "afiar") ;
|
||||
lin aliviar_V = mkV (anunciar_Besch "aliviar") ;
|
||||
lin apreciar_V = mkV (anunciar_Besch "apreciar") ;
|
||||
lin assobiar_V = mkV (anunciar_Besch "assobiar") ;
|
||||
lin avaliar_V = mkV (anunciar_Besch "avaliar") ;
|
||||
lin avariar_V = mkV (anunciar_Besch "avariar") ;
|
||||
lin criar_V = mkV (anunciar_Besch "criar") ;
|
||||
lin denunciar_V = mkV (anunciar_Besch "denunciar") ;
|
||||
lin desviar_V = mkV (anunciar_Besch "desviar") ;
|
||||
lin enfiar_V = mkV (anunciar_Besch "enfiar") ;
|
||||
lin enviar_V = mkV (anunciar_Besch "enviar") ;
|
||||
lin iniciar_V = mkV (anunciar_Besch "iniciar") ;
|
||||
lin principiar_V = mkV (anunciar_Besch "principiar") ;
|
||||
lin pronunciar_V = mkV (anunciar_Besch "pronunciar") ;
|
||||
lin renunciar_V = mkV (anunciar_Besch "renunciar") ;
|
||||
lin assediar_V = mkV (anunciar_Besch "assediar") ;
|
||||
lin aprazer_V = mkV (aprazer_Besch "aprazer") ;
|
||||
lin desprazer_V = mkV (aprazer_Besch "desprazer") ;
|
||||
lin aquecer_V = mkV (aquecer_Besch "aquecer") ;
|
||||
lin agradecer_V = mkV (aquecer_Besch "agradecer") ;
|
||||
lin amarelecer_V = mkV (aquecer_Besch "amarelecer") ;
|
||||
lin amolecer_V = mkV (aquecer_Besch "amolecer") ;
|
||||
lin arrefecer_V = mkV (aquecer_Besch "arrefecer") ;
|
||||
lin empecer_V = mkV (aquecer_Besch "empecer") ;
|
||||
lin entretecer_V = mkV (aquecer_Besch "entretecer") ;
|
||||
lin entristecer_V = mkV (aquecer_Besch "entristecer") ;
|
||||
lin escurecer_V = mkV (aquecer_Besch "escurecer") ;
|
||||
lin estremecer_V = mkV (aquecer_Besch "estremecer") ;
|
||||
lin favorecer_V = mkV (aquecer_Besch "favorecer") ;
|
||||
lin merecer_V = mkV (aquecer_Besch "merecer") ;
|
||||
lin oferecer_V = mkV (aquecer_Besch "oferecer") ;
|
||||
lin parecer_V = mkV (aquecer_Besch "parecer") ;
|
||||
lin perecer_V = mkV (aquecer_Besch "perecer") ;
|
||||
lin reverdecer_V = mkV (aquecer_Besch "reverdecer") ;
|
||||
lin tecer_V = mkV (aquecer_Besch "tecer") ;
|
||||
lin esquecer_V = mkV (aquecer_Besch "esquecer") ;
|
||||
lin escarnecer_V = mkV (aquecer_Besch "escarnecer") ;
|
||||
lin escurecer_V = mkV (aquecer_Besch "escurecer") ;
|
||||
lin arguir_V = mkV (arguir_Besch "arguir") ;
|
||||
lin redarguir_V = mkV (arguir_Besch "redarguir") ;
|
||||
lin averiguar_V = mkV (averiguar_Besch "averiguar") ;
|
||||
lin aguar_V = mkV (averiguar_Besch "aguar") ;
|
||||
lin apaniguar_V = mkV (averiguar_Besch "apaniguar") ;
|
||||
lin apaziguar_V = mkV (averiguar_Besch "apaziguar") ;
|
||||
lin apropinquar_V = mkV (averiguar_Besch "apropinquar") ;
|
||||
lin deliquar_V = mkV (averiguar_Besch "deliquar") ;
|
||||
lin desaguar_V = mkV (averiguar_Besch "desaguar") ;
|
||||
lin enxaguar_V = mkV (averiguar_Besch "enxaguar") ;
|
||||
lin obliquar_V = mkV (averiguar_Besch "obliquar") ;
|
||||
lin caber_V = mkV (caber_Besch "caber") ;
|
||||
lin chegar_V = mkV (chegar_Besch "chegar") ;
|
||||
lin rogar_V = mkV (chegar_Besch "rogar") ;
|
||||
lin jogar_V = mkV (chegar_Besch "jogar") ;
|
||||
lin julgar_V = mkV (chegar_Besch "julgar") ;
|
||||
lin interrogar_V = mkV (chegar_Besch "interrogar") ;
|
||||
lin intrigar_V = mkV (chegar_Besch "intrigar") ;
|
||||
lin investigar_V = mkV (chegar_Besch "investigar") ;
|
||||
lin enxergar_V = mkV (chegar_Besch "enxergar") ;
|
||||
lin enrugar_V = mkV (chegar_Besch "enrugar") ;
|
||||
lin escorregar_V = mkV (chegar_Besch "escorregar") ;
|
||||
lin esmagar_V = mkV (chegar_Besch "esmagar") ;
|
||||
lin esfregar_V = mkV (chegar_Besch "esfregar") ;
|
||||
lin irrigar_V = mkV (chegar_Besch "irrigar") ;
|
||||
lin interligar_V = mkV (chegar_Besch "interligar") ;
|
||||
lin instigar_V = mkV (chegar_Besch "instigar") ;
|
||||
lin largar_V = mkV (chegar_Besch "largar") ;
|
||||
lin legalizar_V = mkV (chegar_Besch "legalizar") ;
|
||||
lin ligar_V = mkV (chegar_Besch "ligar") ;
|
||||
lin litigar_V = mkV (chegar_Besch "litigar") ;
|
||||
lin madrugar_V = mkV (chegar_Besch "madrugar") ;
|
||||
lin esfregar_V = mkV (chegar_Besch "esfregar") ;
|
||||
lin apagar_V = mkV (chegar_Besch "apagar") ;
|
||||
lin tragar_V = mkV (chegar_Besch "tragar") ;
|
||||
lin chover_V = mkV (chover_Besch "chover") ;
|
||||
lin começar_V = mkV (começar_Besch "começar") ;
|
||||
lin caçar_V = mkV (começar_Besch "caçar") ;
|
||||
lin coçar_V = mkV (começar_Besch "coçar") ;
|
||||
lin comerciar_V = mkV (comerciar_Besch "comerciar") ;
|
||||
lin agenciar_V = mkV (comerciar_Besch "agenciar") ;
|
||||
lin licenciar_V = mkV (comerciar_Besch "licenciar") ;
|
||||
lin negociar_V = mkV (comerciar_Besch "negociar") ;
|
||||
lin obsequiar_V = mkV (comerciar_Besch "obsequiar") ;
|
||||
lin premiar_V = mkV (comerciar_Besch "premiar") ;
|
||||
lin providenciar_V = mkV (comerciar_Besch "providenciar") ;
|
||||
lin sentenciar_V = mkV (comerciar_Besch "sentenciar") ;
|
||||
lin silenciar_V = mkV (comerciar_Besch "silenciar") ;
|
||||
lin comprar_V = mkV (comprar_Besch "comprar") ;
|
||||
lin pintar_V = mkV (comprar_Besch "pintar") ;
|
||||
lin perguntar_V = mkV (comprar_Besch "perguntar") ;
|
||||
lin quebrar_V = mkV (comprar_Besch "quebrar") ;
|
||||
lin fechar_V = mkV (comprar_Besch "fechar") ;
|
||||
lin contar_V = mkV (comprar_Besch "contar") ;
|
||||
lin cortar_V = mkV (comprar_Besch "cortar") ;
|
||||
lin compilar_V = mkV (comprar_Besch "compilar") ;
|
||||
lin lutar_V = mkV (comprar_Besch "lutar") ;
|
||||
lin encontrar_V = mkV (comprar_Besch "encontrar") ;
|
||||
lin encomendar_V = mkV (comprar_Besch "encomendar") ;
|
||||
lin encalacrar_V = mkV (comprar_Besch "encalacrar") ;
|
||||
lin encaminhar_V = mkV (comprar_Besch "encaminhar") ;
|
||||
lin estampar_V = mkV (comprar_Besch "estampar") ;
|
||||
lin encanar_V = mkV (comprar_Besch "encanar") ;
|
||||
lin encampar_V = mkV (comprar_Besch "encampar") ;
|
||||
lin encantar_V = mkV (comprar_Besch "encantar") ;
|
||||
lin encapotar_V = mkV (comprar_Besch "encapotar") ;
|
||||
lin encarar_V = mkV (comprar_Besch "encarar") ;
|
||||
lin encarcerar_V = mkV (comprar_Besch "encarcerar") ;
|
||||
lin matar_V = mkV (comprar_Besch "matar") ;
|
||||
lin menosprezar_V = mkV (comprar_Besch "menosprezar") ;
|
||||
lin marchar_V = mkV (comprar_Besch "marchar") ;
|
||||
lin maravilhar_V = mkV (comprar_Besch "maravilhar") ;
|
||||
lin marombar_V = mkV (comprar_Besch "marombar") ;
|
||||
lin respirar_V = mkV (comprar_Besch "respirar") ;
|
||||
lin martirizar_V = mkV (comprar_Besch "martirizar") ;
|
||||
lin martelar_V = mkV (comprar_Besch "martelar") ;
|
||||
lin mascarar_V = mkV (comprar_Besch "mascarar") ;
|
||||
lin masturbar_V = mkV (comprar_Besch "masturbar") ;
|
||||
lin materializar_V = mkV (comprar_Besch "materializar") ;
|
||||
lin matizar_V = mkV (comprar_Besch "matizar") ;
|
||||
lin mazelar_V = mkV (comprar_Besch "mazelar") ;
|
||||
lin mecanizar_V = mkV (comprar_Besch "mecanizar") ;
|
||||
lin mediocrizar_V = mkV (comprar_Besch "mediocrizar") ;
|
||||
lin meditar_V = mkV (comprar_Besch "meditar") ;
|
||||
lin melar_V = mkV (comprar_Besch "melar") ;
|
||||
lin melhorar_V = mkV (comprar_Besch "melhorar") ;
|
||||
lin memorizar_V = mkV (comprar_Besch "memorizar") ;
|
||||
lin mencionar_V = mkV (comprar_Besch "mencionar") ;
|
||||
lin mensurar_V = mkV (comprar_Besch "mensurar") ;
|
||||
lin assoprar_V = mkV (comprar_Besch "assoprar") ;
|
||||
lin metralhar_V = mkV (comprar_Besch "metralhar") ;
|
||||
lin migrar_V = mkV (comprar_Besch "migrar") ;
|
||||
lin militar_V = mkV (comprar_Besch "militar") ;
|
||||
lin militarizar_V = mkV (comprar_Besch "militarizar") ;
|
||||
lin mimar_V = mkV (comprar_Besch "mimar") ;
|
||||
lin mimetizar_V = mkV (comprar_Besch "mimetizar") ;
|
||||
lin mirar_V = mkV (comprar_Besch "mirar") ;
|
||||
lin misturar_V = mkV (comprar_Besch "misturar") ;
|
||||
lin mobilizar_V = mkV (comprar_Besch "mobilizar") ;
|
||||
lin modelar_V = mkV (comprar_Besch "modelar") ;
|
||||
lin modernizar_V = mkV (comprar_Besch "modernizar") ;
|
||||
lin modular_V = mkV (comprar_Besch "modular") ;
|
||||
lin monopolizar_V = mkV (comprar_Besch "monopolizar") ;
|
||||
lin moralizar_V = mkV (comprar_Besch "moralizar") ;
|
||||
lin mostrar_V = mkV (comprar_Besch "mostrar") ;
|
||||
lin motivar_V = mkV (comprar_Besch "motivar") ;
|
||||
lin motorizar_V = mkV (comprar_Besch "motorizar") ;
|
||||
lin movimentar_V = mkV (comprar_Besch "movimentar") ;
|
||||
lin multar_V = mkV (comprar_Besch "multar") ;
|
||||
lin mundanizar_V = mkV (comprar_Besch "mundanizar") ;
|
||||
lin mutilar_V = mkV (comprar_Besch "mutilar") ;
|
||||
lin gostar_V = mkV (comprar_Besch "gostar") ;
|
||||
lin gabar_V = mkV (comprar_Besch "gabar") ;
|
||||
lin galopar_V = mkV (comprar_Besch "galopar") ;
|
||||
lin gangrenar_V = mkV (comprar_Besch "gangrenar") ;
|
||||
lin ganhar_V = mkV (comprar_Besch "ganhar") ;
|
||||
lin garimpar_V = mkV (comprar_Besch "garimpar") ;
|
||||
lin gastar_V = mkV (comprar_Besch "gastar") ;
|
||||
lin generalizar_V = mkV (comprar_Besch "generalizar") ;
|
||||
lin gerar_V = mkV (comprar_Besch "gerar") ;
|
||||
lin girar_V = mkV (comprar_Besch "girar") ;
|
||||
lin gravar_V = mkV (comprar_Besch "gravar") ;
|
||||
lin grelhar_V = mkV (comprar_Besch "grelhar") ;
|
||||
lin gritar_V = mkV (comprar_Besch "gritar") ;
|
||||
lin guardar_V = mkV (comprar_Besch "guardar") ;
|
||||
lin guerrilhar_V = mkV (comprar_Besch "guerrilhar") ;
|
||||
lin guinchar_V = mkV (comprar_Besch "guinchar") ;
|
||||
lin guisar_V = mkV (comprar_Besch "guisar") ;
|
||||
lin herdar_V = mkV (comprar_Besch "herdar") ;
|
||||
lin hibernar_V = mkV (comprar_Besch "hibernar") ;
|
||||
lin hipnotizar_V = mkV (comprar_Besch "hipnotizar") ;
|
||||
lin honrar_V = mkV (comprar_Besch "honrar") ;
|
||||
lin horripular_V = mkV (comprar_Besch "horripular") ;
|
||||
lin hospedar_V = mkV (comprar_Besch "hospedar") ;
|
||||
lin humanizar_V = mkV (comprar_Besch "humanizar") ;
|
||||
lin humilhar_V = mkV (comprar_Besch "humilhar") ;
|
||||
lin humorizar_V = mkV (comprar_Besch "humorizar") ;
|
||||
lin idealizar_V = mkV (comprar_Besch "idealizar") ;
|
||||
lin idolatrar_V = mkV (comprar_Besch "idolatrar") ;
|
||||
lin implementar_V = mkV (comprar_Besch "implementar") ;
|
||||
lin implantar_V = mkV (comprar_Besch "implantar") ;
|
||||
lin incrementar_V = mkV (comprar_Besch "incrementar") ;
|
||||
lin indignar_V = mkV (comprar_Besch "indignar") ;
|
||||
lin informar_V = mkV (comprar_Besch "informar") ;
|
||||
lin escutar_V = mkV (comprar_Besch "escutar") ;
|
||||
lin amar_V = mkV (comprar_Besch "amar") ;
|
||||
lin tirar_V = mkV (comprar_Besch "tirar") ;
|
||||
lin empurrar_V = mkV (comprar_Besch "empurrar") ;
|
||||
lin falar_V = mkV (comprar_Besch "falar") ;
|
||||
lin separar_V = mkV (comprar_Besch "separar") ;
|
||||
lin apertar_V = mkV (comprar_Besch "apertar") ;
|
||||
lin chupar_V = mkV (comprar_Besch "chupar") ;
|
||||
lin ensinar_V = mkV (comprar_Besch "ensinar") ;
|
||||
lin atar_V = mkV (comprar_Besch "atar") ;
|
||||
lin esperar_V = mkV (comprar_Besch "esperar") ;
|
||||
lin lavar_V = mkV (comprar_Besch "lavar") ;
|
||||
lin somar_V = mkV (comprar_Besch "somar") ;
|
||||
lin sensualizar_V = mkV (comprar_Besch "sensualizar") ;
|
||||
lin saltar_V = mkV (comprar_Besch "saltar") ;
|
||||
lin congelar_V = mkV (comprar_Besch "congelar") ;
|
||||
lin virar_V = mkV (comprar_Besch "virar") ;
|
||||
lin escavar_V = mkV (comprar_Besch "escavar") ;
|
||||
lin costurar_V = mkV (comprar_Besch "costurar") ;
|
||||
lin cantar_V = mkV (comprar_Besch "cantar") ;
|
||||
lin sentar_V = mkV (comprar_Besch "sentar") ;
|
||||
lin parar_V = mkV (comprar_Besch "parar") ;
|
||||
lin nadar_V = mkV (comprar_Besch "nadar") ;
|
||||
lin pensar_V = mkV (comprar_Besch "pensar") ;
|
||||
lin vomitar_V = mkV (comprar_Besch "vomitar") ;
|
||||
lin caminhar_V = mkV (comprar_Besch "caminhar") ;
|
||||
lin crer_V = mkV (crer_Besch "crer") ;
|
||||
lin descrer_V = mkV (crer_Besch "descrer") ;
|
||||
lin dar_V = mkV (dar_Besch "dar") ;
|
||||
lin destruir_V = mkV (destruir_Besch "destruir") ;
|
||||
lin construir_V = mkV (destruir_Besch "construir") ;
|
||||
lin reconstruir_V = mkV (destruir_Besch "reconstruir") ;
|
||||
lin distribuir_V = mkV (distribuir_Besch "distribuir") ;
|
||||
lin imbuir_V = mkV (distribuir_Besch "imbuir") ;
|
||||
lin afluir_V = mkV (distribuir_Besch "afluir") ;
|
||||
lin confluir_V = mkV (distribuir_Besch "confluir") ;
|
||||
lin fluir_V = mkV (distribuir_Besch "fluir") ;
|
||||
lin influir_V = mkV (distribuir_Besch "influir") ;
|
||||
lin refluir_V = mkV (distribuir_Besch "refluir") ;
|
||||
lin atribuir_V = mkV (distribuir_Besch "atribuir") ;
|
||||
lin contribuir_V = mkV (distribuir_Besch "contribuir") ;
|
||||
lin retribuir_V = mkV (distribuir_Besch "retribuir") ;
|
||||
lin instituir_V = mkV (distribuir_Besch "instituir") ;
|
||||
lin restituir_V = mkV (distribuir_Besch "restituir") ;
|
||||
lin substituir_V = mkV (distribuir_Besch "substituir") ;
|
||||
lin divergir_V = mkV (divergir_Besch "divergir") ;
|
||||
lin aspergir_V = mkV (divergir_Besch "aspergir") ;
|
||||
lin convergir_V = mkV (divergir_Besch "convergir") ;
|
||||
lin dizer_V = mkV (dizer_Besch "dizer") ;
|
||||
lin bendizer_V = mkV (dizer_Besch "bendizer") ;
|
||||
lin condizer_V = mkV (dizer_Besch "condizer") ;
|
||||
lin contradizer_V = mkV (dizer_Besch "contradizer") ;
|
||||
lin desdizer_V = mkV (dizer_Besch "desdizer") ;
|
||||
lin maldizer_V = mkV (dizer_Besch "maldizer") ;
|
||||
lin predizer_V = mkV (dizer_Besch "predizer") ;
|
||||
lin doer_V = mkV (doer_Besch "doer") ;
|
||||
lin dormir_V = mkV (dormir_Besch "dormir") ;
|
||||
lin cobrir_V = mkV (dormir_Besch "cobrir") ;
|
||||
lin descobrir_V = mkV (dormir_Besch "descobrir") ;
|
||||
lin encobrir_V = mkV (dormir_Besch "encobrir") ;
|
||||
lin recobrir_V = mkV (dormir_Besch "recobrir") ;
|
||||
lin explodir_V = mkV (dormir_Besch "explodir") ;
|
||||
lin engolir_V = mkV (dormir_Besch "engolir") ;
|
||||
lin tossir_V = mkV (dormir_Besch "tossir") ;
|
||||
lin erguer_V = mkV (erguer_Besch "erguer") ;
|
||||
lin soerguer_V = mkV (erguer_Besch "soerguer") ;
|
||||
lin estar_V = mkV (estar_Besch "estar") ;
|
||||
lin extinguir_V = mkV (extinguir_Besch "extinguir") ;
|
||||
lin falir_V = mkV (falir_Besch "falir") ;
|
||||
lin aguerrir_V = mkV (falir_Besch "aguerrir") ;
|
||||
lin combalir_V = mkV (falir_Besch "combalir") ;
|
||||
lin desflorir_V = mkV (falir_Besch "desflorir") ;
|
||||
lin florir_V = mkV (falir_Besch "florir") ;
|
||||
lin reflorir_V = mkV (falir_Besch "reflorir") ;
|
||||
lin renhir_V = mkV (falir_Besch "renhir") ;
|
||||
lin parir_V = mkV (falir_Besch "parir") ;
|
||||
lin fazer_V = mkV (fazer_Besch "fazer") ;
|
||||
lin afazer_V = mkV (fazer_Besch "afazer") ;
|
||||
lin contrafazer_V = mkV (fazer_Besch "contrafazer") ;
|
||||
lin desfazer_V = mkV (fazer_Besch "desfazer") ;
|
||||
lin liquefazer_V = mkV (fazer_Besch "liquefazer") ;
|
||||
lin perfazer_V = mkV (fazer_Besch "perfazer") ;
|
||||
lin rarefazer_V = mkV (fazer_Besch "rarefazer") ;
|
||||
lin refazer_V = mkV (fazer_Besch "refazer") ;
|
||||
lin satisfazer_V = mkV (fazer_Besch "satisfazer") ;
|
||||
lin ficar_V = mkV (ficar_Besch "ficar") ;
|
||||
lin buscar_V = mkV (ficar_Besch "buscar") ;
|
||||
lin frigir_V = mkV (frigir_Besch "frigir") ;
|
||||
lin fugir_V = mkV (fugir_Besch "fugir") ;
|
||||
lin garantir_V = mkV (garantir_Besch "garantir") ;
|
||||
lin partir_V = mkV (garantir_Besch "partir") ;
|
||||
lin haver_V = mkV (haver_Besch "haver") ;
|
||||
lin abolir_V = mkV (imergir_Besch "abolir") ;
|
||||
lin banir_V = mkV (imergir_Besch "banir") ;
|
||||
lin brandir_V = mkV (imergir_Besch "brandir") ;
|
||||
lin brunir_V = mkV (imergir_Besch "brunir") ;
|
||||
lin emergir_V = mkV (imergir_Besch "emergir") ;
|
||||
lin empedernir_V = mkV (imergir_Besch "empedernir") ;
|
||||
lin exaurir_V = mkV (imergir_Besch "exaurir") ;
|
||||
lin extorquir_V = mkV (imergir_Besch "extorquir") ;
|
||||
lin fremir_V = mkV (imergir_Besch "fremir") ;
|
||||
lin fulgir_V = mkV (imergir_Besch "fulgir") ;
|
||||
lin jungir_V = mkV (imergir_Besch "jungir") ;
|
||||
lin retorquir_V = mkV (imergir_Besch "retorquir") ;
|
||||
lin submergir_V = mkV (imergir_Besch "submergir") ;
|
||||
lin ungir_V = mkV (imergir_Besch "ungir") ;
|
||||
lin colorir_V = mkV (imergir_Besch "colorir") ;
|
||||
lin demolir_V = mkV (imergir_Besch "demolir") ;
|
||||
lin ir_V = mkV (ir_Besch "ir") ;
|
||||
lin jazer_V = mkV (jazer_Besch "jazer") ;
|
||||
lin ler_V = mkV (ler_Besch "ler") ;
|
||||
lin reler_V = mkV (ler_Besch "reler") ;
|
||||
lin tresler_V = mkV (ler_Besch "tresler") ;
|
||||
lin moer_V = mkV (moer_Besch "moer") ;
|
||||
lin roer_V = mkV (moer_Besch "roer") ;
|
||||
lin neviscar_V = mkV (neviscar_Besch "neviscar") ;
|
||||
lin odiar_V = mkV (odiar_Besch "odiar") ;
|
||||
lin ansiar_V = mkV (odiar_Besch "ansiar") ;
|
||||
lin incendiar_V = mkV (odiar_Besch "incendiar") ;
|
||||
lin mediar_V = mkV (odiar_Besch "mediar") ;
|
||||
lin remediar_V = mkV (odiar_Besch "remediar") ;
|
||||
lin ouvir_V = mkV (ouvir_Besch "ouvir") ;
|
||||
lin pedir_V = mkV (pedir_Besch "pedir") ;
|
||||
lin despedir_V = mkV (pedir_Besch "despedir") ;
|
||||
lin expedir_V = mkV (pedir_Besch "expedir") ;
|
||||
lin reexpedir_V = mkV (pedir_Besch "reexpedir") ;
|
||||
lin impedir_V = mkV (pedir_Besch "impedir") ;
|
||||
lin desimpedir_V = mkV (pedir_Besch "desimpedir") ;
|
||||
lin medir_V = mkV (pedir_Besch "medir") ;
|
||||
lin perder_V = mkV (perder_Besch "perder") ;
|
||||
lin perdoar_V = mkV (perdoar_Besch "perdoar") ;
|
||||
lin abalroar_V = mkV (perdoar_Besch "abalroar") ;
|
||||
lin abençoar_V = mkV (perdoar_Besch "abençoar") ;
|
||||
lin amaldiçoar_V = mkV (perdoar_Besch "amaldiçoar") ;
|
||||
lin aperfeiçoar_V = mkV (perdoar_Besch "aperfeiçoar") ;
|
||||
lin apregoar_V = mkV (perdoar_Besch "apregoar") ;
|
||||
lin coar_V = mkV (perdoar_Besch "coar") ;
|
||||
lin doar_V = mkV (perdoar_Besch "doar") ;
|
||||
lin entoar_V = mkV (perdoar_Besch "entoar") ;
|
||||
lin esboroar_V = mkV (perdoar_Besch "esboroar") ;
|
||||
lin povoar_V = mkV (perdoar_Besch "povoar") ;
|
||||
lin soar_V = mkV (perdoar_Besch "soar") ;
|
||||
lin toar_V = mkV (perdoar_Besch "toar") ;
|
||||
lin voar_V = mkV (perdoar_Besch "voar") ;
|
||||
lin poder_V = mkV (poder_Besch "poder") ;
|
||||
lin polir_V = mkV (polir_Besch "polir") ;
|
||||
lin pôr_V = mkV (pôr_Besch "pôr") ;
|
||||
lin apor_V = mkV (pôr_Besch "apor") ;
|
||||
lin compor_V = mkV (pôr_Besch "compor") ;
|
||||
lin contrapor_V = mkV (pôr_Besch "contrapor") ;
|
||||
lin decompor_V = mkV (pôr_Besch "decompor") ;
|
||||
lin descompor_V = mkV (pôr_Besch "descompor") ;
|
||||
lin dispor_V = mkV (pôr_Besch "dispor") ;
|
||||
lin expor_V = mkV (pôr_Besch "expor") ;
|
||||
lin impor_V = mkV (pôr_Besch "impor") ;
|
||||
lin opor_V = mkV (pôr_Besch "opor") ;
|
||||
lin propor_V = mkV (pôr_Besch "propor") ;
|
||||
lin repor_V = mkV (pôr_Besch "repor") ;
|
||||
lin supor_V = mkV (pôr_Besch "supor") ;
|
||||
lin prazer_V = mkV (prazer_Besch "prazer") ;
|
||||
lin precaver_V = mkV (precaver_Besch "precaver") ;
|
||||
lin preferir_V = mkV (preferir_Besch "preferir") ;
|
||||
lin aderir_V = mkV (preferir_Besch "aderir") ;
|
||||
lin aferir_V = mkV (preferir_Besch "aferir") ;
|
||||
lin conferir_V = mkV (preferir_Besch "conferir") ;
|
||||
lin deferir_V = mkV (preferir_Besch "deferir") ;
|
||||
lin diferir_V = mkV (preferir_Besch "diferir") ;
|
||||
lin digerir_V = mkV (preferir_Besch "digerir") ;
|
||||
lin ferir_V = mkV (preferir_Besch "ferir") ;
|
||||
lin inferir_V = mkV (preferir_Besch "inferir") ;
|
||||
lin inserir_V = mkV (preferir_Besch "inserir") ;
|
||||
lin proferir_V = mkV (preferir_Besch "proferir") ;
|
||||
lin referir_V = mkV (preferir_Besch "referir") ;
|
||||
lin repelir_V = mkV (preferir_Besch "repelir") ;
|
||||
lin repetir_V = mkV (preferir_Besch "repetir") ;
|
||||
lin sugerir_V = mkV (preferir_Besch "sugerir") ;
|
||||
lin transferir_V = mkV (preferir_Besch "transferir") ;
|
||||
lin proibir_V = mkV (proibir_Besch "proibir") ;
|
||||
lin coibir_V = mkV (proibir_Besch "coibir") ;
|
||||
lin proteger_V = mkV (proteger_Besch "proteger") ;
|
||||
lin eleger_V = mkV (proteger_Besch "eleger") ;
|
||||
lin reger_V = mkV (proteger_Besch "reger") ;
|
||||
lin prover_V = mkV (prover_Besch "prover") ;
|
||||
lin querer_V = mkV (querer_Besch "querer") ;
|
||||
lin reaver_V = mkV (reaver_Besch "reaver") ;
|
||||
lin recear_V = mkV (recear_Besch "recear") ;
|
||||
lin acarear_V = mkV (recear_Besch "acarear") ;
|
||||
lin afear_V = mkV (recear_Besch "afear") ;
|
||||
lin altear_V = mkV (recear_Besch "altear") ;
|
||||
lin apear_V = mkV (recear_Besch "apear") ;
|
||||
lin arquear_V = mkV (recear_Besch "arquear") ;
|
||||
lin asnear_V = mkV (recear_Besch "asnear") ;
|
||||
lin costear_V = mkV (recear_Besch "costear") ;
|
||||
lin custear_V = mkV (recear_Besch "custear") ;
|
||||
lin enfrear_V = mkV (recear_Besch "enfrear") ;
|
||||
lin frear_V = mkV (recear_Besch "frear") ;
|
||||
lin olear_V = mkV (recear_Besch "olear") ;
|
||||
lin passear_V = mkV (recear_Besch "passear") ;
|
||||
lin pear_V = mkV (recear_Besch "pear") ;
|
||||
lin pentear_V = mkV (recear_Besch "pentear") ;
|
||||
lin pratear_V = mkV (recear_Besch "pratear") ;
|
||||
lin presentear_V = mkV (recear_Besch "presentear") ;
|
||||
lin recrear_V = mkV (recear_Besch "recrear") ;
|
||||
lin saborear_V = mkV (recear_Besch "saborear") ;
|
||||
lin sofrear_V = mkV (recear_Besch "sofrear") ;
|
||||
lin esfaquear_V = mkV (recear_Besch "esfaquear") ;
|
||||
lin escassear_V = mkV (recear_Besch "escassear") ;
|
||||
lin escarcear_V = mkV (recear_Besch "escarcear") ;
|
||||
lin escamotear_V = mkV (recear_Besch "escamotear") ;
|
||||
lin esfoguear_V = mkV (recear_Besch "esfoguear") ;
|
||||
lin estear_V = mkV (recear_Besch "estear") ;
|
||||
lin esbofetear_V = mkV (recear_Besch "esbofetear") ;
|
||||
lin espernear_V = mkV (recear_Besch "espernear") ;
|
||||
lin redigir_V = mkV (redigir_Besch "redigir") ;
|
||||
lin afligir_V = mkV (redigir_Besch "afligir") ;
|
||||
lin agir_V = mkV (redigir_Besch "agir") ;
|
||||
lin coligir_V = mkV (redigir_Besch "coligir") ;
|
||||
lin corrigir_V = mkV (redigir_Besch "corrigir") ;
|
||||
lin erigir_V = mkV (redigir_Besch "erigir") ;
|
||||
lin exigir_V = mkV (redigir_Besch "exigir") ;
|
||||
lin fingir_V = mkV (redigir_Besch "fingir") ;
|
||||
lin frangir_V = mkV (redigir_Besch "frangir") ;
|
||||
lin infligir_V = mkV (redigir_Besch "infligir") ;
|
||||
lin transigir_V = mkV (redigir_Besch "transigir") ;
|
||||
lin refletir_V = mkV (refletir_Besch "refletir") ;
|
||||
lin fletir_V = mkV (refletir_Besch "fletir") ;
|
||||
lin defletir_V = mkV (refletir_Besch "defletir") ;
|
||||
lin infletir_V = mkV (refletir_Besch "infletir") ;
|
||||
lin remir_V = mkV (remir_Besch "remir") ;
|
||||
lin requerer_V = mkV (requerer_Besch "requerer") ;
|
||||
lin reunir_V = mkV (reunir_Besch "reunir") ;
|
||||
lin rir_V = mkV (rir_Besch "rir") ;
|
||||
lin sorrir_V = mkV (rir_Besch "sorrir") ;
|
||||
lin saber_V = mkV (saber_Besch "saber") ;
|
||||
lin dessaber_V = mkV (saber_Besch "dessaber") ;
|
||||
lin sair_V = mkV (sair_Besch "sair") ;
|
||||
lin cair_V = mkV (sair_Besch "cair") ;
|
||||
lin decair_V = mkV (sair_Besch "decair") ;
|
||||
lin descair_V = mkV (sair_Besch "descair") ;
|
||||
lin recair_V = mkV (sair_Besch "recair") ;
|
||||
lin trair_V = mkV (sair_Besch "trair") ;
|
||||
lin atrair_V = mkV (sair_Besch "atrair") ;
|
||||
lin contrair_V = mkV (sair_Besch "contrair") ;
|
||||
lin distrair_V = mkV (sair_Besch "distrair") ;
|
||||
lin extrair_V = mkV (sair_Besch "extrair") ;
|
||||
lin protrair_V = mkV (sair_Besch "protrair") ;
|
||||
lin retrair_V = mkV (sair_Besch "retrair") ;
|
||||
lin subtrair_V = mkV (sair_Besch "subtrair") ;
|
||||
lin saudar_V = mkV (saudar_Besch "saudar") ;
|
||||
lin seguir_V = mkV (seguir_Besch "seguir") ;
|
||||
lin conseguir_V = mkV (seguir_Besch "conseguir") ;
|
||||
lin perseguir_V = mkV (seguir_Besch "perseguir") ;
|
||||
lin prosseguir_V = mkV (seguir_Besch "prosseguir") ;
|
||||
lin sentir_V = mkV (sentir_Besch "sentir") ;
|
||||
lin assentir_V = mkV (sentir_Besch "assentir") ;
|
||||
lin consentir_V = mkV (sentir_Besch "consentir") ;
|
||||
lin pressentir_V = mkV (sentir_Besch "pressentir") ;
|
||||
lin ressentir_V = mkV (sentir_Besch "ressentir") ;
|
||||
lin mentir_V = mkV (sentir_Besch "mentir") ;
|
||||
lin desmentir_V = mkV (sentir_Besch "desmentir") ;
|
||||
lin ser_V = mkV (ser_Besch "ser") ;
|
||||
lin servir_V = mkV (servir_Besch "servir") ;
|
||||
lin concernir_V = mkV (servir_Besch "concernir") ;
|
||||
lin discernir_V = mkV (servir_Besch "discernir") ;
|
||||
lin cerzir_V = mkV (servir_Besch "cerzir") ;
|
||||
lin despir_V = mkV (servir_Besch "despir") ;
|
||||
lin vestir_V = mkV (servir_Besch "vestir") ;
|
||||
lin investir_V = mkV (servir_Besch "investir") ;
|
||||
lin revestir_V = mkV (servir_Besch "revestir") ;
|
||||
lin ter_V = mkV (ter_Besch "ter") ;
|
||||
lin conter_V = mkV (ter_Besch "conter") ;
|
||||
lin deter_V = mkV (ter_Besch "deter") ;
|
||||
lin entreter_V = mkV (ter_Besch "entreter") ;
|
||||
lin reter_V = mkV (ter_Besch "reter") ;
|
||||
lin suster_V = mkV (ter_Besch "suster") ;
|
||||
lin traduzir_V = mkV (traduzir_Besch "traduzir") ;
|
||||
lin abduzir_V = mkV (traduzir_Besch "abduzir") ;
|
||||
lin aduzir_V = mkV (traduzir_Besch "aduzir") ;
|
||||
lin conduzir_V = mkV (traduzir_Besch "conduzir") ;
|
||||
lin deduzir_V = mkV (traduzir_Besch "deduzir") ;
|
||||
lin induzir_V = mkV (traduzir_Besch "induzir") ;
|
||||
lin introduzir_V = mkV (traduzir_Besch "introduzir") ;
|
||||
lin luzir_V = mkV (traduzir_Besch "luzir") ;
|
||||
lin perluzir_V = mkV (traduzir_Besch "perluzir") ;
|
||||
lin produzir_V = mkV (traduzir_Besch "produzir") ;
|
||||
lin reduzir_V = mkV (traduzir_Besch "reduzir") ;
|
||||
lin reluzir_V = mkV (traduzir_Besch "reluzir") ;
|
||||
lin seduzir_V = mkV (traduzir_Besch "seduzir") ;
|
||||
lin trazer_V = mkV (trazer_Besch "trazer") ;
|
||||
lin valer_V = mkV (valer_Besch "valer") ;
|
||||
lin desvaler_V = mkV (valer_Besch "desvaler") ;
|
||||
lin equivaler_V = mkV (valer_Besch "equivaler") ;
|
||||
lin vender_V = mkV (vender_Besch "vender") ;
|
||||
lin responder_V = mkV (vender_Besch "responder") ;
|
||||
lin beber_V = mkV (vender_Besch "beber") ;
|
||||
lin comer_V = mkV (vender_Besch "comer") ;
|
||||
lin temer_V = mkV (vender_Besch "temer") ;
|
||||
lin bater_V = mkV (vender_Besch "bater") ;
|
||||
lin benzer_V = mkV (vender_Besch "benzer") ;
|
||||
lin morder_V = mkV (vender_Besch "morder") ;
|
||||
lin aprender_V = mkV (vender_Besch "aprender") ;
|
||||
lin entender_V = mkV (vender_Besch "entender") ;
|
||||
lin envolver_V = mkV (vender_Besch "envolver") ;
|
||||
lin esbater_V = mkV (vender_Besch "esbater") ;
|
||||
lin remover_V = mkV (vender_Besch "remover") ;
|
||||
lin remeter_V = mkV (vender_Besch "remeter") ;
|
||||
lin remexer_V = mkV (vender_Besch "remexer") ;
|
||||
lin resolver_V = mkV (vender_Besch "resolver") ;
|
||||
lin reviver_V = mkV (vender_Besch "reviver") ;
|
||||
lin morrer_V = mkV (vender_Besch "morrer") ;
|
||||
lin viver_V = mkV (vender_Besch "viver") ;
|
||||
lin correr_V = mkV (vender_Besch "correr") ;
|
||||
lin coser_V = mkV (vender_Besch "coser") ;
|
||||
lin ver_V = mkV (ver_Besch "ver") ;
|
||||
lin antever_V = mkV (ver_Besch "antever") ;
|
||||
lin entrever_V = mkV (ver_Besch "entrever") ;
|
||||
lin prever_V = mkV (ver_Besch "prever") ;
|
||||
lin rever_V = mkV (ver_Besch "rever") ;
|
||||
lin vir_V = mkV (vir_Besch "vir") ;
|
||||
lin advir_V = mkV (vir_Besch "advir") ;
|
||||
lin convir_V = mkV (vir_Besch "convir") ;
|
||||
lin desavir_V = mkV (vir_Besch "desavir") ;
|
||||
lin intervir_V = mkV (vir_Besch "intervir") ;
|
||||
lin porvir_V = mkV (vir_Besch "porvir") ;
|
||||
lin sobrevir_V = mkV (vir_Besch "sobrevir") ;
|
||||
lin suar_V = mkV (suar_Besch "suar") ;
|
||||
lin flutuar_V = mkV (suar_Besch "flutuar") ;
|
||||
lin viajar_V = mkV (viajar_Besch "viajar") ;
|
||||
lin peneirar_V = mkV (peneirar_Besch "peneirar") ;
|
||||
lin cheirar_V = mkV (peneirar_Besch "cheirar") ;
|
||||
lin queixar_V = mkV (peneirar_Besch "queixar") ;
|
||||
lin queimar_V = mkV (peneirar_Besch "queimar") ;
|
||||
|
||||
} ;
|
||||
|
||||
Reference in New Issue
Block a user