forked from GitHub/gf-rgl
7e8270381d
- add compN and compNN as mkN paradigms - rm tossir_V from Irreg since it is very wrong - fix oper `a` (contraction of preposition a + definite articles)
554 lines
26 KiB
Plaintext
554 lines
26 KiB
Plaintext
--# -path=.:../romance:../common:../abstract:../prelude
|
|
|
|
concrete IrregPor of IrregPorAbs = CatPor **
|
|
open ParadigmsPor, BeschPor in {
|
|
|
|
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 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") ;
|
|
|
|
} ;
|