--# -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") ;

} ;
