diff --git a/.gitattributes b/.gitattributes index a6344aac8c09253b3b630fb776ae94478aa0275b..b083fd1415e456f5252f157dda5c7c6da20bb3ab 100644 --- a/.gitattributes +++ b/.gitattributes @@ -33,3 +33,107 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text *.zip filter=lfs diff=lfs merge=lfs -text *.zst filter=lfs diff=lfs merge=lfs -text *tfevents* filter=lfs diff=lfs merge=lfs -text +CoreNLP/models/ru/tagger/dict.tsv filter=lfs diff=lfs merge=lfs -text +CoreNLP/models/ru/tagger/russian-ud-mf.tagger filter=lfs diff=lfs merge=lfs -text +CoreNLP/models/ru/tagger/russian-ud-mfmini.tagger filter=lfs diff=lfs merge=lfs -text +CoreNLP/models/ru/tagger/russian-ud-pos.tagger filter=lfs diff=lfs merge=lfs -text +CoreNLP/stanford-postagger-full-2020-11-17/models/arabic-train.tagger filter=lfs diff=lfs merge=lfs -text +CoreNLP/stanford-postagger-full-2020-11-17/models/arabic.tagger filter=lfs diff=lfs merge=lfs -text +CoreNLP/stanford-postagger-full-2020-11-17/models/chinese-distsim.tagger filter=lfs diff=lfs merge=lfs -text +CoreNLP/stanford-postagger-full-2020-11-17/models/chinese-nodistsim.tagger filter=lfs diff=lfs merge=lfs -text +CoreNLP/stanford-postagger-full-2020-11-17/models/english-bidirectional-distsim.tagger filter=lfs diff=lfs merge=lfs -text +CoreNLP/stanford-postagger-full-2020-11-17/models/english-caseless-left3words-distsim.tagger filter=lfs diff=lfs merge=lfs -text +CoreNLP/stanford-postagger-full-2020-11-17/models/english-left3words-distsim.tagger filter=lfs diff=lfs merge=lfs -text +CoreNLP/stanford-postagger-full-2020-11-17/models/french-ud.tagger filter=lfs diff=lfs merge=lfs -text +CoreNLP/stanford-postagger-full-2020-11-17/models/german-ud.tagger filter=lfs diff=lfs merge=lfs -text +CoreNLP/stanford-postagger-full-2020-11-17/models/spanish-ud.tagger filter=lfs diff=lfs merge=lfs -text +CoreNLP/stanford-postagger-full-2020-11-17/stanford-postagger-4.2.0-javadoc.jar filter=lfs diff=lfs merge=lfs -text +CoreNLP/stanford-postagger-full-2020-11-17/stanford-postagger-4.2.0-sources.jar filter=lfs diff=lfs merge=lfs -text +CoreNLP/stanford-postagger-full-2020-11-17/stanford-postagger-4.2.0.jar filter=lfs diff=lfs merge=lfs -text +CoreNLP/stanford-postagger-full-2020-11-17/stanford-postagger.jar filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/binary/linux32/csharp/libudpipe_csharp.so filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/binary/linux32/java/libudpipe_java.so filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/binary/linux32/udpipe filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/binary/linux64/csharp/libudpipe_csharp.so filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/binary/linux64/java/libudpipe_java.so filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/binary/linux64/udpipe filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/binary/linuxArmv7/libudpipe.a filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/binary/linuxArmv7/rest_server/udpipe_server filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/binary/linuxArmv7/udpipe filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/binary/osx/csharp/libudpipe_csharp.dylib filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/binary/osx/java/libudpipe_java.dylib filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/binary/osx/udpipe filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/binary/win64/csharp/udpipe_csharp.dll filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/binary/win64/java/udpipe_java.dll filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/binary/win64/udpipe.exe filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/udpipe_csharp/x64/udpipe_csharp.dll filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/XDependencies/UDPipe/MANUAL.pdf filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/XDependencies/UDPipe/Models/Ancient_greek-PROIEL.udpipe filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/XDependencies/UDPipe/Models/Ancient_greek.udpipe filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/XDependencies/UDPipe/Models/Arabic.udpipe filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/XDependencies/UDPipe/Models/Basque.udpipe filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/XDependencies/UDPipe/Models/Belarusian.udpipe filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/XDependencies/UDPipe/Models/Bulgarian.udpipe filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/XDependencies/UDPipe/Models/Catalan.udpipe filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/XDependencies/UDPipe/Models/Chinese.udpipe filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/XDependencies/UDPipe/Models/Coptic.udpipe filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/XDependencies/UDPipe/Models/Croatian.udpipe filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/XDependencies/UDPipe/Models/Czech-CAC.udpipe filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/XDependencies/UDPipe/Models/Czech-CLTT.udpipe filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/XDependencies/UDPipe/Models/Czech.udpipe filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/XDependencies/UDPipe/Models/Danish.udpipe filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/XDependencies/UDPipe/Models/Dutch-LASSYSMALL.udpipe filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/XDependencies/UDPipe/Models/Dutch.udpipe filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/XDependencies/UDPipe/Models/English-LINES.udpipe filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/XDependencies/UDPipe/Models/English-PARTUT.udpipe filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/XDependencies/UDPipe/Models/English.udpipe filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/XDependencies/UDPipe/Models/Estonian.udpipe filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/XDependencies/UDPipe/Models/Finnish-FTB.udpipe filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/XDependencies/UDPipe/Models/Finnish.udpipe filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/XDependencies/UDPipe/Models/French-PARTUT.udpipe filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/XDependencies/UDPipe/Models/French-SEQUOIA.udpipe filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/XDependencies/UDPipe/Models/French.udpipe filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/XDependencies/UDPipe/Models/Galician-TREEGAL.udpipe filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/XDependencies/UDPipe/Models/Galician.udpipe filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/XDependencies/UDPipe/Models/German.udpipe filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/XDependencies/UDPipe/Models/Gothic.udpipe filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/XDependencies/UDPipe/Models/Greek.udpipe filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/XDependencies/UDPipe/Models/Hebrew.udpipe filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/XDependencies/UDPipe/Models/Hindi.udpipe filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/XDependencies/UDPipe/Models/Hungarian.udpipe filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/XDependencies/UDPipe/Models/Indonesian.udpipe filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/XDependencies/UDPipe/Models/Irish.udpipe filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/XDependencies/UDPipe/Models/Italian.udpipe filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/XDependencies/UDPipe/Models/Japanese.udpipe filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/XDependencies/UDPipe/Models/Kazakh.udpipe filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/XDependencies/UDPipe/Models/Korean.udpipe filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/XDependencies/UDPipe/Models/Latin-ITTB.udpipe filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/XDependencies/UDPipe/Models/Latin-PROIEL.udpipe filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/XDependencies/UDPipe/Models/Latin.udpipe filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/XDependencies/UDPipe/Models/Latvian.udpipe filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/XDependencies/UDPipe/Models/Lithuanian.udpipe filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/XDependencies/UDPipe/Models/Norwegian-BOKMAAL.udpipe filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/XDependencies/UDPipe/Models/Norwegian-NYNORSK.udpipe filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/XDependencies/UDPipe/Models/Old_church_slavonic.udpipe filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/XDependencies/UDPipe/Models/Persian.udpipe filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/XDependencies/UDPipe/Models/Polish.udpipe filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/XDependencies/UDPipe/Models/Portuguese-BR.udpipe filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/XDependencies/UDPipe/Models/Portuguese.udpipe filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/XDependencies/UDPipe/Models/Romanian.udpipe filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/XDependencies/UDPipe/Models/Russian-SYNTAGRUS.udpipe filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/XDependencies/UDPipe/Models/Russian.udpipe filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/XDependencies/UDPipe/Models/Sanskrit.udpipe filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/XDependencies/UDPipe/Models/Slovak.udpipe filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/XDependencies/UDPipe/Models/Slovenian-SST.udpipe filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/XDependencies/UDPipe/Models/Slovenian.udpipe filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/XDependencies/UDPipe/Models/Spanish-ANCORA.udpipe filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/XDependencies/UDPipe/Models/Spanish.udpipe filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/XDependencies/UDPipe/Models/Swedish-LINES.udpipe filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/XDependencies/UDPipe/Models/Swedish.udpipe filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/XDependencies/UDPipe/Models/Tamil.udpipe filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/XDependencies/UDPipe/Models/Turkish.udpipe filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/XDependencies/UDPipe/Models/Ukrainian.udpipe filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/XDependencies/UDPipe/Models/Urdu.udpipe filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/XDependencies/UDPipe/Models/Uyghur.udpipe filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/XDependencies/UDPipe/Models/Vietnamese.udpipe filter=lfs diff=lfs merge=lfs -text +UDPipe/v1/XDependencies/UDPipe/udpipe.exe filter=lfs diff=lfs merge=lfs -text diff --git a/CoreNLP/models/ru/parser/nndep.rus.model81_mf.txt.gz b/CoreNLP/models/ru/parser/nndep.rus.model81_mf.txt.gz new file mode 100644 index 0000000000000000000000000000000000000000..4d2eb42d700769f8ed6edbc4e0edeb7019053822 --- /dev/null +++ b/CoreNLP/models/ru/parser/nndep.rus.model81_mf.txt.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:326fc20cdd0602da6ea44279f4d04761670bb03d86297a9be59d8c921bd11580 +size 115029311 diff --git a/CoreNLP/models/ru/parser/nndep.rus.model90.9_88.6.txt.gz b/CoreNLP/models/ru/parser/nndep.rus.model90.9_88.6.txt.gz new file mode 100644 index 0000000000000000000000000000000000000000..dc028d3a80efb5bcc4002a6221e4eff94560e97f --- /dev/null +++ b/CoreNLP/models/ru/parser/nndep.rus.model90.9_88.6.txt.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9f8e0cb78116c4fba174b6ab19dccc7867b7cea2dd44ccea7067ee949cb04e69 +size 118576259 diff --git a/CoreNLP/models/ru/parser/nndep.rus.modelAr100HS400.txt.gz b/CoreNLP/models/ru/parser/nndep.rus.modelAr100HS400.txt.gz new file mode 100644 index 0000000000000000000000000000000000000000..3d3310e3f429595dd16011c28226d8857d3ed129 --- /dev/null +++ b/CoreNLP/models/ru/parser/nndep.rus.modelAr100HS400.txt.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:91b09c5d84c44ca668372b78f8c20235fb3fe701df25169dd0182e4830043b29 +size 127444031 diff --git a/CoreNLP/models/ru/parser/nndep.rus.modelMFAr100HS400_81.txt.gz b/CoreNLP/models/ru/parser/nndep.rus.modelMFAr100HS400_81.txt.gz new file mode 100644 index 0000000000000000000000000000000000000000..21fb2182737b4915d0b4dda40cac34d90f8728fa --- /dev/null +++ b/CoreNLP/models/ru/parser/nndep.rus.modelMFAr100HS400_81.txt.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2e5ea42afc93a9f9a6c7c915451d1257e6455faaa3f01b06bd1643af3bafaff2 +size 118710465 diff --git a/CoreNLP/models/ru/parser/nndep.rus.modelMFWiki100HS400_80.txt.gz b/CoreNLP/models/ru/parser/nndep.rus.modelMFWiki100HS400_80.txt.gz new file mode 100644 index 0000000000000000000000000000000000000000..a487099da30be90d18e8b10836d1e707cea9e3b8 --- /dev/null +++ b/CoreNLP/models/ru/parser/nndep.rus.modelMFWiki100HS400_80.txt.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8afeae32c7675e237f5cef4f225e9ed92d8c66b80e37b06fe710cfcb6f558617 +size 119027293 diff --git a/CoreNLP/models/ru/tagger/dict.tsv b/CoreNLP/models/ru/tagger/dict.tsv new file mode 100644 index 0000000000000000000000000000000000000000..360d0df7bf979048337023e01d39f7890fb3813e --- /dev/null +++ b/CoreNLP/models/ru/tagger/dict.tsv @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:01234d489dc349b61843573e725f2fd3e265e004a1408a6712c5f6fafca5d506 +size 129696832 diff --git a/CoreNLP/models/ru/tagger/russian-ud-mf.tagger b/CoreNLP/models/ru/tagger/russian-ud-mf.tagger new file mode 100644 index 0000000000000000000000000000000000000000..a6952b1ef02c671f0ce77e199fff196711e39012 --- /dev/null +++ b/CoreNLP/models/ru/tagger/russian-ud-mf.tagger @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:bd10da6d84ec2f8d150d48147dac16d2209b2bd09af0e9740c7fa18abe5b1e8a +size 27644829 diff --git a/CoreNLP/models/ru/tagger/russian-ud-mfmini.tagger b/CoreNLP/models/ru/tagger/russian-ud-mfmini.tagger new file mode 100644 index 0000000000000000000000000000000000000000..8616ff76449cc7d5b777782564c8591575e53142 --- /dev/null +++ b/CoreNLP/models/ru/tagger/russian-ud-mfmini.tagger @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c85cdd823a4c7ea7c62af4607b425b6a303f414d992a22c067d6be58f2a231df +size 22430426 diff --git a/CoreNLP/models/ru/tagger/russian-ud-pos.tagger b/CoreNLP/models/ru/tagger/russian-ud-pos.tagger new file mode 100644 index 0000000000000000000000000000000000000000..e7329d18c7561e9116233e6d07b65c43228a138d --- /dev/null +++ b/CoreNLP/models/ru/tagger/russian-ud-pos.tagger @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:57eb9e303d97d9c115b879deaa0ffa6e8b2519c8713bb040e5bd5827c8ee64de +size 9018233 diff --git a/CoreNLP/stanford-postagger-full-2020-11-17/LICENSE.txt b/CoreNLP/stanford-postagger-full-2020-11-17/LICENSE.txt new file mode 100644 index 0000000000000000000000000000000000000000..d159169d1050894d3ea3b98e1c965c4058208fe1 --- /dev/null +++ b/CoreNLP/stanford-postagger-full-2020-11-17/LICENSE.txt @@ -0,0 +1,339 @@ + GNU GENERAL PUBLIC LICENSE + Version 2, June 1991 + + Copyright (C) 1989, 1991 Free Software Foundation, Inc., + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +License is intended to guarantee your freedom to share and change free +software--to make sure the software is free for all its users. This +General Public License applies to most of the Free Software +Foundation's software and to any other program whose authors commit to +using it. (Some other Free Software Foundation software is covered by +the GNU Lesser General Public License instead.) You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +this service if you wish), that you receive source code or can get it +if you want it, that you can change the software or use pieces of it +in new free programs; and that you know you can do these things. + + To protect your rights, we need to make restrictions that forbid +anyone to deny you these rights or to ask you to surrender the rights. +These restrictions translate to certain responsibilities for you if you +distribute copies of the software, or if you modify it. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must give the recipients all the rights that +you have. You must make sure that they, too, receive or can get the +source code. And you must show them these terms so they know their +rights. + + We protect your rights with two steps: (1) copyright the software, and +(2) offer you this license which gives you legal permission to copy, +distribute and/or modify the software. + + Also, for each author's protection and ours, we want to make certain +that everyone understands that there is no warranty for this free +software. If the software is modified by someone else and passed on, we +want its recipients to know that what they have is not the original, so +that any problems introduced by others will not reflect on the original +authors' reputations. + + Finally, any free program is threatened constantly by software +patents. We wish to avoid the danger that redistributors of a free +program will individually obtain patent licenses, in effect making the +program proprietary. To prevent this, we have made it clear that any +patent must be licensed for everyone's free use or not licensed at all. + + The precise terms and conditions for copying, distribution and +modification follow. + + GNU GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License applies to any program or other work which contains +a notice placed by the copyright holder saying it may be distributed +under the terms of this General Public License. The "Program", below, +refers to any such program or work, and a "work based on the Program" +means either the Program or any derivative work under copyright law: +that is to say, a work containing the Program or a portion of it, +either verbatim or with modifications and/or translated into another +language. (Hereinafter, translation is included without limitation in +the term "modification".) Each licensee is addressed as "you". + +Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running the Program is not restricted, and the output from the Program +is covered only if its contents constitute a work based on the +Program (independent of having been made by running the Program). +Whether that is true depends on what the Program does. + + 1. You may copy and distribute verbatim copies of the Program's +source code as you receive it, in any medium, provided that you +conspicuously and appropriately publish on each copy an appropriate +copyright notice and disclaimer of warranty; keep intact all the +notices that refer to this License and to the absence of any warranty; +and give any other recipients of the Program a copy of this License +along with the Program. + +You may charge a fee for the physical act of transferring a copy, and +you may at your option offer warranty protection in exchange for a fee. + + 2. You may modify your copy or copies of the Program or any portion +of it, thus forming a work based on the Program, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) You must cause the modified files to carry prominent notices + stating that you changed the files and the date of any change. + + b) You must cause any work that you distribute or publish, that in + whole or in part contains or is derived from the Program or any + part thereof, to be licensed as a whole at no charge to all third + parties under the terms of this License. + + c) If the modified program normally reads commands interactively + when run, you must cause it, when started running for such + interactive use in the most ordinary way, to print or display an + announcement including an appropriate copyright notice and a + notice that there is no warranty (or else, saying that you provide + a warranty) and that users may redistribute the program under + these conditions, and telling the user how to view a copy of this + License. (Exception: if the Program itself is interactive but + does not normally print such an announcement, your work based on + the Program is not required to print an announcement.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Program, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Program, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Program. + +In addition, mere aggregation of another work not based on the Program +with the Program (or with a work based on the Program) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may copy and distribute the Program (or a work based on it, +under Section 2) in object code or executable form under the terms of +Sections 1 and 2 above provided that you also do one of the following: + + a) Accompany it with the complete corresponding machine-readable + source code, which must be distributed under the terms of Sections + 1 and 2 above on a medium customarily used for software interchange; or, + + b) Accompany it with a written offer, valid for at least three + years, to give any third party, for a charge no more than your + cost of physically performing source distribution, a complete + machine-readable copy of the corresponding source code, to be + distributed under the terms of Sections 1 and 2 above on a medium + customarily used for software interchange; or, + + c) Accompany it with the information you received as to the offer + to distribute corresponding source code. (This alternative is + allowed only for noncommercial distribution and only if you + received the program in object code or executable form with such + an offer, in accord with Subsection b above.) + +The source code for a work means the preferred form of the work for +making modifications to it. For an executable work, complete source +code means all the source code for all modules it contains, plus any +associated interface definition files, plus the scripts used to +control compilation and installation of the executable. However, as a +special exception, the source code distributed need not include +anything that is normally distributed (in either source or binary +form) with the major components (compiler, kernel, and so on) of the +operating system on which the executable runs, unless that component +itself accompanies the executable. + +If distribution of executable or object code is made by offering +access to copy from a designated place, then offering equivalent +access to copy the source code from the same place counts as +distribution of the source code, even though third parties are not +compelled to copy the source along with the object code. + + 4. You may not copy, modify, sublicense, or distribute the Program +except as expressly provided under this License. Any attempt +otherwise to copy, modify, sublicense or distribute the Program is +void, and will automatically terminate your rights under this License. +However, parties who have received copies, or rights, from you under +this License will not have their licenses terminated so long as such +parties remain in full compliance. + + 5. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Program or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Program (or any work based on the +Program), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Program or works based on it. + + 6. Each time you redistribute the Program (or any work based on the +Program), the recipient automatically receives a license from the +original licensor to copy, distribute or modify the Program subject to +these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties to +this License. + + 7. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Program at all. For example, if a patent +license would not permit royalty-free redistribution of the Program by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Program. + +If any portion of this section is held invalid or unenforceable under +any particular circumstance, the balance of the section is intended to +apply and the section as a whole is intended to apply in other +circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system, which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 8. If the distribution and/or use of the Program is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Program under this License +may add an explicit geographical distribution limitation excluding +those countries, so that distribution is permitted only in or among +countries not thus excluded. In such case, this License incorporates +the limitation as if written in the body of this License. + + 9. The Free Software Foundation may publish revised and/or new versions +of the General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + +Each version is given a distinguishing version number. If the Program +specifies a version number of this License which applies to it and "any +later version", you have the option of following the terms and conditions +either of that version or of any later version published by the Free +Software Foundation. If the Program does not specify a version number of +this License, you may choose any version ever published by the Free Software +Foundation. + + 10. If you wish to incorporate parts of the Program into other free +programs whose distribution conditions are different, write to the author +to ask for permission. For software which is copyrighted by the Free +Software Foundation, write to the Free Software Foundation; we sometimes +make exceptions for this. Our decision will be guided by the two goals +of preserving the free status of all derivatives of our free software and +of promoting the sharing and reuse of software generally. + + NO WARRANTY + + 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY +FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN +OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES +PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED +OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS +TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE +PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, +REPAIR OR CORRECTION. + + 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR +REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, +INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING +OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED +TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY +YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER +PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE +POSSIBILITY OF SUCH DAMAGES. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +convey the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License along + with this program; if not, write to the Free Software Foundation, Inc., + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + +Also add information on how to contact you by electronic and paper mail. + +If the program is interactive, make it output a short notice like this +when it starts in an interactive mode: + + Gnomovision version 69, Copyright (C) year name of author + Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, the commands you use may +be called something other than `show w' and `show c'; they could even be +mouse-clicks or menu items--whatever suits your program. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the program, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the program + `Gnomovision' (which makes passes at compilers) written by James Hacker. + + , 1 April 1989 + Ty Coon, President of Vice + +This General Public License does not permit incorporating your program into +proprietary programs. If your program is a subroutine library, you may +consider it more useful to permit linking proprietary applications with the +library. If this is what you want to do, use the GNU Lesser General +Public License instead of this License. diff --git a/CoreNLP/stanford-postagger-full-2020-11-17/README.txt b/CoreNLP/stanford-postagger-full-2020-11-17/README.txt new file mode 100644 index 0000000000000000000000000000000000000000..475117aaaa31c3462c91541a23cb4bbc253da0e7 --- /dev/null +++ b/CoreNLP/stanford-postagger-full-2020-11-17/README.txt @@ -0,0 +1,315 @@ +Stanford POS Tagger, v4.2.0 - 2020-11-17 +Copyright (c) 2002-2020 The Board of Trustees of +The Leland Stanford Junior University. All Rights Reserved. + +Original tagger author: Kristina Toutanova +Code contributions: Christopher Manning, Dan Klein, William Morgan, +Huihsin Tseng, Anna Rafferty, John Bauer +Major rewrite for version 2.0 by Michel Galley. +Current release prepared by: Jason Bolton + +This package contains a Maximum Entropy part of speech tagger. + +A Part-Of-Speech Tagger (POS Tagger) is a piece of software that reads +text in some language and assigns parts of speech to each word (and +other tokens), such as noun, verb, adjective, etc. Generally +computational applications use more fine-grained POS tags like +'noun-plural'. This software is a Java implementation of the log-linear +part-of-speech (POS) taggers described in: + +Kristina Toutanova and Christopher D. Manning. 2000. Enriching the +Knowledge Sources Used in a Maximum Entropy Part-of-Speech +Tagger. Proceedings of the Joint SIGDAT Conference on Empirical Methods +in Natural Language Processing and Very Large Corpora (EMNLP/VLC-2000), +Hong Kong. + +Kristina Toutanova, Dan Klein, Christopher Manning, and Yoram +Singer. 2003. Feature-Rich Part-of-Speech Tagging with a Cyclic +Dependency Network. In Proceedings of HLT-NAACL 2003 pages 252-259. + +The system requires Java 1.8+ to be installed. About 60 MB of memory is +required to run a trained tagger, depending on the OS, tagging model +chosen, etc. (i.e., you may need to give to java an option like java +-mx120m). Plenty of memory is needed to train a tagger. It depends on +the complexity of the model but at least 1GB is recommended (java +-mx1g). Two trained tagger models for English are included with the +tagger, along with some caseless versions, and we provide models for +some other languages. The tagger can be retrained on other languages +based on POS-annotated training text. + + + +QUICKSTART +----------------------------------------------- + +The Stanford POS Tagger is designed to be used from the command line or +programmatically via its API. + +There is a GUI interface, but it is for +demonstration purposes only; most features of the tagger can only be +accessed via the command line. To run the demonstration GUI you should +be able to use any of the following 2 methods: + +1) +java -mx200m -classpath stanford-postagger.jar edu.stanford.nlp.tagger.maxent.MaxentTaggerGUI models/wsj-0-18-left3words-distsim.tagger + +2) Running the appropriate script for your operating system: + stanford-postagger-gui.bat + ./stanford-postagger-gui.sh + +To run the tagger from the command line, you can start with the provided +script appropriate for you operating system: + ./stanford-postagger.sh models/wsj-0-18-left3words-distsim.tagger sample-input.txt + stanford-postagger models\wsj-0-18-left3words-distsim.tagger sample-input.txt +The output should match what is found in sample-output.txt + +The tagger has three modes: tagging, training, and testing. Tagging +allows you to use a pretrained model (two English models are included) +to assign part of speech tags to unlabeled text. Training allows you to +save a new model based on a set of tagged data that you provide. +Testing allows you to see how well a tagger performs by tagging labeled +data and evaluating the results against the correct tags. + +Many options are available for training, tagging, and testing. These +options can be set using a properties file. To start, you can generate a +default properties file by: + +java -classpath stanford-postagger.jar edu.stanford.nlp.tagger.maxent.MaxentTagger -genprops > myPropsFile.prop + +This will create the file myPropsFile.prop with descriptions of each +option for the tagger and the default values for these options +specified. Any properties you can specify in a properties file can be +specified on the command line or vice versa. For further information, +please consult the Javadocs (start with the entry for MaxentTagger, +which includes a table of all options which may be set to configure the +tagger and descriptions of those options). + + +To tag a file using the pre-trained bidirectional model +======================================================= + +java -mx300m -classpath stanford-postagger.jar edu.stanford.nlp.tagger.maxent.MaxentTagger -model models/wsj-0-18-bidirectional-distsim.tagger -textFile sample-input.txt > sample-tagged.txt + +Tagged output will be printed to standard out, which you can redirect +as above. Note that the bidirectional model is slightly more accurate +but significantly slower than the left3words model. + +To train a simple model +======================= + +java -classpath stanford-postagger.jar edu.stanford.nlp.tagger.maxent.MaxentTagger -prop propertiesFile -model modelFile -trainFile trainingFile + +To test a model +=============== + +java -classpath stanford-postagger.jar edu.stanford.nlp.tagger.maxent.MaxentTagger -prop propertiesFile -model modelFile -testFile testFile + +Using models for French, German, and Spanish +=========================================== + +Starting with version 4.0.0, French, German, and Spanish are tokenized according to the UD 2.0 standard. This includes creating +multiword tokens. This functionality requires the pipeline functionality only available in the full Stanford CoreNLP distribution. +To tag French, German, or Spanish, one must provide UD 2.0 tokenized text, or upgrade to the full Stanford CoreNLP package to get +UD 2.0 tokenization for these languages. + +To run on pretokenized text, add "-tokenize false" to your command. + +Example: + +java -mx300m -classpath stanford-postagger.jar edu.stanford.nlp.tagger.maxent.MaxentTagger -model models/french-ud.tagger -tokenize false -textFile sample-input.txt > sample-tagged.txt + +CONTENTS +----------------------------------------------- +README.txt + + This file. + +LICENSE.txt + + Stanford POS Tagger is licensed under the GNU General Public License (v2+). + +stanford-postagger.jar +stanford-postagger-YYYY-MM-DD.jar + + This is a JAR file containing all the Stanford classes necessary to + run the Stanford POS Tagger. The two jar files are identical. You can use + either the one with a version (date) indication or without, as you prefer. + +src + + A directory containing the Java 1.8 source code for the Stanford POS + Tagger distribution. + +build.xml, Makefile + + Files for building the distribution (with ant and make, respectively) + +models + + A directory containing trained POS taggers; the taggers end in ".tagger" + and the props file used to make the taggers end in ".props". The + ".props" files cannot be directly used on your own machine as they use + paths on the Stanford NLP machines, but they may serve as examples for + your own properties files. Included in the full version are other + English taggers, a German tagger, an Arabic tagger, and a Chinese + tagger. If you chose to download the smaller version of the tagger, + you have only two English taggers (left3words is faster but slightly + less accurate than bidirectional-distsim) - feel free to download any + other taggers you need from the POS tagger website. More information + about the models can be found in the README-Models.txt file in this + directory. + +sample-input.txt + + A sample text file that you can tag to demonstrate the tagger. + +sample-output.txt + + Tagged output of the tagger (using the left3words model) + +stanford-postagger-gui.sh +stanford-postagger-gui.bat + + Scripts for invoking the GUI demonstration version of the tagger. + +stanford-postagger.sh +stanford-postagger.bat + + Scripts for running the command-line version of the tagger. + +javadoc + + Javadocs for the distribution. In particular, look at the javadocs + for the class edu.stanford.nlp.tagger.maxent.MaxentTagger. + +TaggerDemo.java + + A sample file for how to call the tagger in your own program. You + should be able to compile and run it with: + + javac -cp stanford-postagger.jar TaggerDemo.java + java -cp ".:stanford-postagger.jar" TaggerDemo models/wsj-0-18-left3words-distsim.tagger sample-input.txt + + (If you are on Windows, you need to replace the ":" with a ";" in the + -cp argument, and should use a "\" in place of the "/" in the filename....) + +THANKS +----------------------------------------------- + +Thanks to the members of the Stanford Natural Language Processing Lab +for great collaborative work on Java libraries for natural language +processing. + + http://nlp.stanford.edu/javanlp/ + +CHANGES +----------------------------------------------- + +2020-11-17 4.2.0 Add currency data for English models. + +2020-08-06 4.1.0 Add missing extractor, spanish tokenization + upgrades + +2020-05-22 4.0.0 Model tokenization updated to UDv2.0 + +2018-10-16 3.9.2 New English models, better currency symbol + handling + +2018-02-27 3.9.1 new French UD model + +2017-06-09 3.8.0 new Spanish and French UD models + +2016-10-31 3.7.0 Update for compatibility, German UD model + +2015-12-09 3.6.0 Updated for compatibility + +2015-04-20 3.5.2 Update for compatibility + +2015-01-29 3.5.1 General bugfixes + +2014-10-26 3.5.0 Upgrade to Java 1.8 + +2014-08-27 3.4.1 Add Spanish models + +2014-06-16 3.4 Using CC tagset for French + +2014-01-04 3.3.1 Bugfix release + +2013-11-12 3.3.0 Add imperatives to English training data + +2013-06-19 3.2.0 Decrease size and improve speed of tagger + models for all languages + +2013-04-04 3.1.5 Speed improvements, ctb7 model, -nthreads + option + +2012-11-11 3.1.4 Updated Chinese model + +2012-07-09 3.1.3 Minor bug fixes + +2012-05-22 3.1.2 Updated for compatibility with other releases + +2012-03-09 3.1.1 Caseless models added + +2012-01-06 3.1.0 French tagger added, tagging speed improved + +2011-09-14 3.0.4 Updated for compatibility with other releases + +2011-06-15 3.0.3 Updated for compatibility with other releases + +2011-05-15 3.0.2 Can read training files in TSV format + +2011-04-17 3.0.1 Improved German and Arabic models + Compatible with other Stanford releases + +2010-05-21 3.0.0 Re-entrant + +LICENSE +----------------------------------------------- + + Stanford POS Tagger + Copyright (c) 2002-2010 The Board of Trustees of + The Leland Stanford Junior University. All Rights Reserved. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License + as published by the Free Software Foundation; either version 2 + of the License, or (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see http://www.gnu.org/licenses/ . + + For more information, bug reports, fixes, contact: + Christopher Manning + Dept of Computer Science, Gates 2A + Stanford CA 94305-9020 + USA + Support/Questions: java-nlp-user@lists.stanford.edu + Licensing: java-nlp-support@lists.stanford.edu + http://nlp.stanford.edu/software/tagger.html + + +CONTACT +----------------------------------------------- + +For questions about the Stanford POS tagger, please feel free to contact +the Stanford JavaNLP user community at the mailing list +java-nlp-user@lists.stanford.edu. You need to be a member of this +mailing list to be able to post to it. Join the list either by emailing +java-nlp-user-join@lists.stanford.edu (leave the subject and message +body empty) or by using the web interface at: + + https://mailman.stanford.edu/mailman/listinfo/java-nlp-user + +This is the best list to post to in order to ask questions, make +announcements, or for discussion among Stanford JavaNLP tool users. We +provide assistance on a best-effort basis. You can also look at the list +archives via https://mailman.stanford.edu/pipermail/java-nlp-user/. For +licensing questions, please see the tagger webpage or contact Stanford +JavaNLP at java-nlp-support@lists.stanford.edu. + diff --git a/CoreNLP/stanford-postagger-full-2020-11-17/TaggerDemo.java b/CoreNLP/stanford-postagger-full-2020-11-17/TaggerDemo.java new file mode 100644 index 0000000000000000000000000000000000000000..f22c2c8878b5302460eadbeefe972bb73fa3a8ab --- /dev/null +++ b/CoreNLP/stanford-postagger-full-2020-11-17/TaggerDemo.java @@ -0,0 +1,32 @@ +import edu.stanford.nlp.util.logging.Redwood; + +import java.io.BufferedReader; +import java.io.FileReader; +import java.util.List; + +import edu.stanford.nlp.ling.SentenceUtils; +import edu.stanford.nlp.ling.TaggedWord; +import edu.stanford.nlp.ling.HasWord; +import edu.stanford.nlp.tagger.maxent.MaxentTagger; + +public class TaggerDemo { + + /** A logger for this class */ + private static Redwood.RedwoodChannels log = Redwood.channels(TaggerDemo.class); + + private TaggerDemo() {} + + public static void main(String[] args) throws Exception { + if (args.length != 2) { + log.info("usage: java TaggerDemo modelFile fileToTag"); + return; + } + MaxentTagger tagger = new MaxentTagger(args[0]); + List> sentences = MaxentTagger.tokenizeText(new BufferedReader(new FileReader(args[1]))); + for (List sentence : sentences) { + List tSentence = tagger.tagSentence(sentence); + System.out.println(SentenceUtils.listToString(tSentence, false)); + } + } + +} diff --git a/CoreNLP/stanford-postagger-full-2020-11-17/TaggerDemo2.java b/CoreNLP/stanford-postagger-full-2020-11-17/TaggerDemo2.java new file mode 100644 index 0000000000000000000000000000000000000000..13f40d71dfa1e4ebe0689c6e0eba0f8fee76bfcf --- /dev/null +++ b/CoreNLP/stanford-postagger-full-2020-11-17/TaggerDemo2.java @@ -0,0 +1,62 @@ +import edu.stanford.nlp.util.logging.Redwood; + +import java.io.BufferedReader; +import java.io.FileInputStream; +import java.io.InputStreamReader; +import java.io.OutputStreamWriter; +import java.io.PrintWriter; +import java.util.List; + +import edu.stanford.nlp.ling.SentenceUtils; +import edu.stanford.nlp.ling.TaggedWord; +import edu.stanford.nlp.ling.HasWord; +import edu.stanford.nlp.ling.CoreLabel; +import edu.stanford.nlp.process.CoreLabelTokenFactory; +import edu.stanford.nlp.process.DocumentPreprocessor; +import edu.stanford.nlp.process.PTBTokenizer; +import edu.stanford.nlp.process.TokenizerFactory; +import edu.stanford.nlp.tagger.maxent.MaxentTagger; + +/** This demo shows user-provided sentences (i.e., {@code List}) + * being tagged by the tagger. The sentences are generated by direct use + * of the DocumentPreprocessor class. + * + * @author Christopher Manning + */ +public class TaggerDemo2 { + + /** A logger for this class */ + private static Redwood.RedwoodChannels log = Redwood.channels(TaggerDemo2.class); + + private TaggerDemo2() {} + + public static void main(String[] args) throws Exception { + if (args.length != 2) { + log.info("usage: java TaggerDemo2 modelFile fileToTag"); + return; + } + MaxentTagger tagger = new MaxentTagger(args[0]); + TokenizerFactory ptbTokenizerFactory = PTBTokenizer.factory(new CoreLabelTokenFactory(), + "untokenizable=noneKeep"); + BufferedReader r = new BufferedReader(new InputStreamReader(new FileInputStream(args[1]), "utf-8")); + PrintWriter pw = new PrintWriter(new OutputStreamWriter(System.out, "utf-8")); + DocumentPreprocessor documentPreprocessor = new DocumentPreprocessor(r); + documentPreprocessor.setTokenizerFactory(ptbTokenizerFactory); + for (List sentence : documentPreprocessor) { + List tSentence = tagger.tagSentence(sentence); + pw.println(SentenceUtils.listToString(tSentence, false)); + } + + // print the adjectives in one more sentence. This shows how to get at words and tags in a tagged sentence. + List sent = SentenceUtils.toWordList("The", "slimy", "slug", "crawled", "over", "the", "long", ",", "green", "grass", "."); + List taggedSent = tagger.tagSentence(sent); + for (TaggedWord tw : taggedSent) { + if (tw.tag().startsWith("JJ")) { + pw.println(tw.word()); + } + } + + pw.close(); + } + +} diff --git a/CoreNLP/stanford-postagger-full-2020-11-17/build.xml b/CoreNLP/stanford-postagger-full-2020-11-17/build.xml new file mode 100644 index 0000000000000000000000000000000000000000..7ac4873546357e3eb88614ac470ebeb169639934 --- /dev/null +++ b/CoreNLP/stanford-postagger-full-2020-11-17/build.xml @@ -0,0 +1,201 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Stanford NLP Group]]> + + + + + + + + + + + + + + + + + + diff --git a/CoreNLP/stanford-postagger-full-2020-11-17/data/enclitic-inflections.data b/CoreNLP/stanford-postagger-full-2020-11-17/data/enclitic-inflections.data new file mode 100644 index 0000000000000000000000000000000000000000..4bc3819e6f90be2c2df2ddbb6f5abcfa97c6a9eb --- /dev/null +++ b/CoreNLP/stanford-postagger-full-2020-11-17/data/enclitic-inflections.data @@ -0,0 +1,53451 @@ +aba abar VMM02S0 +abad abar VMM02P0 +abaja abajar VMM02S0 +abajad abajar VMM02P0 +abajando abajar VMG0000 +abajar abajar VMN0000 +abaje abajar VMM03S0 +abajemos abajar VMM01P0 +abajen abajar VMM03P0 +abalance abalanzar VMM03S0 +abalancemos abalanzar VMM01P0 +abalancen abalanzar VMM03P0 +abalanza abalanzar VMM02S0 +abalanzad abalanzar VMM02P0 +abalanzando abalanzar VMG0000 +abalanzar abalanzar VMN0000 +abalaustra abalaustrar VMM02S0 +abalaustrad abalaustrar VMM02P0 +abalaustrando abalaustrar VMG0000 +abalaustrar abalaustrar VMN0000 +abalaustre abalaustrar VMM03S0 +abalaustremos abalaustrar VMM01P0 +abalaustren abalaustrar VMM03P0 +abalea abalear VMM02S0 +abalead abalear VMM02P0 +abaleando abalear VMG0000 +abalear abalear VMN0000 +abalee abalear VMM03S0 +abaleemos abalear VMM01P0 +abaleen abalear VMM03P0 +abalice abalizar VMM03S0 +abalicemos abalizar VMM01P0 +abalicen abalizar VMM03P0 +abaliza abalizar VMM02S0 +abalizad abalizar VMM02P0 +abalizando abalizar VMG0000 +abalizar abalizar VMN0000 +aballa aballar VMM02S0 +aballad aballar VMM02P0 +aballando aballar VMG0000 +aballar aballar VMN0000 +aballe aballar VMM03S0 +aballemos aballar VMM01P0 +aballen aballar VMM03P0 +aballesta aballestar VMM02S0 +aballestad aballestar VMM02P0 +aballestando aballestar VMG0000 +aballestar aballestar VMN0000 +aballeste aballestar VMM03S0 +aballestemos aballestar VMM01P0 +aballesten aballestar VMM03P0 +abaluarta abaluartar VMM02S0 +abaluartad abaluartar VMM02P0 +abaluartando abaluartar VMG0000 +abaluartar abaluartar VMN0000 +abaluarte abaluartar VMM03S0 +abaluartemos abaluartar VMM01P0 +abaluarten abaluartar VMM03P0 +abana abanar VMM02S0 +abanad abanar VMM02P0 +abanando abanar VMG0000 +abanar abanar VMN0000 +abandalice abandalizar VMM03S0 +abandalicemos abandalizar VMM01P0 +abandalicen abandalizar VMM03P0 +abandaliza abandalizar VMM02S0 +abandalizad abandalizar VMM02P0 +abandalizando abandalizar VMG0000 +abandalizar abandalizar VMN0000 +abandera abanderar VMM02S0 +abanderad abanderar VMM02P0 +abanderando abanderar VMG0000 +abanderar abanderar VMN0000 +abandere abanderar VMM03S0 +abanderemos abanderar VMM01P0 +abanderen abanderar VMM03P0 +abanderice abanderizar VMM03S0 +abandericemos abanderizar VMM01P0 +abandericen abanderizar VMM03P0 +abanderiza abanderizar VMM02S0 +abanderizad abanderizar VMM02P0 +abanderizando abanderizar VMG0000 +abanderizar abanderizar VMN0000 +abando abar VMG0000 +abandona abandonar VMM02S0 +abandonad abandonar VMM02P0 +abandonando abandonar VMG0000 +abandonar abandonar VMN0000 +abandone abandonar VMM03S0 +abandonemos abandonar VMM01P0 +abandonen abandonar VMM03P0 +abane abanar VMM03S0 +abanemos abanar VMM01P0 +abanen abanar VMM03P0 +abanica abanicar VMM02S0 +abanicad abanicar VMM02P0 +abanicando abanicar VMG0000 +abanicar abanicar VMN0000 +abanique abanicar VMM03S0 +abaniquemos abanicar VMM01P0 +abaniquen abanicar VMM03P0 +abarata abaratar VMM02S0 +abaratad abaratar VMM02P0 +abaratando abaratar VMG0000 +abaratar abaratar VMN0000 +abarate abaratar VMM03S0 +abaratemos abaratar VMM01P0 +abaraten abaratar VMM03P0 +abarbecha abarbechar VMM02S0 +abarbechad abarbechar VMM02P0 +abarbechando abarbechar VMG0000 +abarbechar abarbechar VMN0000 +abarbeche abarbechar VMM03S0 +abarbechemos abarbechar VMM01P0 +abarbechen abarbechar VMM03P0 +abarbeta abarbetar VMM02S0 +abarbetad abarbetar VMM02P0 +abarbetando abarbetar VMG0000 +abarbetar abarbetar VMN0000 +abarbete abarbetar VMM03S0 +abarbetemos abarbetar VMM01P0 +abarbeten abarbetar VMM03P0 +abarca abarcar VMM02S0 +abarcad abarcar VMM02P0 +abarcando abarcar VMG0000 +abarcar abarcar VMN0000 +abarloa abarloar VMM02S0 +abarload abarloar VMM02P0 +abarloando abarloar VMG0000 +abarloar abarloar VMN0000 +abarloe abarloar VMM03S0 +abarloemos abarloar VMM01P0 +abarloen abarloar VMM03P0 +abarque abarcar VMM03S0 +abarquemos abarcar VMM01P0 +abarquen abarcar VMM03P0 +abarquilla abarquillar VMM02S0 +abarquillad abarquillar VMM02P0 +abarquillando abarquillar VMG0000 +abarquillar abarquillar VMN0000 +abarquille abarquillar VMM03S0 +abarquillemos abarquillar VMM01P0 +abarquillen abarquillar VMM03P0 +abarraca abarracar VMM02S0 +abarracad abarracar VMM02P0 +abarracando abarracar VMG0000 +abarracar abarracar VMN0000 +abarragana abarraganar VMM02S0 +abarraganad abarraganar VMM02P0 +abarraganando abarraganar VMG0000 +abarraganar abarraganar VMN0000 +abarragane abarraganar VMM03S0 +abarraganemos abarraganar VMM01P0 +abarraganen abarraganar VMM03P0 +abarraja abarrajar VMM02S0 +abarrajad abarrajar VMM02P0 +abarrajando abarrajar VMG0000 +abarrajar abarrajar VMN0000 +abarraje abarrajar VMM03S0 +abarrajemos abarrajar VMM01P0 +abarrajen abarrajar VMM03P0 +abarranca abarrancar VMM02S0 +abarrancad abarrancar VMM02P0 +abarrancando abarrancar VMG0000 +abarrancar abarrancar VMN0000 +abarranque abarrancar VMM03S0 +abarranquemos abarrancar VMM01P0 +abarranquen abarrancar VMM03P0 +abarraque abarracar VMM03S0 +abarraquemos abarracar VMM01P0 +abarraquen abarracar VMM03P0 +abarrota abarrotar VMM02S0 +abarrotad abarrotar VMM02P0 +abarrotando abarrotar VMG0000 +abarrotar abarrotar VMN0000 +abarrote abarrotar VMM03S0 +abarrotemos abarrotar VMM01P0 +abarroten abarrotar VMM03P0 +abasta abastar VMM02S0 +abastad abastar VMM02P0 +abastando abastar VMG0000 +abastar abastar VMN0000 +abaste abastar VMM03S0 +abastece abastecer VMM02S0 +abasteced abastecer VMM02P0 +abastecer abastecer VMN0000 +abasteciendo abastecer VMG0000 +abastemos abastar VMM01P0 +abasten abastar VMM03P0 +abastezca abastecer VMM03S0 +abastezcamos abastecer VMM01P0 +abastezcan abastecer VMM03P0 +abastiona abastionar VMM02S0 +abastionad abastionar VMM02P0 +abastionando abastionar VMG0000 +abastionar abastionar VMN0000 +abastione abastionar VMM03S0 +abastionemos abastionar VMM01P0 +abastionen abastionar VMM03P0 +abata abatir VMM03S0 +abatamos abatir VMM01P0 +abatan abatir VMM03P0 +abatana abatanar VMM02S0 +abatanad abatanar VMM02P0 +abatanando abatanar VMG0000 +abatanar abatanar VMN0000 +abatane abatanar VMM03S0 +abatanemos abatanar VMM01P0 +abatanen abatanar VMM03P0 +abatata abatatar VMM02S0 +abatatad abatatar VMM02P0 +abatatando abatatar VMG0000 +abatatar abatatar VMN0000 +abatate abatatar VMM03S0 +abatatemos abatatar VMM01P0 +abataten abatatar VMM03P0 +abate abatir VMM02S0 +abatid abatir VMM02P0 +abatiendo abatir VMG0000 +abatir abatir VMN0000 +abatoja abatojar VMM02S0 +abatojad abatojar VMM02P0 +abatojando abatojar VMG0000 +abatojar abatojar VMN0000 +abaña abañar VMM02S0 +abañad abañar VMM02P0 +abañando abañar VMG0000 +abañar abañar VMN0000 +abañe abañar VMM03S0 +abañemos abañar VMM01P0 +abañen abañar VMM03P0 +abdica abdicar VMM02S0 +abdicad abdicar VMM02P0 +abdicando abdicar VMG0000 +abdicar abdicar VMN0000 +abdique abdicar VMM03S0 +abdiquemos abdicar VMM01P0 +abdiquen abdicar VMM03P0 +abellaca abellacar VMM02S0 +abellacad abellacar VMM02P0 +abellacando abellacar VMG0000 +abellacar abellacar VMN0000 +abellaque abellacar VMM03S0 +abellaquemos abellacar VMM01P0 +abellaquen abellacar VMM03P0 +abemola abemolar VMM02S0 +abemolad abemolar VMM02P0 +abemolando abemolar VMG0000 +abemolar abemolar VMN0000 +abemole abemolar VMM03S0 +abemolemos abemolar VMM01P0 +abemolen abemolar VMM03P0 +aberrad aberrar VMM02P0 +aberrando aberrar VMG0000 +aberrar aberrar VMN0000 +aberremos aberrar VMM01P0 +abetuna abetunar VMM02S0 +abetunad abetunar VMM02P0 +abetunando abetunar VMG0000 +abetunar abetunar VMN0000 +abetune abetunar VMM03S0 +abetunemos abetunar VMM01P0 +abetunen abetunar VMM03P0 +abierra aberrar VMM02S0 +abierre aberrar VMM03S0 +abierren aberrar VMM03P0 +abigarra abigarrar VMM02S0 +abigarrad abigarrar VMM02P0 +abigarrando abigarrar VMG0000 +abigarrar abigarrar VMN0000 +abigarre abigarrar VMM03S0 +abigarremos abigarrar VMM01P0 +abigarren abigarrar VMM03P0 +abisma abismar VMM02S0 +abismad abismar VMM02P0 +abismando abismar VMG0000 +abismar abismar VMN0000 +abisme abismar VMM03S0 +abismemos abismar VMM01P0 +abismen abismar VMM03P0 +abita abitar VMM02S0 +abitad abitar VMM02P0 +abitando abitar VMG0000 +abitar abitar VMN0000 +abite abitar VMM03S0 +abitemos abitar VMM01P0 +abiten abitar VMM03P0 +abjura abjurar VMM02S0 +abjurad abjurar VMM02P0 +abjurando abjurar VMG0000 +abjurar abjurar VMN0000 +abjure abjurar VMM03S0 +abjuremos abjurar VMM01P0 +abjuren abjurar VMM03P0 +ablanda ablandar VMM02S0 +ablandad ablandar VMM02P0 +ablandando ablandar VMG0000 +ablandar ablandar VMN0000 +ablande ablandar VMM03S0 +ablandece ablandecer VMM02S0 +ablandeced ablandecer VMM02P0 +ablandecer ablandecer VMN0000 +ablandeciendo ablandecer VMG0000 +ablandemos ablandar VMM01P0 +ablanden ablandar VMM03P0 +ablandezca ablandecer VMM03S0 +ablandezcamos ablandecer VMM01P0 +ablandezcan ablandecer VMM03P0 +aboba abobar VMM02S0 +abobad abobar VMM02P0 +abobando abobar VMG0000 +abobar abobar VMN0000 +abobe abobar VMM03S0 +abobemos abobar VMM01P0 +aboben abobar VMM03P0 +aboca abocar VMM02S0 +abocad abocar VMM02P0 +abocadea abocadear VMM02S0 +abocadead abocadear VMM02P0 +abocadeando abocadear VMG0000 +abocadear abocadear VMN0000 +abocadee abocadear VMM03S0 +abocadeemos abocadear VMM01P0 +abocadeen abocadear VMM03P0 +abocando abocar VMG0000 +abocar abocar VMN0000 +abocarda abocardar VMM02S0 +abocardad abocardar VMM02P0 +abocardando abocardar VMG0000 +abocardar abocardar VMN0000 +abocarde abocardar VMM03S0 +abocardemos abocardar VMM01P0 +abocarden abocardar VMM03P0 +aboceta abocetar VMM02S0 +abocetad abocetar VMM02P0 +abocetando abocetar VMG0000 +abocetar abocetar VMN0000 +abocete abocetar VMM03S0 +abocetemos abocetar VMM01P0 +aboceten abocetar VMM03P0 +abochorna abochornar VMM02S0 +abochornad abochornar VMM02P0 +abochornando abochornar VMG0000 +abochornar abochornar VMN0000 +abochorne abochornar VMM03S0 +abochornemos abochornar VMM01P0 +abochornen abochornar VMM03P0 +abocina abocinar VMM02S0 +abocinad abocinar VMM02P0 +abocinando abocinar VMG0000 +abocinar abocinar VMN0000 +abocine abocinar VMM03S0 +abocinemos abocinar VMM01P0 +abocinen abocinar VMM03P0 +abofetea abofetear VMM02S0 +abofetead abofetear VMM02P0 +abofeteando abofetear VMG0000 +abofetear abofetear VMN0000 +abofetee abofetear VMM03S0 +abofeteemos abofetear VMM01P0 +abofeteen abofetear VMM03P0 +aboga abogar VMM02S0 +abogad abogar VMM02P0 +abogando abogar VMG0000 +abogar abogar VMN0000 +abogue abogar VMM03S0 +aboguemos abogar VMM01P0 +aboguen abogar VMM03P0 +abolid abolir VMM02P0 +aboliendo abolir VMG0000 +abolir abolir VMN0000 +abolla abollar VMM02S0 +abollad abollar VMM02P0 +abollando abollar VMG0000 +abollar abollar VMN0000 +abolle abollar VMM03S0 +abollemos abollar VMM01P0 +abollen abollar VMM03P0 +abollona abollonar VMM02S0 +abollonad abollonar VMM02P0 +abollonando abollonar VMG0000 +abollonar abollonar VMN0000 +abollone abollonar VMM03S0 +abollonemos abollonar VMM01P0 +abollonen abollonar VMM03P0 +abolsa abolsar VMM02S0 +abolsad abolsar VMM02P0 +abolsando abolsar VMG0000 +abolsar abolsar VMN0000 +abolse abolsar VMM03S0 +abolsemos abolsar VMM01P0 +abolsen abolsar VMM03P0 +abomba abombar VMM02S0 +abombad abombar VMM02P0 +abombando abombar VMG0000 +abombar abombar VMN0000 +abombe abombar VMM03S0 +abombemos abombar VMM01P0 +abomben abombar VMM03P0 +abomina abominar VMM02S0 +abominad abominar VMM02P0 +abominando abominar VMG0000 +abominar abominar VMN0000 +abomine abominar VMM03S0 +abominemos abominar VMM01P0 +abominen abominar VMM03P0 +abona abonar VMM02S0 +abonad abonar VMM02P0 +abonance abonanzar VMM03S0 +abonancemos abonanzar VMM01P0 +abonancen abonanzar VMM03P0 +abonando abonar VMG0000 +abonanza abonanzar VMM02S0 +abonanzad abonanzar VMM02P0 +abonanzando abonanzar VMG0000 +abonanzar abonanzar VMN0000 +abonar abonar VMN0000 +abone abonar VMM03S0 +abonemos abonar VMM01P0 +abonen abonar VMM03P0 +aboque abocar VMM03S0 +aboquemos abocar VMM01P0 +aboquen abocar VMM03P0 +aboquilla aboquillar VMM02S0 +aboquillad aboquillar VMM02P0 +aboquillando aboquillar VMG0000 +aboquillar aboquillar VMN0000 +aboquille aboquillar VMM03S0 +aboquillemos aboquillar VMM01P0 +aboquillen aboquillar VMM03P0 +aborda abordar VMM02S0 +abordad abordar VMM02P0 +abordando abordar VMG0000 +abordar abordar VMN0000 +aborde abordar VMM03S0 +abordemos abordar VMM01P0 +aborden abordar VMM03P0 +aborraja aborrajar VMM02S0 +aborrajad aborrajar VMM02P0 +aborrajando aborrajar VMG0000 +aborrajar aborrajar VMN0000 +aborraje aborrajar VMM03S0 +aborrajemos aborrajar VMM01P0 +aborrajen aborrajar VMM03P0 +aborrasca aborrascar VMM02S0 +aborrascad aborrascar VMM02P0 +aborrascando aborrascar VMG0000 +aborrascar aborrascar VMN0000 +aborrasque aborrascar VMM03S0 +aborrasquemos aborrascar VMM01P0 +aborrasquen aborrascar VMM03P0 +aborrece aborrecer VMM02S0 +aborreced aborrecer VMM02P0 +aborrecer aborrecer VMN0000 +aborreciendo aborrecer VMG0000 +aborrega aborregar VMM02S0 +aborregad aborregar VMM02P0 +aborregando aborregar VMG0000 +aborregar aborregar VMN0000 +aborregue aborregar VMM03S0 +aborreguemos aborregar VMM01P0 +aborreguen aborregar VMM03P0 +aborrezca aborrecer VMM03S0 +aborrezcamos aborrecer VMM01P0 +aborrezcan aborrecer VMM03P0 +aborta abortar VMM02S0 +abortad abortar VMM02P0 +abortando abortar VMG0000 +abortar abortar VMN0000 +aborte abortar VMM03S0 +abortemos abortar VMM01P0 +aborten abortar VMM03P0 +aboruja aborujar VMM02S0 +aborujad aborujar VMM02P0 +aborujando aborujar VMG0000 +aborujar aborujar VMN0000 +aboruje aborujar VMM03S0 +aborujemos aborujar VMM01P0 +aborujen aborujar VMM03P0 +abotaga abotagar VMM02S0 +abotagad abotagar VMM02P0 +abotagando abotagar VMG0000 +abotagar abotagar VMN0000 +abotague abotagar VMM03S0 +abotaguemos abotagar VMM01P0 +abotaguen abotagar VMM03P0 +abotarga abotargar VMM02S0 +abotargad abotargar VMM02P0 +abotargando abotargar VMG0000 +abotargar abotargar VMN0000 +abotargue abotargar VMM03S0 +abotarguemos abotargar VMM01P0 +abotarguen abotargar VMM03P0 +abotona abotonar VMM02S0 +abotonad abotonar VMM02P0 +abotonando abotonar VMG0000 +abotonar abotonar VMN0000 +abotone abotonar VMM03S0 +abotonemos abotonar VMM01P0 +abotonen abotonar VMM03P0 +aboveda abovedar VMM02S0 +abovedad abovedar VMM02P0 +abovedando abovedar VMG0000 +abovedar abovedar VMN0000 +abovede abovedar VMM03S0 +abovedemos abovedar VMM01P0 +aboveden abovedar VMM03P0 +aboya aboyar VMM02S0 +aboyad aboyar VMM02P0 +aboyando aboyar VMG0000 +aboyar aboyar VMN0000 +aboye aboyar VMM03S0 +aboyemos aboyar VMM01P0 +aboyen aboyar VMM03P0 +abozala abozalar VMM02S0 +abozalad abozalar VMM02P0 +abozalando abozalar VMG0000 +abozalar abozalar VMN0000 +abozale abozalar VMM03S0 +abozalemos abozalar VMM01P0 +abozalen abozalar VMM03P0 +abra abrir VMM03S0 +abrace abrazar VMM03S0 +abracemos abrazar VMM01P0 +abracen abrazar VMM03P0 +abramos abrir VMM01P0 +abran abrir VMM03P0 +abrasa abrasar VMM02S0 +abrasad abrasar VMM02P0 +abrasando abrasar VMG0000 +abrasar abrasar VMN0000 +abrase abrasar VMM03S0 +abrasemos abrasar VMM01P0 +abrasen abrasar VMM03P0 +abraza abrazar VMM02S0 +abrazad abrazar VMM02P0 +abrazando abrazar VMG0000 +abrazar abrazar VMN0000 +abre abrir VMM02S0 +abreva abrevar VMM02S0 +abrevad abrevar VMM02P0 +abrevando abrevar VMG0000 +abrevar abrevar VMN0000 +abreve abrevar VMM03S0 +abrevemos abrevar VMM01P0 +abreven abrevar VMM03P0 +abrevia abreviar VMM02S0 +abreviad abreviar VMM02P0 +abreviando abreviar VMG0000 +abreviar abreviar VMN0000 +abrevie abreviar VMM03S0 +abreviemos abreviar VMM01P0 +abrevien abreviar VMM03P0 +abribona abribonar VMM02S0 +abribonad abribonar VMM02P0 +abribonando abribonar VMG0000 +abribonar abribonar VMN0000 +abribone abribonar VMM03S0 +abribonemos abribonar VMM01P0 +abribonen abribonar VMM03P0 +abrid abrir VMM02P0 +abriendo abrir VMG0000 +abriga abrigar VMM02S0 +abrigad abrigar VMM02P0 +abrigando abrigar VMG0000 +abrigar abrigar VMN0000 +abrigue abrigar VMM03S0 +abriguemos abrigar VMM01P0 +abriguen abrigar VMM03P0 +abrillanta abrillantar VMM02S0 +abrillantad abrillantar VMM02P0 +abrillantando abrillantar VMG0000 +abrillantar abrillantar VMN0000 +abrillante abrillantar VMM03S0 +abrillantemos abrillantar VMM01P0 +abrillanten abrillantar VMM03P0 +abrir abrir VMN0000 +abroca abrocar VMM02S0 +abrocad abrocar VMM02P0 +abrocando abrocar VMG0000 +abrocar abrocar VMN0000 +abrocha abrochar VMM02S0 +abrochad abrochar VMM02P0 +abrochando abrochar VMG0000 +abrochar abrochar VMN0000 +abroche abrochar VMM03S0 +abrochemos abrochar VMM01P0 +abrochen abrochar VMM03P0 +abroga abrogar VMM02S0 +abrogad abrogar VMM02P0 +abrogando abrogar VMG0000 +abrogar abrogar VMN0000 +abrogue abrogar VMM03S0 +abroguemos abrogar VMM01P0 +abroguen abrogar VMM03P0 +abroma abromar VMM02S0 +abromad abromar VMM02P0 +abromando abromar VMG0000 +abromar abromar VMN0000 +abrome abromar VMM03S0 +abromemos abromar VMM01P0 +abromen abromar VMM03P0 +abronca abroncar VMM02S0 +abroncad abroncar VMM02P0 +abroncando abroncar VMG0000 +abroncar abroncar VMN0000 +abronque abroncar VMM03S0 +abronquemos abroncar VMM01P0 +abronquen abroncar VMM03P0 +abroquela abroquelar VMM02S0 +abroquelad abroquelar VMM02P0 +abroquelando abroquelar VMG0000 +abroquelar abroquelar VMN0000 +abroquele abroquelar VMM03S0 +abroquelemos abroquelar VMM01P0 +abroquelen abroquelar VMM03P0 +abrotoña abrotoñar VMM02S0 +abrotoñad abrotoñar VMM02P0 +abrotoñando abrotoñar VMG0000 +abrotoñar abrotoñar VMN0000 +abrotoñe abrotoñar VMM03S0 +abrotoñemos abrotoñar VMM01P0 +abrotoñen abrotoñar VMM03P0 +abruma abrumar VMM02S0 +abrumad abrumar VMM02P0 +abrumando abrumar VMG0000 +abrumar abrumar VMN0000 +abrume abrumar VMM03S0 +abrumemos abrumar VMM01P0 +abrumen abrumar VMM03P0 +absolvamos absolver VMM01P0 +absolved absolver VMM02P0 +absolver absolver VMN0000 +absolviendo absolver VMG0000 +absorba absorber VMM03S0 +absorbamos absorber VMM01P0 +absorban absorber VMM03P0 +absorbe absorber VMM02S0 +absorbed absorber VMM02P0 +absorber absorber VMN0000 +absorbiendo absorber VMG0000 +absorta absortar VMM02S0 +absortad absortar VMM02P0 +absortando absortar VMG0000 +absortar absortar VMN0000 +absorte absortar VMM03S0 +absortemos absortar VMM01P0 +absorten absortar VMM03P0 +abstened abstener VMM02P0 +abstener abstener VMN0000 +abstenga abstener VMM03S0 +abstengamos abstener VMM01P0 +abstengan abstener VMM03P0 +absteniendo abstener VMG0000 +absterge absterger VMM02S0 +absterged absterger VMM02P0 +absterger absterger VMN0000 +abstergiendo absterger VMG0000 +absterja absterger VMM03S0 +absterjamos absterger VMM01P0 +absterjan absterger VMM03P0 +abstrae abstraer VMM02S0 +abstraed abstraer VMM02P0 +abstraer abstraer VMN0000 +abstraiga abstraer VMM03S0 +abstraigamos abstraer VMM01P0 +abstraigan abstraer VMM03P0 +abstrayendo abstraer VMG0000 +abstén abstener VMM02S0 +absuelva absolver VMM03S0 +absuelvan absolver VMM03P0 +absuelve absolver VMM02S0 +abuchea abuchear VMM02S0 +abuchead abuchear VMM02P0 +abucheando abuchear VMG0000 +abuchear abuchear VMN0000 +abuchee abuchear VMM03S0 +abucheemos abuchear VMM01P0 +abucheen abuchear VMM03P0 +abullona abullonar VMM02S0 +abullonad abullonar VMM02P0 +abullonando abullonar VMG0000 +abullonar abullonar VMN0000 +abullone abullonar VMM03S0 +abullonemos abullonar VMM01P0 +abullonen abullonar VMM03P0 +abulta abultar VMM02S0 +abultad abultar VMM02P0 +abultando abultar VMG0000 +abultar abultar VMN0000 +abulte abultar VMM03S0 +abultemos abultar VMM01P0 +abulten abultar VMM03P0 +abunda abundar VMM02S0 +abundad abundar VMM02P0 +abundando abundar VMG0000 +abundar abundar VMN0000 +abunde abundar VMM03S0 +abundemos abundar VMM01P0 +abunden abundar VMM03P0 +abura aburar VMM02S0 +aburad aburar VMM02P0 +aburando aburar VMG0000 +aburar aburar VMN0000 +abure aburar VMM03S0 +aburemos aburar VMM01P0 +aburen aburar VMM03P0 +aburguesa aburguesar VMM02S0 +aburguesad aburguesar VMM02P0 +aburguesando aburguesar VMG0000 +aburguesar aburguesar VMN0000 +aburguese aburguesar VMM03S0 +aburguesemos aburguesar VMM01P0 +aburguesen aburguesar VMM03P0 +aburra aburrar VMM02S0 +aburra aburrir VMM03S0 +aburrad aburrar VMM02P0 +aburramos aburrir VMM01P0 +aburran aburrir VMM03P0 +aburrando aburrar VMG0000 +aburrar aburrar VMN0000 +aburre aburrar VMM03S0 +aburre aburrir VMM02S0 +aburremos aburrar VMM01P0 +aburren aburrar VMM03P0 +aburrid aburrir VMM02P0 +aburriendo aburrir VMG0000 +aburrir aburrir VMN0000 +aburuja aburujar VMM02S0 +aburujad aburujar VMM02P0 +aburujando aburujar VMG0000 +aburujar aburujar VMN0000 +aburuje aburujar VMM03S0 +aburujemos aburujar VMM01P0 +aburujen aburujar VMM03P0 +abusa abusar VMM02S0 +abusad abusar VMM02P0 +abusando abusar VMG0000 +abusar abusar VMN0000 +abuse abusar VMM03S0 +abusemos abusar VMM01P0 +abusen abusar VMM03P0 +abuñolad abuñolar VMM02P0 +abuñolando abuñolar VMG0000 +abuñolar abuñolar VMN0000 +abuñolemos abuñolar VMM01P0 +abuñuela abuñolar VMM02S0 +abuñuela abuñuelar VMM02S0 +abuñuelad abuñuelar VMM02P0 +abuñuelando abuñuelar VMG0000 +abuñuelar abuñuelar VMN0000 +abuñuele abuñolar VMM03S0 +abuñuele abuñuelar VMM03S0 +abuñuelemos abuñuelar VMM01P0 +abuñuelen abuñolar VMM03P0 +abuñuelen abuñuelar VMM03P0 +acaba acabar VMM02S0 +acabad acabar VMM02P0 +acaballa acaballar VMM02S0 +acaballad acaballar VMM02P0 +acaballando acaballar VMG0000 +acaballar acaballar VMN0000 +acaballe acaballar VMM03S0 +acaballemos acaballar VMM01P0 +acaballen acaballar VMM03P0 +acaballona acaballonar VMM02S0 +acaballonad acaballonar VMM02P0 +acaballonando acaballonar VMG0000 +acaballonar acaballonar VMN0000 +acaballone acaballonar VMM03S0 +acaballonemos acaballonar VMM01P0 +acaballonen acaballonar VMM03P0 +acabando acabar VMG0000 +acabar acabar VMN0000 +acabe acabar VMM03S0 +acabemos acabar VMM01P0 +acaben acabar VMM03P0 +acabilda acabildar VMM02S0 +acabildad acabildar VMM02P0 +acabildando acabildar VMG0000 +acabildar acabildar VMN0000 +acabilde acabildar VMM03S0 +acabildemos acabildar VMM01P0 +acabilden acabildar VMM03P0 +acacheta acachetar VMM02S0 +acachetad acachetar VMM02P0 +acachetando acachetar VMG0000 +acachetar acachetar VMN0000 +acachete acachetar VMM03S0 +acachetea acachetear VMM02S0 +acachetead acachetear VMM02P0 +acacheteando acachetear VMG0000 +acachetear acachetear VMN0000 +acachetee acachetear VMM03S0 +acacheteemos acachetear VMM01P0 +acacheteen acachetear VMM03P0 +acachetemos acachetar VMM01P0 +acacheten acachetar VMM03P0 +academice academizar VMM03S0 +academicemos academizar VMM01P0 +academicen academizar VMM03P0 +academiza academizar VMM02S0 +academizad academizar VMM02P0 +academizando academizar VMG0000 +academizar academizar VMN0000 +acaece acaecer VMM02S0 +acaeced acaecer VMM02P0 +acaecer acaecer VMN0000 +acaeciendo acaecer VMG0000 +acaezca acaecer VMM03S0 +acaezcamos acaecer VMM01P0 +acaezcan acaecer VMM03P0 +acalabrota acalabrotar VMM02S0 +acalabrotad acalabrotar VMM02P0 +acalabrotando acalabrotar VMG0000 +acalabrotar acalabrotar VMN0000 +acalabrote acalabrotar VMM03S0 +acalabrotemos acalabrotar VMM01P0 +acalabroten acalabrotar VMM03P0 +acalambra acalambrar VMM02S0 +acalambrad acalambrar VMM02P0 +acalambrando acalambrar VMG0000 +acalambrar acalambrar VMN0000 +acalambre acalambrar VMM03S0 +acalambremos acalambrar VMM01P0 +acalambren acalambrar VMM03P0 +acalentura acalenturar VMM02S0 +acalenturad acalenturar VMM02P0 +acalenturando acalenturar VMG0000 +acalenturar acalenturar VMN0000 +acalenture acalenturar VMM03S0 +acalenturemos acalenturar VMM01P0 +acalenturen acalenturar VMM03P0 +acalla acallar VMM02S0 +acallad acallar VMM02P0 +acallando acallar VMG0000 +acallanta acallantar VMM02S0 +acallantad acallantar VMM02P0 +acallantando acallantar VMG0000 +acallantar acallantar VMN0000 +acallante acallantar VMM03S0 +acallantemos acallantar VMM01P0 +acallanten acallantar VMM03P0 +acallar acallar VMN0000 +acalle acallar VMM03S0 +acallemos acallar VMM01P0 +acallen acallar VMM03P0 +acalora acalorar VMM02S0 +acalorad acalorar VMM02P0 +acalorando acalorar VMG0000 +acalorar acalorar VMN0000 +acalore acalorar VMM03S0 +acaloremos acalorar VMM01P0 +acaloren acalorar VMM03P0 +acama acamar VMM02S0 +acamad acamar VMM02P0 +acamando acamar VMG0000 +acamar acamar VMN0000 +acame acamar VMM03S0 +acamemos acamar VMM01P0 +acamen acamar VMM03P0 +acampa acampar VMM02S0 +acampad acampar VMM02P0 +acampando acampar VMG0000 +acampar acampar VMN0000 +acampe acampar VMM03S0 +acampemos acampar VMM01P0 +acampen acampar VMM03P0 +acanala acanalar VMM02S0 +acanalad acanalar VMM02P0 +acanalando acanalar VMG0000 +acanalar acanalar VMN0000 +acanale acanalar VMM03S0 +acanalemos acanalar VMM01P0 +acanalen acanalar VMM03P0 +acancha acanchar VMM02S0 +acanchad acanchar VMM02P0 +acanchando acanchar VMG0000 +acanchar acanchar VMN0000 +acanche acanchar VMM03S0 +acanchemos acanchar VMM01P0 +acanchen acanchar VMM03P0 +acanelona acanelonar VMM02S0 +acanelonad acanelonar VMM02P0 +acanelonando acanelonar VMG0000 +acanelonar acanelonar VMN0000 +acanelone acanelonar VMM03S0 +acanelonemos acanelonar VMM01P0 +acanelonen acanelonar VMM03P0 +acantila acantilar VMM02S0 +acantilad acantilar VMM02P0 +acantilando acantilar VMG0000 +acantilar acantilar VMN0000 +acantile acantilar VMM03S0 +acantilemos acantilar VMM01P0 +acantilen acantilar VMM03P0 +acantona acantonar VMM02S0 +acantonad acantonar VMM02P0 +acantonando acantonar VMG0000 +acantonar acantonar VMN0000 +acantone acantonar VMM03S0 +acantonemos acantonar VMM01P0 +acantonen acantonar VMM03P0 +acapara acaparar VMM02S0 +acaparad acaparar VMM02P0 +acaparando acaparar VMG0000 +acaparar acaparar VMN0000 +acapare acaparar VMM03S0 +acaparemos acaparar VMM01P0 +acaparen acaparar VMM03P0 +acaparra acaparrar VMM02S0 +acaparrad acaparrar VMM02P0 +acaparrando acaparrar VMG0000 +acaparrar acaparrar VMN0000 +acaparre acaparrar VMM03S0 +acaparremos acaparrar VMM01P0 +acaparren acaparrar VMM03P0 +acara acarar VMM02S0 +acarad acarar VMM02P0 +acaramela acaramelar VMM02S0 +acaramelad acaramelar VMM02P0 +acaramelando acaramelar VMG0000 +acaramelar acaramelar VMN0000 +acaramele acaramelar VMM03S0 +acaramelemos acaramelar VMM01P0 +acaramelen acaramelar VMM03P0 +acarando acarar VMG0000 +acarar acarar VMN0000 +acardenala acardenalar VMM02S0 +acardenalad acardenalar VMM02P0 +acardenalando acardenalar VMG0000 +acardenalar acardenalar VMN0000 +acardenale acardenalar VMM03S0 +acardenalemos acardenalar VMM01P0 +acardenalen acardenalar VMM03P0 +acare acarar VMM03S0 +acarea acarear VMM02S0 +acaread acarear VMM02P0 +acareando acarear VMG0000 +acarear acarear VMN0000 +acaree acarear VMM03S0 +acareemos acarear VMM01P0 +acareen acarear VMM03P0 +acaremos acarar VMM01P0 +acaren acarar VMM03P0 +acaricia acariciar VMM02S0 +acariciad acariciar VMM02P0 +acariciando acariciar VMG0000 +acariciar acariciar VMN0000 +acaricie acariciar VMM03S0 +acariciemos acariciar VMM01P0 +acaricien acariciar VMM03P0 +acarra acarrar VMM02S0 +acarrad acarrar VMM02P0 +acarrala acarralar VMM02S0 +acarralad acarralar VMM02P0 +acarralando acarralar VMG0000 +acarralar acarralar VMN0000 +acarrale acarralar VMM03S0 +acarralemos acarralar VMM01P0 +acarralen acarralar VMM03P0 +acarrando acarrar VMG0000 +acarrar acarrar VMN0000 +acarre acarrar VMM03S0 +acarrea acarrear VMM02S0 +acarread acarrear VMM02P0 +acarreando acarrear VMG0000 +acarrear acarrear VMN0000 +acarree acarrear VMM03S0 +acarreemos acarrear VMM01P0 +acarreen acarrear VMM03P0 +acarremos acarrar VMM01P0 +acarren acarrar VMM03P0 +acarroña acarroñar VMM02S0 +acarroñad acarroñar VMM02P0 +acarroñando acarroñar VMG0000 +acarroñar acarroñar VMN0000 +acarroñe acarroñar VMM03S0 +acarroñemos acarroñar VMM01P0 +acarroñen acarroñar VMM03P0 +acartona acartonar VMM02S0 +acartonad acartonar VMM02P0 +acartonando acartonar VMG0000 +acartonar acartonar VMN0000 +acartone acartonar VMM03S0 +acartonemos acartonar VMM01P0 +acartonen acartonar VMM03P0 +acata acatar VMM02S0 +acatad acatar VMM02P0 +acatando acatar VMG0000 +acatar acatar VMN0000 +acatarra acatarrar VMM02S0 +acatarrad acatarrar VMM02P0 +acatarrando acatarrar VMG0000 +acatarrar acatarrar VMN0000 +acatarre acatarrar VMM03S0 +acatarremos acatarrar VMM01P0 +acatarren acatarrar VMM03P0 +acate acatar VMM03S0 +acatemos acatar VMM01P0 +acaten acatar VMM03P0 +acaudala acaudalar VMM02S0 +acaudalad acaudalar VMM02P0 +acaudalando acaudalar VMG0000 +acaudalar acaudalar VMN0000 +acaudale acaudalar VMM03S0 +acaudalemos acaudalar VMM01P0 +acaudalen acaudalar VMM03P0 +acaudilla acaudillar VMM02S0 +acaudillad acaudillar VMM02P0 +acaudillando acaudillar VMG0000 +acaudillar acaudillar VMN0000 +acaudille acaudillar VMM03S0 +acaudillemos acaudillar VMM01P0 +acaudillen acaudillar VMM03P0 +acañonea acañonear VMM02S0 +acañonead acañonear VMM02P0 +acañoneando acañonear VMG0000 +acañonear acañonear VMN0000 +acañonee acañonear VMM03S0 +acañoneemos acañonear VMM01P0 +acañoneen acañonear VMM03P0 +acceda acceder VMM03S0 +accedamos acceder VMM01P0 +accedan acceder VMM03P0 +accede acceder VMM02S0 +acceded acceder VMM02P0 +acceder acceder VMN0000 +accediendo acceder VMG0000 +accidenta accidentar VMM02S0 +accidentad accidentar VMM02P0 +accidentando accidentar VMG0000 +accidentar accidentar VMN0000 +accidente accidentar VMM03S0 +accidentemos accidentar VMM01P0 +accidenten accidentar VMM03P0 +acciona accionar VMM02S0 +accionad accionar VMM02P0 +accionando accionar VMG0000 +accionar accionar VMN0000 +accione accionar VMM03S0 +accionemos accionar VMM01P0 +accionen accionar VMM03P0 +acece acezar VMM03S0 +acecemos acezar VMM01P0 +acecen acezar VMM03P0 +acecha acechar VMM02S0 +acechad acechar VMM02P0 +acechando acechar VMG0000 +acechar acechar VMN0000 +aceche acechar VMM03S0 +acechemos acechar VMM01P0 +acechen acechar VMM03P0 +acecina acecinar VMM02S0 +acecinad acecinar VMM02P0 +acecinando acecinar VMG0000 +acecinar acecinar VMN0000 +acecine acecinar VMM03S0 +acecinemos acecinar VMM01P0 +acecinen acecinar VMM03P0 +aceda acedar VMM02S0 +acedad acedar VMM02P0 +acedando acedar VMG0000 +acedar acedar VMN0000 +acede acedar VMM03S0 +acedemos acedar VMM01P0 +aceden acedar VMM03P0 +aceita aceitar VMM02S0 +aceitad aceitar VMM02P0 +aceitando aceitar VMG0000 +aceitar aceitar VMN0000 +aceite aceitar VMM03S0 +aceitemos aceitar VMM01P0 +aceiten aceitar VMM03P0 +acelera acelerar VMM02S0 +acelerad acelerar VMM02P0 +acelerando acelerar VMG0000 +acelerar acelerar VMN0000 +acelere acelerar VMM03S0 +aceleremos acelerar VMM01P0 +aceleren acelerar VMM03P0 +acendra acendrar VMM02S0 +acendrad acendrar VMM02P0 +acendrando acendrar VMG0000 +acendrar acendrar VMN0000 +acendre acendrar VMM03S0 +acendremos acendrar VMM01P0 +acendren acendrar VMM03P0 +acensa acensar VMM02S0 +acensad acensar VMM02P0 +acensando acensar VMG0000 +acensar acensar VMN0000 +acense acensar VMM03S0 +acensemos acensar VMM01P0 +acensen acensar VMM03P0 +acensuad acensuar VMM02P0 +acensuando acensuar VMG0000 +acensuar acensuar VMN0000 +acensuemos acensuar VMM01P0 +acensúa acensuar VMM02S0 +acensúe acensuar VMM03S0 +acensúen acensuar VMM03P0 +acentuad acentuar VMM02P0 +acentuando acentuar VMG0000 +acentuar acentuar VMN0000 +acentuemos acentuar VMM01P0 +acentúa acentuar VMM02S0 +acentúe acentuar VMM03S0 +acentúen acentuar VMM03P0 +acepa acepar VMM02S0 +acepad acepar VMM02P0 +acepando acepar VMG0000 +acepar acepar VMN0000 +acepe acepar VMM03S0 +acepemos acepar VMM01P0 +acepen acepar VMM03P0 +acepilla acepillar VMM02S0 +acepillad acepillar VMM02P0 +acepillando acepillar VMG0000 +acepillar acepillar VMN0000 +acepille acepillar VMM03S0 +acepillemos acepillar VMM01P0 +acepillen acepillar VMM03P0 +acepta aceptar VMM02S0 +aceptad aceptar VMM02P0 +aceptando aceptar VMG0000 +aceptar aceptar VMN0000 +acepte aceptar VMM03S0 +aceptemos aceptar VMM01P0 +acepten aceptar VMM03P0 +acequia acequiar VMM02S0 +acequiad acequiar VMM02P0 +acequiando acequiar VMG0000 +acequiar acequiar VMN0000 +acequie acequiar VMM03S0 +acequiemos acequiar VMM01P0 +acequien acequiar VMM03P0 +acera acerar VMM02S0 +acerad acerar VMM02P0 +acerando acerar VMG0000 +acerar acerar VMN0000 +acerca acercar VMM02S0 +acercad acercar VMM02P0 +acercando acercar VMG0000 +acercar acercar VMN0000 +acere acerar VMM03S0 +aceremos acerar VMM01P0 +aceren acerar VMM03P0 +acerque acercar VMM03S0 +acerquemos acercar VMM01P0 +acerquen acercar VMM03P0 +acerroja acerrojar VMM02S0 +acerrojad acerrojar VMM02P0 +acerrojando acerrojar VMG0000 +acerrojar acerrojar VMN0000 +acerroje acerrojar VMM03S0 +acerrojemos acerrojar VMM01P0 +acerrojen acerrojar VMM03P0 +acertad acertar VMM02P0 +acertando acertar VMG0000 +acertar acertar VMN0000 +acertemos acertar VMM01P0 +acetifica acetificar VMM02S0 +acetificad acetificar VMM02P0 +acetificando acetificar VMG0000 +acetificar acetificar VMN0000 +acetifique acetificar VMM03S0 +acetifiquemos acetificar VMM01P0 +acetifiquen acetificar VMM03P0 +acetrina acetrinar VMM02S0 +acetrinad acetrinar VMM02P0 +acetrinando acetrinar VMG0000 +acetrinar acetrinar VMN0000 +acetrine acetrinar VMM03S0 +acetrinemos acetrinar VMM01P0 +acetrinen acetrinar VMM03P0 +aceza acezar VMM02S0 +acezad acezar VMM02P0 +acezando acezar VMG0000 +acezar acezar VMN0000 +achabacana achabacanar VMM02S0 +achabacanad achabacanar VMM02P0 +achabacanando achabacanar VMG0000 +achabacanar achabacanar VMN0000 +achabacane achabacanar VMM03S0 +achabacanemos achabacanar VMM01P0 +achabacanen achabacanar VMM03P0 +achaca achacar VMM02S0 +achacad achacar VMM02P0 +achacando achacar VMG0000 +achacar achacar VMN0000 +achaflana achaflanar VMM02S0 +achaflanad achaflanar VMM02P0 +achaflanando achaflanar VMG0000 +achaflanar achaflanar VMN0000 +achaflane achaflanar VMM03S0 +achaflanemos achaflanar VMM01P0 +achaflanen achaflanar VMM03P0 +achajuana achajuanar VMM02S0 +achajuanad achajuanar VMM02P0 +achajuanando achajuanar VMG0000 +achajuanar achajuanar VMN0000 +achajuane achajuanar VMM03S0 +achajuanemos achajuanar VMM01P0 +achajuanen achajuanar VMM03P0 +achanta achantar VMM02S0 +achantad achantar VMM02P0 +achantando achantar VMG0000 +achantar achantar VMN0000 +achante achantar VMM03S0 +achantemos achantar VMM01P0 +achanten achantar VMM03P0 +achaparra achaparrar VMM02S0 +achaparrad achaparrar VMM02P0 +achaparrando achaparrar VMG0000 +achaparrar achaparrar VMN0000 +achaparre achaparrar VMM03S0 +achaparremos achaparrar VMM01P0 +achaparren achaparrar VMM03P0 +achaque achacar VMM03S0 +achaquemos achacar VMM01P0 +achaquen achacar VMM03P0 +acharola acharolar VMM02S0 +acharolad acharolar VMM02P0 +acharolando acharolar VMG0000 +acharolar acharolar VMN0000 +acharole acharolar VMM03S0 +acharolemos acharolar VMM01P0 +acharolen acharolar VMM03P0 +achata achatar VMM02S0 +achatad achatar VMM02P0 +achatando achatar VMG0000 +achatar achatar VMN0000 +achate achatar VMM03S0 +achatemos achatar VMM01P0 +achaten achatar VMM03P0 +achica achicar VMM02S0 +achicad achicar VMM02P0 +achicando achicar VMG0000 +achicar achicar VMN0000 +achicharra achicharrar VMM02S0 +achicharrad achicharrar VMM02P0 +achicharrando achicharrar VMG0000 +achicharrar achicharrar VMN0000 +achicharre achicharrar VMM03S0 +achicharremos achicharrar VMM01P0 +achicharren achicharrar VMM03P0 +achigua achiguar VMM02S0 +achiguad achiguar VMM02P0 +achiguando achiguar VMG0000 +achiguar achiguar VMN0000 +achigüe achiguar VMM03S0 +achigüemos achiguar VMM01P0 +achigüen achiguar VMM03P0 +achique achicar VMM03S0 +achiquemos achicar VMM01P0 +achiquen achicar VMM03P0 +achispa achispar VMM02S0 +achispad achispar VMM02P0 +achispando achispar VMG0000 +achispar achispar VMN0000 +achispe achispar VMM03S0 +achispemos achispar VMM01P0 +achispen achispar VMM03P0 +achoca achocar VMM02S0 +achocad achocar VMM02P0 +achocando achocar VMG0000 +achocar achocar VMN0000 +achola acholar VMM02S0 +acholad acholar VMM02P0 +acholando acholar VMG0000 +acholar acholar VMN0000 +achole acholar VMM03S0 +acholemos acholar VMM01P0 +acholen acholar VMM03P0 +achoque achocar VMM03S0 +achoquemos achocar VMM01P0 +achoquen achocar VMM03P0 +achubasca achubascar VMM02S0 +achubascad achubascar VMM02P0 +achubascando achubascar VMG0000 +achubascar achubascar VMN0000 +achubasque achubascar VMM03S0 +achubasquemos achubascar VMM01P0 +achubasquen achubascar VMM03P0 +achucha achuchar VMM02S0 +achuchad achuchar VMM02P0 +achuchando achuchar VMG0000 +achuchar achuchar VMN0000 +achucharra achucharrar VMM02S0 +achucharrad achucharrar VMM02P0 +achucharrando achucharrar VMG0000 +achucharrar achucharrar VMN0000 +achucharre achucharrar VMM03S0 +achucharremos achucharrar VMM01P0 +achucharren achucharrar VMM03P0 +achuche achuchar VMM03S0 +achuchemos achuchar VMM01P0 +achuchen achuchar VMM03P0 +achucuya achucuyar VMM02S0 +achucuyad achucuyar VMM02P0 +achucuyando achucuyar VMG0000 +achucuyar achucuyar VMN0000 +achucuye achucuyar VMM03S0 +achucuyemos achucuyar VMM01P0 +achucuyen achucuyar VMM03P0 +achura achurar VMM02S0 +achurad achurar VMM02P0 +achurando achurar VMG0000 +achurar achurar VMN0000 +achure achurar VMM03S0 +achuremos achurar VMM01P0 +achuren achurar VMM03P0 +acibara acibarar VMM02S0 +acibarad acibarar VMM02P0 +acibarando acibarar VMG0000 +acibarar acibarar VMN0000 +acibare acibarar VMM03S0 +acibaremos acibarar VMM01P0 +acibaren acibarar VMM03P0 +acibera aciberar VMM02S0 +aciberad aciberar VMM02P0 +aciberando aciberar VMG0000 +aciberar aciberar VMN0000 +acibere aciberar VMM03S0 +aciberemos aciberar VMM01P0 +aciberen aciberar VMM03P0 +acicala acicalar VMM02S0 +acicalad acicalar VMM02P0 +acicalando acicalar VMG0000 +acicalar acicalar VMN0000 +acicale acicalar VMM03S0 +acicalemos acicalar VMM01P0 +acicalen acicalar VMM03P0 +acicatea acicatear VMM02S0 +acicatead acicatear VMM02P0 +acicateando acicatear VMG0000 +acicatear acicatear VMN0000 +acicatee acicatear VMM03S0 +acicateemos acicatear VMM01P0 +acicateen acicatear VMM03P0 +acida acidar VMM02S0 +acidad acidar VMM02P0 +acidando acidar VMG0000 +acidar acidar VMN0000 +acidifica acidificar VMM02S0 +acidificad acidificar VMM02P0 +acidificando acidificar VMG0000 +acidificar acidificar VMN0000 +acidifique acidificar VMM03S0 +acidifiquemos acidificar VMM01P0 +acidifiquen acidificar VMM03P0 +acidula acidular VMM02S0 +acidulad acidular VMM02P0 +acidulando acidular VMG0000 +acidular acidular VMN0000 +acidule acidular VMM03S0 +acidulemos acidular VMM01P0 +acidulen acidular VMM03P0 +acierta acertar VMM02S0 +acierte acertar VMM03S0 +acierten acertar VMM03P0 +aciguata aciguatar VMM02S0 +aciguatad aciguatar VMM02P0 +aciguatando aciguatar VMG0000 +aciguatar aciguatar VMN0000 +aciguate aciguatar VMM03S0 +aciguatemos aciguatar VMM01P0 +aciguaten aciguatar VMM03P0 +aclama aclamar VMM02S0 +aclamad aclamar VMM02P0 +aclamando aclamar VMG0000 +aclamar aclamar VMN0000 +aclame aclamar VMM03S0 +aclamemos aclamar VMM01P0 +aclamen aclamar VMM03P0 +aclara aclarar VMM02S0 +aclarad aclarar VMM02P0 +aclarando aclarar VMG0000 +aclarar aclarar VMN0000 +aclare aclarar VMM03S0 +aclaremos aclarar VMM01P0 +aclaren aclarar VMM03P0 +aclimata aclimatar VMM02S0 +aclimatad aclimatar VMM02P0 +aclimatando aclimatar VMG0000 +aclimatar aclimatar VMN0000 +aclimate aclimatar VMM03S0 +aclimatemos aclimatar VMM01P0 +aclimaten aclimatar VMM03P0 +aclocad aclocar VMM02P0 +aclocando aclocar VMG0000 +aclocar aclocar VMN0000 +acloquemos aclocar VMM01P0 +aclueca aclocar VMM02S0 +aclueque aclocar VMM03S0 +acluequen aclocar VMM03P0 +acobarda acobardar VMM02S0 +acobardad acobardar VMM02P0 +acobardando acobardar VMG0000 +acobardar acobardar VMN0000 +acobarde acobardar VMM03S0 +acobardemos acobardar VMM01P0 +acobarden acobardar VMM03P0 +acocea acocear VMM02S0 +acocead acocear VMM02P0 +acoceando acocear VMG0000 +acocear acocear VMN0000 +acocee acocear VMM03S0 +acoceemos acocear VMM01P0 +acoceen acocear VMM03P0 +acochambra acochambrar VMM02S0 +acochambrad acochambrar VMM02P0 +acochambrando acochambrar VMG0000 +acochambrar acochambrar VMN0000 +acochambre acochambrar VMM03S0 +acochambremos acochambrar VMM01P0 +acochambren acochambrar VMM03P0 +acochina acochinar VMM02S0 +acochinad acochinar VMM02P0 +acochinando acochinar VMG0000 +acochinar acochinar VMN0000 +acochine acochinar VMM03S0 +acochinemos acochinar VMM01P0 +acochinen acochinar VMM03P0 +acoda acodar VMM02S0 +acodad acodar VMM02P0 +acodala acodalar VMM02S0 +acodalad acodalar VMM02P0 +acodalando acodalar VMG0000 +acodalar acodalar VMN0000 +acodale acodalar VMM03S0 +acodalemos acodalar VMM01P0 +acodalen acodalar VMM03P0 +acodando acodar VMG0000 +acodar acodar VMN0000 +acode acodar VMM03S0 +acodemos acodar VMM01P0 +acoden acodar VMM03P0 +acodera acoderar VMM02S0 +acoderad acoderar VMM02P0 +acoderando acoderar VMG0000 +acoderar acoderar VMN0000 +acodere acoderar VMM03S0 +acoderemos acoderar VMM01P0 +acoderen acoderar VMM03P0 +acodilla acodillar VMM02S0 +acodillad acodillar VMM02P0 +acodillando acodillar VMG0000 +acodillar acodillar VMN0000 +acodille acodillar VMM03S0 +acodillemos acodillar VMM01P0 +acodillen acodillar VMM03P0 +acoge acoger VMM02S0 +acoged acoger VMM02P0 +acoger acoger VMN0000 +acogiendo acoger VMG0000 +acogolla acogollar VMM02S0 +acogollad acogollar VMM02P0 +acogollando acogollar VMG0000 +acogollar acogollar VMN0000 +acogolle acogollar VMM03S0 +acogollemos acogollar VMM01P0 +acogollen acogollar VMM03P0 +acogombra acogombrar VMM02S0 +acogombrad acogombrar VMM02P0 +acogombrando acogombrar VMG0000 +acogombrar acogombrar VMN0000 +acogombre acogombrar VMM03S0 +acogombremos acogombrar VMM01P0 +acogombren acogombrar VMM03P0 +acogota acogotar VMM02S0 +acogotad acogotar VMM02P0 +acogotando acogotar VMG0000 +acogotar acogotar VMN0000 +acogote acogotar VMM03S0 +acogotemos acogotar VMM01P0 +acogoten acogotar VMM03P0 +acohombra acohombrar VMM02S0 +acohombrad acohombrar VMM02P0 +acohombrando acohombrar VMG0000 +acohombrar acohombrar VMN0000 +acohombre acohombrar VMM03S0 +acohombremos acohombrar VMM01P0 +acohombren acohombrar VMM03P0 +acoita acoitar VMM02S0 +acoitad acoitar VMM02P0 +acoitando acoitar VMG0000 +acoitar acoitar VMN0000 +acoja acoger VMM03S0 +acojamos acoger VMM01P0 +acojan acoger VMM03P0 +acojina acojinar VMM02S0 +acojinad acojinar VMM02P0 +acojinando acojinar VMG0000 +acojinar acojinar VMN0000 +acojine acojinar VMM03S0 +acojinemos acojinar VMM01P0 +acojinen acojinar VMM03P0 +acojona acojonar VMM02S0 +acojonad acojonar VMM02P0 +acojonando acojonar VMG0000 +acojonar acojonar VMN0000 +acojone acojonar VMM03S0 +acojonemos acojonar VMM01P0 +acojonen acojonar VMM03P0 +acola acolar VMM02S0 +acolad acolar VMM02P0 +acolando acolar VMG0000 +acolar acolar VMN0000 +acolcha acolchar VMM02S0 +acolchad acolchar VMM02P0 +acolchando acolchar VMG0000 +acolchar acolchar VMN0000 +acolche acolchar VMM03S0 +acolchemos acolchar VMM01P0 +acolchen acolchar VMM03P0 +acolchona acolchonar VMM02S0 +acolchonad acolchonar VMM02P0 +acolchonando acolchonar VMG0000 +acolchonar acolchonar VMN0000 +acolchone acolchonar VMM03S0 +acolchonemos acolchonar VMM01P0 +acolchonen acolchonar VMM03P0 +acole acolar VMM03S0 +acolemos acolar VMM01P0 +acolen acolar VMM03P0 +acolita acolitar VMM02S0 +acolitad acolitar VMM02P0 +acolitando acolitar VMG0000 +acolitar acolitar VMN0000 +acolite acolitar VMM03S0 +acolitemos acolitar VMM01P0 +acoliten acolitar VMM03P0 +acollad acollar VMM02P0 +acollando acollar VMG0000 +acollar acollar VMN0000 +acollara acollarar VMM02S0 +acollarad acollarar VMM02P0 +acollarando acollarar VMG0000 +acollarar acollarar VMN0000 +acollare acollarar VMM03S0 +acollaremos acollarar VMM01P0 +acollaren acollarar VMM03P0 +acollemos acollar VMM01P0 +acollona acollonar VMM02S0 +acollonad acollonar VMM02P0 +acollonando acollonar VMG0000 +acollonar acollonar VMN0000 +acollone acollonar VMM03S0 +acollonemos acollonar VMM01P0 +acollonen acollonar VMM03P0 +acomedid acomedir VMM02P0 +acomedir acomedir VMN0000 +acometa acometer VMM03S0 +acometamos acometer VMM01P0 +acometan acometer VMM03P0 +acomete acometer VMM02S0 +acometed acometer VMM02P0 +acometer acometer VMN0000 +acometiendo acometer VMG0000 +acomida acomedir VMM03S0 +acomidamos acomedir VMM01P0 +acomidan acomedir VMM03P0 +acomide acomedir VMM02S0 +acomidiendo acomedir VMG0000 +acomoda acomodar VMM02S0 +acomodad acomodar VMM02P0 +acomodando acomodar VMG0000 +acomodar acomodar VMN0000 +acomode acomodar VMM03S0 +acomodemos acomodar VMM01P0 +acomoden acomodar VMM03P0 +acompasa acompasar VMM02S0 +acompasad acompasar VMM02P0 +acompasando acompasar VMG0000 +acompasar acompasar VMN0000 +acompase acompasar VMM03S0 +acompasemos acompasar VMM01P0 +acompasen acompasar VMM03P0 +acompaña acompañar VMM02S0 +acompañad acompañar VMM02P0 +acompañando acompañar VMG0000 +acompañar acompañar VMN0000 +acompañe acompañar VMM03S0 +acompañemos acompañar VMM01P0 +acompañen acompañar VMM03P0 +acompleja acomplejar VMM02S0 +acomplejad acomplejar VMM02P0 +acomplejando acomplejar VMG0000 +acomplejar acomplejar VMN0000 +acompleje acomplejar VMM03S0 +acomplejemos acomplejar VMM01P0 +acomplejen acomplejar VMM03P0 +acomuna acomunar VMM02S0 +acomunad acomunar VMM02P0 +acomunando acomunar VMG0000 +acomunar acomunar VMN0000 +acomune acomunar VMM03S0 +acomunemos acomunar VMM01P0 +acomunen acomunar VMM03P0 +aconcha aconchar VMM02S0 +aconchaba aconchabar VMM02S0 +aconchabad aconchabar VMM02P0 +aconchabando aconchabar VMG0000 +aconchabar aconchabar VMN0000 +aconchabe aconchabar VMM03S0 +aconchabemos aconchabar VMM01P0 +aconchaben aconchabar VMM03P0 +aconchad aconchar VMM02P0 +aconchando aconchar VMG0000 +aconchar aconchar VMN0000 +aconche aconchar VMM03S0 +aconchemos aconchar VMM01P0 +aconchen aconchar VMM03P0 +acondiciona acondicionar VMM02S0 +acondicionad acondicionar VMM02P0 +acondicionando acondicionar VMG0000 +acondicionar acondicionar VMN0000 +acondicione acondicionar VMM03S0 +acondicionemos acondicionar VMM01P0 +acondicionen acondicionar VMM03P0 +acongoja acongojar VMM02S0 +acongojad acongojar VMM02P0 +acongojando acongojar VMG0000 +acongojar acongojar VMN0000 +acongoje acongojar VMM03S0 +acongojemos acongojar VMM01P0 +acongojen acongojar VMM03P0 +aconseja aconsejar VMM02S0 +aconsejad aconsejar VMM02P0 +aconsejando aconsejar VMG0000 +aconsejar aconsejar VMN0000 +aconseje aconsejar VMM03S0 +aconsejemos aconsejar VMM01P0 +aconsejen aconsejar VMM03P0 +aconsonanta aconsonantar VMM02S0 +aconsonantad aconsonantar VMM02P0 +aconsonantando aconsonantar VMG0000 +aconsonantar aconsonantar VMN0000 +aconsonante aconsonantar VMM03S0 +aconsonantemos aconsonantar VMM01P0 +aconsonanten aconsonantar VMM03P0 +acontece acontecer VMM02S0 +aconteced acontecer VMM02P0 +acontecer acontecer VMN0000 +aconteciendo acontecer VMG0000 +acontezca acontecer VMM03S0 +acontezcamos acontecer VMM01P0 +acontezcan acontecer VMM03P0 +acopa acopar VMM02S0 +acopad acopar VMM02P0 +acopando acopar VMG0000 +acopar acopar VMN0000 +acope acopar VMM03S0 +acopemos acopar VMM01P0 +acopen acopar VMM03P0 +acopia acopiar VMM02S0 +acopiad acopiar VMM02P0 +acopiando acopiar VMG0000 +acopiar acopiar VMN0000 +acopie acopiar VMM03S0 +acopiemos acopiar VMM01P0 +acopien acopiar VMM03P0 +acopla acoplar VMM02S0 +acoplad acoplar VMM02P0 +acoplando acoplar VMG0000 +acoplar acoplar VMN0000 +acople acoplar VMM03S0 +acoplemos acoplar VMM01P0 +acoplen acoplar VMM03P0 +acoquina acoquinar VMM02S0 +acoquinad acoquinar VMM02P0 +acoquinando acoquinar VMG0000 +acoquinar acoquinar VMN0000 +acoquine acoquinar VMM03S0 +acoquinemos acoquinar VMM01P0 +acoquinen acoquinar VMM03P0 +acora acorar VMM02S0 +acorace acorazar VMM03S0 +acoracemos acorazar VMM01P0 +acoracen acorazar VMM03P0 +acorad acorar VMM02P0 +acorando acorar VMG0000 +acorar acorar VMN0000 +acoraza acorazar VMM02S0 +acorazad acorazar VMM02P0 +acorazando acorazar VMG0000 +acorazar acorazar VMN0000 +acorcha acorchar VMM02S0 +acorchad acorchar VMM02P0 +acorchando acorchar VMG0000 +acorchar acorchar VMN0000 +acorche acorchar VMM03S0 +acorchemos acorchar VMM01P0 +acorchen acorchar VMM03P0 +acordad acordar VMM02P0 +acordando acordar VMG0000 +acordar acordar VMN0000 +acordela acordelar VMM02S0 +acordelad acordelar VMM02P0 +acordelando acordelar VMG0000 +acordelar acordelar VMN0000 +acordele acordelar VMM03S0 +acordelemos acordelar VMM01P0 +acordelen acordelar VMM03P0 +acordemos acordar VMM01P0 +acordeona acordeonar VMM02S0 +acordeonad acordeonar VMM02P0 +acordeonando acordeonar VMG0000 +acordeonar acordeonar VMN0000 +acordona acordonar VMM02S0 +acordonad acordonar VMM02P0 +acordonando acordonar VMG0000 +acordonar acordonar VMN0000 +acordone acordonar VMM03S0 +acordonemos acordonar VMM01P0 +acordonen acordonar VMM03P0 +acore acorar VMM03S0 +acoremos acorar VMM01P0 +acoren acorar VMM03P0 +acornad acornar VMM02P0 +acornando acornar VMG0000 +acornar acornar VMN0000 +acornea acornear VMM02S0 +acornead acornear VMM02P0 +acorneando acornear VMG0000 +acornear acornear VMN0000 +acornee acornear VMM03S0 +acorneemos acornear VMM01P0 +acorneen acornear VMM03P0 +acornemos acornar VMM01P0 +acorra acorrer VMM03S0 +acorrala acorralar VMM02S0 +acorralad acorralar VMM02P0 +acorralando acorralar VMG0000 +acorralar acorralar VMN0000 +acorrale acorralar VMM03S0 +acorralemos acorralar VMM01P0 +acorralen acorralar VMM03P0 +acorramos acorrer VMM01P0 +acorran acorrer VMM03P0 +acorre acorrer VMM02S0 +acorred acorrer VMM02P0 +acorrer acorrer VMN0000 +acorriendo acorrer VMG0000 +acorta acortar VMM02S0 +acortad acortar VMM02P0 +acortando acortar VMG0000 +acortar acortar VMN0000 +acorte acortar VMM03S0 +acortemos acortar VMM01P0 +acorten acortar VMM03P0 +acosa acosar VMM02S0 +acosad acosar VMM02P0 +acosando acosar VMG0000 +acosar acosar VMN0000 +acose acosar VMM03S0 +acosemos acosar VMM01P0 +acosen acosar VMM03P0 +acosija acosijar VMM02S0 +acosijad acosijar VMM02P0 +acosijando acosijar VMG0000 +acosijar acosijar VMN0000 +acosije acosijar VMM03S0 +acosijemos acosijar VMM01P0 +acosijen acosijar VMM03P0 +acostad acostar VMM02P0 +acostando acostar VMG0000 +acostar acostar VMN0000 +acostemos acostar VMM01P0 +acostumbra acostumbrar VMM02S0 +acostumbrad acostumbrar VMM02P0 +acostumbrando acostumbrar VMG0000 +acostumbrar acostumbrar VMN0000 +acostumbre acostumbrar VMM03S0 +acostumbremos acostumbrar VMM01P0 +acostumbren acostumbrar VMM03P0 +acota acotar VMM02S0 +acotad acotar VMM02P0 +acotando acotar VMG0000 +acotar acotar VMN0000 +acote acotar VMM03S0 +acoteja acotejar VMM02S0 +acotejad acotejar VMM02P0 +acotejando acotejar VMG0000 +acotejar acotejar VMN0000 +acoteje acotejar VMM03S0 +acotejemos acotejar VMM01P0 +acotejen acotejar VMM03P0 +acotemos acotar VMM01P0 +acoten acotar VMM03P0 +acoyunda acoyundar VMM02S0 +acoyundad acoyundar VMM02P0 +acoyundando acoyundar VMG0000 +acoyundar acoyundar VMN0000 +acoyunde acoyundar VMM03S0 +acoyundemos acoyundar VMM01P0 +acoyunden acoyundar VMM03P0 +acoyunta acoyuntar VMM02S0 +acoyuntad acoyuntar VMM02P0 +acoyuntando acoyuntar VMG0000 +acoyuntar acoyuntar VMN0000 +acoyunte acoyuntar VMM03S0 +acoyuntemos acoyuntar VMM01P0 +acoyunten acoyuntar VMM03P0 +acrece acrecer VMM02S0 +acreced acrecer VMM02P0 +acrecentad acrecentar VMM02P0 +acrecentando acrecentar VMG0000 +acrecentar acrecentar VMN0000 +acrecentemos acrecentar VMM01P0 +acrecer acrecer VMN0000 +acreciendo acrecer VMG0000 +acrecienta acrecentar VMM02S0 +acreciente acrecentar VMM03S0 +acrecienten acrecentar VMM03P0 +acredita acreditar VMM02S0 +acreditad acreditar VMM02P0 +acreditando acreditar VMG0000 +acreditar acreditar VMN0000 +acredite acreditar VMM03S0 +acreditemos acreditar VMM01P0 +acrediten acreditar VMM03P0 +acrezca acrecer VMM03S0 +acrezcamos acrecer VMM01P0 +acrezcan acrecer VMM03P0 +acriba acribar VMM02S0 +acribad acribar VMM02P0 +acribando acribar VMG0000 +acribar acribar VMN0000 +acribe acribar VMM03S0 +acribemos acribar VMM01P0 +acriben acribar VMM03P0 +acribilla acribillar VMM02S0 +acribillad acribillar VMM02P0 +acribillando acribillar VMG0000 +acribillar acribillar VMN0000 +acribille acribillar VMM03S0 +acribillemos acribillar VMM01P0 +acribillen acribillar VMM03P0 +acrimina acriminar VMM02S0 +acriminad acriminar VMM02P0 +acriminando acriminar VMG0000 +acriminar acriminar VMN0000 +acrimine acriminar VMM03S0 +acriminemos acriminar VMM01P0 +acriminen acriminar VMM03P0 +acriolla acriollar VMM02S0 +acriollad acriollar VMM02P0 +acriollando acriollar VMG0000 +acriollar acriollar VMN0000 +acriolle acriollar VMM03S0 +acriollemos acriollar VMM01P0 +acriollen acriollar VMM03P0 +acrisola acrisolar VMM02S0 +acrisolad acrisolar VMM02P0 +acrisolando acrisolar VMG0000 +acrisolar acrisolar VMN0000 +acrisole acrisolar VMM03S0 +acrisolemos acrisolar VMM01P0 +acrisolen acrisolar VMM03P0 +acristala acristalar VMM02S0 +acristalad acristalar VMM02P0 +acristalando acristalar VMG0000 +acristalar acristalar VMN0000 +acristale acristalar VMM03S0 +acristalemos acristalar VMM01P0 +acristalen acristalar VMM03P0 +acristiana acristianar VMM02S0 +acristianad acristianar VMM02P0 +acristianando acristianar VMG0000 +acristianar acristianar VMN0000 +acristiane acristianar VMM03S0 +acristianemos acristianar VMM01P0 +acristianen acristianar VMM03P0 +acromatice acromatizar VMM03S0 +acromaticemos acromatizar VMM01P0 +acromaticen acromatizar VMM03P0 +acromatiza acromatizar VMM02S0 +acromatizad acromatizar VMM02P0 +acromatizando acromatizar VMG0000 +acromatizar acromatizar VMN0000 +activa activar VMM02S0 +activad activar VMM02P0 +activando activar VMG0000 +activar activar VMN0000 +active activar VMM03S0 +activemos activar VMM01P0 +activen activar VMM03P0 +actuad actuar VMM02P0 +actualice actualizar VMM03S0 +actualicemos actualizar VMM01P0 +actualicen actualizar VMM03P0 +actualiza actualizar VMM02S0 +actualizad actualizar VMM02P0 +actualizando actualizar VMG0000 +actualizar actualizar VMN0000 +actuando actuar VMG0000 +actuar actuar VMN0000 +actuemos actuar VMM01P0 +actúa actuar VMM02S0 +actúe actuar VMM03S0 +actúen actuar VMM03P0 +acuadrilla acuadrillar VMM02S0 +acuadrillad acuadrillar VMM02P0 +acuadrillando acuadrillar VMG0000 +acuadrillar acuadrillar VMN0000 +acuadrille acuadrillar VMM03S0 +acuadrillemos acuadrillar VMM01P0 +acuadrillen acuadrillar VMM03P0 +acuantia acuantiar VMM02S0 +acuantiad acuantiar VMM02P0 +acuantiando acuantiar VMG0000 +acuantiar acuantiar VMN0000 +acuantie acuantiar VMM03S0 +acuantiemos acuantiar VMM01P0 +acuantien acuantiar VMM03P0 +acuartela acuartelar VMM02S0 +acuartelad acuartelar VMM02P0 +acuartelando acuartelar VMG0000 +acuartelar acuartelar VMN0000 +acuartele acuartelar VMM03S0 +acuartelemos acuartelar VMM01P0 +acuartelen acuartelar VMM03P0 +acuartilla acuartillar VMM02S0 +acuartillad acuartillar VMM02P0 +acuartillando acuartillar VMG0000 +acuartillar acuartillar VMN0000 +acuartille acuartillar VMM03S0 +acuartillemos acuartillar VMM01P0 +acuartillen acuartillar VMM03P0 +acuatice acuatizar VMM03S0 +acuaticemos acuatizar VMM01P0 +acuaticen acuatizar VMM03P0 +acuatiza acuatizar VMM02S0 +acuatizad acuatizar VMM02P0 +acuatizando acuatizar VMG0000 +acuatizar acuatizar VMN0000 +acucha acuchar VMM02S0 +acuchad acuchar VMM02P0 +acuchando acuchar VMG0000 +acuchar acuchar VMN0000 +acuche acuchar VMM03S0 +acuchemos acuchar VMM01P0 +acuchen acuchar VMM03P0 +acuchilla acuchillar VMM02S0 +acuchillad acuchillar VMM02P0 +acuchillando acuchillar VMG0000 +acuchillar acuchillar VMN0000 +acuchille acuchillar VMM03S0 +acuchillemos acuchillar VMM01P0 +acuchillen acuchillar VMM03P0 +acucia acuciar VMM02S0 +acuciad acuciar VMM02P0 +acuciando acuciar VMG0000 +acuciar acuciar VMN0000 +acucie acuciar VMM03S0 +acuciemos acuciar VMM01P0 +acucien acuciar VMM03P0 +acuclilla acuclillar VMM02S0 +acuclillad acuclillar VMM02P0 +acuclillando acuclillar VMG0000 +acuclillar acuclillar VMN0000 +acuclille acuclillar VMM03S0 +acuclillemos acuclillar VMM01P0 +acuclillen acuclillar VMM03P0 +acuda acudir VMM03S0 +acudamos acudir VMM01P0 +acudan acudir VMM03P0 +acude acudir VMM02S0 +acudid acudir VMM02P0 +acudiendo acudir VMG0000 +acudir acudir VMN0000 +acuella acollar VMM02S0 +acuelle acollar VMM03S0 +acuellen acollar VMM03P0 +acuerda acordar VMM02S0 +acuerde acordar VMM03S0 +acuerden acordar VMM03P0 +acuerna acornar VMM02S0 +acuerne acornar VMM03S0 +acuernen acornar VMM03P0 +acuesta acostar VMM02S0 +acueste acostar VMM03S0 +acuesten acostar VMM03P0 +acuita acuitar VMM02S0 +acuitad acuitar VMM02P0 +acuitando acuitar VMG0000 +acuitar acuitar VMN0000 +acuite acuitar VMM03S0 +acuitemos acuitar VMM01P0 +acuiten acuitar VMM03P0 +acula acular VMM02S0 +aculad acular VMM02P0 +aculando acular VMG0000 +acular acular VMN0000 +acule acular VMM03S0 +aculemos acular VMM01P0 +aculen acular VMM03P0 +acumula acumular VMM02S0 +acumulad acumular VMM02P0 +acumulando acumular VMG0000 +acumular acumular VMN0000 +acumule acumular VMM03S0 +acumulemos acumular VMM01P0 +acumulen acumular VMM03P0 +acuna acunar VMM02S0 +acunad acunar VMM02P0 +acunando acunar VMG0000 +acunar acunar VMN0000 +acune acunar VMM03S0 +acunemos acunar VMM01P0 +acunen acunar VMM03P0 +acurruca acurrucar VMM02S0 +acurrucad acurrucar VMM02P0 +acurrucando acurrucar VMG0000 +acurrucar acurrucar VMN0000 +acurrulla acurrullar VMM02S0 +acurrullad acurrullar VMM02P0 +acurrullando acurrullar VMG0000 +acurrullar acurrullar VMN0000 +acurrulle acurrullar VMM03S0 +acurrullemos acurrullar VMM01P0 +acurrullen acurrullar VMM03P0 +acurruque acurrucar VMM03S0 +acurruquemos acurrucar VMM01P0 +acurruquen acurrucar VMM03P0 +acusa acusar VMM02S0 +acusad acusar VMM02P0 +acusando acusar VMG0000 +acusar acusar VMN0000 +acuse acusar VMM03S0 +acusemos acusar VMM01P0 +acusen acusar VMM03P0 +acuña acuñar VMM02S0 +acuñad acuñar VMM02P0 +acuñando acuñar VMG0000 +acuñar acuñar VMN0000 +acuñe acuñar VMM03S0 +acuñemos acuñar VMM01P0 +acuñen acuñar VMM03P0 +ada adir VMM03S0 +adama adamar VMM02S0 +adamad adamar VMM02P0 +adamando adamar VMG0000 +adamar adamar VMN0000 +adamasca adamascar VMM02S0 +adamascad adamascar VMM02P0 +adamascando adamascar VMG0000 +adamascar adamascar VMN0000 +adamasque adamascar VMM03S0 +adamasquemos adamascar VMM01P0 +adamasquen adamascar VMM03P0 +adame adamar VMM03S0 +adamemos adamar VMM01P0 +adamen adamar VMM03P0 +adamos adir VMM01P0 +adan adir VMM03P0 +adapta adaptar VMM02S0 +adaptad adaptar VMM02P0 +adaptando adaptar VMG0000 +adaptar adaptar VMN0000 +adapte adaptar VMM03S0 +adaptemos adaptar VMM01P0 +adapten adaptar VMM03P0 +adardea adardear VMM02S0 +adardead adardear VMM02P0 +adardeando adardear VMG0000 +adardear adardear VMN0000 +adarga adargar VMM02S0 +adargad adargar VMM02P0 +adargando adargar VMG0000 +adargar adargar VMN0000 +adargue adargar VMM03S0 +adarguemos adargar VMM01P0 +adarguen adargar VMM03P0 +adarva adarvar VMM02S0 +adarvad adarvar VMM02P0 +adarvando adarvar VMG0000 +adarvar adarvar VMN0000 +adarve adarvar VMM03S0 +adarvemos adarvar VMM01P0 +adarven adarvar VMM03P0 +ade adir VMM02S0 +adecena adecenar VMM02S0 +adecenad adecenar VMM02P0 +adecenando adecenar VMG0000 +adecenar adecenar VMN0000 +adecene adecenar VMM03S0 +adecenemos adecenar VMM01P0 +adecenen adecenar VMM03P0 +adecenta adecentar VMM02S0 +adecentad adecentar VMM02P0 +adecentando adecentar VMG0000 +adecentar adecentar VMN0000 +adecente adecentar VMM03S0 +adecentemos adecentar VMM01P0 +adecenten adecentar VMM03P0 +adecuad adecuar VMM02P0 +adecuando adecuar VMG0000 +adecuar adecuar VMN0000 +adecuemos adecuar VMM01P0 +adecúa adecuar VMM02S0 +adecúe adecuar VMM03S0 +adecúen adecuar VMM03P0 +adelanta adelantar VMM02S0 +adelantad adelantar VMM02P0 +adelantando adelantar VMG0000 +adelantar adelantar VMN0000 +adelante adelantar VMM03S0 +adelantemos adelantar VMM01P0 +adelanten adelantar VMM03P0 +adelgace adelgazar VMM03S0 +adelgacemos adelgazar VMM01P0 +adelgacen adelgazar VMM03P0 +adelgaza adelgazar VMM02S0 +adelgazad adelgazar VMM02P0 +adelgazando adelgazar VMG0000 +adelgazar adelgazar VMN0000 +adema ademar VMM02S0 +ademad ademar VMM02P0 +ademando ademar VMG0000 +ademar ademar VMN0000 +ademe ademar VMM03S0 +adememos ademar VMM01P0 +ademen ademar VMM03P0 +adentra adentrar VMM02S0 +adentrad adentrar VMM02P0 +adentrando adentrar VMG0000 +adentrar adentrar VMN0000 +adentre adentrar VMM03S0 +adentremos adentrar VMM01P0 +adentren adentrar VMM03P0 +aderece aderezar VMM03S0 +aderecemos aderezar VMM01P0 +aderecen aderezar VMM03P0 +adereza aderezar VMM02S0 +aderezad aderezar VMM02P0 +aderezando aderezar VMG0000 +aderezar aderezar VMN0000 +adestra adestrar VMM02S0 +adestrad adestrar VMM02P0 +adestrando adestrar VMG0000 +adestrar adestrar VMN0000 +adestre adestrar VMM03S0 +adestremos adestrar VMM01P0 +adestren adestrar VMM03P0 +adeuda adeudar VMM02S0 +adeudad adeudar VMM02P0 +adeudando adeudar VMG0000 +adeudar adeudar VMN0000 +adeude adeudar VMM03S0 +adeudemos adeudar VMM01P0 +adeuden adeudar VMM03P0 +adherid adherir VMM02P0 +adherir adherir VMN0000 +adhiera adherir VMM03S0 +adhieran adherir VMM03P0 +adhiere adherir VMM02S0 +adhiramos adherir VMM01P0 +adhiriendo adherir VMG0000 +adiciona adicionar VMM02S0 +adicionad adicionar VMM02P0 +adicionando adicionar VMG0000 +adicionar adicionar VMN0000 +adicione adicionar VMM03S0 +adicionemos adicionar VMM01P0 +adicionen adicionar VMM03P0 +adid adir VMM02P0 +adiendo adir VMG0000 +adiestra adiestrar VMM02S0 +adiestrad adiestrar VMM02P0 +adiestrando adiestrar VMG0000 +adiestrar adiestrar VMN0000 +adiestre adiestrar VMM03S0 +adiestremos adiestrar VMM01P0 +adiestren adiestrar VMM03P0 +adieta adietar VMM02S0 +adietad adietar VMM02P0 +adietando adietar VMG0000 +adietar adietar VMN0000 +adiete adietar VMM03S0 +adietemos adietar VMM01P0 +adieten adietar VMM03P0 +adinera adinerar VMM02S0 +adinerad adinerar VMM02P0 +adinerando adinerar VMG0000 +adinerar adinerar VMN0000 +adinere adinerar VMM03S0 +adineremos adinerar VMM01P0 +adineren adinerar VMM03P0 +adir adir VMN0000 +adivina adivinar VMM02S0 +adivinad adivinar VMM02P0 +adivinando adivinar VMG0000 +adivinar adivinar VMN0000 +adivine adivinar VMM03S0 +adivinemos adivinar VMM01P0 +adivinen adivinar VMM03P0 +adjetiva adjetivar VMM02S0 +adjetivad adjetivar VMM02P0 +adjetivando adjetivar VMG0000 +adjetivar adjetivar VMN0000 +adjetive adjetivar VMM03S0 +adjetivemos adjetivar VMM01P0 +adjetiven adjetivar VMM03P0 +adjudica adjudicar VMM02S0 +adjudicad adjudicar VMM02P0 +adjudicando adjudicar VMG0000 +adjudicar adjudicar VMN0000 +adjudique adjudicar VMM03S0 +adjudiquemos adjudicar VMM01P0 +adjudiquen adjudicar VMM03P0 +adjunta adjuntar VMM02S0 +adjuntad adjuntar VMM02P0 +adjuntando adjuntar VMG0000 +adjuntar adjuntar VMN0000 +adjunte adjuntar VMM03S0 +adjuntemos adjuntar VMM01P0 +adjunten adjuntar VMM03P0 +adjura adjurar VMM02S0 +adjurad adjurar VMM02P0 +adjurando adjurar VMG0000 +adjurar adjurar VMN0000 +adjure adjurar VMM03S0 +adjuremos adjurar VMM01P0 +adjuren adjurar VMM03P0 +adminicula adminicular VMM02S0 +adminiculad adminicular VMM02P0 +adminiculando adminicular VMG0000 +adminicular adminicular VMN0000 +adminicule adminicular VMM03S0 +adminiculemos adminicular VMM01P0 +adminiculen adminicular VMM03P0 +administra administrar VMM02S0 +administrad administrar VMM02P0 +administrando administrar VMG0000 +administrar administrar VMN0000 +administre administrar VMM03S0 +administremos administrar VMM01P0 +administren administrar VMM03P0 +admira admirar VMM02S0 +admirad admirar VMM02P0 +admirando admirar VMG0000 +admirar admirar VMN0000 +admire admirar VMM03S0 +admiremos admirar VMM01P0 +admiren admirar VMM03P0 +admita admitir VMM03S0 +admitamos admitir VMM01P0 +admitan admitir VMM03P0 +admite admitir VMM02S0 +admitid admitir VMM02P0 +admitiendo admitir VMG0000 +admitir admitir VMN0000 +adoba adobar VMM02S0 +adobad adobar VMM02P0 +adobando adobar VMG0000 +adobar adobar VMN0000 +adobe adobar VMM03S0 +adobemos adobar VMM01P0 +adoben adobar VMM03P0 +adocena adocenar VMM02S0 +adocenad adocenar VMM02P0 +adocenando adocenar VMG0000 +adocenar adocenar VMN0000 +adocene adocenar VMM03S0 +adocenemos adocenar VMM01P0 +adocenen adocenar VMM03P0 +adoctrina adoctrinar VMM02S0 +adoctrinad adoctrinar VMM02P0 +adoctrinando adoctrinar VMG0000 +adoctrinar adoctrinar VMN0000 +adoctrine adoctrinar VMM03S0 +adoctrinemos adoctrinar VMM01P0 +adoctrinen adoctrinar VMM03P0 +adolece adolecer VMM02S0 +adoleced adolecer VMM02P0 +adolecer adolecer VMN0000 +adoleciendo adolecer VMG0000 +adolezca adolecer VMM03S0 +adolezcamos adolecer VMM01P0 +adolezcan adolecer VMM03P0 +adopta adoptar VMM02S0 +adoptad adoptar VMM02P0 +adoptando adoptar VMG0000 +adoptar adoptar VMN0000 +adopte adoptar VMM03S0 +adoptemos adoptar VMM01P0 +adopten adoptar VMM03P0 +adoquina adoquinar VMM02S0 +adoquinad adoquinar VMM02P0 +adoquinando adoquinar VMG0000 +adoquinar adoquinar VMN0000 +adoquine adoquinar VMM03S0 +adoquinemos adoquinar VMM01P0 +adoquinen adoquinar VMM03P0 +adora adorar VMM02S0 +adorad adorar VMM02P0 +adorando adorar VMG0000 +adorar adorar VMN0000 +adore adorar VMM03S0 +adoremos adorar VMM01P0 +adoren adorar VMM03P0 +adormece adormecer VMM02S0 +adormeced adormecer VMM02P0 +adormecer adormecer VMN0000 +adormeciendo adormecer VMG0000 +adormezca adormecer VMM03S0 +adormezcamos adormecer VMM01P0 +adormezcan adormecer VMM03P0 +adormila adormilar VMM02S0 +adormilad adormilar VMM02P0 +adormilando adormilar VMG0000 +adormilar adormilar VMN0000 +adormile adormilar VMM03S0 +adormilemos adormilar VMM01P0 +adormilen adormilar VMM03P0 +adormita adormitar VMM02S0 +adormitad adormitar VMM02P0 +adormitando adormitar VMG0000 +adormitar adormitar VMN0000 +adormite adormitar VMM03S0 +adormitemos adormitar VMM01P0 +adormiten adormitar VMM03P0 +adorna adornar VMM02S0 +adornad adornar VMM02P0 +adornando adornar VMG0000 +adornar adornar VMN0000 +adorne adornar VMM03S0 +adornemos adornar VMM01P0 +adornen adornar VMM03P0 +adosa adosar VMM02S0 +adosad adosar VMM02P0 +adosando adosar VMG0000 +adosar adosar VMN0000 +adose adosar VMM03S0 +adosemos adosar VMM01P0 +adosen adosar VMM03P0 +adquiera adquirir VMM03S0 +adquieran adquirir VMM03P0 +adquiere adquirir VMM02S0 +adquiramos adquirir VMM01P0 +adquirid adquirir VMM02P0 +adquiriendo adquirir VMG0000 +adquirir adquirir VMN0000 +adrice adrizar VMM03S0 +adricemos adrizar VMM01P0 +adricen adrizar VMM03P0 +adriza adrizar VMM02S0 +adrizad adrizar VMM02P0 +adrizando adrizar VMG0000 +adrizar adrizar VMN0000 +adroga adrogar VMM02S0 +adrogad adrogar VMM02P0 +adrogando adrogar VMG0000 +adrogar adrogar VMN0000 +adscriba adscribir VMM03S0 +adscribamos adscribir VMM01P0 +adscriban adscribir VMM03P0 +adscribe adscribir VMM02S0 +adscribid adscribir VMM02P0 +adscribiendo adscribir VMG0000 +adscribir adscribir VMN0000 +adsorba adsorber VMM03S0 +adsorbamos adsorber VMM01P0 +adsorban adsorber VMM03P0 +adsorbe adsorber VMM02S0 +adsorbed adsorber VMM02P0 +adsorber adsorber VMN0000 +adsorbiendo adsorber VMG0000 +adstringe adstringir VMM02S0 +adstringid adstringir VMM02P0 +adstringiendo adstringir VMG0000 +adstringir adstringir VMN0000 +adstrinja adstringir VMM03S0 +adstrinjamos adstringir VMM01P0 +adstrinjan adstringir VMM03P0 +aduana aduanar VMM02S0 +aduanad aduanar VMM02P0 +aduanando aduanar VMG0000 +aduanar aduanar VMN0000 +aduane aduanar VMM03S0 +aduanemos aduanar VMM01P0 +aduanen aduanar VMM03P0 +aduce aducir VMM02S0 +aducid aducir VMM02P0 +aduciendo aducir VMG0000 +aducir aducir VMN0000 +adueña adueñar VMM02S0 +adueñad adueñar VMM02P0 +adueñando adueñar VMG0000 +adueñar adueñar VMN0000 +adueñe adueñar VMM03S0 +adueñemos adueñar VMM01P0 +adueñen adueñar VMM03P0 +aduja adujar VMM02S0 +adujad adujar VMM02P0 +adujando adujar VMG0000 +adujar adujar VMN0000 +aduje adujar VMM03S0 +adujemos adujar VMM01P0 +adujen adujar VMM03P0 +adula adular VMM02S0 +adulad adular VMM02P0 +adulando adular VMG0000 +adular adular VMN0000 +adulce adulzar VMM03S0 +adulcemos adulzar VMM01P0 +adulcen adulzar VMM03P0 +adule adular VMM03S0 +adulemos adular VMM01P0 +adulen adular VMM03P0 +adultera adulterar VMM02S0 +adulterad adulterar VMM02P0 +adulterando adulterar VMG0000 +adulterar adulterar VMN0000 +adultere adulterar VMM03S0 +adulteremos adulterar VMM01P0 +adulteren adulterar VMM03P0 +adulza adulzar VMM02S0 +adulzad adulzar VMM02P0 +adulzando adulzar VMG0000 +adulzar adulzar VMN0000 +adulzora adulzorar VMM02S0 +adulzorad adulzorar VMM02P0 +adulzorando adulzorar VMG0000 +adulzorar adulzorar VMN0000 +adulzore adulzorar VMM03S0 +adulzoremos adulzorar VMM01P0 +adulzoren adulzorar VMM03P0 +aduna adunar VMM02S0 +adunad adunar VMM02P0 +adunando adunar VMG0000 +adunar adunar VMN0000 +adune adunar VMM03S0 +adunemos adunar VMM01P0 +adunen adunar VMM03P0 +aduzca aducir VMM03S0 +aduzcamos aducir VMM01P0 +aduzcan aducir VMM03P0 +adven advenir VMM02S0 +advenga advenir VMM03S0 +advengamos advenir VMM01P0 +advengan advenir VMM03P0 +advenid advenir VMM02P0 +advenir advenir VMN0000 +advera adverar VMM02S0 +adverad adverar VMM02P0 +adverando adverar VMG0000 +adverar adverar VMN0000 +adverbialice adverbializar VMM03S0 +adverbialicemos adverbializar VMM01P0 +adverbialicen adverbializar VMM03P0 +adverbializa adverbializar VMM02S0 +adverbializad adverbializar VMM02P0 +adverbializando adverbializar VMG0000 +adverbializar adverbializar VMN0000 +advere adverar VMM03S0 +adveremos adverar VMM01P0 +adveren adverar VMM03P0 +advertid advertir VMM02P0 +advertir advertir VMN0000 +advierta advertir VMM03S0 +adviertan advertir VMM03P0 +advierte advertir VMM02S0 +adviniendo advenir VMG0000 +advirtamos advertir VMM01P0 +advirtiendo advertir VMG0000 +afama afamar VMM02S0 +afamad afamar VMM02P0 +afamando afamar VMG0000 +afamar afamar VMN0000 +afame afamar VMM03S0 +afamemos afamar VMM01P0 +afamen afamar VMM03P0 +afana afanar VMM02S0 +afanad afanar VMM02P0 +afanando afanar VMG0000 +afanar afanar VMN0000 +afane afanar VMM03S0 +afanemos afanar VMM01P0 +afanen afanar VMM03P0 +afea afear VMM02S0 +afead afear VMM02P0 +afeando afear VMG0000 +afear afear VMN0000 +afecta afectar VMM02S0 +afectad afectar VMM02P0 +afectando afectar VMG0000 +afectar afectar VMN0000 +afecte afectar VMM03S0 +afectemos afectar VMM01P0 +afecten afectar VMM03P0 +afee afear VMM03S0 +afeemos afear VMM01P0 +afeen afear VMM03P0 +afeita afeitar VMM02S0 +afeitad afeitar VMM02P0 +afeitando afeitar VMG0000 +afeitar afeitar VMN0000 +afeite afeitar VMM03S0 +afeitemos afeitar VMM01P0 +afeiten afeitar VMM03P0 +afelpa afelpar VMM02S0 +afelpad afelpar VMM02P0 +afelpando afelpar VMG0000 +afelpar afelpar VMN0000 +afelpe afelpar VMM03S0 +afelpemos afelpar VMM01P0 +afelpen afelpar VMM03P0 +afemina afeminar VMM02S0 +afeminad afeminar VMM02P0 +afeminando afeminar VMG0000 +afeminar afeminar VMN0000 +afemine afeminar VMM03S0 +afeminemos afeminar VMM01P0 +afeminen afeminar VMM03P0 +aferra aferrar VMM02S0 +aferrad aferrar VMM02P0 +aferrando aferrar VMG0000 +aferrar aferrar VMN0000 +aferre aferrar VMM03S0 +aferremos aferrar VMM01P0 +aferren aferrar VMM03P0 +afiance afianzar VMM03S0 +afiancemos afianzar VMM01P0 +afiancen afianzar VMM03P0 +afianza afianzar VMM02S0 +afianzad afianzar VMM02P0 +afianzando afianzar VMG0000 +afianzar afianzar VMN0000 +aficiona aficionar VMM02S0 +aficionad aficionar VMM02P0 +aficionando aficionar VMG0000 +aficionar aficionar VMN0000 +aficione aficionar VMM03S0 +aficionemos aficionar VMM01P0 +aficionen aficionar VMM03P0 +afiebra afiebrar VMM02S0 +afiebrad afiebrar VMM02P0 +afiebrando afiebrar VMG0000 +afiebrar afiebrar VMN0000 +afiebre afiebrar VMM03S0 +afiebremos afiebrar VMM01P0 +afiebren afiebrar VMM03P0 +afija afijar VMM02S0 +afijad afijar VMM02P0 +afijando afijar VMG0000 +afijar afijar VMN0000 +afije afijar VMM03S0 +afijemos afijar VMM01P0 +afijen afijar VMM03P0 +afila afilar VMM02S0 +afilad afilar VMM02P0 +afilando afilar VMG0000 +afilar afilar VMN0000 +afile afilar VMM03S0 +afilemos afilar VMM01P0 +afilen afilar VMM03P0 +afilia afiliar VMM02S0 +afiliad afiliar VMM02P0 +afiliando afiliar VMG0000 +afiliar afiliar VMN0000 +afilie afiliar VMM03S0 +afiliemos afiliar VMM01P0 +afilien afiliar VMM03P0 +afiligrana afiligranar VMM02S0 +afiligranad afiligranar VMM02P0 +afiligranando afiligranar VMG0000 +afiligranar afiligranar VMN0000 +afiligrane afiligranar VMM03S0 +afiligranemos afiligranar VMM01P0 +afiligranen afiligranar VMM03P0 +afina afinar VMM02S0 +afinad afinar VMM02P0 +afinando afinar VMG0000 +afinar afinar VMN0000 +afinca afincar VMM02S0 +afincad afincar VMM02P0 +afincando afincar VMG0000 +afincar afincar VMN0000 +afine afinar VMM03S0 +afinemos afinar VMM01P0 +afinen afinar VMM03P0 +afinque afincar VMM03S0 +afinquemos afincar VMM01P0 +afinquen afincar VMM03P0 +afirma afirmar VMM02S0 +afirmad afirmar VMM02P0 +afirmando afirmar VMG0000 +afirmar afirmar VMN0000 +afirme afirmar VMM03S0 +afirmemos afirmar VMM01P0 +afirmen afirmar VMM03P0 +afistula afistular VMM02S0 +afistulad afistular VMM02P0 +afistulando afistular VMG0000 +afistular afistular VMN0000 +afistule afistular VMM03S0 +afistulemos afistular VMM01P0 +afistulen afistular VMM03P0 +aflige afligir VMM02S0 +afligid afligir VMM02P0 +afligiendo afligir VMG0000 +afligir afligir VMN0000 +aflija afligir VMM03S0 +aflijamos afligir VMM01P0 +aflijan afligir VMM03P0 +afloja aflojar VMM02S0 +aflojad aflojar VMM02P0 +aflojando aflojar VMG0000 +aflojar aflojar VMN0000 +afloje aflojar VMM03S0 +aflojemos aflojar VMM01P0 +aflojen aflojar VMM03P0 +aflora aflorar VMM02S0 +aflorad aflorar VMM02P0 +aflorando aflorar VMG0000 +aflorar aflorar VMN0000 +aflore aflorar VMM03S0 +afloremos aflorar VMM01P0 +afloren aflorar VMM03P0 +afluid afluir VMM02P0 +afluir afluir VMN0000 +afluya afluir VMM03S0 +afluyamos afluir VMM01P0 +afluyan afluir VMM03P0 +afluye afluir VMM02S0 +afluyendo afluir VMG0000 +afogara afogarar VMM02S0 +afogarad afogarar VMM02P0 +afogarando afogarar VMG0000 +afogarar afogarar VMN0000 +afogare afogarar VMM03S0 +afogaremos afogarar VMM01P0 +afogaren afogarar VMM03P0 +afollad afollar VMM02P0 +afollando afollar VMG0000 +afollar afollar VMN0000 +afollemos afollar VMM01P0 +aforad aforar VMM02P0 +aforando aforar VMG0000 +aforar aforar VMN0000 +aforemos aforar VMM01P0 +aforra aforrar VMM02S0 +aforrad aforrar VMM02P0 +aforrando aforrar VMG0000 +aforrar aforrar VMN0000 +aforre aforrar VMM03S0 +aforremos aforrar VMM01P0 +aforren aforrar VMM03P0 +afosca afoscar VMM02S0 +afoscad afoscar VMM02P0 +afoscando afoscar VMG0000 +afoscar afoscar VMN0000 +afosque afoscar VMM03S0 +afosquemos afoscar VMM01P0 +afosquen afoscar VMM03P0 +afraila afrailar VMM02S0 +afrailad afrailar VMM02P0 +afrailando afrailar VMG0000 +afrailar afrailar VMN0000 +afraile afrailar VMM03S0 +afrailemos afrailar VMM01P0 +afrailen afrailar VMM03P0 +afrancesa afrancesar VMM02S0 +afrancesad afrancesar VMM02P0 +afrancesando afrancesar VMG0000 +afrancesar afrancesar VMN0000 +afrancese afrancesar VMM03S0 +afrancesemos afrancesar VMM01P0 +afrancesen afrancesar VMM03P0 +afrenilla afrenillar VMM02S0 +afrenillad afrenillar VMM02P0 +afrenillando afrenillar VMG0000 +afrenillar afrenillar VMN0000 +afrenille afrenillar VMM03S0 +afrenillemos afrenillar VMM01P0 +afrenillen afrenillar VMM03P0 +afrenta afrentar VMM02S0 +afrentad afrentar VMM02P0 +afrentando afrentar VMG0000 +afrentar afrentar VMN0000 +afrente afrentar VMM03S0 +afrentemos afrentar VMM01P0 +afrenten afrentar VMM03P0 +afreta afretar VMM02S0 +afretad afretar VMM02P0 +afretando afretar VMG0000 +afretar afretar VMN0000 +afrete afretar VMM03S0 +afretemos afretar VMM01P0 +afreten afretar VMM03P0 +africanice africanizar VMM03S0 +africanicemos africanizar VMM01P0 +africanicen africanizar VMM03P0 +africaniza africanizar VMM02S0 +africanizad africanizar VMM02P0 +africanizando africanizar VMG0000 +africanizar africanizar VMN0000 +afronta afrontar VMM02S0 +afrontad afrontar VMM02P0 +afrontando afrontar VMG0000 +afrontar afrontar VMN0000 +afronte afrontar VMM03S0 +afrontemos afrontar VMM01P0 +afronten afrontar VMM03P0 +afrontila afrontilar VMM02S0 +afrontilad afrontilar VMM02P0 +afrontilando afrontilar VMG0000 +afrontilar afrontilar VMN0000 +afrontile afrontilar VMM03S0 +afrontilemos afrontilar VMM01P0 +afrontilen afrontilar VMM03P0 +afuella afollar VMM02S0 +afuelle afollar VMM03S0 +afuellen afollar VMM03P0 +afuera aforar VMM02S0 +afuere aforar VMM03S0 +afueren aforar VMM03P0 +afuetea afuetear VMM02S0 +afuetead afuetear VMM02P0 +afueteando afuetear VMG0000 +afuetear afuetear VMN0000 +afuetee afuetear VMM03S0 +afueteemos afuetear VMM01P0 +afueteen afuetear VMM03P0 +afufa afufar VMM02S0 +afufad afufar VMM02P0 +afufando afufar VMG0000 +afufar afufar VMN0000 +afufe afufar VMM03S0 +afufemos afufar VMM01P0 +afufen afufar VMM03P0 +afutra afutrar VMM02S0 +afutrad afutrar VMM02P0 +afutrando afutrar VMG0000 +afutrar afutrar VMN0000 +afutre afutrar VMM03S0 +afutremos afutrar VMM01P0 +afutren afutrar VMM03P0 +agacha agachar VMM02S0 +agachad agachar VMM02P0 +agachando agachar VMG0000 +agachar agachar VMN0000 +agache agachar VMM03S0 +agachemos agachar VMM01P0 +agachen agachar VMM03P0 +agamita agamitar VMM02S0 +agamitad agamitar VMM02P0 +agamitando agamitar VMG0000 +agamitar agamitar VMN0000 +agamite agamitar VMM03S0 +agamitemos agamitar VMM01P0 +agamiten agamitar VMM03P0 +agarba agarbar VMM02S0 +agarbad agarbar VMM02P0 +agarbando agarbar VMG0000 +agarbar agarbar VMN0000 +agarbe agarbar VMM03S0 +agarbemos agarbar VMM01P0 +agarben agarbar VMM03P0 +agarbilla agarbillar VMM02S0 +agarbillad agarbillar VMM02P0 +agarbillando agarbillar VMG0000 +agarbillar agarbillar VMN0000 +agarbille agarbillar VMM03S0 +agarbillemos agarbillar VMM01P0 +agarbillen agarbillar VMM03P0 +agarra agarrar VMM02S0 +agarrad agarrar VMM02P0 +agarrando agarrar VMG0000 +agarrar agarrar VMN0000 +agarre agarrar VMM03S0 +agarremos agarrar VMM01P0 +agarren agarrar VMM03P0 +agarrocha agarrochar VMM02S0 +agarrochad agarrochar VMM02P0 +agarrochando agarrochar VMG0000 +agarrochar agarrochar VMN0000 +agarroche agarrochar VMM03S0 +agarrochemos agarrochar VMM01P0 +agarrochen agarrochar VMM03P0 +agarrota agarrotar VMM02S0 +agarrotad agarrotar VMM02P0 +agarrotando agarrotar VMG0000 +agarrotar agarrotar VMN0000 +agarrote agarrotar VMM03S0 +agarrotea agarrotear VMM02S0 +agarrotead agarrotear VMM02P0 +agarroteando agarrotear VMG0000 +agarrotear agarrotear VMN0000 +agarrotee agarrotear VMM03S0 +agarroteemos agarrotear VMM01P0 +agarroteen agarrotear VMM03P0 +agarrotemos agarrotar VMM01P0 +agarroten agarrotar VMM03P0 +agasaja agasajar VMM02S0 +agasajad agasajar VMM02P0 +agasajando agasajar VMG0000 +agasajar agasajar VMN0000 +agasaje agasajar VMM03S0 +agasajemos agasajar VMM01P0 +agasajen agasajar VMM03P0 +agavilla agavillar VMM02S0 +agavillad agavillar VMM02P0 +agavillando agavillar VMG0000 +agavillar agavillar VMN0000 +agaville agavillar VMM03S0 +agavillemos agavillar VMM01P0 +agavillen agavillar VMM03P0 +agazapa agazapar VMM02S0 +agazapad agazapar VMM02P0 +agazapando agazapar VMG0000 +agazapar agazapar VMN0000 +agazape agazapar VMM03S0 +agazapemos agazapar VMM01P0 +agazapen agazapar VMM03P0 +agencia agenciar VMM02S0 +agenciad agenciar VMM02P0 +agenciando agenciar VMG0000 +agenciar agenciar VMN0000 +agencie agenciar VMM03S0 +agenciemos agenciar VMM01P0 +agencien agenciar VMM03P0 +agermana agermanar VMM02S0 +agermanad agermanar VMM02P0 +agermanando agermanar VMG0000 +agermanar agermanar VMN0000 +agermane agermanar VMM03S0 +agermanemos agermanar VMM01P0 +agermanen agermanar VMM03P0 +agiganta agigantar VMM02S0 +agigantad agigantar VMM02P0 +agigantando agigantar VMG0000 +agigantar agigantar VMN0000 +agigante agigantar VMM03S0 +agigantemos agigantar VMM01P0 +agiganten agigantar VMM03P0 +agilice agilizar VMM03S0 +agilicemos agilizar VMM01P0 +agilicen agilizar VMM03P0 +agiliza agilizar VMM02S0 +agilizad agilizar VMM02P0 +agilizando agilizar VMG0000 +agilizar agilizar VMN0000 +agita agitar VMM02S0 +agitad agitar VMM02P0 +agitando agitar VMG0000 +agitar agitar VMN0000 +agite agitar VMM03S0 +agitemos agitar VMM01P0 +agiten agitar VMM03P0 +aglomera aglomerar VMM02S0 +aglomerad aglomerar VMM02P0 +aglomerando aglomerar VMG0000 +aglomerar aglomerar VMN0000 +aglomere aglomerar VMM03S0 +aglomeremos aglomerar VMM01P0 +aglomeren aglomerar VMM03P0 +aglutina aglutinar VMM02S0 +aglutinad aglutinar VMM02P0 +aglutinando aglutinar VMG0000 +aglutinar aglutinar VMN0000 +aglutine aglutinar VMM03S0 +aglutinemos aglutinar VMM01P0 +aglutinen aglutinar VMM03P0 +agobia agobiar VMM02S0 +agobiad agobiar VMM02P0 +agobiando agobiar VMG0000 +agobiar agobiar VMN0000 +agobie agobiar VMM03S0 +agobiemos agobiar VMM01P0 +agobien agobiar VMM03P0 +agolpa agolpar VMM02S0 +agolpad agolpar VMM02P0 +agolpando agolpar VMG0000 +agolpar agolpar VMN0000 +agolpe agolpar VMM03S0 +agolpemos agolpar VMM01P0 +agolpen agolpar VMM03P0 +agonice agonizar VMM03S0 +agonicemos agonizar VMM01P0 +agonicen agonizar VMM03P0 +agoniza agonizar VMM02S0 +agonizad agonizar VMM02P0 +agonizando agonizar VMG0000 +agonizar agonizar VMN0000 +agorad agorar VMM02P0 +agorando agorar VMG0000 +agorar agorar VMN0000 +agoremos agorar VMM01P0 +agorgoja agorgojar VMM02S0 +agorgojad agorgojar VMM02P0 +agorgojando agorgojar VMG0000 +agorgojar agorgojar VMN0000 +agorgoje agorgojar VMM03S0 +agorgojemos agorgojar VMM01P0 +agorgojen agorgojar VMM03P0 +agosta agostar VMM02S0 +agostad agostar VMM02P0 +agostando agostar VMG0000 +agostar agostar VMN0000 +agoste agostar VMM03S0 +agostemos agostar VMM01P0 +agosten agostar VMM03P0 +agota agotar VMM02S0 +agotad agotar VMM02P0 +agotando agotar VMG0000 +agotar agotar VMN0000 +agote agotar VMM03S0 +agotemos agotar VMM01P0 +agoten agotar VMM03P0 +agracia agraciar VMM02S0 +agraciad agraciar VMM02P0 +agraciando agraciar VMG0000 +agraciar agraciar VMN0000 +agracie agraciar VMM03S0 +agraciemos agraciar VMM01P0 +agracien agraciar VMM03P0 +agrada agradar VMM02S0 +agradad agradar VMM02P0 +agradando agradar VMG0000 +agradar agradar VMN0000 +agrade agradar VMM03S0 +agradece agradecer VMM02S0 +agradeced agradecer VMM02P0 +agradecer agradecer VMN0000 +agradeciendo agradecer VMG0000 +agrademos agradar VMM01P0 +agraden agradar VMM03P0 +agradezca agradecer VMM03S0 +agradezcamos agradecer VMM01P0 +agradezcan agradecer VMM03P0 +agrama agramar VMM02S0 +agramad agramar VMM02P0 +agramando agramar VMG0000 +agramar agramar VMN0000 +agrame agramar VMM03S0 +agramemos agramar VMM01P0 +agramen agramar VMM03P0 +agramila agramilar VMM02S0 +agramilad agramilar VMM02P0 +agramilando agramilar VMG0000 +agramilar agramilar VMN0000 +agramile agramilar VMM03S0 +agramilemos agramilar VMM01P0 +agramilen agramilar VMM03P0 +agranda agrandar VMM02S0 +agrandad agrandar VMM02P0 +agrandando agrandar VMG0000 +agrandar agrandar VMN0000 +agrande agrandar VMM03S0 +agrandemos agrandar VMM01P0 +agranden agrandar VMM03P0 +agranuja agranujar VMM02S0 +agranujad agranujar VMM02P0 +agranujando agranujar VMG0000 +agranujar agranujar VMN0000 +agranuje agranujar VMM03S0 +agranujemos agranujar VMM01P0 +agranujen agranujar VMM03P0 +agrava agravar VMM02S0 +agravad agravar VMM02P0 +agravando agravar VMG0000 +agravar agravar VMN0000 +agrave agravar VMM03S0 +agravemos agravar VMM01P0 +agraven agravar VMM03P0 +agravia agraviar VMM02S0 +agraviad agraviar VMM02P0 +agraviando agraviar VMG0000 +agraviar agraviar VMN0000 +agravie agraviar VMM03S0 +agraviemos agraviar VMM01P0 +agravien agraviar VMM03P0 +agreda agredir VMM03S0 +agredamos agredir VMM01P0 +agredan agredir VMM03P0 +agrede agredir VMM02S0 +agredid agredir VMM02P0 +agrediendo agredir VMG0000 +agredir agredir VMN0000 +agrega agregar VMM02S0 +agregad agregar VMM02P0 +agregando agregar VMG0000 +agregar agregar VMN0000 +agregue agregar VMM03S0 +agreguemos agregar VMM01P0 +agreguen agregar VMM03P0 +agremia agremiar VMM02S0 +agremiad agremiar VMM02P0 +agremiando agremiar VMG0000 +agremiar agremiar VMN0000 +agremie agremiar VMM03S0 +agremiemos agremiar VMM01P0 +agremien agremiar VMM03P0 +agria agriar VMM02S0 +agriad agriar VMM02P0 +agriando agriar VMG0000 +agriar agriar VMN0000 +agrie agriar VMM03S0 +agriemos agriar VMM01P0 +agrien agriar VMM03P0 +agrieta agrietar VMM02S0 +agrietad agrietar VMM02P0 +agrietando agrietar VMG0000 +agrietar agrietar VMN0000 +agriete agrietar VMM03S0 +agrietemos agrietar VMM01P0 +agrieten agrietar VMM03P0 +agrupa agrupar VMM02S0 +agrupad agrupar VMM02P0 +agrupando agrupar VMG0000 +agrupar agrupar VMN0000 +agrupe agrupar VMM03S0 +agrupemos agrupar VMM01P0 +agrupen agrupar VMM03P0 +agua aguar VMM02S0 +aguace aguazar VMM03S0 +aguacemos aguazar VMM01P0 +aguacen aguazar VMM03P0 +aguacha aguachar VMM02S0 +aguachad aguachar VMM02P0 +aguachando aguachar VMG0000 +aguachar aguachar VMN0000 +aguacharna aguacharnar VMM02S0 +aguacharnad aguacharnar VMM02P0 +aguacharnando aguacharnar VMG0000 +aguacharnar aguacharnar VMN0000 +aguacharne aguacharnar VMM03S0 +aguacharnemos aguacharnar VMM01P0 +aguacharnen aguacharnar VMM03P0 +aguache aguachar VMM03S0 +aguachemos aguachar VMM01P0 +aguachen aguachar VMM03P0 +aguachina aguachinar VMM02S0 +aguachinad aguachinar VMM02P0 +aguachinando aguachinar VMG0000 +aguachinar aguachinar VMN0000 +aguachine aguachinar VMM03S0 +aguachinemos aguachinar VMM01P0 +aguachinen aguachinar VMM03P0 +aguad aguar VMM02P0 +aguaita aguaitar VMM02S0 +aguaitad aguaitar VMM02P0 +aguaitando aguaitar VMG0000 +aguaitar aguaitar VMN0000 +aguaite aguaitar VMM03S0 +aguaitemos aguaitar VMM01P0 +aguaiten aguaitar VMM03P0 +aguando aguar VMG0000 +aguanta aguantar VMM02S0 +aguantad aguantar VMM02P0 +aguantando aguantar VMG0000 +aguantar aguantar VMN0000 +aguante aguantar VMM03S0 +aguantemos aguantar VMM01P0 +aguanten aguantar VMM03P0 +aguar aguar VMN0000 +aguarda aguardar VMM02S0 +aguardad aguardar VMM02P0 +aguardando aguardar VMG0000 +aguardar aguardar VMN0000 +aguarde aguardar VMM03S0 +aguardemos aguardar VMM01P0 +aguarden aguardar VMM03P0 +aguaza aguazar VMM02S0 +aguazad aguazar VMM02P0 +aguazando aguazar VMG0000 +aguazar aguazar VMN0000 +aguce aguzar VMM03S0 +agucemos aguzar VMM01P0 +agucen aguzar VMM03P0 +agudice agudizar VMM03S0 +agudicemos agudizar VMM01P0 +agudicen agudizar VMM03P0 +agudiza agudizar VMM02S0 +agudizad agudizar VMM02P0 +agudizando agudizar VMG0000 +agudizar agudizar VMN0000 +aguerra aguerrir VMM03S0 +aguerramos aguerrir VMM01P0 +aguerran aguerrir VMM03P0 +aguerre aguerrir VMM02S0 +aguerrid aguerrir VMM02P0 +aguerriendo aguerrir VMG0000 +aguerrir aguerrir VMN0000 +aguija aguijar VMM02S0 +aguijad aguijar VMM02P0 +aguijando aguijar VMG0000 +aguijar aguijar VMN0000 +aguije aguijar VMM03S0 +aguijemos aguijar VMM01P0 +aguijen aguijar VMM03P0 +aguijonea aguijonear VMM02S0 +aguijonead aguijonear VMM02P0 +aguijoneando aguijonear VMG0000 +aguijonear aguijonear VMN0000 +aguijonee aguijonear VMM03S0 +aguijoneemos aguijonear VMM01P0 +aguijoneen aguijonear VMM03P0 +aguizga aguizgar VMM02S0 +aguizgad aguizgar VMM02P0 +aguizgando aguizgar VMG0000 +aguizgar aguizgar VMN0000 +aguizgue aguizgar VMM03S0 +aguizguemos aguizgar VMM01P0 +aguizguen aguizgar VMM03P0 +agujera agujerar VMM02S0 +agujerad agujerar VMM02P0 +agujerando agujerar VMG0000 +agujerar agujerar VMN0000 +agujere agujerar VMM03S0 +agujerea agujerear VMM02S0 +agujeread agujerear VMM02P0 +agujereando agujerear VMG0000 +agujerear agujerear VMN0000 +agujeree agujerear VMM03S0 +agujereemos agujerear VMM01P0 +agujereen agujerear VMM03P0 +agujeremos agujerar VMM01P0 +agujeren agujerar VMM03P0 +agusana agusanar VMM02S0 +agusanad agusanar VMM02P0 +agusanando agusanar VMG0000 +agusanar agusanar VMN0000 +agusane agusanar VMM03S0 +agusanemos agusanar VMM01P0 +agusanen agusanar VMM03P0 +aguza aguzar VMM02S0 +aguzad aguzar VMM02P0 +aguzando aguzar VMG0000 +aguzar aguzar VMN0000 +agüe aguar VMM03S0 +agüemos aguar VMM01P0 +agüen aguar VMM03P0 +agüera agorar VMM02S0 +agüere agorar VMM03S0 +agüeren agorar VMM03P0 +ahecha ahechar VMM02S0 +ahechad ahechar VMM02P0 +ahechando ahechar VMG0000 +ahechar ahechar VMN0000 +aheche ahechar VMM03S0 +ahechemos ahechar VMM01P0 +ahechen ahechar VMM03P0 +ahelea ahelear VMM02S0 +ahelead ahelear VMM02P0 +aheleando ahelear VMG0000 +ahelear ahelear VMN0000 +ahelee ahelear VMM03S0 +aheleemos ahelear VMM01P0 +aheleen ahelear VMM03P0 +aherroja aherrojar VMM02S0 +aherrojad aherrojar VMM02P0 +aherrojando aherrojar VMG0000 +aherrojar aherrojar VMN0000 +aherroje aherrojar VMM03S0 +aherrojemos aherrojar VMM01P0 +aherrojen aherrojar VMM03P0 +aherrumbra aherrumbrar VMM02S0 +aherrumbrad aherrumbrar VMM02P0 +aherrumbrando aherrumbrar VMG0000 +aherrumbrar aherrumbrar VMN0000 +aherrumbre aherrumbrar VMM03S0 +aherrumbremos aherrumbrar VMM01P0 +aherrumbren aherrumbrar VMM03P0 +ahervora ahervorar VMM02S0 +ahervorad ahervorar VMM02P0 +ahervorando ahervorar VMG0000 +ahervorar ahervorar VMN0000 +ahervore ahervorar VMM03S0 +ahervoremos ahervorar VMM01P0 +ahervoren ahervorar VMM03P0 +ahijad ahijar VMM02P0 +ahijando ahijar VMG0000 +ahijar ahijar VMN0000 +ahijemos ahijar VMM01P0 +ahilad ahilar VMM02P0 +ahilando ahilar VMG0000 +ahilar ahilar VMN0000 +ahilemos ahilar VMM01P0 +ahincad ahincar VMM02P0 +ahincando ahincar VMG0000 +ahincar ahincar VMN0000 +ahinoja ahinojar VMM02S0 +ahinojad ahinojar VMM02P0 +ahinojando ahinojar VMG0000 +ahinquemos ahincar VMM01P0 +ahitad ahitar VMM02P0 +ahitando ahitar VMG0000 +ahitar ahitar VMN0000 +ahitemos ahitar VMM01P0 +ahocica ahocicar VMM02S0 +ahocicad ahocicar VMM02P0 +ahocicando ahocicar VMG0000 +ahocicar ahocicar VMN0000 +ahocina ahocinar VMM02S0 +ahocinad ahocinar VMM02P0 +ahocinando ahocinar VMG0000 +ahocinar ahocinar VMN0000 +ahocine ahocinar VMM03S0 +ahocinemos ahocinar VMM01P0 +ahocinen ahocinar VMM03P0 +ahocique ahocicar VMM03S0 +ahociquemos ahocicar VMM01P0 +ahociquen ahocicar VMM03P0 +ahoga ahogar VMM02S0 +ahogad ahogar VMM02P0 +ahogando ahogar VMG0000 +ahogar ahogar VMN0000 +ahogue ahogar VMM03S0 +ahoguemos ahogar VMM01P0 +ahoguen ahogar VMM03P0 +ahonda ahondar VMM02S0 +ahondad ahondar VMM02P0 +ahondando ahondar VMG0000 +ahondar ahondar VMN0000 +ahonde ahondar VMM03S0 +ahondemos ahondar VMM01P0 +ahonden ahondar VMM03P0 +ahorca ahorcar VMM02S0 +ahorcad ahorcar VMM02P0 +ahorcaja ahorcajar VMM02S0 +ahorcajad ahorcajar VMM02P0 +ahorcajando ahorcajar VMG0000 +ahorcajar ahorcajar VMN0000 +ahorcaje ahorcajar VMM03S0 +ahorcajemos ahorcajar VMM01P0 +ahorcajen ahorcajar VMM03P0 +ahorcando ahorcar VMG0000 +ahorcar ahorcar VMN0000 +ahorma ahormar VMM02S0 +ahormad ahormar VMM02P0 +ahormando ahormar VMG0000 +ahormar ahormar VMN0000 +ahorme ahormar VMM03S0 +ahormemos ahormar VMM01P0 +ahormen ahormar VMM03P0 +ahornaga ahornagar VMM02S0 +ahornagad ahornagar VMM02P0 +ahornagando ahornagar VMG0000 +ahornagar ahornagar VMN0000 +ahornague ahornagar VMM03S0 +ahornaguemos ahornagar VMM01P0 +ahornaguen ahornagar VMM03P0 +ahorque ahorcar VMM03S0 +ahorquemos ahorcar VMM01P0 +ahorquen ahorcar VMM03P0 +ahorquilla ahorquillar VMM02S0 +ahorquillad ahorquillar VMM02P0 +ahorquillando ahorquillar VMG0000 +ahorquillar ahorquillar VMN0000 +ahorquille ahorquillar VMM03S0 +ahorquillemos ahorquillar VMM01P0 +ahorquillen ahorquillar VMM03P0 +ahorra ahorrar VMM02S0 +ahorrad ahorrar VMM02P0 +ahorrando ahorrar VMG0000 +ahorrar ahorrar VMN0000 +ahorre ahorrar VMM03S0 +ahorremos ahorrar VMM01P0 +ahorren ahorrar VMM03P0 +ahuchad ahuchar VMM02P0 +ahuchando ahuchar VMG0000 +ahuchar ahuchar VMN0000 +ahuchemos ahuchar VMM01P0 +ahueca ahuecar VMM02S0 +ahuecad ahuecar VMM02P0 +ahuecando ahuecar VMG0000 +ahuecar ahuecar VMN0000 +ahueque ahuecar VMM03S0 +ahuequemos ahuecar VMM01P0 +ahuequen ahuecar VMM03P0 +ahueva ahuevar VMM02S0 +ahuevad ahuevar VMM02P0 +ahuevando ahuevar VMG0000 +ahuevar ahuevar VMN0000 +ahueve ahuevar VMM03S0 +ahuevemos ahuevar VMM01P0 +ahueven ahuevar VMM03P0 +ahumad ahumar VMM02P0 +ahumando ahumar VMG0000 +ahumar ahumar VMN0000 +ahumemos ahumar VMM01P0 +ahusad ahusar VMM02P0 +ahusando ahusar VMG0000 +ahusar ahusar VMN0000 +ahusemos ahusar VMM01P0 +ahuyenta ahuyentar VMM02S0 +ahuyentad ahuyentar VMM02P0 +ahuyentando ahuyentar VMG0000 +ahuyentar ahuyentar VMN0000 +ahuyente ahuyentar VMM03S0 +ahuyentemos ahuyentar VMM01P0 +ahuyenten ahuyentar VMM03P0 +ahíja ahijar VMM02S0 +ahíje ahijar VMM03S0 +ahíjen ahijar VMM03P0 +ahíla ahilar VMM02S0 +ahíle ahilar VMM03S0 +ahílen ahilar VMM03P0 +ahínca ahincar VMM02S0 +ahínque ahincar VMM03S0 +ahínquen ahincar VMM03P0 +ahíta ahitar VMM02S0 +ahíte ahitar VMM03S0 +ahíten ahitar VMM03P0 +ahúcha ahuchar VMM02S0 +ahúche ahuchar VMM03S0 +ahúchen ahuchar VMM03P0 +ahúma ahumar VMM02S0 +ahúme ahumar VMM03S0 +ahúmen ahumar VMM03P0 +ahúsa ahusar VMM02S0 +ahúse ahusar VMM03S0 +ahúsen ahusar VMM03P0 +airad airar VMM02P0 +airando airar VMG0000 +airar airar VMN0000 +airea airear VMM02S0 +airead airear VMM02P0 +aireando airear VMG0000 +airear airear VMN0000 +airee airear VMM03S0 +aireemos airear VMM01P0 +aireen airear VMM03P0 +airemos airar VMM01P0 +aislad aislar VMM02P0 +aislando aislar VMG0000 +aislar aislar VMN0000 +aislemos aislar VMM01P0 +aja ajar VMM02S0 +ajad ajar VMM02P0 +ajamona ajamonar VMM02S0 +ajamonad ajamonar VMM02P0 +ajamonando ajamonar VMG0000 +ajamonar ajamonar VMN0000 +ajamone ajamonar VMM03S0 +ajamonemos ajamonar VMM01P0 +ajamonen ajamonar VMM03P0 +ajando ajar VMG0000 +ajaqueca ajaquecar VMM02S0 +ajaquecad ajaquecar VMM02P0 +ajaquecando ajaquecar VMG0000 +ajaquecar ajaquecar VMN0000 +ajaqueque ajaquecar VMM03S0 +ajaquequemos ajaquecar VMM01P0 +ajaquequen ajaquecar VMM03P0 +ajar ajar VMN0000 +ajardina ajardinar VMM02S0 +ajardinad ajardinar VMM02P0 +ajardinando ajardinar VMG0000 +ajardinar ajardinar VMN0000 +ajardine ajardinar VMM03S0 +ajardinemos ajardinar VMM01P0 +ajardinen ajardinar VMM03P0 +aje ajar VMM03S0 +ajea ajear VMM02S0 +ajead ajear VMM02P0 +ajeando ajear VMG0000 +ajear ajear VMN0000 +ajee ajear VMM03S0 +ajeemos ajear VMM01P0 +ajeen ajear VMM03P0 +ajemos ajar VMM01P0 +ajen ajar VMM03P0 +ajetrea ajetrear VMM02S0 +ajetread ajetrear VMM02P0 +ajetreando ajetrear VMG0000 +ajetrear ajetrear VMN0000 +ajetree ajetrear VMM03S0 +ajetreemos ajetrear VMM01P0 +ajetreen ajetrear VMM03P0 +ajoba ajobar VMM02S0 +ajobad ajobar VMM02P0 +ajobando ajobar VMG0000 +ajobar ajobar VMN0000 +ajobe ajobar VMM03S0 +ajobemos ajobar VMM01P0 +ajoben ajobar VMM03P0 +ajorad ajorar VMM02P0 +ajorando ajorar VMG0000 +ajorar ajorar VMN0000 +ajoremos ajorar VMM01P0 +ajornala ajornalar VMM02S0 +ajornalad ajornalar VMM02P0 +ajornalando ajornalar VMG0000 +ajornalar ajornalar VMN0000 +ajornale ajornalar VMM03S0 +ajornalemos ajornalar VMM01P0 +ajornalen ajornalar VMM03P0 +ajuara ajuarar VMM02S0 +ajuarad ajuarar VMM02P0 +ajuarando ajuarar VMG0000 +ajuarar ajuarar VMN0000 +ajuare ajuarar VMM03S0 +ajuaremos ajuarar VMM01P0 +ajuaren ajuarar VMM03P0 +ajuera ajorar VMM02S0 +ajuere ajorar VMM03S0 +ajueren ajorar VMM03P0 +ajuicia ajuiciar VMM02S0 +ajuiciad ajuiciar VMM02P0 +ajuiciando ajuiciar VMG0000 +ajuiciar ajuiciar VMN0000 +ajuicie ajuiciar VMM03S0 +ajuiciemos ajuiciar VMM01P0 +ajuicien ajuiciar VMM03P0 +ajuma ajumar VMM02S0 +ajumad ajumar VMM02P0 +ajumando ajumar VMG0000 +ajumar ajumar VMN0000 +ajume ajumar VMM03S0 +ajumemos ajumar VMM01P0 +ajumen ajumar VMM03P0 +ajusta ajustar VMM02S0 +ajustad ajustar VMM02P0 +ajustando ajustar VMG0000 +ajustar ajustar VMN0000 +ajuste ajustar VMM03S0 +ajustemos ajustar VMM01P0 +ajusten ajustar VMM03P0 +ajusticia ajusticiar VMM02S0 +ajusticiad ajusticiar VMM02P0 +ajusticiando ajusticiar VMG0000 +ajusticiar ajusticiar VMN0000 +ajusticie ajusticiar VMM03S0 +ajusticiemos ajusticiar VMM01P0 +ajusticien ajusticiar VMM03P0 +alaba alabar VMM02S0 +alabad alabar VMM02P0 +alabando alabar VMG0000 +alabar alabar VMN0000 +alabe alabar VMM03S0 +alabea alabear VMM02S0 +alabead alabear VMM02P0 +alabeando alabear VMG0000 +alabear alabear VMN0000 +alabee alabear VMM03S0 +alabeemos alabear VMM01P0 +alabeen alabear VMM03P0 +alabemos alabar VMM01P0 +alaben alabar VMM03P0 +alaga alagar VMM02S0 +alagad alagar VMM02P0 +alagando alagar VMG0000 +alagar alagar VMN0000 +alagarta alagartar VMM02S0 +alagartad alagartar VMM02P0 +alagartando alagartar VMG0000 +alagartar alagartar VMN0000 +alagarte alagartar VMM03S0 +alagartemos alagartar VMM01P0 +alagarten alagartar VMM03P0 +alague alagar VMM03S0 +alaguemos alagar VMM01P0 +alaguen alagar VMM03P0 +alambica alambicar VMM02S0 +alambicad alambicar VMM02P0 +alambicando alambicar VMG0000 +alambicar alambicar VMN0000 +alambique alambicar VMM03S0 +alambiquemos alambicar VMM01P0 +alambiquen alambicar VMM03P0 +alambra alambrar VMM02S0 +alambrad alambrar VMM02P0 +alambrando alambrar VMG0000 +alambrar alambrar VMN0000 +alambre alambrar VMM03S0 +alambrea alambrear VMM02S0 +alambread alambrear VMM02P0 +alambreando alambrear VMG0000 +alambrear alambrear VMN0000 +alambree alambrear VMM03S0 +alambreemos alambrear VMM01P0 +alambreen alambrear VMM03P0 +alambremos alambrar VMM01P0 +alambren alambrar VMM03P0 +alampa alampar VMM02S0 +alampad alampar VMM02P0 +alampando alampar VMG0000 +alampar alampar VMN0000 +alampe alampar VMM03S0 +alampemos alampar VMM01P0 +alampen alampar VMM03P0 +alancea alancear VMM02S0 +alancead alancear VMM02P0 +alanceando alancear VMG0000 +alancear alancear VMN0000 +alancee alancear VMM03S0 +alanceemos alancear VMM01P0 +alanceen alancear VMM03P0 +alardea alardear VMM02S0 +alardead alardear VMM02P0 +alardeando alardear VMG0000 +alardear alardear VMN0000 +alardee alardear VMM03S0 +alardeemos alardear VMM01P0 +alardeen alardear VMM03P0 +alarga alargar VMM02S0 +alargad alargar VMM02P0 +alargando alargar VMG0000 +alargar alargar VMN0000 +alargue alargar VMM03S0 +alarguemos alargar VMM01P0 +alarguen alargar VMM03P0 +alarma alarmar VMM02S0 +alarmad alarmar VMM02P0 +alarmando alarmar VMG0000 +alarmar alarmar VMN0000 +alarme alarmar VMM03S0 +alarmemos alarmar VMM01P0 +alarmen alarmar VMM03P0 +alastra alastrar VMM02S0 +alastrad alastrar VMM02P0 +alastrando alastrar VMG0000 +alastrar alastrar VMN0000 +alastre alastrar VMM03S0 +alastremos alastrar VMM01P0 +alastren alastrar VMM03P0 +albarda albardar VMM02S0 +albardad albardar VMM02P0 +albardando albardar VMG0000 +albardanea albardanear VMM02S0 +albardanead albardanear VMM02P0 +albardaneando albardanear VMG0000 +albardanear albardanear VMN0000 +albardar albardar VMN0000 +albarde albardar VMM03S0 +albardemos albardar VMM01P0 +albarden albardar VMM03P0 +albea albear VMM02S0 +albead albear VMM02P0 +albeando albear VMG0000 +albear albear VMN0000 +albee albear VMM03S0 +albeemos albear VMM01P0 +albeen albear VMM03P0 +alberga albergar VMM02S0 +albergad albergar VMM02P0 +albergando albergar VMG0000 +albergar albergar VMN0000 +albergue albergar VMM03S0 +alberguemos albergar VMM01P0 +alberguen albergar VMM03P0 +alborea alborear VMM02S0 +alboread alborear VMM02P0 +alboreando alborear VMG0000 +alborear alborear VMN0000 +alboree alborear VMM03S0 +alboreemos alborear VMM01P0 +alboreen alborear VMM03P0 +alboroce alborozar VMM03S0 +alborocemos alborozar VMM01P0 +alborocen alborozar VMM03P0 +alborota alborotar VMM02S0 +alborotad alborotar VMM02P0 +alborotando alborotar VMG0000 +alborotar alborotar VMN0000 +alborote alborotar VMM03S0 +alborotemos alborotar VMM01P0 +alboroten alborotar VMM03P0 +alboroza alborozar VMM02S0 +alborozad alborozar VMM02P0 +alborozando alborozar VMG0000 +alborozar alborozar VMN0000 +alburea alburear VMM02S0 +alburead alburear VMM02P0 +albureando alburear VMG0000 +alburear alburear VMN0000 +alburee alburear VMM03S0 +albureemos alburear VMM01P0 +albureen alburear VMM03P0 +alcahace alcahazar VMM03S0 +alcahacemos alcahazar VMM01P0 +alcahacen alcahazar VMM03P0 +alcahaza alcahazar VMM02S0 +alcahazad alcahazar VMM02P0 +alcahazando alcahazar VMG0000 +alcahazar alcahazar VMN0000 +alcahuetea alcahuetear VMM02S0 +alcahuetead alcahuetear VMM02P0 +alcahueteando alcahuetear VMG0000 +alcahuetear alcahuetear VMN0000 +alcahuetee alcahuetear VMM03S0 +alcahueteemos alcahuetear VMM01P0 +alcahueteen alcahuetear VMM03P0 +alcalice alcalizar VMM03S0 +alcalicemos alcalizar VMM01P0 +alcalicen alcalizar VMM03P0 +alcaliza alcalizar VMM02S0 +alcalizad alcalizar VMM02P0 +alcalizando alcalizar VMG0000 +alcalizar alcalizar VMN0000 +alcance alcanzar VMM03S0 +alcancemos alcanzar VMM01P0 +alcancen alcanzar VMM03P0 +alcanfora alcanforar VMM02S0 +alcanforad alcanforar VMM02P0 +alcanforando alcanforar VMG0000 +alcanforar alcanforar VMN0000 +alcanfore alcanforar VMM03S0 +alcanforemos alcanforar VMM01P0 +alcanforen alcanforar VMM03P0 +alcantarilla alcantarillar VMM02S0 +alcantarillad alcantarillar VMM02P0 +alcantarillando alcantarillar VMG0000 +alcantarillar alcantarillar VMN0000 +alcantarille alcantarillar VMM03S0 +alcantarillemos alcantarillar VMM01P0 +alcantarillen alcantarillar VMM03P0 +alcanza alcanzar VMM02S0 +alcanzad alcanzar VMM02P0 +alcanzando alcanzar VMG0000 +alcanzar alcanzar VMN0000 +alce alzar VMM03S0 +alcemos alzar VMM01P0 +alcen alzar VMM03P0 +alcohola alcoholar VMM02S0 +alcoholad alcoholar VMM02P0 +alcoholando alcoholar VMG0000 +alcoholar alcoholar VMN0000 +alcohole alcoholar VMM03S0 +alcoholemos alcoholar VMM01P0 +alcoholen alcoholar VMM03P0 +alcoholice alcoholizar VMM03S0 +alcoholicemos alcoholizar VMM01P0 +alcoholicen alcoholizar VMM03P0 +alcoholiza alcoholizar VMM02S0 +alcoholizad alcoholizar VMM02P0 +alcoholizando alcoholizar VMG0000 +alcoholizar alcoholizar VMN0000 +alcorce alcorzar VMM03S0 +alcorcemos alcorzar VMM01P0 +alcorcen alcorzar VMM03P0 +alcorza alcorzar VMM02S0 +alcorzad alcorzar VMM02P0 +alcorzando alcorzar VMG0000 +alcorzar alcorzar VMN0000 +aldabea aldabear VMM02S0 +aldabead aldabear VMM02P0 +aldabeando aldabear VMG0000 +aldabear aldabear VMN0000 +aldabee aldabear VMM03S0 +aldabeemos aldabear VMM01P0 +aldabeen aldabear VMM03P0 +alea alear VMM02S0 +alead alear VMM02P0 +aleando alear VMG0000 +alear alear VMN0000 +alebrad alebrar VMM02P0 +alebrando alebrar VMG0000 +alebrar alebrar VMN0000 +alebrasta alebrastar VMM02S0 +alebrastad alebrastar VMM02P0 +alebrastando alebrastar VMG0000 +alebrastar alebrastar VMN0000 +alebraste alebrastar VMM03S0 +alebrastemos alebrastar VMM01P0 +alebrasten alebrastar VMM03P0 +alebremos alebrar VMM01P0 +alebresta alebrestar VMM02S0 +alebrestad alebrestar VMM02P0 +alebrestando alebrestar VMG0000 +alebrestar alebrestar VMN0000 +alebreste alebrestar VMM03S0 +alebrestemos alebrestar VMM01P0 +alebresten alebrestar VMM03P0 +alebrona alebronar VMM02S0 +alebronad alebronar VMM02P0 +alebronando alebronar VMG0000 +alebronar alebronar VMN0000 +alebrone alebronar VMM03S0 +alebronemos alebronar VMM01P0 +alebronen alebronar VMM03P0 +alecciona aleccionar VMM02S0 +aleccionad aleccionar VMM02P0 +aleccionando aleccionar VMG0000 +aleccionar aleccionar VMN0000 +aleccione aleccionar VMM03S0 +aleccionemos aleccionar VMM01P0 +aleccionen aleccionar VMM03P0 +alechuga alechugar VMM02S0 +alechugad alechugar VMM02P0 +alechugando alechugar VMG0000 +alechugar alechugar VMN0000 +alechugue alechugar VMM03S0 +alechuguemos alechugar VMM01P0 +alechuguen alechugar VMM03P0 +alee alear VMM03S0 +aleemos alear VMM01P0 +aleen alear VMM03P0 +alega alegar VMM02S0 +alegad alegar VMM02P0 +alegando alegar VMG0000 +alegar alegar VMN0000 +alegorice alegorizar VMM03S0 +alegoricemos alegorizar VMM01P0 +alegoricen alegorizar VMM03P0 +alegoriza alegorizar VMM02S0 +alegorizad alegorizar VMM02P0 +alegorizando alegorizar VMG0000 +alegorizar alegorizar VMN0000 +alegra alegrar VMM02S0 +alegrad alegrar VMM02P0 +alegrando alegrar VMG0000 +alegrar alegrar VMN0000 +alegre alegrar VMM03S0 +alegremos alegrar VMM01P0 +alegren alegrar VMM03P0 +alegue alegar VMM03S0 +aleguemos alegar VMM01P0 +aleguen alegar VMM03P0 +aleja alejar VMM02S0 +alejad alejar VMM02P0 +alejando alejar VMG0000 +alejar alejar VMN0000 +aleje alejar VMM03S0 +alejemos alejar VMM01P0 +alejen alejar VMM03P0 +alela alelar VMM02S0 +alelad alelar VMM02P0 +alelando alelar VMG0000 +alelar alelar VMN0000 +alele alelar VMM03S0 +alelemos alelar VMM01P0 +alelen alelar VMM03P0 +alentad alentar VMM02P0 +alentando alentar VMG0000 +alentar alentar VMN0000 +alentemos alentar VMM01P0 +alerta alertar VMM02S0 +alertad alertar VMM02P0 +alertando alertar VMG0000 +alertar alertar VMN0000 +alerte alertar VMM03S0 +alertemos alertar VMM01P0 +alerten alertar VMM03P0 +aletarga aletargar VMM02S0 +aletargad aletargar VMM02P0 +aletargando aletargar VMG0000 +aletargar aletargar VMN0000 +aletargue aletargar VMM03S0 +aletarguemos aletargar VMM01P0 +aletarguen aletargar VMM03P0 +aletea aletear VMM02S0 +aletead aletear VMM02P0 +aleteando aletear VMG0000 +aletear aletear VMN0000 +aletee aletear VMM03S0 +aleteemos aletear VMM01P0 +aleteen aletear VMM03P0 +alfabetice alfabetizar VMM03S0 +alfabeticemos alfabetizar VMM01P0 +alfabeticen alfabetizar VMM03P0 +alfabetiza alfabetizar VMM02S0 +alfabetizad alfabetizar VMM02P0 +alfabetizando alfabetizar VMG0000 +alfabetizar alfabetizar VMN0000 +alfalfa alfalfar VMM02S0 +alfalfad alfalfar VMM02P0 +alfalfando alfalfar VMG0000 +alfalfar alfalfar VMN0000 +alfalfe alfalfar VMM03S0 +alfalfemos alfalfar VMM01P0 +alfalfen alfalfar VMM03P0 +alfarrace alfarrazar VMM03S0 +alfarracemos alfarrazar VMM01P0 +alfarracen alfarrazar VMM03P0 +alfarraza alfarrazar VMM02S0 +alfarrazad alfarrazar VMM02P0 +alfarrazando alfarrazar VMG0000 +alfarrazar alfarrazar VMN0000 +alfeñica alfeñicar VMM02S0 +alfeñicad alfeñicar VMM02P0 +alfeñicando alfeñicar VMG0000 +alfeñicar alfeñicar VMN0000 +alfeñique alfeñicar VMM03S0 +alfeñiquemos alfeñicar VMM01P0 +alfeñiquen alfeñicar VMM03P0 +alfombra alfombrar VMM02S0 +alfombrad alfombrar VMM02P0 +alfombrando alfombrar VMG0000 +alfombrar alfombrar VMN0000 +alfombre alfombrar VMM03S0 +alfombremos alfombrar VMM01P0 +alfombren alfombrar VMM03P0 +alforce alforzar VMM03S0 +alforcemos alforzar VMM01P0 +alforcen alforzar VMM03P0 +alforza alforzar VMM02S0 +alforzad alforzar VMM02P0 +alforzando alforzar VMG0000 +alforzar alforzar VMN0000 +algalia algaliar VMM02S0 +algaliad algaliar VMM02P0 +algaliando algaliar VMG0000 +algaliar algaliar VMN0000 +algalie algaliar VMM03S0 +algaliemos algaliar VMM01P0 +algalien algaliar VMM03P0 +algodona algodonar VMM02S0 +algodonad algodonar VMM02P0 +algodonando algodonar VMG0000 +algodonar algodonar VMN0000 +algodone algodonar VMM03S0 +algodonemos algodonar VMM01P0 +algodonen algodonar VMM03P0 +alhaja alhajar VMM02S0 +alhajad alhajar VMM02P0 +alhajando alhajar VMG0000 +alhajar alhajar VMN0000 +alhaje alhajar VMM03S0 +alhajemos alhajar VMM01P0 +alhajen alhajar VMM03P0 +alheña alheñar VMM02S0 +alheñad alheñar VMM02P0 +alheñando alheñar VMG0000 +alheñar alheñar VMN0000 +alheñe alheñar VMM03S0 +alheñemos alheñar VMM01P0 +alheñen alheñar VMM03P0 +aliad aliar VMM02P0 +aliando aliar VMG0000 +aliar aliar VMN0000 +alicata alicatar VMM02S0 +alicatad alicatar VMM02P0 +alicatando alicatar VMG0000 +alicatar alicatar VMN0000 +alicate alicatar VMM03S0 +alicatemos alicatar VMM01P0 +alicaten alicatar VMM03P0 +alicorta alicortar VMM02S0 +alicortad alicortar VMM02P0 +alicortando alicortar VMG0000 +alicortar alicortar VMN0000 +alicorte alicortar VMM03S0 +alicortemos alicortar VMM01P0 +alicorten alicortar VMM03P0 +aliebra alebrar VMM02S0 +aliebre alebrar VMM03S0 +aliebren alebrar VMM03P0 +aliemos aliar VMM01P0 +aliena alienar VMM02S0 +alienad alienar VMM02P0 +alienando alienar VMG0000 +alienar alienar VMN0000 +aliene alienar VMM03S0 +alienemos alienar VMM01P0 +alienen alienar VMM03P0 +alienta alentar VMM02S0 +aliente alentar VMM03S0 +alienten alentar VMM03P0 +aligera aligerar VMM02S0 +aligerad aligerar VMM02P0 +aligerando aligerar VMG0000 +aligerar aligerar VMN0000 +aligere aligerar VMM03S0 +aligeremos aligerar VMM01P0 +aligeren aligerar VMM03P0 +alija alijar VMM02S0 +alijad alijar VMM02P0 +alijando alijar VMG0000 +alijar alijar VMN0000 +alijara alijarar VMM02S0 +alijarad alijarar VMM02P0 +alijarando alijarar VMG0000 +alijarar alijarar VMN0000 +alijare alijarar VMM03S0 +alijaremos alijarar VMM01P0 +alijaren alijarar VMM03P0 +alije alijar VMM03S0 +alijemos alijar VMM01P0 +alijen alijar VMM03P0 +alimenta alimentar VMM02S0 +alimentad alimentar VMM02P0 +alimentando alimentar VMG0000 +alimentar alimentar VMN0000 +alimente alimentar VMM03S0 +alimentemos alimentar VMM01P0 +alimenten alimentar VMM03P0 +alimona alimonar VMM02S0 +alimonad alimonar VMM02P0 +alimonando alimonar VMG0000 +alimonar alimonar VMN0000 +alimone alimonar VMM03S0 +alimonemos alimonar VMM01P0 +alimonen alimonar VMM03P0 +alinda alindar VMM02S0 +alindad alindar VMM02P0 +alindando alindar VMG0000 +alindar alindar VMN0000 +alinde alindar VMM03S0 +alindemos alindar VMM01P0 +alinden alindar VMM03P0 +alindera alinderar VMM02S0 +alinderad alinderar VMM02P0 +alinderando alinderar VMG0000 +alinderar alinderar VMN0000 +alindere alinderar VMM03S0 +alinderemos alinderar VMM01P0 +alinderen alinderar VMM03P0 +alinea alinear VMM02S0 +alinead alinear VMM02P0 +alineando alinear VMG0000 +alinear alinear VMN0000 +alinee alinear VMM03S0 +alineemos alinear VMM01P0 +alineen alinear VMM03P0 +alisa alisar VMM02S0 +alisad alisar VMM02P0 +alisando alisar VMG0000 +alisar alisar VMN0000 +alise alisar VMM03S0 +alisemos alisar VMM01P0 +alisen alisar VMM03P0 +alista alistar VMM02S0 +alistad alistar VMM02P0 +alistando alistar VMG0000 +alistar alistar VMN0000 +aliste alistar VMM03S0 +alistemos alistar VMM01P0 +alisten alistar VMM03P0 +alivia aliviar VMM02S0 +aliviad aliviar VMM02P0 +aliviana alivianar VMM02S0 +alivianad alivianar VMM02P0 +alivianando alivianar VMG0000 +alivianar alivianar VMN0000 +aliviando aliviar VMG0000 +aliviane alivianar VMM03S0 +alivianemos alivianar VMM01P0 +alivianen alivianar VMM03P0 +aliviar aliviar VMN0000 +alivie aliviar VMM03S0 +aliviemos aliviar VMM01P0 +alivien aliviar VMM03P0 +aliña aliñar VMM02S0 +aliñad aliñar VMM02P0 +aliñando aliñar VMG0000 +aliñar aliñar VMN0000 +aliñe aliñar VMM03S0 +aliñemos aliñar VMM01P0 +aliñen aliñar VMM03P0 +aljofara aljofarar VMM02S0 +aljofarad aljofarar VMM02P0 +aljofarando aljofarar VMG0000 +aljofarar aljofarar VMN0000 +aljofare aljofarar VMM03S0 +aljofaremos aljofarar VMM01P0 +aljofaren aljofarar VMM03P0 +aljofifa aljofifar VMM02S0 +aljofifad aljofifar VMM02P0 +aljofifando aljofifar VMG0000 +aljofifar aljofifar VMN0000 +aljofife aljofifar VMM03S0 +aljofifemos aljofifar VMM01P0 +aljofifen aljofifar VMM03P0 +allana allanar VMM02S0 +allanad allanar VMM02P0 +allanando allanar VMG0000 +allanar allanar VMN0000 +allane allanar VMM03S0 +allanemos allanar VMM01P0 +allanen allanar VMM03P0 +allega allegar VMM02S0 +allegad allegar VMM02P0 +allegando allegar VMG0000 +allegar allegar VMN0000 +allegue allegar VMM03S0 +alleguemos allegar VMM01P0 +alleguen allegar VMM03P0 +almacena almacenar VMM02S0 +almacenad almacenar VMM02P0 +almacenando almacenar VMG0000 +almacenar almacenar VMN0000 +almacene almacenar VMM03S0 +almacenemos almacenar VMM01P0 +almacenen almacenar VMM03P0 +almadia almadiar VMM02S0 +almadiad almadiar VMM02P0 +almadiando almadiar VMG0000 +almadiar almadiar VMN0000 +almadie almadiar VMM03S0 +almadiemos almadiar VMM01P0 +almadien almadiar VMM03P0 +almagra almagrar VMM02S0 +almagrad almagrar VMM02P0 +almagrando almagrar VMG0000 +almagrar almagrar VMN0000 +almagre almagrar VMM03S0 +almagremos almagrar VMM01P0 +almagren almagrar VMM03P0 +almarbata almarbatar VMM02S0 +almarbatad almarbatar VMM02P0 +almarbatando almarbatar VMG0000 +almarbatar almarbatar VMN0000 +almarbate almarbatar VMM03S0 +almarbatemos almarbatar VMM01P0 +almarbaten almarbatar VMM03P0 +almena almenar VMM02S0 +almenad almenar VMM02P0 +almenando almenar VMG0000 +almenar almenar VMN0000 +almene almenar VMM03S0 +almenemos almenar VMM01P0 +almenen almenar VMM03P0 +almibara almibarar VMM02S0 +almibarad almibarar VMM02P0 +almibarando almibarar VMG0000 +almibarar almibarar VMN0000 +almibare almibarar VMM03S0 +almibaremos almibarar VMM01P0 +almibaren almibarar VMM03P0 +almidona almidonar VMM02S0 +almidonad almidonar VMM02P0 +almidonando almidonar VMG0000 +almidonar almidonar VMN0000 +almidone almidonar VMM03S0 +almidonemos almidonar VMM01P0 +almidonen almidonar VMM03P0 +almizcla almizclar VMM02S0 +almizclad almizclar VMM02P0 +almizclando almizclar VMG0000 +almizclar almizclar VMN0000 +almizcle almizclar VMM03S0 +almizclemos almizclar VMM01P0 +almizclen almizclar VMM03P0 +almogavarea almogavarear VMM02S0 +almogavaread almogavarear VMM02P0 +almogavareando almogavarear VMG0000 +almogavarear almogavarear VMN0000 +almogavaree almogavarear VMM03S0 +almogavareemos almogavarear VMM01P0 +almogavareen almogavarear VMM03P0 +almohace almohazar VMM03S0 +almohacemos almohazar VMM01P0 +almohacen almohazar VMM03P0 +almohadilla almohadillar VMM02S0 +almohadillad almohadillar VMM02P0 +almohadillando almohadillar VMG0000 +almohadillar almohadillar VMN0000 +almohadille almohadillar VMM03S0 +almohadillemos almohadillar VMM01P0 +almohadillen almohadillar VMM03P0 +almohaza almohazar VMM02S0 +almohazad almohazar VMM02P0 +almohazando almohazar VMG0000 +almohazar almohazar VMN0000 +almorcemos almorzar VMM01P0 +almorzad almorzar VMM02P0 +almorzando almorzar VMG0000 +almorzar almorzar VMN0000 +almuerce almorzar VMM03S0 +almuercen almorzar VMM03P0 +almuerza almorzar VMM02S0 +aloja alojar VMM02S0 +alojad alojar VMM02P0 +alojando alojar VMG0000 +alojar alojar VMN0000 +aloje alojar VMM03S0 +alojemos alojar VMM01P0 +alojen alojar VMM03P0 +aloma alomar VMM02S0 +alomad alomar VMM02P0 +alomando alomar VMG0000 +alomar alomar VMN0000 +alome alomar VMM03S0 +alomemos alomar VMM01P0 +alomen alomar VMM03P0 +alota alotar VMM02S0 +alotad alotar VMM02P0 +alotando alotar VMG0000 +alotar alotar VMN0000 +alote alotar VMM03S0 +alotemos alotar VMM01P0 +aloten alotar VMM03P0 +alquila alquilar VMM02S0 +alquilad alquilar VMM02P0 +alquilando alquilar VMG0000 +alquilar alquilar VMN0000 +alquile alquilar VMM03S0 +alquilemos alquilar VMM01P0 +alquilen alquilar VMM03P0 +alquitara alquitarar VMM02S0 +alquitarad alquitarar VMM02P0 +alquitarando alquitarar VMG0000 +alquitarar alquitarar VMN0000 +alquitare alquitarar VMM03S0 +alquitaremos alquitarar VMM01P0 +alquitaren alquitarar VMM03P0 +alquitrana alquitranar VMM02S0 +alquitranad alquitranar VMM02P0 +alquitranando alquitranar VMG0000 +alquitranar alquitranar VMN0000 +alquitrane alquitranar VMM03S0 +alquitranemos alquitranar VMM01P0 +alquitranen alquitranar VMM03P0 +altea altear VMM02S0 +altead altear VMM02P0 +alteando altear VMG0000 +altear altear VMN0000 +altee altear VMM03S0 +alteemos altear VMM01P0 +alteen altear VMM03P0 +altera alterar VMM02S0 +alterad alterar VMM02P0 +alterando alterar VMG0000 +alterar alterar VMN0000 +alterca altercar VMM02S0 +altercad altercar VMM02P0 +altercando altercar VMG0000 +altercar altercar VMN0000 +altere alterar VMM03S0 +alteremos alterar VMM01P0 +alteren alterar VMM03P0 +alterna alternar VMM02S0 +alternad alternar VMM02P0 +alternando alternar VMG0000 +alternar alternar VMN0000 +alterne alternar VMM03S0 +alternemos alternar VMM01P0 +alternen alternar VMM03P0 +alterque altercar VMM03S0 +alterquemos altercar VMM01P0 +alterquen altercar VMM03P0 +altiva altivar VMM02S0 +altivad altivar VMM02P0 +altivando altivar VMG0000 +altivar altivar VMN0000 +altive altivar VMM03S0 +altivece altivecer VMM02S0 +altiveced altivecer VMM02P0 +altivecer altivecer VMN0000 +altiveciendo altivecer VMG0000 +altivemos altivar VMM01P0 +altiven altivar VMM03P0 +altivezca altivecer VMM03S0 +altivezcamos altivecer VMM01P0 +altivezcan altivecer VMM03P0 +alucia aluciar VMM02S0 +aluciad aluciar VMM02P0 +aluciando aluciar VMG0000 +aluciar aluciar VMN0000 +alucie aluciar VMM03S0 +aluciemos aluciar VMM01P0 +alucien aluciar VMM03P0 +alucina alucinar VMM02S0 +alucinad alucinar VMM02P0 +alucinando alucinar VMG0000 +alucinar alucinar VMN0000 +alucine alucinar VMM03S0 +alucinemos alucinar VMM01P0 +alucinen alucinar VMM03P0 +aluda aludir VMM03S0 +aludamos aludir VMM01P0 +aludan aludir VMM03P0 +alude aludir VMM02S0 +aludid aludir VMM02P0 +aludiendo aludir VMG0000 +aludir aludir VMN0000 +aluja alujar VMM02S0 +alujad alujar VMM02P0 +alujando alujar VMG0000 +alujar alujar VMN0000 +aluje alujar VMM03S0 +alujemos alujar VMM01P0 +alujen alujar VMM03P0 +alumbra alumbrar VMM02S0 +alumbrad alumbrar VMM02P0 +alumbrando alumbrar VMG0000 +alumbrar alumbrar VMN0000 +alumbre alumbrar VMM03S0 +alumbremos alumbrar VMM01P0 +alumbren alumbrar VMM03P0 +aluna alunar VMM02S0 +alunad alunar VMM02P0 +alunando alunar VMG0000 +alunar alunar VMN0000 +alune alunar VMM03S0 +alunemos alunar VMM01P0 +alunen alunar VMM03P0 +alunice alunizar VMM03S0 +alunicemos alunizar VMM01P0 +alunicen alunizar VMM03P0 +aluniza alunizar VMM02S0 +alunizad alunizar VMM02P0 +alunizando alunizar VMG0000 +alunizar alunizar VMN0000 +alustra alustrar VMM02S0 +alustrad alustrar VMM02P0 +alustrando alustrar VMG0000 +alustrar alustrar VMN0000 +alustre alustrar VMM03S0 +alustremos alustrar VMM01P0 +alustren alustrar VMM03P0 +alza alzar VMM02S0 +alzad alzar VMM02P0 +alzando alzar VMG0000 +alzaprima alzaprimar VMM02S0 +alzaprimad alzaprimar VMM02P0 +alzaprimando alzaprimar VMG0000 +alzaprimar alzaprimar VMN0000 +alzaprime alzaprimar VMM03S0 +alzaprimemos alzaprimar VMM01P0 +alzaprimen alzaprimar VMM03P0 +alzar alzar VMN0000 +alía aliar VMM02S0 +alíe aliar VMM03S0 +alíen aliar VMM03P0 +ama amar VMM02S0 +amachambra amachambrar VMM02S0 +amachambrad amachambrar VMM02P0 +amachambrando amachambrar VMG0000 +amachambrar amachambrar VMN0000 +amachambre amachambrar VMM03S0 +amachambremos amachambrar VMM01P0 +amachambren amachambrar VMM03P0 +amachetea amachetear VMM02S0 +amachetead amachetear VMM02P0 +amacheteando amachetear VMG0000 +amachetear amachetear VMN0000 +amachetee amachetear VMM03S0 +amacheteemos amachetear VMM01P0 +amacheteen amachetear VMM03P0 +amachina amachinar VMM02S0 +amachinad amachinar VMM02P0 +amachinando amachinar VMG0000 +amachinar amachinar VMN0000 +amachine amachinar VMM03S0 +amachinemos amachinar VMM01P0 +amachinen amachinar VMM03P0 +amacice amacizar VMM03S0 +amacicemos amacizar VMM01P0 +amacicen amacizar VMM03P0 +amaciza amacizar VMM02S0 +amacizad amacizar VMM02P0 +amacizando amacizar VMG0000 +amacizar amacizar VMN0000 +amacolla amacollar VMM02S0 +amacollad amacollar VMM02P0 +amacollando amacollar VMG0000 +amacollar amacollar VMN0000 +amacolle amacollar VMM03S0 +amacollemos amacollar VMM01P0 +amacollen amacollar VMM03P0 +amad amar VMM02P0 +amadriga amadrigar VMM02S0 +amadrigad amadrigar VMM02P0 +amadrigando amadrigar VMG0000 +amadrigar amadrigar VMN0000 +amadrigue amadrigar VMM03S0 +amadriguemos amadrigar VMM01P0 +amadriguen amadrigar VMM03P0 +amadrina amadrinar VMM02S0 +amadrinad amadrinar VMM02P0 +amadrinando amadrinar VMG0000 +amadrinar amadrinar VMN0000 +amadrine amadrinar VMM03S0 +amadrinemos amadrinar VMM01P0 +amadrinen amadrinar VMM03P0 +amaestra amaestrar VMM02S0 +amaestrad amaestrar VMM02P0 +amaestrando amaestrar VMG0000 +amaestrar amaestrar VMN0000 +amaestre amaestrar VMM03S0 +amaestremos amaestrar VMM01P0 +amaestren amaestrar VMM03P0 +amaga amagar VMM02S0 +amagad amagar VMM02P0 +amagando amagar VMG0000 +amagar amagar VMN0000 +amague amagar VMM03S0 +amaguemos amagar VMM01P0 +amaguen amagar VMM03P0 +amaina amainar VMM02S0 +amainad amainar VMM02P0 +amainando amainar VMG0000 +amainar amainar VMN0000 +amaine amainar VMM03S0 +amainemos amainar VMM01P0 +amainen amainar VMM03P0 +amajada amajadar VMM02S0 +amajadad amajadar VMM02P0 +amajadando amajadar VMG0000 +amajadar amajadar VMN0000 +amajade amajadar VMM03S0 +amajademos amajadar VMM01P0 +amajaden amajadar VMM03P0 +amalaya amalayar VMM02S0 +amalayad amalayar VMM02P0 +amalayando amalayar VMG0000 +amalayar amalayar VMN0000 +amalaye amalayar VMM03S0 +amalayemos amalayar VMM01P0 +amalayen amalayar VMM03P0 +amalgama amalgamar VMM02S0 +amalgamad amalgamar VMM02P0 +amalgamando amalgamar VMG0000 +amalgamar amalgamar VMN0000 +amalgame amalgamar VMM03S0 +amalgamemos amalgamar VMM01P0 +amalgamen amalgamar VMM03P0 +amamanta amamantar VMM02S0 +amamantad amamantar VMM02P0 +amamantando amamantar VMG0000 +amamantar amamantar VMN0000 +amamante amamantar VMM03S0 +amamantemos amamantar VMM01P0 +amamanten amamantar VMM03P0 +amanceba amancebar VMM02S0 +amancebad amancebar VMM02P0 +amancebando amancebar VMG0000 +amancebar amancebar VMN0000 +amancebe amancebar VMM03S0 +amancebemos amancebar VMM01P0 +amanceben amancebar VMM03P0 +amancilla amancillar VMM02S0 +amancillad amancillar VMM02P0 +amancillando amancillar VMG0000 +amancillar amancillar VMN0000 +amancille amancillar VMM03S0 +amancillemos amancillar VMM01P0 +amancillen amancillar VMM03P0 +amando amar VMG0000 +amanece amanecer VMM02S0 +amaneced amanecer VMM02P0 +amanecer amanecer VMN0000 +amaneciendo amanecer VMG0000 +amanera amanerar VMM02S0 +amanerad amanerar VMM02P0 +amanerando amanerar VMG0000 +amanerar amanerar VMN0000 +amanere amanerar VMM03S0 +amaneremos amanerar VMM01P0 +amaneren amanerar VMM03P0 +amanezca amanecer VMM03S0 +amanezcamos amanecer VMM01P0 +amanezcan amanecer VMM03P0 +amanoja amanojar VMM02S0 +amanojad amanojar VMM02P0 +amanojando amanojar VMG0000 +amanojar amanojar VMN0000 +amanoje amanojar VMM03S0 +amanojemos amanojar VMM01P0 +amanojen amanojar VMM03P0 +amansa amansar VMM02S0 +amansad amansar VMM02P0 +amansando amansar VMG0000 +amansar amansar VMN0000 +amanse amansar VMM03S0 +amansemos amansar VMM01P0 +amansen amansar VMM03P0 +amar amar VMN0000 +amara amarar VMM02S0 +amarad amarar VMM02P0 +amarando amarar VMG0000 +amarar amarar VMN0000 +amarchanta amarchantar VMM02S0 +amarchantad amarchantar VMM02P0 +amarchantando amarchantar VMG0000 +amarchantar amarchantar VMN0000 +amarchante amarchantar VMM03S0 +amarchantemos amarchantar VMM01P0 +amarchanten amarchantar VMM03P0 +amare amarar VMM03S0 +amaremos amarar VMM01P0 +amaren amarar VMM03P0 +amarga amargar VMM02S0 +amargad amargar VMM02P0 +amargando amargar VMG0000 +amargar amargar VMN0000 +amargue amargar VMM03S0 +amarguemos amargar VMM01P0 +amarguen amargar VMM03P0 +amarillea amarillear VMM02S0 +amarillead amarillear VMM02P0 +amarilleando amarillear VMG0000 +amarillear amarillear VMN0000 +amarillece amarillecer VMM02S0 +amarilleced amarillecer VMM02P0 +amarillecer amarillecer VMN0000 +amarilleciendo amarillecer VMG0000 +amarillee amarillear VMM03S0 +amarilleemos amarillear VMM01P0 +amarilleen amarillear VMM03P0 +amarillezca amarillecer VMM03S0 +amarillezcamos amarillecer VMM01P0 +amarillezcan amarillecer VMM03P0 +amarina amarinar VMM02S0 +amarinad amarinar VMM02P0 +amarinando amarinar VMG0000 +amarinar amarinar VMN0000 +amarine amarinar VMM03S0 +amarinemos amarinar VMM01P0 +amarinen amarinar VMM03P0 +amaroma amaromar VMM02S0 +amaromad amaromar VMM02P0 +amaromando amaromar VMG0000 +amaromar amaromar VMN0000 +amarome amaromar VMM03S0 +amaromemos amaromar VMM01P0 +amaromen amaromar VMM03P0 +amarra amarrar VMM02S0 +amarrad amarrar VMM02P0 +amarrando amarrar VMG0000 +amarrar amarrar VMN0000 +amarre amarrar VMM03S0 +amarremos amarrar VMM01P0 +amarren amarrar VMM03P0 +amartela amartelar VMM02S0 +amartelad amartelar VMM02P0 +amartelando amartelar VMG0000 +amartelar amartelar VMN0000 +amartele amartelar VMM03S0 +amartelemos amartelar VMM01P0 +amartelen amartelar VMM03P0 +amartilla amartillar VMM02S0 +amartillad amartillar VMM02P0 +amartillando amartillar VMG0000 +amartillar amartillar VMN0000 +amartille amartillar VMM03S0 +amartillemos amartillar VMM01P0 +amartillen amartillar VMM03P0 +amasa amasar VMM02S0 +amasad amasar VMM02P0 +amasando amasar VMG0000 +amasar amasar VMN0000 +amase amasar VMM03S0 +amasemos amasar VMM01P0 +amasen amasar VMM03P0 +amayorazga amayorazgar VMM02S0 +amayorazgad amayorazgar VMM02P0 +amayorazgando amayorazgar VMG0000 +amayorazgar amayorazgar VMN0000 +amayorazgue amayorazgar VMM03S0 +amayorazguemos amayorazgar VMM01P0 +amayorazguen amayorazgar VMM03P0 +amazacota amazacotar VMM02S0 +amazacotad amazacotar VMM02P0 +amazacotando amazacotar VMG0000 +amazacotar amazacotar VMN0000 +amazacote amazacotar VMM03S0 +amazacotemos amazacotar VMM01P0 +amazacoten amazacotar VMM03P0 +amaña amañar VMM02S0 +amañad amañar VMM02P0 +amañando amañar VMG0000 +amañar amañar VMN0000 +amañe amañar VMM03S0 +amañemos amañar VMM01P0 +amañen amañar VMM03P0 +ambara ambarar VMM02S0 +ambarad ambarar VMM02P0 +ambarando ambarar VMG0000 +ambarar ambarar VMN0000 +ambiciona ambicionar VMM02S0 +ambicionad ambicionar VMM02P0 +ambicionando ambicionar VMG0000 +ambicionar ambicionar VMN0000 +ambicione ambicionar VMM03S0 +ambicionemos ambicionar VMM01P0 +ambicionen ambicionar VMM03P0 +ambienta ambientar VMM02S0 +ambientad ambientar VMM02P0 +ambientando ambientar VMG0000 +ambientar ambientar VMN0000 +ambiente ambientar VMM03S0 +ambientemos ambientar VMM01P0 +ambienten ambientar VMM03P0 +ambla amblar VMM02S0 +amblad amblar VMM02P0 +amblando amblar VMG0000 +amblar amblar VMN0000 +amble amblar VMM03S0 +amblemos amblar VMM01P0 +amblen amblar VMM03P0 +ambula ambular VMM02S0 +ambulad ambular VMM02P0 +ambulando ambular VMG0000 +ambular ambular VMN0000 +ambule ambular VMM03S0 +ambulemos ambular VMM01P0 +ambulen ambular VMM03P0 +ame amar VMM03S0 +amecha amechar VMM02S0 +amechad amechar VMM02P0 +amechando amechar VMG0000 +amechar amechar VMN0000 +ameche amechar VMM03S0 +amechemos amechar VMM01P0 +amechen amechar VMM03P0 +amedrenta amedrentar VMM02S0 +amedrentad amedrentar VMM02P0 +amedrentando amedrentar VMG0000 +amedrentar amedrentar VMN0000 +amedrente amedrentar VMM03S0 +amedrentemos amedrentar VMM01P0 +amedrenten amedrentar VMM03P0 +amelga amelgar VMM02S0 +amelgad amelgar VMM02P0 +amelgando amelgar VMG0000 +amelgar amelgar VMN0000 +amelgue amelgar VMM03S0 +amelguemos amelgar VMM01P0 +amelguen amelgar VMM03P0 +amemos amar VMM01P0 +amen amar VMM03P0 +amenace amenazar VMM03S0 +amenacemos amenazar VMM01P0 +amenacen amenazar VMM03P0 +amenaza amenazar VMM02S0 +amenazad amenazar VMM02P0 +amenazando amenazar VMG0000 +amenazar amenazar VMN0000 +amengua amenguar VMM02S0 +amenguad amenguar VMM02P0 +amenguando amenguar VMG0000 +amenguar amenguar VMN0000 +amengüe amenguar VMM03S0 +amengüemos amenguar VMM01P0 +amengüen amenguar VMM03P0 +amenice amenizar VMM03S0 +amenicemos amenizar VMM01P0 +amenicen amenizar VMM03P0 +ameniza amenizar VMM02S0 +amenizad amenizar VMM02P0 +amenizando amenizar VMG0000 +amenizar amenizar VMN0000 +amera amerar VMM02S0 +amerad amerar VMM02P0 +amerando amerar VMG0000 +amerar amerar VMN0000 +amere amerar VMM03S0 +ameremos amerar VMM01P0 +ameren amerar VMM03P0 +americanice americanizar VMM03S0 +americanicemos americanizar VMM01P0 +americanicen americanizar VMM03P0 +americaniza americanizar VMM02S0 +americanizad americanizar VMM02P0 +americanizando americanizar VMG0000 +americanizar americanizar VMN0000 +americe amerizar VMM03S0 +americemos amerizar VMM01P0 +americen amerizar VMM03P0 +amerita ameritar VMM02S0 +ameritad ameritar VMM02P0 +ameritando ameritar VMG0000 +ameritar ameritar VMN0000 +amerite ameritar VMM03S0 +ameritemos ameritar VMM01P0 +ameriten ameritar VMM03P0 +ameriza amerizar VMM02S0 +amerizad amerizar VMM02P0 +amerizando amerizar VMG0000 +amerizar amerizar VMN0000 +ametralla ametrallar VMM02S0 +ametrallad ametrallar VMM02P0 +ametrallando ametrallar VMG0000 +ametrallar ametrallar VMN0000 +ametralle ametrallar VMM03S0 +ametrallemos ametrallar VMM01P0 +ametrallen ametrallar VMM03P0 +amezquinda amezquindar VMM02S0 +amezquindad amezquindar VMM02P0 +amezquindando amezquindar VMG0000 +amezquindar amezquindar VMN0000 +amezquinde amezquindar VMM03S0 +amezquindemos amezquindar VMM01P0 +amezquinden amezquindar VMM03P0 +amiga amigar VMM02S0 +amigad amigar VMM02P0 +amigando amigar VMG0000 +amigar amigar VMN0000 +amigue amigar VMM03S0 +amiguemos amigar VMM01P0 +amiguen amigar VMM03P0 +amilana amilanar VMM02S0 +amilanad amilanar VMM02P0 +amilanando amilanar VMG0000 +amilanar amilanar VMN0000 +amilane amilanar VMM03S0 +amilanemos amilanar VMM01P0 +amilanen amilanar VMM03P0 +amillara amillarar VMM02S0 +amillarad amillarar VMM02P0 +amillarando amillarar VMG0000 +amillarar amillarar VMN0000 +amillare amillarar VMM03S0 +amillaremos amillarar VMM01P0 +amillaren amillarar VMM03P0 +aminora aminorar VMM02S0 +aminorad aminorar VMM02P0 +aminorando aminorar VMG0000 +aminorar aminorar VMN0000 +aminore aminorar VMM03S0 +aminoremos aminorar VMM01P0 +aminoren aminorar VMM03P0 +amista amistar VMM02S0 +amistad amistar VMM02P0 +amistando amistar VMG0000 +amistar amistar VMN0000 +amiste amistar VMM03S0 +amistemos amistar VMM01P0 +amisten amistar VMM03P0 +amnistiad amnistiar VMM02P0 +amnistiando amnistiar VMG0000 +amnistiar amnistiar VMN0000 +amnistiemos amnistiar VMM01P0 +amnistía amnistiar VMM02S0 +amnistíe amnistiar VMM03S0 +amnistíen amnistiar VMM03P0 +amoblad amoblar VMM02P0 +amoblando amoblar VMG0000 +amoblar amoblar VMN0000 +amoblemos amoblar VMM01P0 +amocha amochar VMM02S0 +amochad amochar VMM02P0 +amochando amochar VMG0000 +amochar amochar VMN0000 +amoche amochar VMM03S0 +amochemos amochar VMM01P0 +amochen amochar VMM03P0 +amodorra amodorrar VMM02S0 +amodorrad amodorrar VMM02P0 +amodorrando amodorrar VMG0000 +amodorrar amodorrar VMN0000 +amodorre amodorrar VMM03S0 +amodorremos amodorrar VMM01P0 +amodorren amodorrar VMM03P0 +amohinad amohinar VMM02P0 +amohinando amohinar VMG0000 +amohinar amohinar VMN0000 +amohinemos amohinar VMM01P0 +amohína amohinar VMM02S0 +amohíne amohinar VMM03S0 +amohínen amohinar VMM03P0 +amojama amojamar VMM02S0 +amojamad amojamar VMM02P0 +amojamando amojamar VMG0000 +amojamar amojamar VMN0000 +amojame amojamar VMM03S0 +amojamemos amojamar VMM01P0 +amojamen amojamar VMM03P0 +amojela amojelar VMM02S0 +amojelad amojelar VMM02P0 +amojelando amojelar VMG0000 +amojelar amojelar VMN0000 +amojele amojelar VMM03S0 +amojelemos amojelar VMM01P0 +amojelen amojelar VMM03P0 +amojona amojonar VMM02S0 +amojonad amojonar VMM02P0 +amojonando amojonar VMG0000 +amojonar amojonar VMN0000 +amojone amojonar VMM03S0 +amojonemos amojonar VMM01P0 +amojonen amojonar VMM03P0 +amolad amolar VMM02P0 +amolando amolar VMG0000 +amolar amolar VMN0000 +amolda amoldar VMM02S0 +amoldad amoldar VMM02P0 +amoldando amoldar VMG0000 +amoldar amoldar VMN0000 +amolde amoldar VMM03S0 +amoldemos amoldar VMM01P0 +amolden amoldar VMM03P0 +amolemos amolar VMM01P0 +amolla amollar VMM02S0 +amollad amollar VMM02P0 +amollando amollar VMG0000 +amollar amollar VMN0000 +amolle amollar VMM03S0 +amollemos amollar VMM01P0 +amollen amollar VMM03P0 +amona amonar VMM02S0 +amonad amonar VMM02P0 +amonando amonar VMG0000 +amonar amonar VMN0000 +amone amonar VMM03S0 +amoneda amonedar VMM02S0 +amonedad amonedar VMM02P0 +amonedando amonedar VMG0000 +amonedar amonedar VMN0000 +amonede amonedar VMM03S0 +amonedemos amonedar VMM01P0 +amoneden amonedar VMM03P0 +amonemos amonar VMM01P0 +amonen amonar VMM03P0 +amonesta amonestar VMM02S0 +amonestad amonestar VMM02P0 +amonestando amonestar VMG0000 +amonestar amonestar VMN0000 +amoneste amonestar VMM03S0 +amonestemos amonestar VMM01P0 +amonesten amonestar VMM03P0 +amontona amontonar VMM02S0 +amontonad amontonar VMM02P0 +amontonando amontonar VMG0000 +amontonar amontonar VMN0000 +amontone amontonar VMM03S0 +amontonemos amontonar VMM01P0 +amontonen amontonar VMM03P0 +amorata amoratar VMM02S0 +amoratad amoratar VMM02P0 +amoratando amoratar VMG0000 +amoratar amoratar VMN0000 +amorate amoratar VMM03S0 +amoratemos amoratar VMM01P0 +amoraten amoratar VMM03P0 +amorca amorcar VMM02S0 +amorcad amorcar VMM02P0 +amorcando amorcar VMG0000 +amorcar amorcar VMN0000 +amordace amordazar VMM03S0 +amordacemos amordazar VMM01P0 +amordacen amordazar VMM03P0 +amordaza amordazar VMM02S0 +amordazad amordazar VMM02P0 +amordazando amordazar VMG0000 +amordazar amordazar VMN0000 +amorece amorecer VMM02S0 +amoreced amorecer VMM02P0 +amorecer amorecer VMN0000 +amoreciendo amorecer VMG0000 +amorezca amorecer VMM03S0 +amorezcamos amorecer VMM01P0 +amorezcan amorecer VMM03P0 +amorilla amorillar VMM02S0 +amorillad amorillar VMM02P0 +amorillando amorillar VMG0000 +amorillar amorillar VMN0000 +amorille amorillar VMM03S0 +amorillemos amorillar VMM01P0 +amorillen amorillar VMM03P0 +amorque amorcar VMM03S0 +amorquemos amorcar VMM01P0 +amorquen amorcar VMM03P0 +amorra amorrar VMM02S0 +amorrad amorrar VMM02P0 +amorrando amorrar VMG0000 +amorrar amorrar VMN0000 +amorre amorrar VMM03S0 +amorremos amorrar VMM01P0 +amorren amorrar VMM03P0 +amorrona amorronar VMM02S0 +amorronad amorronar VMM02P0 +amorronando amorronar VMG0000 +amorronar amorronar VMN0000 +amorrone amorronar VMM03S0 +amorronemos amorronar VMM01P0 +amorronen amorronar VMM03P0 +amortaja amortajar VMM02S0 +amortajad amortajar VMM02P0 +amortajando amortajar VMG0000 +amortajar amortajar VMN0000 +amortaje amortajar VMM03S0 +amortajemos amortajar VMM01P0 +amortajen amortajar VMM03P0 +amortece amortecer VMM02S0 +amorteced amortecer VMM02P0 +amortecer amortecer VMN0000 +amorteciendo amortecer VMG0000 +amortezca amortecer VMM03S0 +amortezcamos amortecer VMM01P0 +amortezcan amortecer VMM03P0 +amortice amortizar VMM03S0 +amorticemos amortizar VMM01P0 +amorticen amortizar VMM03P0 +amortigua amortiguar VMM02S0 +amortiguad amortiguar VMM02P0 +amortiguando amortiguar VMG0000 +amortiguar amortiguar VMN0000 +amortigüe amortiguar VMM03S0 +amortigüemos amortiguar VMM01P0 +amortigüen amortiguar VMM03P0 +amortiza amortizar VMM02S0 +amortizad amortizar VMM02P0 +amortizando amortizar VMG0000 +amortizar amortizar VMN0000 +amosca amoscar VMM02S0 +amoscad amoscar VMM02P0 +amoscando amoscar VMG0000 +amoscar amoscar VMN0000 +amosque amoscar VMM03S0 +amosquemos amoscar VMM01P0 +amosquen amoscar VMM03P0 +amostace amostazar VMM03S0 +amostacemos amostazar VMM01P0 +amostacen amostazar VMM03P0 +amostaza amostazar VMM02S0 +amostazad amostazar VMM02P0 +amostazando amostazar VMG0000 +amostazar amostazar VMN0000 +amotina amotinar VMM02S0 +amotinad amotinar VMM02P0 +amotinando amotinar VMG0000 +amotinar amotinar VMN0000 +amotine amotinar VMM03S0 +amotinemos amotinar VMM01P0 +amotinen amotinar VMM03P0 +amovamos amover VMM01P0 +amoved amover VMM02P0 +amover amover VMN0000 +amoviendo amover VMG0000 +ampara amparar VMM02S0 +amparad amparar VMM02P0 +amparando amparar VMG0000 +amparar amparar VMN0000 +ampare amparar VMM03S0 +amparemos amparar VMM01P0 +amparen amparar VMM03P0 +ampliad ampliar VMM02P0 +ampliando ampliar VMG0000 +ampliar ampliar VMN0000 +ampliemos ampliar VMM01P0 +amplifica amplificar VMM02S0 +amplificad amplificar VMM02P0 +amplificando amplificar VMG0000 +amplificar amplificar VMN0000 +amplifique amplificar VMM03S0 +amplifiquemos amplificar VMM01P0 +amplifiquen amplificar VMM03P0 +amplía ampliar VMM02S0 +amplíe ampliar VMM03S0 +amplíen ampliar VMM03P0 +ampolla ampollar VMM02S0 +ampollad ampollar VMM02P0 +ampollando ampollar VMG0000 +ampollar ampollar VMN0000 +ampolle ampollar VMM03S0 +ampollemos ampollar VMM01P0 +ampollen ampollar VMM03P0 +amputa amputar VMM02S0 +amputad amputar VMM02P0 +amputando amputar VMG0000 +amputar amputar VMN0000 +ampute amputar VMM03S0 +amputemos amputar VMM01P0 +amputen amputar VMM03P0 +amuebla amoblar VMM02S0 +amuebla amueblar VMM02S0 +amueblad amueblar VMM02P0 +amueblando amueblar VMG0000 +amueblar amueblar VMN0000 +amueble amoblar VMM03S0 +amueble amueblar VMM03S0 +amueblemos amueblar VMM01P0 +amueblen amoblar VMM03P0 +amueblen amueblar VMM03P0 +amuela amolar VMM02S0 +amuele amolar VMM03S0 +amuelen amolar VMM03P0 +amueva amover VMM03S0 +amuevan amover VMM03P0 +amueve amover VMM02S0 +amugrona amugronar VMM02S0 +amugronad amugronar VMM02P0 +amugronando amugronar VMG0000 +amugronar amugronar VMN0000 +amugrone amugronar VMM03S0 +amugronemos amugronar VMM01P0 +amugronen amugronar VMM03P0 +amuniciona amunicionar VMM02S0 +amunicionad amunicionar VMM02P0 +amunicionando amunicionar VMG0000 +amunicionar amunicionar VMN0000 +amunicione amunicionar VMM03S0 +amunicionemos amunicionar VMM01P0 +amunicionen amunicionar VMM03P0 +amura amurar VMM02S0 +amurad amurar VMM02P0 +amuralla amurallar VMM02S0 +amurallad amurallar VMM02P0 +amurallando amurallar VMG0000 +amurallar amurallar VMN0000 +amuralle amurallar VMM03S0 +amurallemos amurallar VMM01P0 +amurallen amurallar VMM03P0 +amurando amurar VMG0000 +amurar amurar VMN0000 +amurca amurcar VMM02S0 +amurcad amurcar VMM02P0 +amurcando amurcar VMG0000 +amurcar amurcar VMN0000 +amure amurar VMM03S0 +amuremos amurar VMM01P0 +amuren amurar VMM03P0 +amurque amurcar VMM03S0 +amurquemos amurcar VMM01P0 +amurquen amurcar VMM03P0 +amurra amurrar VMM02S0 +amurrad amurrar VMM02P0 +amurrando amurrar VMG0000 +amurrar amurrar VMN0000 +amurre amurrar VMM03S0 +amurremos amurrar VMM01P0 +amurren amurrar VMM03P0 +amurria amurriar VMM02S0 +amurriad amurriar VMM02P0 +amurriando amurriar VMG0000 +amurriar amurriar VMN0000 +amurrie amurriar VMM03S0 +amurriemos amurriar VMM01P0 +amurrien amurriar VMM03P0 +amurriña amurriñar VMM02S0 +amurriñad amurriñar VMM02P0 +amurriñando amurriñar VMG0000 +amurriñar amurriñar VMN0000 +amurriñe amurriñar VMM03S0 +amurriñemos amurriñar VMM01P0 +amurriñen amurriñar VMM03P0 +amusga amusgar VMM02S0 +amusgad amusgar VMM02P0 +amusgando amusgar VMG0000 +amusgar amusgar VMN0000 +amusgue amusgar VMM03S0 +amusguemos amusgar VMM01P0 +amusguen amusgar VMM03P0 +amustia amustiar VMM02S0 +amustiad amustiar VMM02P0 +amustiando amustiar VMG0000 +amustiar amustiar VMN0000 +amustie amustiar VMM03S0 +amustiemos amustiar VMM01P0 +amustien amustiar VMM03P0 +anadea anadear VMM02S0 +anadead anadear VMM02P0 +anadeando anadear VMG0000 +anadear anadear VMN0000 +anadee anadear VMM03S0 +anadeemos anadear VMM01P0 +anadeen anadear VMM03P0 +analice analizar VMM03S0 +analicemos analizar VMM01P0 +analicen analizar VMM03P0 +analiza analizar VMM02S0 +analizad analizar VMM02P0 +analizando analizar VMG0000 +analizar analizar VMN0000 +anarquice anarquizar VMM03S0 +anarquicemos anarquizar VMM01P0 +anarquicen anarquizar VMM03P0 +anarquiza anarquizar VMM02S0 +anarquizad anarquizar VMM02P0 +anarquizando anarquizar VMG0000 +anarquizar anarquizar VMN0000 +anastomosa anastomosar VMM02S0 +anastomosad anastomosar VMM02P0 +anastomosando anastomosar VMG0000 +anastomosar anastomosar VMN0000 +anastomose anastomosar VMM03S0 +anastomosemos anastomosar VMM01P0 +anastomosen anastomosar VMM03P0 +anatematice anatematizar VMM03S0 +anatematicemos anatematizar VMM01P0 +anatematicen anatematizar VMM03P0 +anatematiza anatematizar VMM02S0 +anatematizad anatematizar VMM02P0 +anatematizando anatematizar VMG0000 +anatematizar anatematizar VMN0000 +anatomice anatomizar VMM03S0 +anatomicemos anatomizar VMM01P0 +anatomicen anatomizar VMM03P0 +anatomiza anatomizar VMM02S0 +anatomizad anatomizar VMM02P0 +anatomizando anatomizar VMG0000 +anatomizar anatomizar VMN0000 +ancla anclar VMM02S0 +anclad anclar VMM02P0 +anclando anclar VMG0000 +anclar anclar VMN0000 +ancle anclar VMM03S0 +anclemos anclar VMM01P0 +anclen anclar VMM03P0 +ancora ancorar VMM02S0 +ancorad ancorar VMM02P0 +ancorando ancorar VMG0000 +ancorar ancorar VMN0000 +ancore ancorar VMM03S0 +ancoremos ancorar VMM01P0 +ancoren ancorar VMM03P0 +anda andar VMM02S0 +andad andar VMM02P0 +andando andar VMG0000 +andar andar VMN0000 +ande andar VMM03S0 +andemos andar VMM01P0 +anden andar VMM03P0 +andorrea andorrear VMM02S0 +andorread andorrear VMM02P0 +andorreando andorrear VMG0000 +andorrear andorrear VMN0000 +andorree andorrear VMM03S0 +andorreemos andorrear VMM01P0 +andorreen andorrear VMM03P0 +aneblad aneblar VMM02P0 +aneblando aneblar VMG0000 +aneblar aneblar VMN0000 +aneblemos aneblar VMM01P0 +anega anegar VMM02S0 +anegad anegar VMM02P0 +anegando anegar VMG0000 +anegar anegar VMN0000 +anegue anegar VMM03S0 +aneguemos anegar VMM01P0 +aneguen anegar VMM03P0 +aneja anejar VMM02S0 +anejad anejar VMM02P0 +anejando anejar VMG0000 +anejar anejar VMN0000 +aneje anejar VMM03S0 +anejemos anejar VMM01P0 +anejen anejar VMM03P0 +anestesia anestesiar VMM02S0 +anestesiad anestesiar VMM02P0 +anestesiando anestesiar VMG0000 +anestesiar anestesiar VMN0000 +anestesie anestesiar VMM03S0 +anestesiemos anestesiar VMM01P0 +anestesien anestesiar VMM03P0 +anexa anexar VMM02S0 +anexad anexar VMM02P0 +anexando anexar VMG0000 +anexar anexar VMN0000 +anexe anexar VMM03S0 +anexemos anexar VMM01P0 +anexen anexar VMM03P0 +anexiona anexionar VMM02S0 +anexionad anexionar VMM02P0 +anexionando anexionar VMG0000 +anexionar anexionar VMN0000 +anexione anexionar VMM03S0 +anexionemos anexionar VMM01P0 +anexionen anexionar VMM03P0 +angosta angostar VMM02S0 +angostad angostar VMM02P0 +angostando angostar VMG0000 +angostar angostar VMN0000 +angoste angostar VMM03S0 +angostemos angostar VMM01P0 +angosten angostar VMM03P0 +angustia angustiar VMM02S0 +angustiad angustiar VMM02P0 +angustiando angustiar VMG0000 +angustiar angustiar VMN0000 +angustie angustiar VMM03S0 +angustiemos angustiar VMM01P0 +angustien angustiar VMM03P0 +anhela anhelar VMM02S0 +anhelad anhelar VMM02P0 +anhelando anhelar VMG0000 +anhelar anhelar VMN0000 +anhele anhelar VMM03S0 +anhelemos anhelar VMM01P0 +anhelen anhelar VMM03P0 +anida anidar VMM02S0 +anidad anidar VMM02P0 +anidando anidar VMG0000 +anidar anidar VMN0000 +anide anidar VMM03S0 +anidemos anidar VMM01P0 +aniden anidar VMM03P0 +aniebla aneblar VMM02S0 +aniebla anieblar VMM02S0 +anieblad anieblar VMM02P0 +anieblando anieblar VMG0000 +anieblar anieblar VMN0000 +anieble aneblar VMM03S0 +anieble anieblar VMM03S0 +anieblemos anieblar VMM01P0 +anieblen aneblar VMM03P0 +anieblen anieblar VMM03P0 +anihila anihilar VMM02S0 +anihilad anihilar VMM02P0 +anihilando anihilar VMG0000 +anihilar anihilar VMN0000 +anihile anihilar VMM03S0 +anihilemos anihilar VMM01P0 +anihilen anihilar VMM03P0 +anilla anillar VMM02S0 +anillad anillar VMM02P0 +anillando anillar VMG0000 +anillar anillar VMN0000 +anille anillar VMM03S0 +anillemos anillar VMM01P0 +anillen anillar VMM03P0 +anima animar VMM02S0 +animad animar VMM02P0 +animalice animalizar VMM03S0 +animalicemos animalizar VMM01P0 +animalicen animalizar VMM03P0 +animaliza animalizar VMM02S0 +animalizad animalizar VMM02P0 +animalizando animalizar VMG0000 +animalizar animalizar VMN0000 +animando animar VMG0000 +animar animar VMN0000 +anime animar VMM03S0 +animemos animar VMM01P0 +animen animar VMM03P0 +aniquila aniquilar VMM02S0 +aniquilad aniquilar VMM02P0 +aniquilando aniquilar VMG0000 +aniquilar aniquilar VMN0000 +aniquile aniquilar VMM03S0 +aniquilemos aniquilar VMM01P0 +aniquilen aniquilar VMM03P0 +anisa anisar VMM02S0 +anisad anisar VMM02P0 +anisando anisar VMG0000 +anisar anisar VMN0000 +anise anisar VMM03S0 +anisemos anisar VMM01P0 +anisen anisar VMM03P0 +anochece anochecer VMM02S0 +anocheced anochecer VMM02P0 +anochecer anochecer VMN0000 +anocheciendo anochecer VMG0000 +anochezca anochecer VMM03S0 +anochezcamos anochecer VMM01P0 +anochezcan anochecer VMM03P0 +anodice anodizar VMM03S0 +anodicemos anodizar VMM01P0 +anodicen anodizar VMM03P0 +anodina anodinar VMM02S0 +anodinad anodinar VMM02P0 +anodinando anodinar VMG0000 +anodinar anodinar VMN0000 +anodine anodinar VMM03S0 +anodinemos anodinar VMM01P0 +anodinen anodinar VMM03P0 +anodiza anodizar VMM02S0 +anodizad anodizar VMM02P0 +anodizando anodizar VMG0000 +anodizar anodizar VMN0000 +anonada anonadar VMM02S0 +anonadad anonadar VMM02P0 +anonadando anonadar VMG0000 +anonadar anonadar VMN0000 +anonade anonadar VMM03S0 +anonademos anonadar VMM01P0 +anonaden anonadar VMM03P0 +anota anotar VMM02S0 +anotad anotar VMM02P0 +anotando anotar VMG0000 +anotar anotar VMN0000 +anote anotar VMM03S0 +anotemos anotar VMM01P0 +anoten anotar VMM03P0 +anquilosa anquilosar VMM02S0 +anquilosad anquilosar VMM02P0 +anquilosando anquilosar VMG0000 +anquilosar anquilosar VMN0000 +anquilose anquilosar VMM03S0 +anquilosemos anquilosar VMM01P0 +anquilosen anquilosar VMM03P0 +ansiad ansiar VMM02P0 +ansiando ansiar VMG0000 +ansiar ansiar VMN0000 +ansiemos ansiar VMM01P0 +ansía ansiar VMM02S0 +ansíe ansiar VMM03S0 +ansíen ansiar VMM03P0 +antagalla antagallar VMM02S0 +antagallad antagallar VMM02P0 +antagallando antagallar VMG0000 +antagallar antagallar VMN0000 +antagalle antagallar VMM03S0 +antagallemos antagallar VMM01P0 +antagallen antagallar VMM03P0 +anteceda anteceder VMM03S0 +antecedamos anteceder VMM01P0 +antecedan anteceder VMM03P0 +antecede anteceder VMM02S0 +anteceded anteceder VMM02P0 +anteceder anteceder VMN0000 +antecediendo anteceder VMG0000 +antedata antedatar VMM02S0 +antedatad antedatar VMM02P0 +antedatando antedatar VMG0000 +antedatar antedatar VMN0000 +antedate antedatar VMM03S0 +antedatemos antedatar VMM01P0 +antedaten antedatar VMM03P0 +antedecid antedecir VMM02P0 +antedecir antedecir VMN0000 +antedi antedecir VMM02S0 +antedice antedecir VMM02S0 +antediciendo antedecir VMG0000 +antediga antedecir VMM03S0 +antedigamos antedecir VMM01P0 +antedigan antedecir VMM03P0 +anteponed anteponer VMM02P0 +anteponer anteponer VMN0000 +anteponga anteponer VMM03S0 +antepongamos anteponer VMM01P0 +antepongan anteponer VMM03P0 +anteponiendo anteponer VMG0000 +antepón anteponer VMM02S0 +antevea antever VMM03S0 +anteveamos antever VMM01P0 +antevean antever VMM03P0 +anteved antever VMM02P0 +anteven antevenir VMM02S0 +antevenga antevenir VMM03S0 +antevengamos antevenir VMM01P0 +antevengan antevenir VMM03P0 +antevenid antevenir VMM02P0 +antevenir antevenir VMN0000 +antever antever VMN0000 +anteviendo antever VMG0000 +anteviniendo antevenir VMG0000 +antevé antever VMM02S0 +anticipa anticipar VMM02S0 +anticipad anticipar VMM02P0 +anticipando anticipar VMG0000 +anticipar anticipar VMN0000 +anticipe anticipar VMM03S0 +anticipemos anticipar VMM01P0 +anticipen anticipar VMM03P0 +anticuad anticuar VMM02P0 +anticuando anticuar VMG0000 +anticuar anticuar VMN0000 +anticuemos anticuar VMM01P0 +anticúa anticuar VMM02S0 +anticúe anticuar VMM03S0 +anticúen anticuar VMM03P0 +antigua antiguar VMM02S0 +antiguad antiguar VMM02P0 +antiguando antiguar VMG0000 +antiguar antiguar VMN0000 +antigüe antiguar VMM03S0 +antigüemos antiguar VMM01P0 +antigüen antiguar VMM03P0 +antoja antojar VMM02S0 +antojad antojar VMM02P0 +antojando antojar VMG0000 +antojar antojar VMN0000 +antoje antojar VMM03S0 +antojemos antojar VMM01P0 +antojen antojar VMM03P0 +antrueja antruejar VMM02S0 +antruejad antruejar VMM02P0 +antruejando antruejar VMG0000 +antruejar antruejar VMN0000 +antrueje antruejar VMM03S0 +antruejemos antruejar VMM01P0 +antruejen antruejar VMM03P0 +anubla anublar VMM02S0 +anublad anublar VMM02P0 +anublando anublar VMG0000 +anublar anublar VMN0000 +anuble anublar VMM03S0 +anublemos anublar VMM01P0 +anublen anublar VMM03P0 +anuda anudar VMM02S0 +anudad anudar VMM02P0 +anudando anudar VMG0000 +anudar anudar VMN0000 +anude anudar VMM03S0 +anudemos anudar VMM01P0 +anuden anudar VMM03P0 +anula anular VMM02S0 +anulad anular VMM02P0 +anulando anular VMG0000 +anular anular VMN0000 +anule anular VMM03S0 +anulemos anular VMM01P0 +anulen anular VMM03P0 +anuncia anunciar VMM02S0 +anunciad anunciar VMM02P0 +anunciando anunciar VMG0000 +anunciar anunciar VMN0000 +anuncie anunciar VMM03S0 +anunciemos anunciar VMM01P0 +anuncien anunciar VMM03P0 +aoja aojar VMM02S0 +aojad aojar VMM02P0 +aojando aojar VMG0000 +aojar aojar VMN0000 +aoje aojar VMM03S0 +aojemos aojar VMM01P0 +aojen aojar VMM03P0 +aova aovar VMM02S0 +aovad aovar VMM02P0 +aovando aovar VMG0000 +aovar aovar VMN0000 +aove aovar VMM03S0 +aovemos aovar VMM01P0 +aoven aovar VMM03P0 +aovilla aovillar VMM02S0 +aovillad aovillar VMM02P0 +aovillando aovillar VMG0000 +aovillar aovillar VMN0000 +aoville aovillar VMM03S0 +aovillemos aovillar VMM01P0 +aovillen aovillar VMM03P0 +apabila apabilar VMM02S0 +apabilad apabilar VMM02P0 +apabilando apabilar VMG0000 +apabilar apabilar VMN0000 +apabile apabilar VMM03S0 +apabilemos apabilar VMM01P0 +apabilen apabilar VMM03P0 +apabulla apabullar VMM02S0 +apabullad apabullar VMM02P0 +apabullando apabullar VMG0000 +apabullar apabullar VMN0000 +apabulle apabullar VMM03S0 +apabullemos apabullar VMM01P0 +apabullen apabullar VMM03P0 +apacentad apacentar VMM02P0 +apacentando apacentar VMG0000 +apacentar apacentar VMN0000 +apacentemos apacentar VMM01P0 +apachurra apachurrar VMM02S0 +apachurrad apachurrar VMM02P0 +apachurrando apachurrar VMG0000 +apachurrar apachurrar VMN0000 +apachurre apachurrar VMM03S0 +apachurremos apachurrar VMM01P0 +apachurren apachurrar VMM03P0 +apacienta apacentar VMM02S0 +apaciente apacentar VMM03S0 +apacienten apacentar VMM03P0 +apacigua apaciguar VMM02S0 +apaciguad apaciguar VMM02P0 +apaciguando apaciguar VMG0000 +apaciguar apaciguar VMN0000 +apacigüe apaciguar VMM03S0 +apacigüemos apaciguar VMM01P0 +apacigüen apaciguar VMM03P0 +apadrina apadrinar VMM02S0 +apadrinad apadrinar VMM02P0 +apadrinando apadrinar VMG0000 +apadrinar apadrinar VMN0000 +apadrine apadrinar VMM03S0 +apadrinemos apadrinar VMM01P0 +apadrinen apadrinar VMM03P0 +apaga apagar VMM02S0 +apagad apagar VMM02P0 +apagando apagar VMG0000 +apagar apagar VMN0000 +apague apagar VMM03S0 +apaguemos apagar VMM01P0 +apaguen apagar VMM03P0 +apalabra apalabrar VMM02S0 +apalabrad apalabrar VMM02P0 +apalabrando apalabrar VMG0000 +apalabrar apalabrar VMN0000 +apalabre apalabrar VMM03S0 +apalabremos apalabrar VMM01P0 +apalabren apalabrar VMM03P0 +apalanca apalancar VMM02S0 +apalancad apalancar VMM02P0 +apalancando apalancar VMG0000 +apalancar apalancar VMN0000 +apalanque apalancar VMM03S0 +apalanquemos apalancar VMM01P0 +apalanquen apalancar VMM03P0 +apalea apalear VMM02S0 +apalead apalear VMM02P0 +apaleando apalear VMG0000 +apalear apalear VMN0000 +apalee apalear VMM03S0 +apaleemos apalear VMM01P0 +apaleen apalear VMM03P0 +apana apanar VMM02S0 +apanad apanar VMM02P0 +apanando apanar VMG0000 +apanar apanar VMN0000 +apanda apandar VMM02S0 +apandad apandar VMM02P0 +apandando apandar VMG0000 +apandar apandar VMN0000 +apande apandar VMM03S0 +apandemos apandar VMM01P0 +apanden apandar VMM03P0 +apandilla apandillar VMM02S0 +apandillad apandillar VMM02P0 +apandillando apandillar VMG0000 +apandillar apandillar VMN0000 +apandille apandillar VMM03S0 +apandillemos apandillar VMM01P0 +apandillen apandillar VMM03P0 +apandonga apandongar VMM02S0 +apandongad apandongar VMM02P0 +apandongando apandongar VMG0000 +apane apanar VMM03S0 +apanemos apanar VMM01P0 +apanen apanar VMM03P0 +apantalla apantallar VMM02S0 +apantallad apantallar VMM02P0 +apantallando apantallar VMG0000 +apantallar apantallar VMN0000 +apantalle apantallar VMM03S0 +apantallemos apantallar VMM01P0 +apantallen apantallar VMM03P0 +apantana apantanar VMM02S0 +apantanad apantanar VMM02P0 +apantanando apantanar VMG0000 +apantanar apantanar VMN0000 +apantane apantanar VMM03S0 +apantanemos apantanar VMM01P0 +apantanen apantanar VMM03P0 +apara aparar VMM02S0 +aparad aparar VMM02P0 +aparando aparar VMG0000 +aparar aparar VMN0000 +aparca aparcar VMM02S0 +aparcad aparcar VMM02P0 +aparcando aparcar VMG0000 +aparcar aparcar VMN0000 +apare aparar VMM03S0 +aparea aparear VMM02S0 +aparead aparear VMM02P0 +apareando aparear VMG0000 +aparear aparear VMN0000 +aparece aparecer VMM02S0 +apareced aparecer VMM02P0 +aparecer aparecer VMN0000 +apareciendo aparecer VMG0000 +aparee aparear VMM03S0 +apareemos aparear VMM01P0 +apareen aparear VMM03P0 +apareja aparejar VMM02S0 +aparejad aparejar VMM02P0 +aparejando aparejar VMG0000 +aparejar aparejar VMN0000 +apareje aparejar VMM03S0 +aparejemos aparejar VMM01P0 +aparejen aparejar VMM03P0 +aparemos aparar VMM01P0 +aparen aparar VMM03P0 +aparenta aparentar VMM02S0 +aparentad aparentar VMM02P0 +aparentando aparentar VMG0000 +aparentar aparentar VMN0000 +aparente aparentar VMM03S0 +aparentemos aparentar VMM01P0 +aparenten aparentar VMM03P0 +aparezca aparecer VMM03S0 +aparezcamos aparecer VMM01P0 +aparezcan aparecer VMM03P0 +aparque aparcar VMM03S0 +aparquemos aparcar VMM01P0 +aparquen aparcar VMM03P0 +aparra aparrar VMM02S0 +aparrad aparrar VMM02P0 +aparrando aparrar VMG0000 +aparrar aparrar VMN0000 +aparre aparrar VMM03S0 +aparremos aparrar VMM01P0 +aparren aparrar VMM03P0 +aparroquia aparroquiar VMM02S0 +aparroquiad aparroquiar VMM02P0 +aparroquiando aparroquiar VMG0000 +aparroquiar aparroquiar VMN0000 +aparroquie aparroquiar VMM03S0 +aparroquiemos aparroquiar VMM01P0 +aparroquien aparroquiar VMM03P0 +aparta apartar VMM02S0 +apartad apartar VMM02P0 +apartando apartar VMG0000 +apartar apartar VMN0000 +aparte apartar VMM03S0 +apartemos apartar VMM01P0 +aparten apartar VMM03P0 +aparva aparvar VMM02S0 +aparvad aparvar VMM02P0 +aparvando aparvar VMG0000 +aparvar aparvar VMN0000 +aparve aparvar VMM03S0 +aparvemos aparvar VMM01P0 +aparven aparvar VMM03P0 +apasiona apasionar VMM02S0 +apasionad apasionar VMM02P0 +apasionando apasionar VMG0000 +apasionar apasionar VMN0000 +apasione apasionar VMM03S0 +apasionemos apasionar VMM01P0 +apasionen apasionar VMM03P0 +apasta apastar VMM02S0 +apastad apastar VMM02P0 +apastando apastar VMG0000 +apastar apastar VMN0000 +apaste apastar VMM03S0 +apastemos apastar VMM01P0 +apasten apastar VMM03P0 +apaula apaular VMM02S0 +apaulad apaular VMM02P0 +apaulando apaular VMG0000 +apaulilla apaulillar VMM02S0 +apaulillad apaulillar VMM02P0 +apaulillando apaulillar VMG0000 +apaña apañar VMM02S0 +apañad apañar VMM02P0 +apañando apañar VMG0000 +apañar apañar VMN0000 +apañe apañar VMM03S0 +apañemos apañar VMM01P0 +apañen apañar VMM03P0 +apañusca apañuscar VMM02S0 +apañuscad apañuscar VMM02P0 +apañuscando apañuscar VMG0000 +apañuscar apañuscar VMN0000 +apañusque apañuscar VMM03S0 +apañusquemos apañuscar VMM01P0 +apañusquen apañuscar VMM03P0 +apea apear VMM02S0 +apead apear VMM02P0 +apeala apealar VMM02S0 +apealad apealar VMM02P0 +apealando apealar VMG0000 +apealar apealar VMN0000 +apeale apealar VMM03S0 +apealemos apealar VMM01P0 +apealen apealar VMM03P0 +apeando apear VMG0000 +apear apear VMN0000 +apecha apechar VMM02S0 +apechad apechar VMM02P0 +apechando apechar VMG0000 +apechar apechar VMN0000 +apeche apechar VMM03S0 +apechemos apechar VMM01P0 +apechen apechar VMM03P0 +apechuga apechugar VMM02S0 +apechugad apechugar VMM02P0 +apechugando apechugar VMG0000 +apechugar apechugar VMN0000 +apechugue apechugar VMM03S0 +apechuguemos apechugar VMM01P0 +apechuguen apechugar VMM03P0 +apedace apedazar VMM03S0 +apedacemos apedazar VMM01P0 +apedacen apedazar VMM03P0 +apedaza apedazar VMM02S0 +apedazad apedazar VMM02P0 +apedazando apedazar VMG0000 +apedazar apedazar VMN0000 +apedrea apedrear VMM02S0 +apedread apedrear VMM02P0 +apedreando apedrear VMG0000 +apedrear apedrear VMN0000 +apedree apedrear VMM03S0 +apedreemos apedrear VMM01P0 +apedreen apedrear VMM03P0 +apee apear VMM03S0 +apeemos apear VMM01P0 +apeen apear VMM03P0 +apeguala apegualar VMM02S0 +apegualad apegualar VMM02P0 +apegualando apegualar VMG0000 +apegualar apegualar VMN0000 +apeguale apegualar VMM03S0 +apegualemos apegualar VMM01P0 +apegualen apegualar VMM03P0 +apela apelar VMM02S0 +apelad apelar VMM02P0 +apelambra apelambrar VMM02S0 +apelambrad apelambrar VMM02P0 +apelambrando apelambrar VMG0000 +apelambrar apelambrar VMN0000 +apelambre apelambrar VMM03S0 +apelambremos apelambrar VMM01P0 +apelambren apelambrar VMM03P0 +apelando apelar VMG0000 +apelar apelar VMN0000 +apelda apeldar VMM02S0 +apeldad apeldar VMM02P0 +apeldando apeldar VMG0000 +apeldar apeldar VMN0000 +apelde apeldar VMM03S0 +apeldemos apeldar VMM01P0 +apelden apeldar VMM03P0 +apele apelar VMM03S0 +apelemos apelar VMM01P0 +apelen apelar VMM03P0 +apella apellar VMM02S0 +apellad apellar VMM02P0 +apellando apellar VMG0000 +apellar apellar VMN0000 +apelle apellar VMM03S0 +apellemos apellar VMM01P0 +apellen apellar VMM03P0 +apellida apellidar VMM02S0 +apellidad apellidar VMM02P0 +apellidando apellidar VMG0000 +apellidar apellidar VMN0000 +apellide apellidar VMM03S0 +apellidemos apellidar VMM01P0 +apelliden apellidar VMM03P0 +apelmace apelmazar VMM03S0 +apelmacemos apelmazar VMM01P0 +apelmacen apelmazar VMM03P0 +apelmaza apelmazar VMM02S0 +apelmazad apelmazar VMM02P0 +apelmazando apelmazar VMG0000 +apelmazar apelmazar VMN0000 +apelotona apelotonar VMM02S0 +apelotonad apelotonar VMM02P0 +apelotonando apelotonar VMG0000 +apelotonar apelotonar VMN0000 +apelotone apelotonar VMM03S0 +apelotonemos apelotonar VMM01P0 +apelotonen apelotonar VMM03P0 +apena apenar VMM02S0 +apenad apenar VMM02P0 +apenando apenar VMG0000 +apenar apenar VMN0000 +apenca apencar VMM02S0 +apencad apencar VMM02P0 +apencando apencar VMG0000 +apencar apencar VMN0000 +apene apenar VMM03S0 +apenemos apenar VMM01P0 +apenen apenar VMM03P0 +apenque apencar VMM03S0 +apenquemos apencar VMM01P0 +apenquen apencar VMM03P0 +apeona apeonar VMM02S0 +apeonad apeonar VMM02P0 +apeonando apeonar VMG0000 +apeonar apeonar VMN0000 +apeone apeonar VMM03S0 +apeonemos apeonar VMM01P0 +apeonen apeonar VMM03P0 +apera aperar VMM02S0 +aperad aperar VMM02P0 +aperando aperar VMG0000 +aperar aperar VMN0000 +aperciba apercibir VMM03S0 +apercibamos apercibir VMM01P0 +aperciban apercibir VMM03P0 +apercibe apercibir VMM02S0 +apercibid apercibir VMM02P0 +apercibiendo apercibir VMG0000 +apercibir apercibir VMN0000 +apercollad apercollar VMM02P0 +apercollando apercollar VMG0000 +apercollar apercollar VMN0000 +apercollemos apercollar VMM01P0 +apercuella apercollar VMM02S0 +apercuelle apercollar VMM03S0 +apercuellen apercollar VMM03P0 +apere aperar VMM03S0 +aperemos aperar VMM01P0 +aperen aperar VMM03P0 +apergamina apergaminar VMM02S0 +apergaminad apergaminar VMM02P0 +apergaminando apergaminar VMG0000 +apergaminar apergaminar VMN0000 +apergamine apergaminar VMM03S0 +apergaminemos apergaminar VMM01P0 +apergaminen apergaminar VMM03P0 +apernad apernar VMM02P0 +apernando apernar VMG0000 +apernar apernar VMN0000 +apernemos apernar VMM01P0 +aperrea aperrear VMM02S0 +aperread aperrear VMM02P0 +aperreando aperrear VMG0000 +aperrear aperrear VMN0000 +aperree aperrear VMM03S0 +aperreemos aperrear VMM01P0 +aperreen aperrear VMM03P0 +apersona apersonar VMM02S0 +apersonad apersonar VMM02P0 +apersonando apersonar VMG0000 +apersonar apersonar VMN0000 +apersone apersonar VMM03S0 +apersonemos apersonar VMM01P0 +apersonen apersonar VMM03P0 +apesadumbra apesadumbrar VMM02S0 +apesadumbrad apesadumbrar VMM02P0 +apesadumbrando apesadumbrar VMG0000 +apesadumbrar apesadumbrar VMN0000 +apesadumbre apesadumbrar VMM03S0 +apesadumbremos apesadumbrar VMM01P0 +apesadumbren apesadumbrar VMM03P0 +apesara apesarar VMM02S0 +apesarad apesarar VMM02P0 +apesarando apesarar VMG0000 +apesarar apesarar VMN0000 +apesare apesarar VMM03S0 +apesaremos apesarar VMM01P0 +apesaren apesarar VMM03P0 +apesga apesgar VMM02S0 +apesgad apesgar VMM02P0 +apesgando apesgar VMG0000 +apesgar apesgar VMN0000 +apesgue apesgar VMM03S0 +apesguemos apesgar VMM01P0 +apesguen apesgar VMM03P0 +apesta apestar VMM02S0 +apestad apestar VMM02P0 +apestando apestar VMG0000 +apestar apestar VMN0000 +apeste apestar VMM03S0 +apestemos apestar VMM01P0 +apesten apestar VMM03P0 +apetece apetecer VMM02S0 +apeteced apetecer VMM02P0 +apetecer apetecer VMN0000 +apeteciendo apetecer VMG0000 +apetezca apetecer VMM03S0 +apetezcamos apetecer VMM01P0 +apetezcan apetecer VMM03P0 +apeñusca apeñuscar VMM02S0 +apeñuscad apeñuscar VMM02P0 +apeñuscando apeñuscar VMG0000 +apeñuscar apeñuscar VMN0000 +apeñusque apeñuscar VMM03S0 +apeñusquemos apeñuscar VMM01P0 +apeñusquen apeñuscar VMM03P0 +apiada apiadar VMM02S0 +apiadad apiadar VMM02P0 +apiadando apiadar VMG0000 +apiadar apiadar VMN0000 +apiade apiadar VMM03S0 +apiademos apiadar VMM01P0 +apiaden apiadar VMM03P0 +apiana apianar VMM02S0 +apianad apianar VMM02P0 +apianando apianar VMG0000 +apianar apianar VMN0000 +apiane apianar VMM03S0 +apianemos apianar VMM01P0 +apianen apianar VMM03P0 +apicara apicarar VMM02S0 +apicarad apicarar VMM02P0 +apicarando apicarar VMG0000 +apicarar apicarar VMN0000 +apicare apicarar VMM03S0 +apicaremos apicarar VMM01P0 +apicaren apicarar VMM03P0 +apierna apernar VMM02S0 +apierne apernar VMM03S0 +apiernen apernar VMM03P0 +apila apilar VMM02S0 +apilad apilar VMM02P0 +apilando apilar VMG0000 +apilar apilar VMN0000 +apile apilar VMM03S0 +apilemos apilar VMM01P0 +apilen apilar VMM03P0 +apilgua apilguar VMM02S0 +apilguad apilguar VMM02P0 +apilguando apilguar VMG0000 +apilguar apilguar VMN0000 +apilgüe apilguar VMM03S0 +apilgüemos apilguar VMM01P0 +apilgüen apilguar VMM03P0 +apimpolla apimpollar VMM02S0 +apimpollad apimpollar VMM02P0 +apimpollando apimpollar VMG0000 +apimpollar apimpollar VMN0000 +apimpolle apimpollar VMM03S0 +apimpollemos apimpollar VMM01P0 +apimpollen apimpollar VMM03P0 +apiola apiolar VMM02S0 +apiolad apiolar VMM02P0 +apiolando apiolar VMG0000 +apiolar apiolar VMN0000 +apiole apiolar VMM03S0 +apiolemos apiolar VMM01P0 +apiolen apiolar VMM03P0 +apipa apipar VMM02S0 +apipad apipar VMM02P0 +apipando apipar VMG0000 +apipar apipar VMN0000 +apipe apipar VMM03S0 +apipemos apipar VMM01P0 +apipen apipar VMM03P0 +apirgüina apirgüinar VMM02S0 +apirgüinad apirgüinar VMM02P0 +apirgüinando apirgüinar VMG0000 +apirgüinar apirgüinar VMN0000 +apirgüine apirgüinar VMM03S0 +apirgüinemos apirgüinar VMM01P0 +apirgüinen apirgüinar VMM03P0 +apisona apisonar VMM02S0 +apisonad apisonar VMM02P0 +apisonando apisonar VMG0000 +apisonar apisonar VMN0000 +apisone apisonar VMM03S0 +apisonemos apisonar VMM01P0 +apisonen apisonar VMM03P0 +apitona apitonar VMM02S0 +apitonad apitonar VMM02P0 +apitonando apitonar VMG0000 +apitonar apitonar VMN0000 +apitone apitonar VMM03S0 +apitonemos apitonar VMM01P0 +apitonen apitonar VMM03P0 +apiña apiñar VMM02S0 +apiñad apiñar VMM02P0 +apiñando apiñar VMG0000 +apiñar apiñar VMN0000 +apiñe apiñar VMM03S0 +apiñemos apiñar VMM01P0 +apiñen apiñar VMM03P0 +aplaca aplacar VMM02S0 +aplacad aplacar VMM02P0 +aplacando aplacar VMG0000 +aplacar aplacar VMN0000 +aplace aplazar VMM03S0 +aplacemos aplazar VMM01P0 +aplacen aplazar VMM03P0 +aplana aplanar VMM02S0 +aplanad aplanar VMM02P0 +aplanando aplanar VMG0000 +aplanar aplanar VMN0000 +aplane aplanar VMM03S0 +aplanemos aplanar VMM01P0 +aplanen aplanar VMM03P0 +aplantilla aplantillar VMM02S0 +aplantillad aplantillar VMM02P0 +aplantillando aplantillar VMG0000 +aplantillar aplantillar VMN0000 +aplantille aplantillar VMM03S0 +aplantillemos aplantillar VMM01P0 +aplantillen aplantillar VMM03P0 +aplaque aplacar VMM03S0 +aplaquemos aplacar VMM01P0 +aplaquen aplacar VMM03P0 +aplasta aplastar VMM02S0 +aplastad aplastar VMM02P0 +aplastando aplastar VMG0000 +aplastar aplastar VMN0000 +aplaste aplastar VMM03S0 +aplastemos aplastar VMM01P0 +aplasten aplastar VMM03P0 +aplatana aplatanar VMM02S0 +aplatanad aplatanar VMM02P0 +aplatanando aplatanar VMG0000 +aplatanar aplatanar VMN0000 +aplatane aplatanar VMM03S0 +aplatanemos aplatanar VMM01P0 +aplatanen aplatanar VMM03P0 +aplauda aplaudir VMM03S0 +aplaudamos aplaudir VMM01P0 +aplaudan aplaudir VMM03P0 +aplaude aplaudir VMM02S0 +aplaudid aplaudir VMM02P0 +aplaudiendo aplaudir VMG0000 +aplaudir aplaudir VMN0000 +aplaza aplazar VMM02S0 +aplazad aplazar VMM02P0 +aplazando aplazar VMG0000 +aplazar aplazar VMN0000 +aplebeya aplebeyar VMM02S0 +aplebeyad aplebeyar VMM02P0 +aplebeyando aplebeyar VMG0000 +aplebeyar aplebeyar VMN0000 +aplebeye aplebeyar VMM03S0 +aplebeyemos aplebeyar VMM01P0 +aplebeyen aplebeyar VMM03P0 +aplica aplicar VMM02S0 +aplicad aplicar VMM02P0 +aplicando aplicar VMG0000 +aplicar aplicar VMN0000 +aplique aplicar VMM03S0 +apliquemos aplicar VMM01P0 +apliquen aplicar VMM03P0 +aploma aplomar VMM02S0 +aplomad aplomar VMM02P0 +aplomando aplomar VMG0000 +aplomar aplomar VMN0000 +aplome aplomar VMM03S0 +aplomemos aplomar VMM01P0 +aplomen aplomar VMM03P0 +apoca apocar VMM02S0 +apocad apocar VMM02P0 +apocando apocar VMG0000 +apocar apocar VMN0000 +apocopa apocopar VMM02S0 +apocopad apocopar VMM02P0 +apocopando apocopar VMG0000 +apocopar apocopar VMN0000 +apocope apocopar VMM03S0 +apocopemos apocopar VMM01P0 +apocopen apocopar VMM03P0 +apoda apodar VMM02S0 +apodad apodar VMM02P0 +apodando apodar VMG0000 +apodar apodar VMN0000 +apode apodar VMM03S0 +apodemos apodar VMM01P0 +apoden apodar VMM03P0 +apodera apoderar VMM02S0 +apoderad apoderar VMM02P0 +apoderando apoderar VMG0000 +apoderar apoderar VMN0000 +apodere apoderar VMM03S0 +apoderemos apoderar VMM01P0 +apoderen apoderar VMM03P0 +apolilla apolillar VMM02S0 +apolillad apolillar VMM02P0 +apolillando apolillar VMG0000 +apolillar apolillar VMN0000 +apolille apolillar VMM03S0 +apolillemos apolillar VMM01P0 +apolillen apolillar VMM03P0 +apoltrona apoltronar VMM02S0 +apoltronad apoltronar VMM02P0 +apoltronando apoltronar VMG0000 +apoltronar apoltronar VMN0000 +apoltrone apoltronar VMM03S0 +apoltronemos apoltronar VMM01P0 +apoltronen apoltronar VMM03P0 +apolvilla apolvillar VMM02S0 +apolvillad apolvillar VMM02P0 +apolvillando apolvillar VMG0000 +apolvillar apolvillar VMN0000 +apolville apolvillar VMM03S0 +apolvillemos apolvillar VMM01P0 +apolvillen apolvillar VMM03P0 +apomace apomazar VMM03S0 +apomacemos apomazar VMM01P0 +apomacen apomazar VMM03P0 +apomaza apomazar VMM02S0 +apomazad apomazar VMM02P0 +apomazando apomazar VMG0000 +apomazar apomazar VMN0000 +apontoca apontocar VMM02S0 +apontocad apontocar VMM02P0 +apontocando apontocar VMG0000 +apontocar apontocar VMN0000 +apontoque apontocar VMM03S0 +apontoquemos apontocar VMM01P0 +apontoquen apontocar VMM03P0 +apopa apopar VMM02S0 +apopad apopar VMM02P0 +apopando apopar VMG0000 +apopar apopar VMN0000 +apope apopar VMM03S0 +apopemos apopar VMM01P0 +apopen apopar VMM03P0 +apoque apocar VMM03S0 +apoquemos apocar VMM01P0 +apoquen apocar VMM03P0 +apoquina apoquinar VMM02S0 +apoquinad apoquinar VMM02P0 +apoquinando apoquinar VMG0000 +apoquinar apoquinar VMN0000 +apoquine apoquinar VMM03S0 +apoquinemos apoquinar VMM01P0 +apoquinen apoquinar VMM03P0 +aporca aporcar VMM02S0 +aporcad aporcar VMM02P0 +aporcando aporcar VMG0000 +aporcar aporcar VMN0000 +aporque aporcar VMM03S0 +aporquemos aporcar VMM01P0 +aporquen aporcar VMM03P0 +aporra aporrar VMM02S0 +aporrad aporrar VMM02P0 +aporrando aporrar VMG0000 +aporrar aporrar VMN0000 +aporre aporrar VMM03S0 +aporrea aporrear VMM02S0 +aporread aporrear VMM02P0 +aporreando aporrear VMG0000 +aporrear aporrear VMN0000 +aporree aporrear VMM03S0 +aporreemos aporrear VMM01P0 +aporreen aporrear VMM03P0 +aporremos aporrar VMM01P0 +aporren aporrar VMM03P0 +aporta aportar VMM02S0 +aportad aportar VMM02P0 +aportando aportar VMG0000 +aportar aportar VMN0000 +aporte aportar VMM03S0 +aportemos aportar VMM01P0 +aporten aportar VMM03P0 +aportilla aportillar VMM02S0 +aportillad aportillar VMM02P0 +aportillando aportillar VMG0000 +aportillar aportillar VMN0000 +aportille aportillar VMM03S0 +aportillemos aportillar VMM01P0 +aportillen aportillar VMM03P0 +aposenta aposentar VMM02S0 +aposentad aposentar VMM02P0 +aposentando aposentar VMG0000 +aposentar aposentar VMN0000 +aposente aposentar VMM03S0 +aposentemos aposentar VMM01P0 +aposenten aposentar VMM03P0 +aposesiona aposesionar VMM02S0 +aposesionad aposesionar VMM02P0 +aposesionando aposesionar VMG0000 +aposesionar aposesionar VMN0000 +aposesione aposesionar VMM03S0 +aposesionemos aposesionar VMM01P0 +aposesionen aposesionar VMM03P0 +aposta apostar VMM02S0 +apostad apostar VMM02P0 +apostando apostar VMG0000 +apostar apostar VMN0000 +apostata apostatar VMM02S0 +apostatad apostatar VMM02P0 +apostatando apostatar VMG0000 +apostatar apostatar VMN0000 +apostate apostatar VMM03S0 +apostatemos apostatar VMM01P0 +apostaten apostatar VMM03P0 +aposte apostar VMM03S0 +apostema apostemar VMM02S0 +apostemad apostemar VMM02P0 +apostemando apostemar VMG0000 +apostemar apostemar VMN0000 +aposteme apostemar VMM03S0 +apostememos apostemar VMM01P0 +apostemen apostemar VMM03P0 +apostemos apostar VMM01P0 +aposten apostar VMM03P0 +apostilla apostillar VMM02S0 +apostillad apostillar VMM02P0 +apostillando apostillar VMG0000 +apostillar apostillar VMN0000 +apostille apostillar VMM03S0 +apostillemos apostillar VMM01P0 +apostillen apostillar VMM03P0 +apostrofa apostrofar VMM02S0 +apostrofad apostrofar VMM02P0 +apostrofando apostrofar VMG0000 +apostrofar apostrofar VMN0000 +apostrofe apostrofar VMM03S0 +apostrofemos apostrofar VMM01P0 +apostrofen apostrofar VMM03P0 +apotrera apotrerar VMM02S0 +apotrerad apotrerar VMM02P0 +apotrerando apotrerar VMG0000 +apotrerar apotrerar VMN0000 +apotrere apotrerar VMM03S0 +apotreremos apotrerar VMM01P0 +apotreren apotrerar VMM03P0 +apoya apoyar VMM02S0 +apoyad apoyar VMM02P0 +apoyando apoyar VMG0000 +apoyar apoyar VMN0000 +apoye apoyar VMM03S0 +apoyemos apoyar VMM01P0 +apoyen apoyar VMM03P0 +aprecia apreciar VMM02S0 +apreciad apreciar VMM02P0 +apreciando apreciar VMG0000 +apreciar apreciar VMN0000 +aprecie apreciar VMM03S0 +apreciemos apreciar VMM01P0 +aprecien apreciar VMM03P0 +aprehenda aprehender VMM03S0 +aprehendamos aprehender VMM01P0 +aprehendan aprehender VMM03P0 +aprehende aprehender VMM02S0 +aprehended aprehender VMM02P0 +aprehender aprehender VMN0000 +aprehendiendo aprehender VMG0000 +apremia apremiar VMM02S0 +apremiad apremiar VMM02P0 +apremiando apremiar VMG0000 +apremiar apremiar VMN0000 +apremie apremiar VMM03S0 +apremiemos apremiar VMM01P0 +apremien apremiar VMM03P0 +aprenda aprender VMM03S0 +aprendamos aprender VMM01P0 +aprendan aprender VMM03P0 +aprende aprender VMM02S0 +aprended aprender VMM02P0 +aprender aprender VMN0000 +aprendiendo aprender VMG0000 +aprensa aprensar VMM02S0 +aprensad aprensar VMM02P0 +aprensando aprensar VMG0000 +aprensar aprensar VMN0000 +aprense aprensar VMM03S0 +aprensemos aprensar VMM01P0 +aprensen aprensar VMM03P0 +apresa apresar VMM02S0 +apresad apresar VMM02P0 +apresando apresar VMG0000 +apresar apresar VMN0000 +aprese apresar VMM03S0 +apresemos apresar VMM01P0 +apresen apresar VMM03P0 +apresta aprestar VMM02S0 +aprestad aprestar VMM02P0 +aprestando aprestar VMG0000 +aprestar aprestar VMN0000 +apreste aprestar VMM03S0 +aprestemos aprestar VMM01P0 +apresten aprestar VMM03P0 +apresura apresurar VMM02S0 +apresurad apresurar VMM02P0 +apresurando apresurar VMG0000 +apresurar apresurar VMN0000 +apresure apresurar VMM03S0 +apresuremos apresurar VMM01P0 +apresuren apresurar VMM03P0 +apretad apretar VMM02P0 +apretando apretar VMG0000 +apretar apretar VMN0000 +apretemos apretar VMM01P0 +apretuja apretujar VMM02S0 +apretujad apretujar VMM02P0 +apretujando apretujar VMG0000 +apretujar apretujar VMN0000 +apretuje apretujar VMM03S0 +apretujemos apretujar VMM01P0 +apretujen apretujar VMM03P0 +aprieta apretar VMM02S0 +apriete apretar VMM03S0 +aprieten apretar VMM03P0 +aprisca apriscar VMM02S0 +apriscad apriscar VMM02P0 +apriscando apriscar VMG0000 +apriscar apriscar VMN0000 +aprisiona aprisionar VMM02S0 +aprisionad aprisionar VMM02P0 +aprisionando aprisionar VMG0000 +aprisionar aprisionar VMN0000 +aprisione aprisionar VMM03S0 +aprisionemos aprisionar VMM01P0 +aprisionen aprisionar VMM03P0 +aprisque apriscar VMM03S0 +aprisquemos apriscar VMM01P0 +aprisquen apriscar VMM03P0 +aproa aproar VMM02S0 +aproad aproar VMM02P0 +aproando aproar VMG0000 +aproar aproar VMN0000 +aprobad aprobar VMM02P0 +aprobando aprobar VMG0000 +aprobar aprobar VMN0000 +aprobemos aprobar VMM01P0 +aproe aproar VMM03S0 +aproemos aproar VMM01P0 +aproen aproar VMM03P0 +apronta aprontar VMM02S0 +aprontad aprontar VMM02P0 +aprontando aprontar VMG0000 +aprontar aprontar VMN0000 +apronte aprontar VMM03S0 +aprontemos aprontar VMM01P0 +apronten aprontar VMM03P0 +apropia apropiar VMM02S0 +apropiad apropiar VMM02P0 +apropiando apropiar VMG0000 +apropiar apropiar VMN0000 +apropie apropiar VMM03S0 +apropiemos apropiar VMM01P0 +apropien apropiar VMM03P0 +apropincuad apropincuar VMM02P0 +apropincuando apropincuar VMG0000 +apropincuar apropincuar VMN0000 +apropincuemos apropincuar VMM01P0 +apropincúa apropincuar VMM02S0 +apropincúe apropincuar VMM03S0 +apropincúen apropincuar VMM03P0 +aprovecha aprovechar VMM02S0 +aprovechad aprovechar VMM02P0 +aprovechando aprovechar VMG0000 +aprovechar aprovechar VMN0000 +aproveche aprovechar VMM03S0 +aprovechemos aprovechar VMM01P0 +aprovechen aprovechar VMM03P0 +aprovisiona aprovisionar VMM02S0 +aprovisionad aprovisionar VMM02P0 +aprovisionando aprovisionar VMG0000 +aprovisionar aprovisionar VMN0000 +aprovisione aprovisionar VMM03S0 +aprovisionemos aprovisionar VMM01P0 +aprovisionen aprovisionar VMM03P0 +aproxima aproximar VMM02S0 +aproximad aproximar VMM02P0 +aproximando aproximar VMG0000 +aproximar aproximar VMN0000 +aproxime aproximar VMM03S0 +aproximemos aproximar VMM01P0 +aproximen aproximar VMM03P0 +aprueba aprobar VMM02S0 +apruebe aprobar VMM03S0 +aprueben aprobar VMM03P0 +apta aptar VMM02S0 +aptad aptar VMM02P0 +aptando aptar VMG0000 +aptar aptar VMN0000 +apte aptar VMM03S0 +aptemos aptar VMM01P0 +apten aptar VMM03P0 +apuesta apostar VMM02S0 +apueste apostar VMM03S0 +apuesten apostar VMM03P0 +apulgara apulgarar VMM02S0 +apulgarad apulgarar VMM02P0 +apulgarando apulgarar VMG0000 +apulgarar apulgarar VMN0000 +apulgare apulgarar VMM03S0 +apulgaremos apulgarar VMM01P0 +apulgaren apulgarar VMM03P0 +apuna apunar VMM02S0 +apunad apunar VMM02P0 +apunando apunar VMG0000 +apunar apunar VMN0000 +apune apunar VMM03S0 +apunemos apunar VMM01P0 +apunen apunar VMM03P0 +apunta apuntar VMM02S0 +apuntad apuntar VMM02P0 +apuntala apuntalar VMM02S0 +apuntalad apuntalar VMM02P0 +apuntalando apuntalar VMG0000 +apuntalar apuntalar VMN0000 +apuntale apuntalar VMM03S0 +apuntalemos apuntalar VMM01P0 +apuntalen apuntalar VMM03P0 +apuntando apuntar VMG0000 +apuntar apuntar VMN0000 +apunte apuntar VMM03S0 +apuntemos apuntar VMM01P0 +apunten apuntar VMM03P0 +apuntilla apuntillar VMM02S0 +apuntillad apuntillar VMM02P0 +apuntillando apuntillar VMG0000 +apuntillar apuntillar VMN0000 +apuntille apuntillar VMM03S0 +apuntillemos apuntillar VMM01P0 +apuntillen apuntillar VMM03P0 +apura apurar VMM02S0 +apurad apurar VMM02P0 +apurando apurar VMG0000 +apurar apurar VMN0000 +apure apurar VMM03S0 +apuremos apurar VMM01P0 +apuren apurar VMM03P0 +apuña apuñar VMM02S0 +apuñad apuñar VMM02P0 +apuñala apuñalar VMM02S0 +apuñalad apuñalar VMM02P0 +apuñalando apuñalar VMG0000 +apuñalar apuñalar VMN0000 +apuñale apuñalar VMM03S0 +apuñalemos apuñalar VMM01P0 +apuñalen apuñalar VMM03P0 +apuñando apuñar VMG0000 +apuñar apuñar VMN0000 +apuñe apuñar VMM03S0 +apuñea apuñear VMM02S0 +apuñead apuñear VMM02P0 +apuñeando apuñear VMG0000 +apuñear apuñear VMN0000 +apuñee apuñear VMM03S0 +apuñeemos apuñear VMM01P0 +apuñeen apuñear VMM03P0 +apuñemos apuñar VMM01P0 +apuñen apuñar VMM03P0 +apuñetea apuñetear VMM02S0 +apuñetead apuñetear VMM02P0 +apuñeteando apuñetear VMG0000 +apuñetear apuñetear VMN0000 +apuñetee apuñetear VMM03S0 +apuñeteemos apuñetear VMM01P0 +apuñeteen apuñetear VMM03P0 +aqueja aquejar VMM02S0 +aquejad aquejar VMM02P0 +aquejando aquejar VMG0000 +aquejar aquejar VMN0000 +aqueje aquejar VMM03S0 +aquejemos aquejar VMM01P0 +aquejen aquejar VMM03P0 +aquerencia aquerenciar VMM02S0 +aquerenciad aquerenciar VMM02P0 +aquerenciando aquerenciar VMG0000 +aquerenciar aquerenciar VMN0000 +aquerencie aquerenciar VMM03S0 +aquerenciemos aquerenciar VMM01P0 +aquerencien aquerenciar VMM03P0 +aquieta aquietar VMM02S0 +aquietad aquietar VMM02P0 +aquietando aquietar VMG0000 +aquietar aquietar VMN0000 +aquiete aquietar VMM03S0 +aquietemos aquietar VMM01P0 +aquieten aquietar VMM03P0 +aquilata aquilatar VMM02S0 +aquilatad aquilatar VMM02P0 +aquilatando aquilatar VMG0000 +aquilatar aquilatar VMN0000 +aquilate aquilatar VMM03S0 +aquilatemos aquilatar VMM01P0 +aquilaten aquilatar VMM03P0 +ara arar VMM02S0 +arabice arabizar VMM03S0 +arabicemos arabizar VMM01P0 +arabicen arabizar VMM03P0 +arabiza arabizar VMM02S0 +arabizad arabizar VMM02P0 +arabizando arabizar VMG0000 +arabizar arabizar VMN0000 +arad arar VMM02P0 +arando arar VMG0000 +arar arar VMN0000 +araña arañar VMM02S0 +arañad arañar VMM02P0 +arañando arañar VMG0000 +arañar arañar VMN0000 +arañe arañar VMM03S0 +arañemos arañar VMM01P0 +arañen arañar VMM03P0 +arbitra arbitrar VMM02S0 +arbitrad arbitrar VMM02P0 +arbitrando arbitrar VMG0000 +arbitrar arbitrar VMN0000 +arbitre arbitrar VMM03S0 +arbitremos arbitrar VMM01P0 +arbitren arbitrar VMM03P0 +arbola arbolar VMM02S0 +arbolad arbolar VMM02P0 +arbolando arbolar VMG0000 +arbolar arbolar VMN0000 +arbole arbolar VMM03S0 +arbolece arbolecer VMM02S0 +arboleced arbolecer VMM02P0 +arbolecer arbolecer VMN0000 +arboleciendo arbolecer VMG0000 +arbolemos arbolar VMM01P0 +arbolen arbolar VMM03P0 +arbolezca arbolecer VMM03S0 +arbolezcamos arbolecer VMM01P0 +arbolezcan arbolecer VMM03P0 +arborece arborecer VMM02S0 +arboreced arborecer VMM02P0 +arborecer arborecer VMN0000 +arboreciendo arborecer VMG0000 +arborezca arborecer VMM03S0 +arborezcamos arborecer VMM01P0 +arborezcan arborecer VMM03P0 +arcabucea arcabucear VMM02S0 +arcabucead arcabucear VMM02P0 +arcabuceando arcabucear VMG0000 +arcabucear arcabucear VMN0000 +arcabucee arcabucear VMM03S0 +arcabuceemos arcabucear VMM01P0 +arcabuceen arcabucear VMM03P0 +arcaicemos arcaizar VMM01P0 +arcaizad arcaizar VMM02P0 +arcaizando arcaizar VMG0000 +arcaizar arcaizar VMN0000 +arcaíce arcaizar VMM03S0 +arcaícen arcaizar VMM03P0 +arcaíza arcaizar VMM02S0 +archiva archivar VMM02S0 +archivad archivar VMM02P0 +archivando archivar VMG0000 +archivar archivar VMN0000 +archive archivar VMM03S0 +archivemos archivar VMM01P0 +archiven archivar VMM03P0 +arcilla arcillar VMM02S0 +arcillad arcillar VMM02P0 +arcillando arcillar VMG0000 +arcillar arcillar VMN0000 +arcille arcillar VMM03S0 +arcillemos arcillar VMM01P0 +arcillen arcillar VMM03P0 +arda arder VMM03S0 +ardamos arder VMM01P0 +ardan arder VMM03P0 +arde arder VMM02S0 +arded arder VMM02P0 +arder arder VMN0000 +ardiendo arder VMG0000 +are arar VMM03S0 +arela arelar VMM02S0 +arelad arelar VMM02P0 +arelando arelar VMG0000 +arelar arelar VMN0000 +arele arelar VMM03S0 +arelemos arelar VMM01P0 +arelen arelar VMM03P0 +aremos arar VMM01P0 +aren arar VMM03P0 +arena arenar VMM02S0 +arenad arenar VMM02P0 +arenando arenar VMG0000 +arenar arenar VMN0000 +arenca arencar VMM02S0 +arencad arencar VMM02P0 +arencando arencar VMG0000 +arencar arencar VMN0000 +arene arenar VMM03S0 +arenemos arenar VMM01P0 +arenen arenar VMM03P0 +arenga arengar VMM02S0 +arengad arengar VMM02P0 +arengando arengar VMG0000 +arengar arengar VMN0000 +arengue arengar VMM03S0 +arenguemos arengar VMM01P0 +arenguen arengar VMM03P0 +arenque arencar VMM03S0 +arenquemos arencar VMM01P0 +arenquen arencar VMM03P0 +arfa arfar VMM02S0 +arfad arfar VMM02P0 +arfando arfar VMG0000 +arfar arfar VMN0000 +arfe arfar VMM03S0 +arfemos arfar VMM01P0 +arfen arfar VMM03P0 +argamasa argamasar VMM02S0 +argamasad argamasar VMM02P0 +argamasando argamasar VMG0000 +argamasar argamasar VMN0000 +argamase argamasar VMM03S0 +argamasemos argamasar VMM01P0 +argamasen argamasar VMM03P0 +argenta argentar VMM02S0 +argentad argentar VMM02P0 +argentando argentar VMG0000 +argentar argentar VMN0000 +argente argentar VMM03S0 +argentemos argentar VMM01P0 +argenten argentar VMM03P0 +argumenta argumentar VMM02S0 +argumentad argumentar VMM02P0 +argumentando argumentar VMG0000 +argumentar argumentar VMN0000 +argumente argumentar VMM03S0 +argumentemos argumentar VMM01P0 +argumenten argumentar VMM03P0 +arguya argüir VMM03S0 +arguyamos argüir VMM01P0 +arguyan argüir VMM03P0 +arguye argüir VMM02S0 +arguyendo argüir VMG0000 +argüid argüir VMM02P0 +argüir argüir VMN0000 +arica aricar VMM02S0 +aricad aricar VMM02P0 +aricando aricar VMG0000 +aricar aricar VMN0000 +aridece aridecer VMM02S0 +arideced aridecer VMM02P0 +aridecer aridecer VMN0000 +arideciendo aridecer VMG0000 +aridezca aridecer VMM03S0 +aridezcamos aridecer VMM01P0 +aridezcan aridecer VMM03P0 +arique aricar VMM03S0 +ariquemos aricar VMM01P0 +ariquen aricar VMM03P0 +aristocratice aristocratizar VMM03S0 +aristocraticemos aristocratizar VMM01P0 +aristocraticen aristocratizar VMM03P0 +aristocratiza aristocratizar VMM02S0 +aristocratizad aristocratizar VMM02P0 +aristocratizando aristocratizar VMG0000 +aristocratizar aristocratizar VMN0000 +arma armar VMM02S0 +armad armar VMM02P0 +armando armar VMG0000 +armar armar VMN0000 +arme armar VMM03S0 +armemos armar VMM01P0 +armen armar VMM03P0 +armonice armonizar VMM03S0 +armonicemos armonizar VMM01P0 +armonicen armonizar VMM03P0 +armoniza armonizar VMM02S0 +armonizad armonizar VMM02P0 +armonizando armonizar VMG0000 +armonizar armonizar VMN0000 +aroma aromar VMM02S0 +aromad aromar VMM02P0 +aromando aromar VMG0000 +aromar aromar VMN0000 +aromatice aromatizar VMM03S0 +aromaticemos aromatizar VMM01P0 +aromaticen aromatizar VMM03P0 +aromatiza aromatizar VMM02S0 +aromatizad aromatizar VMM02P0 +aromatizando aromatizar VMG0000 +aromatizar aromatizar VMN0000 +arome aromar VMM03S0 +aromemos aromar VMM01P0 +aromen aromar VMM03P0 +arpa arpar VMM02S0 +arpad arpar VMM02P0 +arpando arpar VMG0000 +arpar arpar VMN0000 +arpe arpar VMM03S0 +arpegia arpegiar VMM02S0 +arpegiad arpegiar VMM02P0 +arpegiando arpegiar VMG0000 +arpegiar arpegiar VMN0000 +arpegie arpegiar VMM03S0 +arpegiemos arpegiar VMM01P0 +arpegien arpegiar VMM03P0 +arpemos arpar VMM01P0 +arpen arpar VMM03P0 +arpilla arpillar VMM02S0 +arpillad arpillar VMM02P0 +arpillando arpillar VMG0000 +arpillar arpillar VMN0000 +arpille arpillar VMM03S0 +arpillemos arpillar VMM01P0 +arpillen arpillar VMM03P0 +arpona arponar VMM02S0 +arponad arponar VMM02P0 +arponando arponar VMG0000 +arponar arponar VMN0000 +arpone arponar VMM03S0 +arponea arponear VMM02S0 +arponead arponear VMM02P0 +arponeando arponear VMG0000 +arponear arponear VMN0000 +arponee arponear VMM03S0 +arponeemos arponear VMM01P0 +arponeen arponear VMM03P0 +arponemos arponar VMM01P0 +arponen arponar VMM03P0 +arquea arquear VMM02S0 +arquead arquear VMM02P0 +arqueando arquear VMG0000 +arquear arquear VMN0000 +arquee arquear VMM03S0 +arqueemos arquear VMM01P0 +arqueen arquear VMM03P0 +arracima arracimar VMM02S0 +arracimad arracimar VMM02P0 +arracimando arracimar VMG0000 +arracimar arracimar VMN0000 +arracime arracimar VMM03S0 +arracimemos arracimar VMM01P0 +arracimen arracimar VMM03P0 +arraiga arraigar VMM02S0 +arraigad arraigar VMM02P0 +arraigando arraigar VMG0000 +arraigar arraigar VMN0000 +arraigue arraigar VMM03S0 +arraiguemos arraigar VMM01P0 +arraiguen arraigar VMM03P0 +arrambla arramblar VMM02S0 +arramblad arramblar VMM02P0 +arramblando arramblar VMG0000 +arramblar arramblar VMN0000 +arramble arramblar VMM03S0 +arramblemos arramblar VMM01P0 +arramblen arramblar VMM03P0 +arrampla arramplar VMM02S0 +arramplad arramplar VMM02P0 +arramplando arramplar VMG0000 +arramplar arramplar VMN0000 +arrample arramplar VMM03S0 +arramplemos arramplar VMM01P0 +arramplen arramplar VMM03P0 +arranca arrancar VMM02S0 +arrancad arrancar VMM02P0 +arrancando arrancar VMG0000 +arrancar arrancar VMN0000 +arrancha arranchar VMM02S0 +arranchad arranchar VMM02P0 +arranchando arranchar VMG0000 +arranchar arranchar VMN0000 +arranche arranchar VMM03S0 +arranchemos arranchar VMM01P0 +arranchen arranchar VMM03P0 +arranque arrancar VMM03S0 +arranquemos arrancar VMM01P0 +arranquen arrancar VMM03P0 +arrasa arrasar VMM02S0 +arrasad arrasar VMM02P0 +arrasando arrasar VMG0000 +arrasar arrasar VMN0000 +arrase arrasar VMM03S0 +arrasemos arrasar VMM01P0 +arrasen arrasar VMM03P0 +arrastra arrastrar VMM02S0 +arrastrad arrastrar VMM02P0 +arrastrando arrastrar VMG0000 +arrastrar arrastrar VMN0000 +arrastre arrastrar VMM03S0 +arrastremos arrastrar VMM01P0 +arrastren arrastrar VMM03P0 +arrea arrear VMM02S0 +arread arrear VMM02P0 +arreando arrear VMG0000 +arrear arrear VMN0000 +arrebata arrebatar VMM02S0 +arrebatad arrebatar VMM02P0 +arrebatando arrebatar VMG0000 +arrebatar arrebatar VMN0000 +arrebate arrebatar VMM03S0 +arrebatemos arrebatar VMM01P0 +arrebaten arrebatar VMM03P0 +arrebaña arrebañar VMM02S0 +arrebañad arrebañar VMM02P0 +arrebañando arrebañar VMG0000 +arrebañar arrebañar VMN0000 +arrebañe arrebañar VMM03S0 +arrebañemos arrebañar VMM01P0 +arrebañen arrebañar VMM03P0 +arreboce arrebozar VMM03S0 +arrebocemos arrebozar VMM01P0 +arrebocen arrebozar VMM03P0 +arrebola arrebolar VMM02S0 +arrebolad arrebolar VMM02P0 +arrebolando arrebolar VMG0000 +arrebolar arrebolar VMN0000 +arrebole arrebolar VMM03S0 +arrebolemos arrebolar VMM01P0 +arrebolen arrebolar VMM03P0 +arreboza arrebozar VMM02S0 +arrebozad arrebozar VMM02P0 +arrebozando arrebozar VMG0000 +arrebozar arrebozar VMN0000 +arrebuja arrebujar VMM02S0 +arrebujad arrebujar VMM02P0 +arrebujando arrebujar VMG0000 +arrebujar arrebujar VMN0000 +arrebuje arrebujar VMM03S0 +arrebujemos arrebujar VMM01P0 +arrebujen arrebujar VMM03P0 +arrecia arreciar VMM02S0 +arreciad arreciar VMM02P0 +arreciando arreciar VMG0000 +arreciar arreciar VMN0000 +arrecie arreciar VMM03S0 +arreciemos arreciar VMM01P0 +arrecien arreciar VMM03P0 +arredila arredilar VMM02S0 +arredilad arredilar VMM02P0 +arredilando arredilar VMG0000 +arredilar arredilar VMN0000 +arredile arredilar VMM03S0 +arredilemos arredilar VMM01P0 +arredilen arredilar VMM03P0 +arredra arredrar VMM02S0 +arredrad arredrar VMM02P0 +arredrando arredrar VMG0000 +arredrar arredrar VMN0000 +arredre arredrar VMM03S0 +arredremos arredrar VMM01P0 +arredren arredrar VMM03P0 +arree arrear VMM03S0 +arreemos arrear VMM01P0 +arreen arrear VMM03P0 +arregace arregazar VMM03S0 +arregacemos arregazar VMM01P0 +arregacen arregazar VMM03P0 +arregaza arregazar VMM02S0 +arregazad arregazar VMM02P0 +arregazando arregazar VMG0000 +arregazar arregazar VMN0000 +arregla arreglar VMM02S0 +arreglad arreglar VMM02P0 +arreglando arreglar VMG0000 +arreglar arreglar VMN0000 +arregle arreglar VMM03S0 +arreglemos arreglar VMM01P0 +arreglen arreglar VMM03P0 +arregosta arregostar VMM02S0 +arregostad arregostar VMM02P0 +arregostando arregostar VMG0000 +arregostar arregostar VMN0000 +arregoste arregostar VMM03S0 +arregostemos arregostar VMM01P0 +arregosten arregostar VMM03P0 +arrejaca arrejacar VMM02S0 +arrejacad arrejacar VMM02P0 +arrejacando arrejacar VMG0000 +arrejacar arrejacar VMN0000 +arrejaque arrejacar VMM03S0 +arrejaquemos arrejacar VMM01P0 +arrejaquen arrejacar VMM03P0 +arrejera arrejerar VMM02S0 +arrejerad arrejerar VMM02P0 +arrejerando arrejerar VMG0000 +arrejerar arrejerar VMN0000 +arrejere arrejerar VMM03S0 +arrejeremos arrejerar VMM01P0 +arrejeren arrejerar VMM03P0 +arrejunta arrejuntar VMM02S0 +arrejuntad arrejuntar VMM02P0 +arrejuntando arrejuntar VMG0000 +arrejuntar arrejuntar VMN0000 +arrejunte arrejuntar VMM03S0 +arrejuntemos arrejuntar VMM01P0 +arrejunten arrejuntar VMM03P0 +arrellana arrellanar VMM02S0 +arrellanad arrellanar VMM02P0 +arrellanando arrellanar VMG0000 +arrellanar arrellanar VMN0000 +arrellane arrellanar VMM03S0 +arrellanemos arrellanar VMM01P0 +arrellanen arrellanar VMM03P0 +arremanga arremangar VMM02S0 +arremangad arremangar VMM02P0 +arremangando arremangar VMG0000 +arremangar arremangar VMN0000 +arremangue arremangar VMM03S0 +arremanguemos arremangar VMM01P0 +arremanguen arremangar VMM03P0 +arremeta arremeter VMM03S0 +arremetamos arremeter VMM01P0 +arremetan arremeter VMM03P0 +arremete arremeter VMM02S0 +arremeted arremeter VMM02P0 +arremeter arremeter VMN0000 +arremetiendo arremeter VMG0000 +arremolina arremolinar VMM02S0 +arremolinad arremolinar VMM02P0 +arremolinando arremolinar VMG0000 +arremolinar arremolinar VMN0000 +arremoline arremolinar VMM03S0 +arremolinemos arremolinar VMM01P0 +arremolinen arremolinar VMM03P0 +arrempuja arrempujar VMM02S0 +arrempujad arrempujar VMM02P0 +arrempujando arrempujar VMG0000 +arrempujar arrempujar VMN0000 +arrempuje arrempujar VMM03S0 +arrempujemos arrempujar VMM01P0 +arrempujen arrempujar VMM03P0 +arrendad arrendar VMM02P0 +arrendando arrendar VMG0000 +arrendar arrendar VMN0000 +arrendemos arrendar VMM01P0 +arrepanchiga arrepanchigar VMM02S0 +arrepanchigad arrepanchigar VMM02P0 +arrepanchigando arrepanchigar VMG0000 +arrepanchigar arrepanchigar VMN0000 +arrepanchigue arrepanchigar VMM03S0 +arrepanchiguemos arrepanchigar VMM01P0 +arrepanchiguen arrepanchigar VMM03P0 +arrepentid arrepentir VMM02P0 +arrepentir arrepentir VMN0000 +arrepienta arrepentir VMM03S0 +arrepientan arrepentir VMM03P0 +arrepiente arrepentir VMM02S0 +arrepintamos arrepentir VMM01P0 +arrepintiendo arrepentir VMG0000 +arrequesona arrequesonar VMM02S0 +arrequesonad arrequesonar VMM02P0 +arrequesonando arrequesonar VMG0000 +arrequesonar arrequesonar VMN0000 +arrequesone arrequesonar VMM03S0 +arrequesonemos arrequesonar VMM01P0 +arrequesonen arrequesonar VMM03P0 +arresta arrestar VMM02S0 +arrestad arrestar VMM02P0 +arrestando arrestar VMG0000 +arrestar arrestar VMN0000 +arreste arrestar VMM03S0 +arrestemos arrestar VMM01P0 +arresten arrestar VMM03P0 +arrezaga arrezagar VMM02S0 +arrezagad arrezagar VMM02P0 +arrezagando arrezagar VMG0000 +arrezagar arrezagar VMN0000 +arrezague arrezagar VMM03S0 +arrezaguemos arrezagar VMM01P0 +arrezaguen arrezagar VMM03P0 +arriad arriar VMM02P0 +arriando arriar VMG0000 +arriar arriar VMN0000 +arriba arribar VMM02S0 +arribad arribar VMM02P0 +arribando arribar VMG0000 +arribar arribar VMN0000 +arribe arribar VMM03S0 +arribemos arribar VMM01P0 +arriben arribar VMM03P0 +arrice arrizar VMM03S0 +arricemos arrizar VMM01P0 +arricen arrizar VMM03P0 +arrida arridar VMM02S0 +arridad arridar VMM02P0 +arridando arridar VMG0000 +arridar arridar VMN0000 +arride arridar VMM03S0 +arridemos arridar VMM01P0 +arriden arridar VMM03P0 +arriemos arriar VMM01P0 +arrienda arrendar VMM02S0 +arriende arrendar VMM03S0 +arrienden arrendar VMM03P0 +arriesga arriesgar VMM02S0 +arriesgad arriesgar VMM02P0 +arriesgando arriesgar VMG0000 +arriesgar arriesgar VMN0000 +arriesgue arriesgar VMM03S0 +arriesguemos arriesgar VMM01P0 +arriesguen arriesgar VMM03P0 +arrima arrimar VMM02S0 +arrimad arrimar VMM02P0 +arrimando arrimar VMG0000 +arrimar arrimar VMN0000 +arrime arrimar VMM03S0 +arrimemos arrimar VMM01P0 +arrimen arrimar VMM03P0 +arrincona arrinconar VMM02S0 +arrinconad arrinconar VMM02P0 +arrinconando arrinconar VMG0000 +arrinconar arrinconar VMN0000 +arrincone arrinconar VMM03S0 +arrinconemos arrinconar VMM01P0 +arrinconen arrinconar VMM03P0 +arriostra arriostrar VMM02S0 +arriostrad arriostrar VMM02P0 +arriostrando arriostrar VMG0000 +arriostrar arriostrar VMN0000 +arriostre arriostrar VMM03S0 +arriostremos arriostrar VMM01P0 +arriostren arriostrar VMM03P0 +arrisca arriscar VMM02S0 +arriscad arriscar VMM02P0 +arriscando arriscar VMG0000 +arriscar arriscar VMN0000 +arrisque arriscar VMM03S0 +arrisquemos arriscar VMM01P0 +arrisquen arriscar VMM03P0 +arriza arrizar VMM02S0 +arrizad arrizar VMM02P0 +arrizando arrizar VMG0000 +arrizar arrizar VMN0000 +arroba arrobar VMM02S0 +arrobad arrobar VMM02P0 +arrobando arrobar VMG0000 +arrobar arrobar VMN0000 +arrobe arrobar VMM03S0 +arrobemos arrobar VMM01P0 +arroben arrobar VMM03P0 +arrochela arrochelar VMM02S0 +arrochelad arrochelar VMM02P0 +arrochelando arrochelar VMG0000 +arrochelar arrochelar VMN0000 +arrochele arrochelar VMM03S0 +arrochelemos arrochelar VMM01P0 +arrochelen arrochelar VMM03P0 +arrocina arrocinar VMM02S0 +arrocinad arrocinar VMM02P0 +arrocinando arrocinar VMG0000 +arrocinar arrocinar VMN0000 +arrocine arrocinar VMM03S0 +arrocinemos arrocinar VMM01P0 +arrocinen arrocinar VMM03P0 +arrodaja arrodajar VMM02S0 +arrodajad arrodajar VMM02P0 +arrodajando arrodajar VMG0000 +arrodajar arrodajar VMN0000 +arrodaje arrodajar VMM03S0 +arrodajemos arrodajar VMM01P0 +arrodajen arrodajar VMM03P0 +arrodilla arrodillar VMM02S0 +arrodillad arrodillar VMM02P0 +arrodillando arrodillar VMG0000 +arrodillar arrodillar VMN0000 +arrodille arrodillar VMM03S0 +arrodillemos arrodillar VMM01P0 +arrodillen arrodillar VMM03P0 +arrodriga arrodrigar VMM02S0 +arrodrigad arrodrigar VMM02P0 +arrodrigando arrodrigar VMG0000 +arrodrigar arrodrigar VMN0000 +arrodrigona arrodrigonar VMM02S0 +arrodrigonad arrodrigonar VMM02P0 +arrodrigonando arrodrigonar VMG0000 +arrodrigonar arrodrigonar VMN0000 +arrodrigone arrodrigonar VMM03S0 +arrodrigonemos arrodrigonar VMM01P0 +arrodrigonen arrodrigonar VMM03P0 +arrodrigue arrodrigar VMM03S0 +arrodriguemos arrodrigar VMM01P0 +arrodriguen arrodrigar VMM03P0 +arroga arrogar VMM02S0 +arrogad arrogar VMM02P0 +arrogando arrogar VMG0000 +arrogar arrogar VMN0000 +arrogue arrogar VMM03S0 +arroguemos arrogar VMM01P0 +arroguen arrogar VMM03P0 +arroja arrojar VMM02S0 +arrojad arrojar VMM02P0 +arrojando arrojar VMG0000 +arrojar arrojar VMN0000 +arroje arrojar VMM03S0 +arrojemos arrojar VMM01P0 +arrojen arrojar VMM03P0 +arrolla arrollar VMM02S0 +arrollad arrollar VMM02P0 +arrollando arrollar VMG0000 +arrollar arrollar VMN0000 +arrolle arrollar VMM03S0 +arrollemos arrollar VMM01P0 +arrollen arrollar VMM03P0 +arroma arromar VMM02S0 +arromad arromar VMM02P0 +arromance arromanzar VMM03S0 +arromancemos arromanzar VMM01P0 +arromancen arromanzar VMM03P0 +arromando arromar VMG0000 +arromanza arromanzar VMM02S0 +arromanzad arromanzar VMM02P0 +arromanzando arromanzar VMG0000 +arromanzar arromanzar VMN0000 +arromar arromar VMN0000 +arrome arromar VMM03S0 +arromemos arromar VMM01P0 +arromen arromar VMM03P0 +arrompa arromper VMM03S0 +arrompamos arromper VMM01P0 +arrompan arromper VMM03P0 +arrompe arromper VMM02S0 +arromped arromper VMM02P0 +arromper arromper VMN0000 +arrompiendo arromper VMG0000 +arronce arronzar VMM03S0 +arroncemos arronzar VMM01P0 +arroncen arronzar VMM03P0 +arronza arronzar VMM02S0 +arronzad arronzar VMM02P0 +arronzando arronzar VMG0000 +arronzar arronzar VMN0000 +arropa arropar VMM02S0 +arropad arropar VMM02P0 +arropando arropar VMG0000 +arropar arropar VMN0000 +arrope arropar VMM03S0 +arropemos arropar VMM01P0 +arropen arropar VMM03P0 +arrostra arrostrar VMM02S0 +arrostrad arrostrar VMM02P0 +arrostrando arrostrar VMG0000 +arrostrar arrostrar VMN0000 +arrostre arrostrar VMM03S0 +arrostremos arrostrar VMM01P0 +arrostren arrostrar VMM03P0 +arroya arroyar VMM02S0 +arroyad arroyar VMM02P0 +arroyando arroyar VMG0000 +arroyar arroyar VMN0000 +arroye arroyar VMM03S0 +arroyemos arroyar VMM01P0 +arroyen arroyar VMM03P0 +arruad arruar VMM02P0 +arruando arruar VMG0000 +arruar arruar VMN0000 +arruemos arruar VMM01P0 +arrufa arrufar VMM02S0 +arrufad arrufar VMM02P0 +arrufando arrufar VMG0000 +arrufar arrufar VMN0000 +arrufe arrufar VMM03S0 +arrufemos arrufar VMM01P0 +arrufen arrufar VMM03P0 +arruga arrugar VMM02S0 +arrugad arrugar VMM02P0 +arrugando arrugar VMG0000 +arrugar arrugar VMN0000 +arrugue arrugar VMM03S0 +arruguemos arrugar VMM01P0 +arruguen arrugar VMM03P0 +arruina arruinar VMM02S0 +arruinad arruinar VMM02P0 +arruinando arruinar VMG0000 +arruinar arruinar VMN0000 +arruine arruinar VMM03S0 +arruinemos arruinar VMM01P0 +arruinen arruinar VMM03P0 +arrulla arrullar VMM02S0 +arrullad arrullar VMM02P0 +arrullando arrullar VMG0000 +arrullar arrullar VMN0000 +arrulle arrullar VMM03S0 +arrullemos arrullar VMM01P0 +arrullen arrullar VMM03P0 +arruma arrumar VMM02S0 +arrumad arrumar VMM02P0 +arrumando arrumar VMG0000 +arrumar arrumar VMN0000 +arrumba arrumbar VMM02S0 +arrumbad arrumbar VMM02P0 +arrumbando arrumbar VMG0000 +arrumbar arrumbar VMN0000 +arrumbe arrumbar VMM03S0 +arrumbemos arrumbar VMM01P0 +arrumben arrumbar VMM03P0 +arrume arrumar VMM03S0 +arrumemos arrumar VMM01P0 +arrumen arrumar VMM03P0 +arría arriar VMM02S0 +arríe arriar VMM03S0 +arríen arriar VMM03P0 +arrúa arruar VMM02S0 +arrúe arruar VMM03S0 +arrúen arruar VMM03P0 +artesona artesonar VMM02S0 +artesonad artesonar VMM02P0 +artesonando artesonar VMG0000 +artesonar artesonar VMN0000 +artesone artesonar VMM03S0 +artesonemos artesonar VMM01P0 +artesonen artesonar VMM03P0 +articula articular VMM02S0 +articulad articular VMM02P0 +articulando articular VMG0000 +articular articular VMN0000 +articule articular VMM03S0 +articulemos articular VMM01P0 +articulen articular VMM03P0 +artiga artigar VMM02S0 +artigad artigar VMM02P0 +artigando artigar VMG0000 +artigar artigar VMN0000 +artigue artigar VMM03S0 +artiguemos artigar VMM01P0 +artiguen artigar VMM03P0 +artilla artillar VMM02S0 +artillad artillar VMM02P0 +artillando artillar VMG0000 +artillar artillar VMN0000 +artille artillar VMM03S0 +artillemos artillar VMM01P0 +artillen artillar VMM03P0 +asa asar VMM02S0 +asad asar VMM02P0 +asaeta asaetar VMM02S0 +asaetad asaetar VMM02P0 +asaetando asaetar VMG0000 +asaetar asaetar VMN0000 +asaete asaetar VMM03S0 +asaetemos asaetar VMM01P0 +asaeten asaetar VMM03P0 +asainetea asainetear VMM02S0 +asainetead asainetear VMM02P0 +asaineteando asainetear VMG0000 +asainetear asainetear VMN0000 +asainetee asainetear VMM03S0 +asaineteemos asainetear VMM01P0 +asaineteen asainetear VMM03P0 +asalaria asalariar VMM02S0 +asalariad asalariar VMM02P0 +asalariando asalariar VMG0000 +asalariar asalariar VMN0000 +asalarie asalariar VMM03S0 +asalariemos asalariar VMM01P0 +asalarien asalariar VMM03P0 +asalmera asalmerar VMM02S0 +asalmerad asalmerar VMM02P0 +asalmerando asalmerar VMG0000 +asalmerar asalmerar VMN0000 +asalmere asalmerar VMM03S0 +asalmeremos asalmerar VMM01P0 +asalmeren asalmerar VMM03P0 +asalta asaltar VMM02S0 +asaltad asaltar VMM02P0 +asaltando asaltar VMG0000 +asaltar asaltar VMN0000 +asalte asaltar VMM03S0 +asaltemos asaltar VMM01P0 +asalten asaltar VMM03P0 +asando asar VMG0000 +asar asar VMN0000 +ascendamos ascender VMM01P0 +ascended ascender VMM02P0 +ascender ascender VMN0000 +ascendiendo ascender VMG0000 +ascienda ascender VMM03S0 +asciendan ascender VMM03P0 +asciende ascender VMM02S0 +ase asar VMM03S0 +ase asir VMM02S0 +asea asear VMM02S0 +asead asear VMM02P0 +aseando asear VMG0000 +asear asear VMN0000 +asecha asechar VMM02S0 +asechad asechar VMM02P0 +asechando asechar VMG0000 +asechar asechar VMN0000 +aseche asechar VMM03S0 +asechemos asechar VMM01P0 +asechen asechar VMM03P0 +aseda asedar VMM02S0 +asedad asedar VMM02P0 +asedando asedar VMG0000 +asedar asedar VMN0000 +asede asedar VMM03S0 +asedemos asedar VMM01P0 +aseden asedar VMM03P0 +asedia asediar VMM02S0 +asediad asediar VMM02P0 +asediando asediar VMG0000 +asediar asediar VMN0000 +asedie asediar VMM03S0 +asediemos asediar VMM01P0 +asedien asediar VMM03P0 +asee asear VMM03S0 +aseemos asear VMM01P0 +aseen asear VMM03P0 +aseglara aseglarar VMM02S0 +aseglarad aseglarar VMM02P0 +aseglarando aseglarar VMG0000 +aseglarar aseglarar VMN0000 +aseglare aseglarar VMM03S0 +aseglaremos aseglarar VMM01P0 +aseglaren aseglarar VMM03P0 +aseglarice aseglarizar VMM03S0 +aseglaricemos aseglarizar VMM01P0 +aseglaricen aseglarizar VMM03P0 +aseglariza aseglarizar VMM02S0 +aseglarizad aseglarizar VMM02P0 +aseglarizando aseglarizar VMG0000 +aseglarizar aseglarizar VMN0000 +asegura asegurar VMM02S0 +asegurad asegurar VMM02P0 +asegurando asegurar VMG0000 +asegurar asegurar VMN0000 +asegure asegurar VMM03S0 +aseguremos asegurar VMM01P0 +aseguren asegurar VMM03P0 +asemeja asemejar VMM02S0 +asemejad asemejar VMM02P0 +asemejando asemejar VMG0000 +asemejar asemejar VMN0000 +asemeje asemejar VMM03S0 +asemejemos asemejar VMM01P0 +asemejen asemejar VMM03P0 +asemos asar VMM01P0 +asen asar VMM03P0 +asenderea asenderear VMM02S0 +asenderead asenderear VMM02P0 +asendereando asenderear VMG0000 +asenderear asenderear VMN0000 +asenderee asenderear VMM03S0 +asendereemos asenderear VMM01P0 +asendereen asenderear VMM03P0 +asentad asentar VMM02P0 +asentando asentar VMG0000 +asentar asentar VMN0000 +asentemos asentar VMM01P0 +asentid asentir VMM02P0 +asentir asentir VMN0000 +aserena aserenar VMM02S0 +aserenad aserenar VMM02P0 +aserenando aserenar VMG0000 +aserenar aserenar VMN0000 +aserene aserenar VMM03S0 +aserenemos aserenar VMM01P0 +aserenen aserenar VMM03P0 +aseria aseriar VMM02S0 +aseriad aseriar VMM02P0 +aseriando aseriar VMG0000 +aseriar aseriar VMN0000 +aserie aseriar VMM03S0 +aseriemos aseriar VMM01P0 +aserien aseriar VMM03P0 +aserrad aserrar VMM02P0 +aserrando aserrar VMG0000 +aserrar aserrar VMN0000 +aserremos aserrar VMM01P0 +aserrucha aserruchar VMM02S0 +aserruchad aserruchar VMM02P0 +aserruchando aserruchar VMG0000 +aserruchar aserruchar VMN0000 +aserruche aserruchar VMM03S0 +aserruchemos aserruchar VMM01P0 +aserruchen aserruchar VMM03P0 +asesa asesar VMM02S0 +asesad asesar VMM02P0 +asesando asesar VMG0000 +asesar asesar VMN0000 +asese asesar VMM03S0 +asesemos asesar VMM01P0 +asesen asesar VMM03P0 +asesina asesinar VMM02S0 +asesinad asesinar VMM02P0 +asesinando asesinar VMG0000 +asesinar asesinar VMN0000 +asesine asesinar VMM03S0 +asesinemos asesinar VMM01P0 +asesinen asesinar VMM03P0 +asesora asesorar VMM02S0 +asesorad asesorar VMM02P0 +asesorando asesorar VMG0000 +asesorar asesorar VMN0000 +asesore asesorar VMM03S0 +asesoremos asesorar VMM01P0 +asesoren asesorar VMM03P0 +asestad asestar VMM02P0 +asestando asestar VMG0000 +asestar asestar VMN0000 +asestemos asestar VMM01P0 +asevera aseverar VMM02S0 +aseverad aseverar VMM02P0 +aseverando aseverar VMG0000 +aseverar aseverar VMN0000 +asevere aseverar VMM03S0 +aseveremos aseverar VMM01P0 +aseveren aseverar VMM03P0 +asfalta asfaltar VMM02S0 +asfaltad asfaltar VMM02P0 +asfaltando asfaltar VMG0000 +asfaltar asfaltar VMN0000 +asfalte asfaltar VMM03S0 +asfaltemos asfaltar VMM01P0 +asfalten asfaltar VMM03P0 +asfixia asfixiar VMM02S0 +asfixiad asfixiar VMM02P0 +asfixiando asfixiar VMG0000 +asfixiar asfixiar VMN0000 +asfixie asfixiar VMM03S0 +asfixiemos asfixiar VMM01P0 +asfixien asfixiar VMM03P0 +asga asir VMM03S0 +asgamos asir VMM01P0 +asgan asir VMM03P0 +asibila asibilar VMM02S0 +asibilad asibilar VMM02P0 +asibilando asibilar VMG0000 +asibilar asibilar VMN0000 +asibile asibilar VMM03S0 +asibilemos asibilar VMM01P0 +asibilen asibilar VMM03P0 +asid asir VMM02P0 +asiendo asir VMG0000 +asienta asentar VMM02S0 +asienta asentir VMM03S0 +asientan asentir VMM03P0 +asiente asentar VMM03S0 +asiente asentir VMM02S0 +asienten asentar VMM03P0 +asierra aserrar VMM02S0 +asierre aserrar VMM03S0 +asierren aserrar VMM03P0 +asiesta asestar VMM02S0 +asieste asestar VMM03S0 +asiesten asestar VMM03P0 +asigna asignar VMM02S0 +asignad asignar VMM02P0 +asignando asignar VMG0000 +asignar asignar VMN0000 +asigne asignar VMM03S0 +asignemos asignar VMM01P0 +asignen asignar VMM03P0 +asila asilar VMM02S0 +asilad asilar VMM02P0 +asilando asilar VMG0000 +asilar asilar VMN0000 +asile asilar VMM03S0 +asilemos asilar VMM01P0 +asilen asilar VMM03P0 +asimila asimilar VMM02S0 +asimilad asimilar VMM02P0 +asimilando asimilar VMG0000 +asimilar asimilar VMN0000 +asimile asimilar VMM03S0 +asimilemos asimilar VMM01P0 +asimilen asimilar VMM03P0 +asintamos asentir VMM01P0 +asintiendo asentir VMG0000 +asir asir VMN0000 +asista asistir VMM03S0 +asistamos asistir VMM01P0 +asistan asistir VMM03P0 +asiste asistir VMM02S0 +asistid asistir VMM02P0 +asistiendo asistir VMG0000 +asistir asistir VMN0000 +asobarca asobarcar VMM02S0 +asobarcad asobarcar VMM02P0 +asobarcando asobarcar VMG0000 +asobarcar asobarcar VMN0000 +asobarque asobarcar VMM03S0 +asobarquemos asobarcar VMM01P0 +asobarquen asobarcar VMM03P0 +asobina asobinar VMM02S0 +asobinad asobinar VMM02P0 +asobinando asobinar VMG0000 +asobinar asobinar VMN0000 +asobine asobinar VMM03S0 +asobinemos asobinar VMM01P0 +asobinen asobinar VMM03P0 +asocia asociar VMM02S0 +asociad asociar VMM02P0 +asociando asociar VMG0000 +asociar asociar VMN0000 +asocie asociar VMM03S0 +asociemos asociar VMM01P0 +asocien asociar VMM03P0 +asola asolar VMM02S0 +asolad asolar VMM02P0 +asolana asolanar VMM02S0 +asolanad asolanar VMM02P0 +asolanando asolanar VMG0000 +asolanar asolanar VMN0000 +asolando asolar VMG0000 +asolane asolanar VMM03S0 +asolanemos asolanar VMM01P0 +asolanen asolanar VMM03P0 +asolar asolar VMN0000 +asole asolar VMM03S0 +asolea asolear VMM02S0 +asolead asolear VMM02P0 +asoleando asolear VMG0000 +asolear asolear VMN0000 +asolee asolear VMM03S0 +asoleemos asolear VMM01P0 +asoleen asolear VMM03P0 +asolemos asolar VMM01P0 +asolen asolar VMM03P0 +asoma asomar VMM02S0 +asomad asomar VMM02P0 +asomando asomar VMG0000 +asomar asomar VMN0000 +asombra asombrar VMM02S0 +asombrad asombrar VMM02P0 +asombrando asombrar VMG0000 +asombrar asombrar VMN0000 +asombre asombrar VMM03S0 +asombremos asombrar VMM01P0 +asombren asombrar VMM03P0 +asome asomar VMM03S0 +asomemos asomar VMM01P0 +asomen asomar VMM03P0 +asonad asonar VMM02P0 +asonando asonar VMG0000 +asonanta asonantar VMM02S0 +asonantad asonantar VMM02P0 +asonantando asonantar VMG0000 +asonantar asonantar VMN0000 +asonante asonantar VMM03S0 +asonantemos asonantar VMM01P0 +asonanten asonantar VMM03P0 +asonar asonar VMN0000 +asonemos asonar VMM01P0 +asorocha asorochar VMM02S0 +asorochad asorochar VMM02P0 +asorochando asorochar VMG0000 +asorochar asorochar VMN0000 +asoroche asorochar VMM03S0 +asorochemos asorochar VMM01P0 +asorochen asorochar VMM03P0 +aspa aspar VMM02S0 +aspad aspar VMM02P0 +aspando aspar VMG0000 +aspar aspar VMN0000 +aspaventad aspaventar VMM02P0 +aspaventando aspaventar VMG0000 +aspaventar aspaventar VMN0000 +aspaventemos aspaventar VMM01P0 +aspavienta aspaventar VMM02S0 +aspaviente aspaventar VMM03S0 +aspavienten aspaventar VMM03P0 +aspe aspar VMM03S0 +aspemos aspar VMM01P0 +aspen aspar VMM03P0 +asperea asperear VMM02S0 +asperead asperear VMM02P0 +aspereando asperear VMG0000 +asperear asperear VMN0000 +asperee asperear VMM03S0 +aspereemos asperear VMM01P0 +aspereen asperear VMM03P0 +asperge asperger VMM02S0 +asperged asperger VMM02P0 +asperger asperger VMN0000 +aspergiendo asperger VMG0000 +asperja asperger VMM03S0 +asperja asperjar VMM02S0 +asperjad asperjar VMM02P0 +asperjamos asperger VMM01P0 +asperjan asperger VMM03P0 +asperjando asperjar VMG0000 +asperjar asperjar VMN0000 +asperje asperjar VMM03S0 +asperjemos asperjar VMM01P0 +asperjen asperjar VMM03P0 +aspira aspirar VMM02S0 +aspirad aspirar VMM02P0 +aspirando aspirar VMG0000 +aspirar aspirar VMN0000 +aspire aspirar VMM03S0 +aspiremos aspirar VMM01P0 +aspiren aspirar VMM03P0 +asquea asquear VMM02S0 +asquead asquear VMM02P0 +asqueando asquear VMG0000 +asquear asquear VMN0000 +asquee asquear VMM03S0 +asqueemos asquear VMM01P0 +asqueen asquear VMM03P0 +astilla astillar VMM02S0 +astillad astillar VMM02P0 +astillando astillar VMG0000 +astillar astillar VMN0000 +astille astillar VMM03S0 +astillemos astillar VMM01P0 +astillen astillar VMM03P0 +astreñid astreñir VMM02P0 +astreñir astreñir VMN0000 +astringe astringir VMM02S0 +astringid astringir VMM02P0 +astringiendo astringir VMG0000 +astringir astringir VMN0000 +astrinja astringir VMM03S0 +astrinjamos astringir VMM01P0 +astrinjan astringir VMM03P0 +astriña astreñir VMM03S0 +astriña astriñir VMM03S0 +astriñamos astreñir VMM01P0 +astriñamos astriñir VMM01P0 +astriñan astreñir VMM03P0 +astriñan astriñir VMM03P0 +astriñe astreñir VMM02S0 +astriñe astriñir VMM02S0 +astriñendo astreñir VMG0000 +astriñendo astriñir VMG0000 +astriñid astriñir VMM02P0 +astriñir astriñir VMN0000 +astrologa astrologar VMM02S0 +astrologad astrologar VMM02P0 +astrologando astrologar VMG0000 +astrologar astrologar VMN0000 +astrologue astrologar VMM03S0 +astrologuemos astrologar VMM01P0 +astrologuen astrologar VMM03P0 +asuela asolar VMM02S0 +asuele asolar VMM03S0 +asuelen asolar VMM03P0 +asuena asonar VMM02S0 +asuene asonar VMM03S0 +asuenen asonar VMM03P0 +asuma asumir VMM03S0 +asumamos asumir VMM01P0 +asuman asumir VMM03P0 +asume asumir VMM02S0 +asumid asumir VMM02P0 +asumiendo asumir VMG0000 +asumir asumir VMN0000 +asura asurar VMM02S0 +asurad asurar VMM02P0 +asurando asurar VMG0000 +asurar asurar VMN0000 +asurca asurcar VMM02S0 +asurcad asurcar VMM02P0 +asurcando asurcar VMG0000 +asurcar asurcar VMN0000 +asure asurar VMM03S0 +asuremos asurar VMM01P0 +asuren asurar VMM03P0 +asurque asurcar VMM03S0 +asurquemos asurcar VMM01P0 +asurquen asurcar VMM03P0 +asusta asustar VMM02S0 +asustad asustar VMM02P0 +asustando asustar VMG0000 +asustar asustar VMN0000 +asuste asustar VMM03S0 +asustemos asustar VMM01P0 +asusten asustar VMM03P0 +asutila asutilar VMM02S0 +asutilad asutilar VMM02P0 +asutilando asutilar VMG0000 +asutilar asutilar VMN0000 +asutile asutilar VMM03S0 +asutilemos asutilar VMM01P0 +asutilen asutilar VMM03P0 +ata atar VMM02S0 +atabalea atabalear VMM02S0 +atabalead atabalear VMM02P0 +atabaleando atabalear VMG0000 +atabalear atabalear VMN0000 +atabalee atabalear VMM03S0 +atabaleemos atabalear VMM01P0 +atabaleen atabalear VMM03P0 +atabilla atabillar VMM02S0 +atabillad atabillar VMM02P0 +atabillando atabillar VMG0000 +atabillar atabillar VMN0000 +atabille atabillar VMM03S0 +atabillemos atabillar VMM01P0 +atabillen atabillar VMM03P0 +atabla atablar VMM02S0 +atablad atablar VMM02P0 +atablando atablar VMG0000 +atablar atablar VMN0000 +atable atablar VMM03S0 +atablemos atablar VMM01P0 +atablen atablar VMM03P0 +ataca atacar VMM02S0 +atacad atacar VMM02P0 +atacando atacar VMG0000 +atacar atacar VMN0000 +atad atar VMM02P0 +atafaga atafagar VMM02S0 +atafagad atafagar VMM02P0 +atafagando atafagar VMG0000 +atafagar atafagar VMN0000 +atafague atafagar VMM03S0 +atafaguemos atafagar VMM01P0 +atafaguen atafagar VMM03P0 +atagalla atagallar VMM02S0 +atagallad atagallar VMM02P0 +atagallando atagallar VMG0000 +atagallar atagallar VMN0000 +atagalle atagallar VMM03S0 +atagallemos atagallar VMM01P0 +atagallen atagallar VMM03P0 +ataira atairar VMM02S0 +atairad atairar VMM02P0 +atairando atairar VMG0000 +atairar atairar VMN0000 +ataire atairar VMM03S0 +atairemos atairar VMM01P0 +atairen atairar VMM03P0 +ataja atajar VMM02S0 +atajad atajar VMM02P0 +atajando atajar VMG0000 +atajar atajar VMN0000 +ataje atajar VMM03S0 +atajemos atajar VMM01P0 +atajen atajar VMM03P0 +atalaja atalajar VMM02S0 +atalajad atalajar VMM02P0 +atalajando atalajar VMG0000 +atalajar atalajar VMN0000 +atalaje atalajar VMM03S0 +atalajemos atalajar VMM01P0 +atalajen atalajar VMM03P0 +atalanta atalantar VMM02S0 +atalantad atalantar VMM02P0 +atalantando atalantar VMG0000 +atalantar atalantar VMN0000 +atalante atalantar VMM03S0 +atalantemos atalantar VMM01P0 +atalanten atalantar VMM03P0 +atalaya atalayar VMM02S0 +atalayad atalayar VMM02P0 +atalayando atalayar VMG0000 +atalayar atalayar VMN0000 +atalaye atalayar VMM03S0 +atalayemos atalayar VMM01P0 +atalayen atalayar VMM03P0 +ataluce ataluzar VMM03S0 +atalucemos ataluzar VMM01P0 +atalucen ataluzar VMM03P0 +ataluda ataludar VMM02S0 +ataludad ataludar VMM02P0 +ataludando ataludar VMG0000 +ataludar ataludar VMN0000 +atalude ataludar VMM03S0 +ataludemos ataludar VMM01P0 +ataluden ataludar VMM03P0 +ataluza ataluzar VMM02S0 +ataluzad ataluzar VMM02P0 +ataluzando ataluzar VMG0000 +ataluzar ataluzar VMN0000 +atando atar VMG0000 +atapa atapar VMM02S0 +atapad atapar VMM02P0 +atapando atapar VMG0000 +atapar atapar VMN0000 +atape atapar VMM03S0 +atapemos atapar VMM01P0 +atapen atapar VMM03P0 +ataque atacar VMM03S0 +ataquemos atacar VMM01P0 +ataquen atacar VMM03P0 +atar atar VMN0000 +atarace atarazar VMM03S0 +ataracea ataracear VMM02S0 +ataracead ataracear VMM02P0 +ataraceando ataracear VMG0000 +ataracear ataracear VMN0000 +ataracee ataracear VMM03S0 +ataraceemos ataracear VMM01P0 +ataraceen ataracear VMM03P0 +ataracemos atarazar VMM01P0 +ataracen atarazar VMM03P0 +ataranta atarantar VMM02S0 +atarantad atarantar VMM02P0 +atarantando atarantar VMG0000 +atarantar atarantar VMN0000 +atarante atarantar VMM03S0 +atarantemos atarantar VMM01P0 +ataranten atarantar VMM03P0 +ataraza atarazar VMM02S0 +atarazad atarazar VMM02P0 +atarazando atarazar VMG0000 +atarazar atarazar VMN0000 +atardece atardecer VMM02S0 +atardeced atardecer VMM02P0 +atardecer atardecer VMN0000 +atardeciendo atardecer VMG0000 +atardezca atardecer VMM03S0 +atardezcamos atardecer VMM01P0 +atardezcan atardecer VMM03P0 +atarea atarear VMM02S0 +ataread atarear VMM02P0 +atareando atarear VMG0000 +atarear atarear VMN0000 +ataree atarear VMM03S0 +atareemos atarear VMM01P0 +atareen atarear VMM03P0 +atarquina atarquinar VMM02S0 +atarquinad atarquinar VMM02P0 +atarquinando atarquinar VMG0000 +atarquinar atarquinar VMN0000 +atarquine atarquinar VMM03S0 +atarquinemos atarquinar VMM01P0 +atarquinen atarquinar VMM03P0 +atarraga atarragar VMM02S0 +atarragad atarragar VMM02P0 +atarragando atarragar VMG0000 +atarragar atarragar VMN0000 +atarrague atarragar VMM03S0 +atarraguemos atarragar VMM01P0 +atarraguen atarragar VMM03P0 +atarraja atarrajar VMM02S0 +atarrajad atarrajar VMM02P0 +atarrajando atarrajar VMG0000 +atarrajar atarrajar VMN0000 +atarraje atarrajar VMM03S0 +atarrajemos atarrajar VMM01P0 +atarrajen atarrajar VMM03P0 +ataruga atarugar VMM02S0 +atarugad atarugar VMM02P0 +atarugando atarugar VMG0000 +atarugar atarugar VMN0000 +atarugue atarugar VMM03S0 +ataruguemos atarugar VMM01P0 +ataruguen atarugar VMM03P0 +atasaja atasajar VMM02S0 +atasajad atasajar VMM02P0 +atasajando atasajar VMG0000 +atasajar atasajar VMN0000 +atasaje atasajar VMM03S0 +atasajemos atasajar VMM01P0 +atasajen atasajar VMM03P0 +atasca atascar VMM02S0 +atascad atascar VMM02P0 +atascando atascar VMG0000 +atascar atascar VMN0000 +atasque atascar VMM03S0 +atasquemos atascar VMM01P0 +atasquen atascar VMM03P0 +ataviad ataviar VMM02P0 +ataviando ataviar VMG0000 +ataviar ataviar VMN0000 +ataviemos ataviar VMM01P0 +atavía ataviar VMM02S0 +atavíe ataviar VMM03S0 +atavíen ataviar VMM03P0 +ataña atañer VMM03S0 +atañamos atañer VMM01P0 +atañan atañer VMM03P0 +atañe atañer VMM02S0 +atañed atañer VMM02P0 +atañendo atañer VMG0000 +atañer atañer VMN0000 +ate atar VMM03S0 +atece atezar VMM03S0 +atecemos atezar VMM01P0 +atecen atezar VMM03P0 +atedia atediar VMM02S0 +atediad atediar VMM02P0 +atediando atediar VMG0000 +atediar atediar VMN0000 +atedie atediar VMM03S0 +atediemos atediar VMM01P0 +atedien atediar VMM03P0 +atemorice atemorizar VMM03S0 +atemoricemos atemorizar VMM01P0 +atemoricen atemorizar VMM03P0 +atemoriza atemorizar VMM02S0 +atemorizad atemorizar VMM02P0 +atemorizando atemorizar VMG0000 +atemorizar atemorizar VMN0000 +atemos atar VMM01P0 +atempera atemperar VMM02S0 +atemperad atemperar VMM02P0 +atemperando atemperar VMG0000 +atemperar atemperar VMN0000 +atempere atemperar VMM03S0 +atemperemos atemperar VMM01P0 +atemperen atemperar VMM03P0 +aten atar VMM03P0 +atenace atenazar VMM03S0 +atenacea atenacear VMM02S0 +atenacead atenacear VMM02P0 +atenaceando atenacear VMG0000 +atenacear atenacear VMN0000 +atenacee atenacear VMM03S0 +atenaceemos atenacear VMM01P0 +atenaceen atenacear VMM03P0 +atenacemos atenazar VMM01P0 +atenacen atenazar VMM03P0 +atenaza atenazar VMM02S0 +atenazad atenazar VMM02P0 +atenazando atenazar VMG0000 +atenazar atenazar VMN0000 +atendamos atender VMM01P0 +atended atender VMM02P0 +atender atender VMN0000 +atendiendo atender VMG0000 +atenebra atenebrar VMM02S0 +atenebrad atenebrar VMM02P0 +atenebrando atenebrar VMG0000 +atenebrar atenebrar VMN0000 +atenebre atenebrar VMM03S0 +atenebremos atenebrar VMM01P0 +atenebren atenebrar VMM03P0 +atened atener VMM02P0 +atener atener VMN0000 +atenga atener VMM03S0 +atengamos atener VMM01P0 +atengan atener VMM03P0 +ateniendo atener VMG0000 +atenta atentar VMM02S0 +atentad atentar VMM02P0 +atentando atentar VMG0000 +atentar atentar VMN0000 +atente atentar VMM03S0 +atentemos atentar VMM01P0 +atenten atentar VMM03P0 +atenuad atenuar VMM02P0 +atenuando atenuar VMG0000 +atenuar atenuar VMN0000 +atenuemos atenuar VMM01P0 +atenúa atenuar VMM02S0 +atenúe atenuar VMM03S0 +atenúen atenuar VMM03P0 +atera aterir VMM03S0 +ateramos aterir VMM01P0 +ateran aterir VMM03P0 +atere aterir VMM02S0 +aterid aterir VMM02P0 +ateriendo aterir VMG0000 +aterir aterir VMN0000 +aterra aterrar VMM02S0 +aterrad aterrar VMM02P0 +aterraja aterrajar VMM02S0 +aterrajad aterrajar VMM02P0 +aterrajando aterrajar VMG0000 +aterrajar aterrajar VMN0000 +aterraje aterrajar VMM03S0 +aterrajemos aterrajar VMM01P0 +aterrajen aterrajar VMM03P0 +aterrando aterrar VMG0000 +aterrar aterrar VMN0000 +aterre aterrar VMM03S0 +aterremos aterrar VMM01P0 +aterren aterrar VMM03P0 +aterrice aterrizar VMM03S0 +aterricemos aterrizar VMM01P0 +aterricen aterrizar VMM03P0 +aterriza aterrizar VMM02S0 +aterrizad aterrizar VMM02P0 +aterrizando aterrizar VMG0000 +aterrizar aterrizar VMN0000 +aterrona aterronar VMM02S0 +aterronad aterronar VMM02P0 +aterronando aterronar VMG0000 +aterronar aterronar VMN0000 +aterrone aterronar VMM03S0 +aterronemos aterronar VMM01P0 +aterronen aterronar VMM03P0 +aterrorice aterrorizar VMM03S0 +aterroricemos aterrorizar VMM01P0 +aterroricen aterrorizar VMM03P0 +aterroriza aterrorizar VMM02S0 +aterrorizad aterrorizar VMM02P0 +aterrorizando aterrorizar VMG0000 +aterrorizar aterrorizar VMN0000 +atesad atesar VMM02P0 +atesando atesar VMG0000 +atesar atesar VMN0000 +atesemos atesar VMM01P0 +atesora atesorar VMM02S0 +atesorad atesorar VMM02P0 +atesorando atesorar VMG0000 +atesorar atesorar VMN0000 +atesore atesorar VMM03S0 +atesoremos atesorar VMM01P0 +atesoren atesorar VMM03P0 +atesta atestar VMM02S0 +atestad atestar VMM02P0 +atestando atestar VMG0000 +atestar atestar VMN0000 +ateste atestar VMM03S0 +atestemos atestar VMM01P0 +atesten atestar VMM03P0 +atestigua atestiguar VMM02S0 +atestiguad atestiguar VMM02P0 +atestiguando atestiguar VMG0000 +atestiguar atestiguar VMN0000 +atestigüe atestiguar VMM03S0 +atestigüemos atestiguar VMM01P0 +atestigüen atestiguar VMM03P0 +ateza atezar VMM02S0 +atezad atezar VMM02P0 +atezando atezar VMG0000 +atezar atezar VMN0000 +atiba atibar VMM02S0 +atibad atibar VMM02P0 +atibando atibar VMG0000 +atibar atibar VMN0000 +atibe atibar VMM03S0 +atibemos atibar VMM01P0 +atiben atibar VMM03P0 +atiborra atiborrar VMM02S0 +atiborrad atiborrar VMM02P0 +atiborrando atiborrar VMG0000 +atiborrar atiborrar VMN0000 +atiborre atiborrar VMM03S0 +atiborremos atiborrar VMM01P0 +atiborren atiborrar VMM03P0 +atice atizar VMM03S0 +aticemos atizar VMM01P0 +aticen atizar VMM03P0 +atienda atender VMM03S0 +atiendan atender VMM03P0 +atiende atender VMM02S0 +atierra aterrar VMM02S0 +atierre aterrar VMM03S0 +atierren aterrar VMM03P0 +atiesa atesar VMM02S0 +atiesa atiesar VMM02S0 +atiesad atiesar VMM02P0 +atiesando atiesar VMG0000 +atiesar atiesar VMN0000 +atiese atesar VMM03S0 +atiese atiesar VMM03S0 +atiesemos atiesar VMM01P0 +atiesen atesar VMM03P0 +atiesen atiesar VMM03P0 +atiesta atestar VMM02S0 +atieste atestar VMM03S0 +atiesten atestar VMM03P0 +atilda atildar VMM02S0 +atildad atildar VMM02P0 +atildando atildar VMG0000 +atildar atildar VMN0000 +atilde atildar VMM03S0 +atildemos atildar VMM01P0 +atilden atildar VMM03P0 +atina atinar VMM02S0 +atinad atinar VMM02P0 +atinando atinar VMG0000 +atinar atinar VMN0000 +atincona atinconar VMM02S0 +atinconad atinconar VMM02P0 +atinconando atinconar VMG0000 +atinconar atinconar VMN0000 +atincone atinconar VMM03S0 +atinconemos atinconar VMM01P0 +atinconen atinconar VMM03P0 +atine atinar VMM03S0 +atinemos atinar VMM01P0 +atinen atinar VMM03P0 +atipla atiplar VMM02S0 +atiplad atiplar VMM02P0 +atiplando atiplar VMG0000 +atiplar atiplar VMN0000 +atiple atiplar VMM03S0 +atiplemos atiplar VMM01P0 +atiplen atiplar VMM03P0 +atiranta atirantar VMM02S0 +atirantad atirantar VMM02P0 +atirantando atirantar VMG0000 +atirantar atirantar VMN0000 +atirante atirantar VMM03S0 +atirantemos atirantar VMM01P0 +atiranten atirantar VMM03P0 +atisba atisbar VMM02S0 +atisbad atisbar VMM02P0 +atisbando atisbar VMG0000 +atisbar atisbar VMN0000 +atisbe atisbar VMM03S0 +atisbemos atisbar VMM01P0 +atisben atisbar VMM03P0 +atiza atizar VMM02S0 +atizad atizar VMM02P0 +atizando atizar VMG0000 +atizar atizar VMN0000 +atizona atizonar VMM02S0 +atizonad atizonar VMM02P0 +atizonando atizonar VMG0000 +atizonar atizonar VMN0000 +atizone atizonar VMM03S0 +atizonemos atizonar VMM01P0 +atizonen atizonar VMM03P0 +atoa atoar VMM02S0 +atoad atoar VMM02P0 +atoando atoar VMG0000 +atoar atoar VMN0000 +atocha atochar VMM02S0 +atochad atochar VMM02P0 +atochando atochar VMG0000 +atochar atochar VMN0000 +atoche atochar VMM03S0 +atochemos atochar VMM01P0 +atochen atochar VMM03P0 +atocina atocinar VMM02S0 +atocinad atocinar VMM02P0 +atocinando atocinar VMG0000 +atocinar atocinar VMN0000 +atocine atocinar VMM03S0 +atocinemos atocinar VMM01P0 +atocinen atocinar VMM03P0 +atoe atoar VMM03S0 +atoemos atoar VMM01P0 +atoen atoar VMM03P0 +atolla atollar VMM02S0 +atollad atollar VMM02P0 +atollando atollar VMG0000 +atollar atollar VMN0000 +atolle atollar VMM03S0 +atollemos atollar VMM01P0 +atollen atollar VMM03P0 +atolondra atolondrar VMM02S0 +atolondrad atolondrar VMM02P0 +atolondrando atolondrar VMG0000 +atolondrar atolondrar VMN0000 +atolondre atolondrar VMM03S0 +atolondremos atolondrar VMM01P0 +atolondren atolondrar VMM03P0 +atomice atomizar VMM03S0 +atomicemos atomizar VMM01P0 +atomicen atomizar VMM03P0 +atomiza atomizar VMM02S0 +atomizad atomizar VMM02P0 +atomizando atomizar VMG0000 +atomizar atomizar VMN0000 +atonda atondar VMM02S0 +atondad atondar VMM02P0 +atondando atondar VMG0000 +atondar atondar VMN0000 +atonde atondar VMM03S0 +atondemos atondar VMM01P0 +atonden atondar VMM03P0 +atonta atontar VMM02S0 +atontad atontar VMM02P0 +atontando atontar VMG0000 +atontar atontar VMN0000 +atonte atontar VMM03S0 +atontemos atontar VMM01P0 +atonten atontar VMM03P0 +atora atorar VMM02S0 +atorad atorar VMM02P0 +atorando atorar VMG0000 +atorar atorar VMN0000 +atore atorar VMM03S0 +atoremos atorar VMM01P0 +atoren atorar VMM03P0 +atormenta atormentar VMM02S0 +atormentad atormentar VMM02P0 +atormentando atormentar VMG0000 +atormentar atormentar VMN0000 +atormente atormentar VMM03S0 +atormentemos atormentar VMM01P0 +atormenten atormentar VMM03P0 +atornilla atornillar VMM02S0 +atornillad atornillar VMM02P0 +atornillando atornillar VMG0000 +atornillar atornillar VMN0000 +atornille atornillar VMM03S0 +atornillemos atornillar VMM01P0 +atornillen atornillar VMM03P0 +atortola atortolar VMM02S0 +atortolad atortolar VMM02P0 +atortolando atortolar VMG0000 +atortolar atortolar VMN0000 +atortole atortolar VMM03S0 +atortolemos atortolar VMM01P0 +atortolen atortolar VMM03P0 +atortora atortorar VMM02S0 +atortorad atortorar VMM02P0 +atortorando atortorar VMG0000 +atortorar atortorar VMN0000 +atortore atortorar VMM03S0 +atortoremos atortorar VMM01P0 +atortoren atortorar VMM03P0 +atosiga atosigar VMM02S0 +atosigad atosigar VMM02P0 +atosigando atosigar VMG0000 +atosigar atosigar VMN0000 +atosigue atosigar VMM03S0 +atosiguemos atosigar VMM01P0 +atosiguen atosigar VMM03P0 +atrabanca atrabancar VMM02S0 +atrabancad atrabancar VMM02P0 +atrabancando atrabancar VMG0000 +atrabancar atrabancar VMN0000 +atrabanque atrabancar VMM03S0 +atrabanquemos atrabancar VMM01P0 +atrabanquen atrabancar VMM03P0 +atraca atracar VMM02S0 +atracad atracar VMM02P0 +atracando atracar VMG0000 +atracar atracar VMN0000 +atrae atraer VMM02S0 +atraed atraer VMM02P0 +atraer atraer VMN0000 +atrafaga atrafagar VMM02S0 +atrafagad atrafagar VMM02P0 +atrafagando atrafagar VMG0000 +atrafagar atrafagar VMN0000 +atrafague atrafagar VMM03S0 +atrafaguemos atrafagar VMM01P0 +atrafaguen atrafagar VMM03P0 +atraganta atragantar VMM02S0 +atragantad atragantar VMM02P0 +atragantando atragantar VMG0000 +atragantar atragantar VMN0000 +atragante atragantar VMM03S0 +atragantemos atragantar VMM01P0 +atraganten atragantar VMM03P0 +atraiga atraer VMM03S0 +atraigamos atraer VMM01P0 +atraigan atraer VMM03P0 +atraillad atraillar VMM02P0 +atraillando atraillar VMG0000 +atraillar atraillar VMN0000 +atraillemos atraillar VMM01P0 +atrampa atrampar VMM02S0 +atrampad atrampar VMM02P0 +atrampando atrampar VMG0000 +atrampar atrampar VMN0000 +atrampe atrampar VMM03S0 +atrampemos atrampar VMM01P0 +atrampen atrampar VMM03P0 +atranca atrancar VMM02S0 +atrancad atrancar VMM02P0 +atrancando atrancar VMG0000 +atrancar atrancar VMN0000 +atranque atrancar VMM03S0 +atranquemos atrancar VMM01P0 +atranquen atrancar VMM03P0 +atrapa atrapar VMM02S0 +atrapad atrapar VMM02P0 +atrapando atrapar VMG0000 +atrapar atrapar VMN0000 +atrape atrapar VMM03S0 +atrapemos atrapar VMM01P0 +atrapen atrapar VMM03P0 +atraque atracar VMM03S0 +atraquemos atracar VMM01P0 +atraquen atracar VMM03P0 +atrasa atrasar VMM02S0 +atrasad atrasar VMM02P0 +atrasando atrasar VMG0000 +atrasar atrasar VMN0000 +atrase atrasar VMM03S0 +atrasemos atrasar VMM01P0 +atrasen atrasar VMM03P0 +atravesad atravesar VMM02P0 +atravesando atravesar VMG0000 +atravesar atravesar VMN0000 +atravesemos atravesar VMM01P0 +atraviesa atravesar VMM02S0 +atraviese atravesar VMM03S0 +atraviesen atravesar VMM03P0 +atrayendo atraer VMG0000 +atraílla atraillar VMM02S0 +atraílle atraillar VMM03S0 +atraíllen atraillar VMM03P0 +atresnala atresnalar VMM02S0 +atresnalad atresnalar VMM02P0 +atresnalando atresnalar VMG0000 +atresnalar atresnalar VMN0000 +atresnale atresnalar VMM03S0 +atresnalemos atresnalar VMM01P0 +atresnalen atresnalar VMM03P0 +atreva atrever VMM03S0 +atrevamos atrever VMM01P0 +atrevan atrever VMM03P0 +atreve atrever VMM02S0 +atreved atrever VMM02P0 +atrever atrever VMN0000 +atreviendo atrever VMG0000 +atribuid atribuir VMM02P0 +atribuir atribuir VMN0000 +atribula atribular VMM02S0 +atribulad atribular VMM02P0 +atribulando atribular VMG0000 +atribular atribular VMN0000 +atribule atribular VMM03S0 +atribulemos atribular VMM01P0 +atribulen atribular VMM03P0 +atribuya atribuir VMM03S0 +atribuyamos atribuir VMM01P0 +atribuyan atribuir VMM03P0 +atribuye atribuir VMM02S0 +atribuyendo atribuir VMG0000 +atrinca atrincar VMM02S0 +atrincad atrincar VMM02P0 +atrincando atrincar VMG0000 +atrincar atrincar VMN0000 +atrinchera atrincherar VMM02S0 +atrincherad atrincherar VMM02P0 +atrincherando atrincherar VMG0000 +atrincherar atrincherar VMN0000 +atrinchere atrincherar VMM03S0 +atrincheremos atrincherar VMM01P0 +atrincheren atrincherar VMM03P0 +atrinque atrincar VMM03S0 +atrinquemos atrincar VMM01P0 +atrinquen atrincar VMM03P0 +atrocha atrochar VMM02S0 +atrochad atrochar VMM02P0 +atrochando atrochar VMG0000 +atrochar atrochar VMN0000 +atroche atrochar VMM03S0 +atrochemos atrochar VMM01P0 +atrochen atrochar VMM03P0 +atrofia atrofiar VMM02S0 +atrofiad atrofiar VMM02P0 +atrofiando atrofiar VMG0000 +atrofiar atrofiar VMN0000 +atrofie atrofiar VMM03S0 +atrofiemos atrofiar VMM01P0 +atrofien atrofiar VMM03P0 +atroja atrojar VMM02S0 +atrojad atrojar VMM02P0 +atrojando atrojar VMG0000 +atrojar atrojar VMN0000 +atroje atrojar VMM03S0 +atrojemos atrojar VMM01P0 +atrojen atrojar VMM03P0 +atronad atronar VMM02P0 +atronando atronar VMG0000 +atronar atronar VMN0000 +atronemos atronar VMM01P0 +atronera atronerar VMM02S0 +atronerad atronerar VMM02P0 +atronerando atronerar VMG0000 +atronerar atronerar VMN0000 +atronere atronerar VMM03S0 +atroneremos atronerar VMM01P0 +atroneren atronerar VMM03P0 +atropa atropar VMM02S0 +atropad atropar VMM02P0 +atropando atropar VMG0000 +atropar atropar VMN0000 +atrope atropar VMM03S0 +atropella atropellar VMM02S0 +atropellad atropellar VMM02P0 +atropellando atropellar VMG0000 +atropellar atropellar VMN0000 +atropelle atropellar VMM03S0 +atropellemos atropellar VMM01P0 +atropellen atropellar VMM03P0 +atropemos atropar VMM01P0 +atropen atropar VMM03P0 +atruena atronar VMM02S0 +atruene atronar VMM03S0 +atruenen atronar VMM03P0 +atuera atorar VMM02S0 +atuere atorar VMM03S0 +atueren atorar VMM03P0 +atufa atufar VMM02S0 +atufad atufar VMM02P0 +atufando atufar VMG0000 +atufar atufar VMN0000 +atufe atufar VMM03S0 +atufemos atufar VMM01P0 +atufen atufar VMM03P0 +atura aturar VMM02S0 +aturad aturar VMM02P0 +aturando aturar VMG0000 +aturar aturar VMN0000 +aturbona aturbonar VMM02S0 +aturbonad aturbonar VMM02P0 +aturbonando aturbonar VMG0000 +aturda aturdir VMM03S0 +aturdamos aturdir VMM01P0 +aturdan aturdir VMM03P0 +aturde aturdir VMM02S0 +aturdid aturdir VMM02P0 +aturdiendo aturdir VMG0000 +aturdir aturdir VMN0000 +ature aturar VMM03S0 +aturemos aturar VMM01P0 +aturen aturar VMM03P0 +aturrulla aturrullar VMM02S0 +aturrullad aturrullar VMM02P0 +aturrullando aturrullar VMG0000 +aturrullar aturrullar VMN0000 +aturrulle aturrullar VMM03S0 +aturrullemos aturrullar VMM01P0 +aturrullen aturrullar VMM03P0 +aturulla aturullar VMM02S0 +aturullad aturullar VMM02P0 +aturullando aturullar VMG0000 +aturullar aturullar VMN0000 +aturulle aturullar VMM03S0 +aturullemos aturullar VMM01P0 +aturullen aturullar VMM03P0 +atusa atusar VMM02S0 +atusad atusar VMM02P0 +atusando atusar VMG0000 +atusar atusar VMN0000 +atuse atusar VMM03S0 +atusemos atusar VMM01P0 +atusen atusar VMM03P0 +atén atener VMM02S0 +audita auditar VMM02S0 +auditad auditar VMM02P0 +auditando auditar VMG0000 +auditar auditar VMN0000 +audite auditar VMM03S0 +auditemos auditar VMM01P0 +auditen auditar VMM03P0 +augura augurar VMM02S0 +augurad augurar VMM02P0 +augurando augurar VMG0000 +augurar augurar VMN0000 +augure augurar VMM03S0 +auguremos augurar VMM01P0 +auguren augurar VMM03P0 +aullad aullar VMM02P0 +aullando aullar VMG0000 +aullar aullar VMN0000 +aullemos aullar VMM01P0 +aumenta aumentar VMM02S0 +aumentad aumentar VMM02P0 +aumentando aumentar VMG0000 +aumentar aumentar VMN0000 +aumente aumentar VMM03S0 +aumentemos aumentar VMM01P0 +aumenten aumentar VMM03P0 +aunad aunar VMM02P0 +aunando aunar VMG0000 +aunar aunar VMN0000 +aunemos aunar VMM01P0 +aupad aupar VMM02P0 +aupando aupar VMG0000 +aupar aupar VMN0000 +aupemos aupar VMM01P0 +aureola aureolar VMM02S0 +aureolad aureolar VMM02P0 +aureolando aureolar VMG0000 +aureolar aureolar VMN0000 +aureole aureolar VMM03S0 +aureolemos aureolar VMM01P0 +aureolen aureolar VMM03P0 +ausculta auscultar VMM02S0 +auscultad auscultar VMM02P0 +auscultando auscultar VMG0000 +auscultar auscultar VMN0000 +ausculte auscultar VMM03S0 +auscultemos auscultar VMM01P0 +ausculten auscultar VMM03P0 +ausenta ausentar VMM02S0 +ausentad ausentar VMM02P0 +ausentando ausentar VMG0000 +ausentar ausentar VMN0000 +ausente ausentar VMM03S0 +ausentemos ausentar VMM01P0 +ausenten ausentar VMM03P0 +auspicia auspiciar VMM02S0 +auspiciad auspiciar VMM02P0 +auspiciando auspiciar VMG0000 +auspiciar auspiciar VMN0000 +auspicie auspiciar VMM03S0 +auspiciemos auspiciar VMM01P0 +auspicien auspiciar VMM03P0 +autentica autenticar VMM02S0 +autenticad autenticar VMM02P0 +autenticando autenticar VMG0000 +autenticar autenticar VMN0000 +autentifica autentificar VMM02S0 +autentificad autentificar VMM02P0 +autentificando autentificar VMG0000 +autentificar autentificar VMN0000 +autentifique autentificar VMM03S0 +autentifiquemos autentificar VMM01P0 +autentifiquen autentificar VMM03P0 +autentique autenticar VMM03S0 +autentiquemos autenticar VMM01P0 +autentiquen autenticar VMM03P0 +autoafirma autoafirmar VMM02S0 +autoafirmad autoafirmar VMM02P0 +autoafirmando autoafirmar VMG0000 +autoafirmar autoafirmar VMN0000 +autoafirme autoafirmar VMM03S0 +autoafirmemos autoafirmar VMM01P0 +autoafirmen autoafirmar VMM03P0 +autocontened autocontener VMM02P0 +autocontener autocontener VMN0000 +autoconteniendo autocontener VMG0000 +autocontén autocontener VMM02S0 +autodefina autodefinir VMM03S0 +autodefinamos autodefinir VMM01P0 +autodefinan autodefinir VMM03P0 +autodefine autodefinir VMM02S0 +autodefinid autodefinir VMM02P0 +autodefiniendo autodefinir VMG0000 +autodefinir autodefinir VMN0000 +autogenera autogenerar VMM02S0 +autogenerad autogenerar VMM02P0 +autogenerando autogenerar VMG0000 +autogenerar autogenerar VMN0000 +autogeneremos autogenerar VMM01P0 +autogenere autogenerar VMM03S0 +autogeneren autogenerar VMM03P0 +autografiad autografiar VMM02P0 +autografiando autografiar VMG0000 +autografiar autografiar VMN0000 +autografiemos autografiar VMM01P0 +autografía autografiar VMM02S0 +autografíe autografiar VMM03S0 +autografíen autografiar VMM03P0 +automatice automatizar VMM03S0 +automaticemos automatizar VMM01P0 +automaticen automatizar VMM03P0 +automatiza automatizar VMM02S0 +automatizad automatizar VMM02P0 +automatizando automatizar VMG0000 +automatizar automatizar VMN0000 +autonomice autonomizar VMM03S0 +autonomicemos autonomizar VMM01P0 +autonomicen autonomizar VMM03P0 +autonomiza autonomizar VMM02S0 +autonomizad autonomizar VMM02P0 +autonomizando autonomizar VMG0000 +autonomizar autonomizar VMN0000 +autorice autorizar VMM03S0 +autoricemos autorizar VMM01P0 +autoricen autorizar VMM03P0 +autoriza autorizar VMM02S0 +autorizad autorizar VMM02P0 +autorizando autorizar VMG0000 +autorizar autorizar VMN0000 +autorregula autorregular VMM02S0 +autorregulad autorregular VMM02P0 +autorregulando autorregular VMG0000 +autorregular autorregular VMN0000 +autorregule autorregular VMM03S0 +autorregulemos autorregular VMM01P0 +autorregulen autorregular VMM03P0 +autosugestiona autosugestionar VMM02S0 +autosugestionad autosugestionar VMM02P0 +autosugestionando autosugestionar VMG0000 +autosugestionar autosugestionar VMN0000 +autosugestione autosugestionar VMM03S0 +autosugestionemos autosugestionar VMM01P0 +autosugestionen autosugestionar VMM03P0 +auxilia auxiliar VMM02S0 +auxiliad auxiliar VMM02P0 +auxiliando auxiliar VMG0000 +auxiliar auxiliar VMN0000 +auxilie auxiliar VMM03S0 +auxiliemos auxiliar VMM01P0 +auxilien auxiliar VMM03P0 +avada avadar VMM02S0 +avadad avadar VMM02P0 +avadando avadar VMG0000 +avadar avadar VMN0000 +avade avadar VMM03S0 +avademos avadar VMM01P0 +avaden avadar VMM03P0 +avaha avahar VMM02S0 +avahad avahar VMM02P0 +avahando avahar VMG0000 +avahar avahar VMN0000 +avahe avahar VMM03S0 +avahemos avahar VMM01P0 +avahen avahar VMM03P0 +avala avalar VMM02S0 +avalad avalar VMM02P0 +avalando avalar VMG0000 +avalar avalar VMN0000 +avale avalar VMM03S0 +avalemos avalar VMM01P0 +avalen avalar VMM03P0 +avalora avalorar VMM02S0 +avalorad avalorar VMM02P0 +avalorando avalorar VMG0000 +avalorar avalorar VMN0000 +avalore avalorar VMM03S0 +avaloremos avalorar VMM01P0 +avaloren avalorar VMM03P0 +avaluad avaluar VMM02P0 +avaluando avaluar VMG0000 +avaluar avaluar VMN0000 +avaluemos avaluar VMM01P0 +avalúa avaluar VMM02S0 +avalúe avaluar VMM03S0 +avalúen avaluar VMM03P0 +avance avanzar VMM03S0 +avancemos avanzar VMM01P0 +avancen avanzar VMM03P0 +avanece avanecer VMM02S0 +avaneced avanecer VMM02P0 +avanecer avanecer VMN0000 +avaneciendo avanecer VMG0000 +avanezca avanecer VMM03S0 +avanezcamos avanecer VMM01P0 +avanezcan avanecer VMM03P0 +avanza avanzar VMM02S0 +avanzad avanzar VMM02P0 +avanzando avanzar VMG0000 +avanzar avanzar VMN0000 +avasalla avasallar VMM02S0 +avasallad avasallar VMM02P0 +avasallando avasallar VMG0000 +avasallar avasallar VMN0000 +avasalle avasallar VMM03S0 +avasallemos avasallar VMM01P0 +avasallen avasallar VMM03P0 +avece avezar VMM03S0 +avecemos avezar VMM01P0 +avecen avezar VMM03P0 +avecina avecinar VMM02S0 +avecinad avecinar VMM02P0 +avecinando avecinar VMG0000 +avecinar avecinar VMN0000 +avecinda avecindar VMM02S0 +avecindad avecindar VMM02P0 +avecindando avecindar VMG0000 +avecindar avecindar VMN0000 +avecinde avecindar VMM03S0 +avecindemos avecindar VMM01P0 +avecinden avecindar VMM03P0 +avecine avecinar VMM03S0 +avecinemos avecinar VMM01P0 +avecinen avecinar VMM03P0 +avejenta avejentar VMM02S0 +avejentad avejentar VMM02P0 +avejentando avejentar VMG0000 +avejentar avejentar VMN0000 +avejente avejentar VMM03S0 +avejentemos avejentar VMM01P0 +avejenten avejentar VMM03P0 +avejiga avejigar VMM02S0 +avejigad avejigar VMM02P0 +avejigando avejigar VMG0000 +avejigar avejigar VMN0000 +avejigue avejigar VMM03S0 +avejiguemos avejigar VMM01P0 +avejiguen avejigar VMM03P0 +avellana avellanar VMM02S0 +avellanad avellanar VMM02P0 +avellanando avellanar VMG0000 +avellanar avellanar VMN0000 +avellane avellanar VMM03S0 +avellanemos avellanar VMM01P0 +avellanen avellanar VMM03P0 +aven avenir VMM02S0 +avena avenar VMM02S0 +avenad avenar VMM02P0 +avenando avenar VMG0000 +avenar avenar VMN0000 +avene avenar VMM03S0 +avenemos avenar VMM01P0 +avenen avenar VMM03P0 +avenga avenir VMM03S0 +avengamos avenir VMM01P0 +avengan avenir VMM03P0 +avenid avenir VMM02P0 +avenir avenir VMN0000 +aventad aventar VMM02P0 +aventaja aventajar VMM02S0 +aventajad aventajar VMM02P0 +aventajando aventajar VMG0000 +aventajar aventajar VMN0000 +aventaje aventajar VMM03S0 +aventajemos aventajar VMM01P0 +aventajen aventajar VMM03P0 +aventando aventar VMG0000 +aventar aventar VMN0000 +aventemos aventar VMM01P0 +aventura aventurar VMM02S0 +aventurad aventurar VMM02P0 +aventurando aventurar VMG0000 +aventurar aventurar VMN0000 +aventure aventurar VMM03S0 +aventuremos aventurar VMM01P0 +aventuren aventurar VMM03P0 +avergoncemos avergonzar VMM01P0 +avergonzad avergonzar VMM02P0 +avergonzando avergonzar VMG0000 +avergonzar avergonzar VMN0000 +avergüence avergonzar VMM03S0 +avergüencen avergonzar VMM03P0 +avergüenza avergonzar VMM02S0 +averiad averiar VMM02P0 +averiando averiar VMG0000 +averiar averiar VMN0000 +averiemos averiar VMM01P0 +averigua averiguar VMM02S0 +averiguad averiguar VMM02P0 +averiguando averiguar VMG0000 +averiguar averiguar VMN0000 +averigüe averiguar VMM03S0 +averigüemos averiguar VMM01P0 +averigüen averiguar VMM03P0 +avería averiar VMM02S0 +averíe averiar VMM03S0 +averíen averiar VMM03P0 +aveza avezar VMM02S0 +avezad avezar VMM02P0 +avezando avezar VMG0000 +avezar avezar VMN0000 +aviad aviar VMM02P0 +aviando aviar VMG0000 +aviar aviar VMN0000 +avicia aviciar VMM02S0 +aviciad aviciar VMM02P0 +aviciando aviciar VMG0000 +aviciar aviciar VMN0000 +avicie aviciar VMM03S0 +aviciemos aviciar VMM01P0 +avicien aviciar VMM03P0 +avieja aviejar VMM02S0 +aviejad aviejar VMM02P0 +aviejando aviejar VMG0000 +aviejar aviejar VMN0000 +avieje aviejar VMM03S0 +aviejemos aviejar VMM01P0 +aviejen aviejar VMM03P0 +aviemos aviar VMM01P0 +avienta aventar VMM02S0 +aviente aventar VMM03S0 +avienten aventar VMM03P0 +avigora avigorar VMM02S0 +avigorad avigorar VMM02P0 +avigorando avigorar VMG0000 +avigorar avigorar VMN0000 +avigore avigorar VMM03S0 +avigoremos avigorar VMM01P0 +avigoren avigorar VMM03P0 +avilanta avilantar VMM02S0 +avilantad avilantar VMM02P0 +avilantando avilantar VMG0000 +avilantar avilantar VMN0000 +avilante avilantar VMM03S0 +avilantemos avilantar VMM01P0 +avilanten avilantar VMM03P0 +avillana avillanar VMM02S0 +avillanad avillanar VMM02P0 +avillanando avillanar VMG0000 +avillanar avillanar VMN0000 +avillane avillanar VMM03S0 +avillanemos avillanar VMM01P0 +avillanen avillanar VMM03P0 +avinagra avinagrar VMM02S0 +avinagrad avinagrar VMM02P0 +avinagrando avinagrar VMG0000 +avinagrar avinagrar VMN0000 +avinagre avinagrar VMM03S0 +avinagremos avinagrar VMM01P0 +avinagren avinagrar VMM03P0 +aviniendo avenir VMG0000 +avisa avisar VMM02S0 +avisad avisar VMM02P0 +avisando avisar VMG0000 +avisar avisar VMN0000 +avise avisar VMM03S0 +avisemos avisar VMM01P0 +avisen avisar VMM03P0 +avispa avispar VMM02S0 +avispad avispar VMM02P0 +avispando avispar VMG0000 +avispar avispar VMN0000 +avispe avispar VMM03S0 +avispemos avispar VMM01P0 +avispen avispar VMM03P0 +avista avistar VMM02S0 +avistad avistar VMM02P0 +avistando avistar VMG0000 +avistar avistar VMN0000 +aviste avistar VMM03S0 +avistemos avistar VMM01P0 +avisten avistar VMM03P0 +avitualla avituallar VMM02S0 +avituallad avituallar VMM02P0 +avituallando avituallar VMG0000 +avituallar avituallar VMN0000 +avitualle avituallar VMM03S0 +avituallemos avituallar VMM01P0 +avituallen avituallar VMM03P0 +aviva avivar VMM02S0 +avivad avivar VMM02P0 +avivando avivar VMG0000 +avivar avivar VMN0000 +avive avivar VMM03S0 +avivemos avivar VMM01P0 +aviven avivar VMM03P0 +avizora avizorar VMM02S0 +avizorad avizorar VMM02P0 +avizorando avizorar VMG0000 +avizorar avizorar VMN0000 +avizore avizorar VMM03S0 +avizoremos avizorar VMM01P0 +avizoren avizorar VMM03P0 +avoca avocar VMM02S0 +avocad avocar VMM02P0 +avocando avocar VMG0000 +avocar avocar VMN0000 +avoque avocar VMM03S0 +avoquemos avocar VMM01P0 +avoquen avocar VMM03P0 +avía aviar VMM02S0 +avíe aviar VMM03S0 +avíen aviar VMM03P0 +ayea ayear VMM02S0 +ayead ayear VMM02P0 +ayeando ayear VMG0000 +ayear ayear VMN0000 +ayee ayear VMM03S0 +ayeemos ayear VMM01P0 +ayeen ayear VMM03P0 +ayuda ayudar VMM02S0 +ayudad ayudar VMM02P0 +ayudando ayudar VMG0000 +ayudar ayudar VMN0000 +ayude ayudar VMM03S0 +ayudemos ayudar VMM01P0 +ayuden ayudar VMM03P0 +ayuna ayunar VMM02S0 +ayunad ayunar VMM02P0 +ayunando ayunar VMG0000 +ayunar ayunar VMN0000 +ayune ayunar VMM03S0 +ayunemos ayunar VMM01P0 +ayunen ayunar VMM03P0 +ayusta ayustar VMM02S0 +ayustad ayustar VMM02P0 +ayustando ayustar VMG0000 +ayustar ayustar VMN0000 +ayuste ayustar VMM03S0 +ayustemos ayustar VMM01P0 +ayusten ayustar VMM03P0 +azacana azacanar VMM02S0 +azacanad azacanar VMM02P0 +azacanando azacanar VMG0000 +azacanar azacanar VMN0000 +azacane azacanar VMM03S0 +azacanemos azacanar VMM01P0 +azacanen azacanar VMM03P0 +azafrana azafranar VMM02S0 +azafranad azafranar VMM02P0 +azafranando azafranar VMG0000 +azafranar azafranar VMN0000 +azafrane azafranar VMM03S0 +azafranemos azafranar VMM01P0 +azafranen azafranar VMM03P0 +azara azarar VMM02S0 +azarad azarar VMM02P0 +azaranda azarandar VMM02S0 +azarandad azarandar VMM02P0 +azarandando azarandar VMG0000 +azarandar azarandar VMN0000 +azarande azarandar VMM03S0 +azarandemos azarandar VMM01P0 +azaranden azarandar VMM03P0 +azarando azarar VMG0000 +azarar azarar VMN0000 +azare azarar VMM03S0 +azarea azarear VMM02S0 +azaread azarear VMM02P0 +azareando azarear VMG0000 +azarear azarear VMN0000 +azaree azarear VMM03S0 +azareemos azarear VMM01P0 +azareen azarear VMM03P0 +azaremos azarar VMM01P0 +azaren azarar VMM03P0 +azoa azoar VMM02S0 +azoad azoar VMM02P0 +azoando azoar VMG0000 +azoar azoar VMN0000 +azoe azoar VMM03S0 +azoemos azoar VMM01P0 +azoen azoar VMM03P0 +azoga azogar VMM02S0 +azogad azogar VMM02P0 +azogando azogar VMG0000 +azogar azogar VMN0000 +azogue azogar VMM03S0 +azoguemos azogar VMM01P0 +azoguen azogar VMM03P0 +azolad azolar VMM02P0 +azolando azolar VMG0000 +azolar azolar VMN0000 +azolemos azolar VMM01P0 +azolva azolvar VMM02S0 +azolvad azolvar VMM02P0 +azolvando azolvar VMG0000 +azolvar azolvar VMN0000 +azolve azolvar VMM03S0 +azolvemos azolvar VMM01P0 +azolven azolvar VMM03P0 +azora azorar VMM02S0 +azorad azorar VMM02P0 +azorando azorar VMG0000 +azorar azorar VMN0000 +azore azorar VMM03S0 +azoremos azorar VMM01P0 +azoren azorar VMM03P0 +azorra azorrar VMM02S0 +azorrad azorrar VMM02P0 +azorrando azorrar VMG0000 +azorrar azorrar VMN0000 +azorre azorrar VMM03S0 +azorremos azorrar VMM01P0 +azorren azorrar VMM03P0 +azota azotar VMM02S0 +azotad azotar VMM02P0 +azotando azotar VMG0000 +azotar azotar VMN0000 +azote azotar VMM03S0 +azotemos azotar VMM01P0 +azoten azotar VMM03P0 +azucara azucarar VMM02S0 +azucarad azucarar VMM02P0 +azucarando azucarar VMG0000 +azucarar azucarar VMN0000 +azucare azucarar VMM03S0 +azucaremos azucarar VMM01P0 +azucaren azucarar VMM03P0 +azuce azuzar VMM03S0 +azucemos azuzar VMM01P0 +azucen azuzar VMM03P0 +azuela azolar VMM02S0 +azuele azolar VMM03S0 +azuelen azolar VMM03P0 +azufra azufrar VMM02S0 +azufrad azufrar VMM02P0 +azufrando azufrar VMG0000 +azufrar azufrar VMN0000 +azufre azufrar VMM03S0 +azufremos azufrar VMM01P0 +azufren azufrar VMM03P0 +azula azular VMM02S0 +azulad azular VMM02P0 +azulando azular VMG0000 +azular azular VMN0000 +azule azular VMM03S0 +azulea azulear VMM02S0 +azulead azulear VMM02P0 +azuleando azulear VMG0000 +azulear azulear VMN0000 +azulee azulear VMM03S0 +azuleemos azulear VMM01P0 +azuleen azulear VMM03P0 +azulejea azulejear VMM02S0 +azulejead azulejear VMM02P0 +azulejeando azulejear VMG0000 +azulejear azulejear VMN0000 +azulemos azular VMM01P0 +azulen azular VMM03P0 +azuma azumar VMM02S0 +azumad azumar VMM02P0 +azumando azumar VMG0000 +azumar azumar VMN0000 +azume azumar VMM03S0 +azumemos azumar VMM01P0 +azumen azumar VMM03P0 +azurrona azurronar VMM02S0 +azurronad azurronar VMM02P0 +azurronando azurronar VMG0000 +azurronar azurronar VMN0000 +azurrone azurronar VMM03S0 +azurronemos azurronar VMM01P0 +azurronen azurronar VMM03P0 +azuza azuzar VMM02S0 +azuzad azuzar VMM02P0 +azuzando azuzar VMG0000 +azuzar azuzar VMN0000 +aíra airar VMM02S0 +aíre airar VMM03S0 +aíren airar VMM03P0 +aísla aislar VMM02S0 +aísle aislar VMM03S0 +aíslen aislar VMM03P0 +añada añadir VMM03S0 +añadamos añadir VMM01P0 +añadan añadir VMM03P0 +añade añadir VMM02S0 +añadid añadir VMM02P0 +añadiendo añadir VMG0000 +añadir añadir VMN0000 +añeja añejar VMM02S0 +añejad añejar VMM02P0 +añejando añejar VMG0000 +añejar añejar VMN0000 +añeje añejar VMM03S0 +añejemos añejar VMM01P0 +añejen añejar VMM03P0 +añora añorar VMM02S0 +añorad añorar VMM02P0 +añorando añorar VMG0000 +añorar añorar VMN0000 +añore añorar VMM03S0 +añoremos añorar VMM01P0 +añoren añorar VMM03P0 +aúlla aullar VMM02S0 +aúlle aullar VMM03S0 +aúllen aullar VMM03P0 +aúna aunar VMM02S0 +aúne aunar VMM03S0 +aúnen aunar VMM03P0 +aúpa aupar VMM02S0 +aúpe aupar VMM03S0 +aúpen aupar VMM03P0 +babea babear VMM02S0 +babead babear VMM02P0 +babeando babear VMG0000 +babear babear VMN0000 +babee babear VMM03S0 +babeemos babear VMM01P0 +babeen babear VMM03P0 +babosea babosear VMM02S0 +babosead babosear VMM02P0 +baboseando babosear VMG0000 +babosear babosear VMN0000 +babosee babosear VMM03S0 +baboseemos babosear VMM01P0 +baboseen babosear VMM03P0 +bachea bachear VMM02S0 +bachead bachear VMM02P0 +bacheando bachear VMG0000 +bachear bachear VMN0000 +bachee bachear VMM03S0 +bacheemos bachear VMM01P0 +bacheen bachear VMM03P0 +bachillerea bachillerear VMM02S0 +bachilleread bachillerear VMM02P0 +bachillereando bachillerear VMG0000 +bachillerear bachillerear VMN0000 +bachilleree bachillerear VMM03S0 +bachillereemos bachillerear VMM01P0 +bachillereen bachillerear VMM03P0 +badajea badajear VMM02S0 +badajead badajear VMM02P0 +badajeando badajear VMG0000 +badajear badajear VMN0000 +badajee badajear VMM03S0 +badajeemos badajear VMM01P0 +badajeen badajear VMM03P0 +baga bagar VMM02S0 +bagad bagar VMM02P0 +bagando bagar VMG0000 +bagar bagar VMN0000 +bague bagar VMM03S0 +baguemos bagar VMM01P0 +baguen bagar VMM03P0 +baila bailar VMM02S0 +bailad bailar VMM02P0 +bailando bailar VMG0000 +bailar bailar VMN0000 +baile bailar VMM03S0 +bailemos bailar VMM01P0 +bailen bailar VMM03P0 +bailotea bailotear VMM02S0 +bailotead bailotear VMM02P0 +bailoteando bailotear VMG0000 +bailotear bailotear VMN0000 +bailotee bailotear VMM03S0 +bailoteemos bailotear VMM01P0 +bailoteen bailotear VMM03P0 +baja bajar VMM02S0 +bajad bajar VMM02P0 +bajando bajar VMG0000 +bajar bajar VMN0000 +baje bajar VMM03S0 +bajemos bajar VMM01P0 +bajen bajar VMM03P0 +bala balar VMM02S0 +balad balar VMM02P0 +baladronea baladronear VMM02S0 +baladronead baladronear VMM02P0 +baladroneando baladronear VMG0000 +baladronear baladronear VMN0000 +baladronee baladronear VMM03S0 +baladroneemos baladronear VMM01P0 +baladroneen baladronear VMM03P0 +balancea balancear VMM02S0 +balancead balancear VMM02P0 +balanceando balancear VMG0000 +balancear balancear VMN0000 +balancee balancear VMM03S0 +balanceemos balancear VMM01P0 +balanceen balancear VMM03P0 +balando balar VMG0000 +balar balar VMN0000 +balbuca balbucir VMM03S0 +balbucamos balbucir VMM01P0 +balbucan balbucir VMM03P0 +balbuce balbucir VMM02S0 +balbucea balbucear VMM02S0 +balbucead balbucear VMM02P0 +balbuceando balbucear VMG0000 +balbucear balbucear VMN0000 +balbucee balbucear VMM03S0 +balbuceemos balbucear VMM01P0 +balbuceen balbucear VMM03P0 +balbucid balbucir VMM02P0 +balbuciendo balbucir VMG0000 +balbucir balbucir VMN0000 +balcanice balcanizar VMM03S0 +balcanicemos balcanizar VMM01P0 +balcanicen balcanizar VMM03P0 +balcaniza balcanizar VMM02S0 +balcanizad balcanizar VMM02P0 +balcanizando balcanizar VMG0000 +balcanizar balcanizar VMN0000 +balconea balconear VMM02S0 +balconead balconear VMM02P0 +balconeando balconear VMG0000 +balconear balconear VMN0000 +balconee balconear VMM03S0 +balconeemos balconear VMM01P0 +balconeen balconear VMM03P0 +balda baldar VMM02S0 +baldad baldar VMM02P0 +baldando baldar VMG0000 +baldar baldar VMN0000 +balde baldar VMM03S0 +baldea baldear VMM02S0 +baldead baldear VMM02P0 +baldeando baldear VMG0000 +baldear baldear VMN0000 +baldee baldear VMM03S0 +baldeemos baldear VMM01P0 +baldeen baldear VMM03P0 +baldemos baldar VMM01P0 +balden baldar VMM03P0 +baldona baldonar VMM02S0 +baldonad baldonar VMM02P0 +baldonando baldonar VMG0000 +baldonar baldonar VMN0000 +baldone baldonar VMM03S0 +baldonea baldonear VMM02S0 +baldonead baldonear VMM02P0 +baldoneando baldonear VMG0000 +baldonear baldonear VMN0000 +baldonee baldonear VMM03S0 +baldoneemos baldonear VMM01P0 +baldoneen baldonear VMM03P0 +baldonemos baldonar VMM01P0 +baldonen baldonar VMM03P0 +baldosa baldosar VMM02S0 +baldosad baldosar VMM02P0 +baldosando baldosar VMG0000 +baldosar baldosar VMN0000 +baldose baldosar VMM03S0 +baldosemos baldosar VMM01P0 +baldosen baldosar VMM03P0 +bale balar VMM03S0 +balea balear VMM02S0 +balead balear VMM02P0 +baleando balear VMG0000 +balear balear VMN0000 +balee balear VMM03S0 +baleemos balear VMM01P0 +baleen balear VMM03P0 +balemos balar VMM01P0 +balen balar VMM03P0 +balice balizar VMM03S0 +balicemos balizar VMM01P0 +balicen balizar VMM03P0 +balita balitar VMM02S0 +balitad balitar VMM02P0 +balitando balitar VMG0000 +balitar balitar VMN0000 +balite balitar VMM03S0 +balitea balitear VMM02S0 +balitead balitear VMM02P0 +baliteando balitear VMG0000 +balitear balitear VMN0000 +balitee balitear VMM03S0 +baliteemos balitear VMM01P0 +baliteen balitear VMM03P0 +balitemos balitar VMM01P0 +baliten balitar VMM03P0 +baliza balizar VMM02S0 +balizad balizar VMM02P0 +balizando balizar VMG0000 +balizar balizar VMN0000 +ballestea ballestear VMM02S0 +ballestead ballestear VMM02P0 +ballesteando ballestear VMG0000 +ballestear ballestear VMN0000 +ballestee ballestear VMM03S0 +ballesteemos ballestear VMM01P0 +ballesteen ballestear VMM03P0 +balota balotar VMM02S0 +balotad balotar VMM02P0 +balotando balotar VMG0000 +balotar balotar VMN0000 +balote balotar VMM03S0 +balotemos balotar VMM01P0 +baloten balotar VMM03P0 +bambalea bambalear VMM02S0 +bambalead bambalear VMM02P0 +bambaleando bambalear VMG0000 +bambalear bambalear VMN0000 +bambalee bambalear VMM03S0 +bambaleemos bambalear VMM01P0 +bambaleen bambalear VMM03P0 +bambolea bambolear VMM02S0 +bambolead bambolear VMM02P0 +bamboleando bambolear VMG0000 +bambolear bambolear VMN0000 +bambolee bambolear VMM03S0 +bamboleemos bambolear VMM01P0 +bamboleen bambolear VMM03P0 +bambonea bambonear VMM02S0 +bambonead bambonear VMM02P0 +bamboneando bambonear VMG0000 +bambonear bambonear VMN0000 +bambonee bambonear VMM03S0 +bamboneemos bambonear VMM01P0 +bamboneen bambonear VMM03P0 +bandea bandear VMM02S0 +bandead bandear VMM02P0 +bandeando bandear VMG0000 +bandear bandear VMN0000 +bandee bandear VMM03S0 +bandeemos bandear VMM01P0 +bandeen bandear VMM03P0 +banderice banderizar VMM03S0 +bandericemos banderizar VMM01P0 +bandericen banderizar VMM03P0 +banderillea banderillear VMM02S0 +banderillead banderillear VMM02P0 +banderilleando banderillear VMG0000 +banderillear banderillear VMN0000 +banderillee banderillear VMM03S0 +banderilleemos banderillear VMM01P0 +banderilleen banderillear VMM03P0 +banderiza banderizar VMM02S0 +banderizad banderizar VMM02P0 +banderizando banderizar VMG0000 +banderizar banderizar VMN0000 +banquea banquear VMM02S0 +banquead banquear VMM02P0 +banqueando banquear VMG0000 +banquear banquear VMN0000 +banquee banquear VMM03S0 +banqueemos banquear VMM01P0 +banqueen banquear VMM03P0 +banquetea banquetear VMM02S0 +banquetead banquetear VMM02P0 +banqueteando banquetear VMG0000 +banquetear banquetear VMN0000 +banquetee banquetear VMM03S0 +banqueteemos banquetear VMM01P0 +banqueteen banquetear VMM03P0 +baquea baquear VMM02S0 +baquead baquear VMM02P0 +baqueando baquear VMG0000 +baquear baquear VMN0000 +baquee baquear VMM03S0 +baqueemos baquear VMM01P0 +baqueen baquear VMM03P0 +baquetea baquetear VMM02S0 +baquetead baquetear VMM02P0 +baqueteando baquetear VMG0000 +baquetear baquetear VMN0000 +baquetee baquetear VMM03S0 +baqueteemos baquetear VMM01P0 +baqueteen baquetear VMM03P0 +baquiad baquiar VMM02P0 +baquiando baquiar VMG0000 +baquiar baquiar VMN0000 +baquiemos baquiar VMM01P0 +baquía baquiar VMM02S0 +baquíe baquiar VMM03S0 +baquíen baquiar VMM03P0 +baraja barajar VMM02S0 +barajad barajar VMM02P0 +barajando barajar VMG0000 +barajar barajar VMN0000 +baraje barajar VMM03S0 +barajemos barajar VMM01P0 +barajen barajar VMM03P0 +baratea baratear VMM02S0 +baratead baratear VMM02P0 +barateando baratear VMG0000 +baratear baratear VMN0000 +baratee baratear VMM03S0 +barateemos baratear VMM01P0 +barateen baratear VMM03P0 +barba barbar VMM02S0 +barbad barbar VMM02P0 +barbando barbar VMG0000 +barbar barbar VMN0000 +barbarea barbarear VMM02S0 +barbaread barbarear VMM02P0 +barbareando barbarear VMG0000 +barbarear barbarear VMN0000 +barbaree barbarear VMM03S0 +barbareemos barbarear VMM01P0 +barbareen barbarear VMM03P0 +barbarice barbarizar VMM03S0 +barbaricemos barbarizar VMM01P0 +barbaricen barbarizar VMM03P0 +barbariza barbarizar VMM02S0 +barbarizad barbarizar VMM02P0 +barbarizando barbarizar VMG0000 +barbarizar barbarizar VMN0000 +barbe barbar VMM03S0 +barbea barbear VMM02S0 +barbead barbear VMM02P0 +barbeando barbear VMG0000 +barbear barbear VMN0000 +barbecha barbechar VMM02S0 +barbechad barbechar VMM02P0 +barbechando barbechar VMG0000 +barbechar barbechar VMN0000 +barbeche barbechar VMM03S0 +barbechemos barbechar VMM01P0 +barbechen barbechar VMM03P0 +barbee barbear VMM03S0 +barbeemos barbear VMM01P0 +barbeen barbear VMM03P0 +barbemos barbar VMM01P0 +barben barbar VMM03P0 +barbota barbotar VMM02S0 +barbotad barbotar VMM02P0 +barbotando barbotar VMG0000 +barbotar barbotar VMN0000 +barbote barbotar VMM03S0 +barbotea barbotear VMM02S0 +barbotead barbotear VMM02P0 +barboteando barbotear VMG0000 +barbotear barbotear VMN0000 +barbotee barbotear VMM03S0 +barboteemos barbotear VMM01P0 +barboteen barbotear VMM03P0 +barbotemos barbotar VMM01P0 +barboten barbotar VMM03P0 +barbulla barbullar VMM02S0 +barbullad barbullar VMM02P0 +barbullando barbullar VMG0000 +barbullar barbullar VMN0000 +barbulle barbullar VMM03S0 +barbullemos barbullar VMM01P0 +barbullen barbullar VMM03P0 +barloa barloar VMM02S0 +barload barloar VMM02P0 +barloando barloar VMG0000 +barloar barloar VMN0000 +barloe barloar VMM03S0 +barloemos barloar VMM01P0 +barloen barloar VMM03P0 +barloventea barloventear VMM02S0 +barloventead barloventear VMM02P0 +barloventeando barloventear VMG0000 +barloventear barloventear VMN0000 +barloventee barloventear VMM03S0 +barloventeemos barloventear VMM01P0 +barloventeen barloventear VMM03P0 +barnice barnizar VMM03S0 +barnicemos barnizar VMM01P0 +barnicen barnizar VMM03P0 +barniza barnizar VMM02S0 +barnizad barnizar VMM02P0 +barnizando barnizar VMG0000 +barnizar barnizar VMN0000 +barquea barquear VMM02S0 +barquead barquear VMM02P0 +barqueando barquear VMG0000 +barquear barquear VMN0000 +barquee barquear VMM03S0 +barqueemos barquear VMM01P0 +barqueen barquear VMM03P0 +barra barrar VMM02S0 +barra barrer VMM03S0 +barrad barrar VMM02P0 +barramos barrer VMM01P0 +barran barrer VMM03P0 +barrando barrar VMG0000 +barrar barrar VMN0000 +barre barrar VMM03S0 +barre barrer VMM02S0 +barrea barrear VMM02S0 +barread barrear VMM02P0 +barreando barrear VMG0000 +barrear barrear VMN0000 +barred barrer VMM02P0 +barree barrear VMM03S0 +barreemos barrear VMM01P0 +barreen barrear VMM03P0 +barremos barrar VMM01P0 +barren barrar VMM03P0 +barrena barrenar VMM02S0 +barrenad barrenar VMM02P0 +barrenando barrenar VMG0000 +barrenar barrenar VMN0000 +barrene barrenar VMM03S0 +barrenemos barrenar VMM01P0 +barrenen barrenar VMM03P0 +barrer barrer VMN0000 +barretea barretear VMM02S0 +barretead barretear VMM02P0 +barreteando barretear VMG0000 +barretear barretear VMN0000 +barretee barretear VMM03S0 +barreteemos barretear VMM01P0 +barreteen barretear VMM03P0 +barriendo barrer VMG0000 +barrunta barruntar VMM02S0 +barruntad barruntar VMM02P0 +barruntando barruntar VMG0000 +barruntar barruntar VMN0000 +barrunte barruntar VMM03S0 +barruntemos barruntar VMM01P0 +barrunten barruntar VMM03P0 +bartolea bartolear VMM02S0 +bartolead bartolear VMM02P0 +bartoleando bartolear VMG0000 +bartolear bartolear VMN0000 +bartolee bartolear VMM03S0 +bartoleemos bartolear VMM01P0 +bartoleen bartolear VMM03P0 +bartulea bartulear VMM02S0 +bartulead bartulear VMM02P0 +bartuleando bartulear VMG0000 +bartulear bartulear VMN0000 +bartulee bartulear VMM03S0 +bartuleemos bartulear VMM01P0 +bartuleen bartulear VMM03P0 +barzonea barzonear VMM02S0 +barzonead barzonear VMM02P0 +barzoneando barzonear VMG0000 +barzonear barzonear VMN0000 +barzonee barzonear VMM03S0 +barzoneemos barzonear VMM01P0 +barzoneen barzonear VMM03P0 +basa basar VMM02S0 +basad basar VMM02P0 +basando basar VMG0000 +basar basar VMN0000 +bascula bascular VMM02S0 +basculad bascular VMM02P0 +basculando bascular VMG0000 +bascular bascular VMN0000 +bascule bascular VMM03S0 +basculemos bascular VMM01P0 +basculen bascular VMM03P0 +base basar VMM03S0 +basemos basar VMM01P0 +basen basar VMM03P0 +basquea basquear VMM02S0 +basquead basquear VMM02P0 +basqueando basquear VMG0000 +basquear basquear VMN0000 +basquee basquear VMM03S0 +basqueemos basquear VMM01P0 +basqueen basquear VMM03P0 +basta bastar VMM02S0 +bastad bastar VMM02P0 +bastando bastar VMG0000 +bastantea bastantear VMM02S0 +bastantead bastantear VMM02P0 +bastanteando bastantear VMG0000 +bastantear bastantear VMN0000 +bastantee bastantear VMM03S0 +bastanteemos bastantear VMM01P0 +bastanteen bastantear VMM03P0 +bastar bastar VMN0000 +bastardea bastardear VMM02S0 +bastardead bastardear VMM02P0 +bastardeando bastardear VMG0000 +bastardear bastardear VMN0000 +bastardee bastardear VMM03S0 +bastardeemos bastardear VMM01P0 +bastardeen bastardear VMM03P0 +baste bastar VMM03S0 +bastea bastear VMM02S0 +bastead bastear VMM02P0 +basteando bastear VMG0000 +bastear bastear VMN0000 +bastee bastear VMM03S0 +basteemos bastear VMM01P0 +basteen bastear VMM03P0 +bastemos bastar VMM01P0 +basten bastar VMM03P0 +bastimenta bastimentar VMM02S0 +bastimentad bastimentar VMM02P0 +bastimentando bastimentar VMG0000 +bastimentar bastimentar VMN0000 +bastimente bastimentar VMM03S0 +bastimentemos bastimentar VMM01P0 +bastimenten bastimentar VMM03P0 +bastonea bastonear VMM02S0 +bastonead bastonear VMM02P0 +bastoneando bastonear VMG0000 +bastonear bastonear VMN0000 +bastonee bastonear VMM03S0 +bastoneemos bastonear VMM01P0 +bastoneen bastonear VMM03P0 +basurea basurear VMM02S0 +basuread basurear VMM02P0 +basureando basurear VMG0000 +basurear basurear VMN0000 +basuree basurear VMM03S0 +basureemos basurear VMM01P0 +basureen basurear VMM03P0 +bata batir VMM03S0 +batalla batallar VMM02S0 +batallad batallar VMM02P0 +batallando batallar VMG0000 +batallar batallar VMN0000 +batalle batallar VMM03S0 +batallemos batallar VMM01P0 +batallen batallar VMM03P0 +batamos batir VMM01P0 +batan batir VMM03P0 +batana batanar VMM02S0 +batanad batanar VMM02P0 +batanando batanar VMG0000 +batanar batanar VMN0000 +batane batanar VMM03S0 +batanea batanear VMM02S0 +batanead batanear VMM02P0 +bataneando batanear VMG0000 +batanear batanear VMN0000 +batanee batanear VMM03S0 +bataneemos batanear VMM01P0 +bataneen batanear VMM03P0 +batanemos batanar VMM01P0 +batanen batanar VMM03P0 +bate batir VMM02S0 +batea batear VMM02S0 +batead batear VMM02P0 +bateando batear VMG0000 +batear batear VMN0000 +batee batear VMM03S0 +bateemos batear VMM01P0 +bateen batear VMM03P0 +batid batir VMM02P0 +batiendo batir VMG0000 +batiporta batiportar VMM02S0 +batiportad batiportar VMM02P0 +batiportando batiportar VMG0000 +batiportar batiportar VMN0000 +batiporte batiportar VMM03S0 +batiportemos batiportar VMM01P0 +batiporten batiportar VMM03P0 +batir batir VMN0000 +batoja batojar VMM02S0 +batojad batojar VMM02P0 +batojando batojar VMG0000 +batojar batojar VMN0000 +batoje batojar VMM03S0 +batojemos batojar VMM01P0 +batojen batojar VMM03P0 +batuquea batuquear VMM02S0 +batuquead batuquear VMM02P0 +batuqueando batuquear VMG0000 +batuquear batuquear VMN0000 +batuquee batuquear VMM03S0 +batuqueemos batuquear VMM01P0 +batuqueen batuquear VMM03P0 +bautice bautizar VMM03S0 +bauticemos bautizar VMM01P0 +bauticen bautizar VMM03P0 +bautiza bautizar VMM02S0 +bautizad bautizar VMM02P0 +bautizando bautizar VMG0000 +bautizar bautizar VMN0000 +bazuca bazucar VMM02S0 +bazucad bazucar VMM02P0 +bazucando bazucar VMG0000 +bazucar bazucar VMN0000 +bazuque bazucar VMM03S0 +bazuquea bazuquear VMM02S0 +bazuquead bazuquear VMM02P0 +bazuqueando bazuquear VMG0000 +bazuquear bazuquear VMN0000 +bazuquee bazuquear VMM03S0 +bazuqueemos bazuquear VMM01P0 +bazuqueen bazuquear VMM03P0 +bazuquemos bazucar VMM01P0 +bazuquen bazucar VMM03P0 +baña bañar VMM02S0 +bañad bañar VMM02P0 +bañando bañar VMG0000 +bañar bañar VMN0000 +bañe bañar VMM03S0 +bañemos bañar VMM01P0 +bañen bañar VMM03P0 +beatifica beatificar VMM02S0 +beatificad beatificar VMM02P0 +beatificando beatificar VMG0000 +beatificar beatificar VMN0000 +beatifique beatificar VMM03S0 +beatifiquemos beatificar VMM01P0 +beatifiquen beatificar VMM03P0 +beba beber VMM03S0 +bebamos beber VMM01P0 +beban beber VMM03P0 +bebe beber VMM02S0 +bebed beber VMM02P0 +beber beber VMN0000 +bebiendo beber VMG0000 +beborrotea beborrotear VMM02S0 +beborrotead beborrotear VMM02P0 +beborroteando beborrotear VMG0000 +beborrotear beborrotear VMN0000 +beborrotee beborrotear VMM03S0 +beborroteemos beborrotear VMM01P0 +beborroteen beborrotear VMM03P0 +beca becar VMM02S0 +becad becar VMM02P0 +becando becar VMG0000 +becar becar VMN0000 +befa befar VMM02S0 +befad befar VMM02P0 +befando befar VMG0000 +befar befar VMN0000 +befe befar VMM03S0 +befemos befar VMM01P0 +befen befar VMM03P0 +bejuquea bejuquear VMM02S0 +bejuquead bejuquear VMM02P0 +bejuqueando bejuquear VMG0000 +bejuquear bejuquear VMN0000 +bejuquee bejuquear VMM03S0 +bejuqueemos bejuquear VMM01P0 +bejuqueen bejuquear VMM03P0 +beldad beldar VMM02P0 +beldando beldar VMG0000 +beldar beldar VMN0000 +beldemos beldar VMM01P0 +bellaquea bellaquear VMM02S0 +bellaquead bellaquear VMM02P0 +bellaqueando bellaquear VMG0000 +bellaquear bellaquear VMN0000 +bellaquee bellaquear VMM03S0 +bellaqueemos bellaquear VMM01P0 +bellaqueen bellaquear VMM03P0 +bendecid bendecir VMM02P0 +bendecir bendecir VMN0000 +bendice bendecir VMM02S0 +bendiciendo bendecir VMG0000 +bendiga bendecir VMM03S0 +bendigamos bendecir VMM01P0 +bendigan bendecir VMM03P0 +beneficia beneficiar VMM02S0 +beneficiad beneficiar VMM02P0 +beneficiando beneficiar VMG0000 +beneficiar beneficiar VMN0000 +beneficie beneficiar VMM03S0 +beneficiemos beneficiar VMM01P0 +beneficien beneficiar VMM03P0 +beque becar VMM03S0 +bequemos becar VMM01P0 +bequen becar VMM03P0 +berrea berrear VMM02S0 +berread berrear VMM02P0 +berreando berrear VMG0000 +berrear berrear VMN0000 +berree berrear VMM03S0 +berreemos berrear VMM01P0 +berreen berrear VMM03P0 +besa besar VMM02S0 +besad besar VMM02P0 +besando besar VMG0000 +besar besar VMN0000 +bese besar VMM03S0 +besemos besar VMM01P0 +besen besar VMM03P0 +besuca besucar VMM02S0 +besucad besucar VMM02P0 +besucando besucar VMG0000 +besucar besucar VMN0000 +besuque besucar VMM03S0 +besuquea besuquear VMM02S0 +besuquead besuquear VMM02P0 +besuqueando besuquear VMG0000 +besuquear besuquear VMN0000 +besuquee besuquear VMM03S0 +besuqueemos besuquear VMM01P0 +besuqueen besuquear VMM03P0 +besuquemos besucar VMM01P0 +besuquen besucar VMM03P0 +bicha bichar VMM02S0 +bichad bichar VMM02P0 +bichando bichar VMG0000 +bichar bichar VMN0000 +biche bichar VMM03S0 +bichea bichear VMM02S0 +bichead bichear VMM02P0 +bicheando bichear VMG0000 +bichear bichear VMN0000 +bichee bichear VMM03S0 +bicheemos bichear VMM01P0 +bicheen bichear VMM03P0 +bichemos bichar VMM01P0 +bichen bichar VMM03P0 +bielda beldar VMM02S0 +bielda bieldar VMM02S0 +bieldad bieldar VMM02P0 +bieldando bieldar VMG0000 +bieldar bieldar VMN0000 +bielde beldar VMM03S0 +bielde bieldar VMM03S0 +bieldemos bieldar VMM01P0 +bielden beldar VMM03P0 +bielden bieldar VMM03P0 +bienqueramos bienquerer VMM01P0 +bienquered bienquerer VMM02P0 +bienquerer bienquerer VMN0000 +bienqueriendo bienquerer VMG0000 +bienquiera bienquerer VMM03S0 +bienquieran bienquerer VMM03P0 +bienquiere bienquerer VMM02S0 +bienquista bienquistar VMM02S0 +bienquistad bienquistar VMM02P0 +bienquistando bienquistar VMG0000 +bienquistar bienquistar VMN0000 +bienquiste bienquistar VMM03S0 +bienquistemos bienquistar VMM01P0 +bienquisten bienquistar VMM03P0 +bifurca bifurcar VMM02S0 +bifurcad bifurcar VMM02P0 +bifurcando bifurcar VMG0000 +bifurcar bifurcar VMN0000 +bifurque bifurcar VMM03S0 +bifurquemos bifurcar VMM01P0 +bifurquen bifurcar VMM03P0 +bigardea bigardear VMM02S0 +bigardead bigardear VMM02P0 +bigardeando bigardear VMG0000 +bigardear bigardear VMN0000 +bigardee bigardear VMM03S0 +bigardeemos bigardear VMM01P0 +bigardeen bigardear VMM03P0 +bina binar VMM02S0 +binad binar VMM02P0 +binando binar VMG0000 +binar binar VMN0000 +bine binar VMM03S0 +binemos binar VMM01P0 +binen binar VMM03P0 +biografiad biografiar VMM02P0 +biografiando biografiar VMG0000 +biografiar biografiar VMN0000 +biografiemos biografiar VMM01P0 +biografía biografiar VMM02S0 +biografíe biografiar VMM03S0 +biografíen biografiar VMM03P0 +birla birlar VMM02S0 +birlad birlar VMM02P0 +birlando birlar VMG0000 +birlar birlar VMN0000 +birle birlar VMM03S0 +birlemos birlar VMM01P0 +birlen birlar VMM03P0 +bisa bisar VMM02S0 +bisad bisar VMM02P0 +bisando bisar VMG0000 +bisar bisar VMN0000 +bisbisa bisbisar VMM02S0 +bisbisad bisbisar VMM02P0 +bisbisando bisbisar VMG0000 +bisbisar bisbisar VMN0000 +bisbise bisbisar VMM03S0 +bisbisea bisbisear VMM02S0 +bisbisead bisbisear VMM02P0 +bisbiseando bisbisear VMG0000 +bisbisear bisbisear VMN0000 +bisbisee bisbisear VMM03S0 +bisbiseemos bisbisear VMM01P0 +bisbiseen bisbisear VMM03P0 +bisbisemos bisbisar VMM01P0 +bisbisen bisbisar VMM03P0 +bise bisar VMM03S0 +biseca bisecar VMM02S0 +bisecad bisecar VMM02P0 +bisecando bisecar VMG0000 +bisecar bisecar VMN0000 +bisela biselar VMM02S0 +biselad biselar VMM02P0 +biselando biselar VMG0000 +biselar biselar VMN0000 +bisele biselar VMM03S0 +biselemos biselar VMM01P0 +biselen biselar VMM03P0 +bisemos bisar VMM01P0 +bisen bisar VMM03P0 +biseque bisecar VMM03S0 +bisequemos bisecar VMM01P0 +bisequen bisecar VMM03P0 +bizca bizcar VMM02S0 +bizcad bizcar VMM02P0 +bizcando bizcar VMG0000 +bizcar bizcar VMN0000 +bizcocha bizcochar VMM02S0 +bizcochad bizcochar VMM02P0 +bizcochando bizcochar VMG0000 +bizcochar bizcochar VMN0000 +bizcoche bizcochar VMM03S0 +bizcochemos bizcochar VMM01P0 +bizcochen bizcochar VMM03P0 +bizcornea bizcornear VMM02S0 +bizcornead bizcornear VMM02P0 +bizcorneando bizcornear VMG0000 +bizcornear bizcornear VMN0000 +bizcornee bizcornear VMM03S0 +bizcorneemos bizcornear VMM01P0 +bizcorneen bizcornear VMM03P0 +bizque bizcar VMM03S0 +bizquea bizquear VMM02S0 +bizquead bizquear VMM02P0 +bizqueando bizquear VMG0000 +bizquear bizquear VMN0000 +bizquee bizquear VMM03S0 +bizqueemos bizquear VMM01P0 +bizqueen bizquear VMM03P0 +bizquemos bizcar VMM01P0 +bizquen bizcar VMM03P0 +blanda blandir VMM03S0 +blandamos blandir VMM01P0 +blandan blandir VMM03P0 +blande blandir VMM02S0 +blandea blandear VMM02S0 +blandead blandear VMM02P0 +blandeando blandear VMG0000 +blandear blandear VMN0000 +blandee blandear VMM03S0 +blandeemos blandear VMM01P0 +blandeen blandear VMM03P0 +blandid blandir VMM02P0 +blandiendo blandir VMG0000 +blandir blandir VMN0000 +blanquea blanquear VMM02S0 +blanquead blanquear VMM02P0 +blanqueando blanquear VMG0000 +blanquear blanquear VMN0000 +blanquece blanquecer VMM02S0 +blanqueced blanquecer VMM02P0 +blanquecer blanquecer VMN0000 +blanqueciendo blanquecer VMG0000 +blanquee blanquear VMM03S0 +blanqueemos blanquear VMM01P0 +blanqueen blanquear VMM03P0 +blanquezca blanquecer VMM03S0 +blanquezcamos blanquecer VMM01P0 +blanquezcan blanquecer VMM03P0 +blasfema blasfemar VMM02S0 +blasfemad blasfemar VMM02P0 +blasfemando blasfemar VMG0000 +blasfemar blasfemar VMN0000 +blasfeme blasfemar VMM03S0 +blasfememos blasfemar VMM01P0 +blasfemen blasfemar VMM03P0 +blasona blasonar VMM02S0 +blasonad blasonar VMM02P0 +blasonando blasonar VMG0000 +blasonar blasonar VMN0000 +blasone blasonar VMM03S0 +blasonemos blasonar VMM01P0 +blasonen blasonar VMM03P0 +blinda blindar VMM02S0 +blindad blindar VMM02P0 +blindando blindar VMG0000 +blindar blindar VMN0000 +blinde blindar VMM03S0 +blindemos blindar VMM01P0 +blinden blindar VMM03P0 +bloca blocar VMM02S0 +blocad blocar VMM02P0 +blocando blocar VMG0000 +blocar blocar VMN0000 +bloque blocar VMM03S0 +bloquea bloquear VMM02S0 +bloquead bloquear VMM02P0 +bloqueando bloquear VMG0000 +bloquear bloquear VMN0000 +bloquee bloquear VMM03S0 +bloqueemos bloquear VMM01P0 +bloqueen bloquear VMM03P0 +bloquemos blocar VMM01P0 +bloquen blocar VMM03P0 +bobea bobear VMM02S0 +bobead bobear VMM02P0 +bobeando bobear VMG0000 +bobear bobear VMN0000 +bobee bobear VMM03S0 +bobeemos bobear VMM01P0 +bobeen bobear VMM03P0 +bobina bobinar VMM02S0 +bobinad bobinar VMM02P0 +bobinando bobinar VMG0000 +bobinar bobinar VMN0000 +bobine bobinar VMM03S0 +bobinemos bobinar VMM01P0 +bobinen bobinar VMM03P0 +bocadea bocadear VMM02S0 +bocadead bocadear VMM02P0 +bocadeando bocadear VMG0000 +bocadear bocadear VMN0000 +bocadee bocadear VMM03S0 +bocadeemos bocadear VMM01P0 +bocadeen bocadear VMM03P0 +bocea bocear VMM02S0 +bocead bocear VMM02P0 +boceando bocear VMG0000 +bocear bocear VMN0000 +bocece bocezar VMM03S0 +bocecemos bocezar VMM01P0 +bocecen bocezar VMM03P0 +bocee bocear VMM03S0 +boceemos bocear VMM01P0 +boceen bocear VMM03P0 +bocela bocelar VMM02S0 +bocelad bocelar VMM02P0 +bocelando bocelar VMG0000 +bocelar bocelar VMN0000 +bocele bocelar VMM03S0 +bocelemos bocelar VMM01P0 +bocelen bocelar VMM03P0 +boceza bocezar VMM02S0 +bocezad bocezar VMM02P0 +bocezando bocezar VMG0000 +bocezar bocezar VMN0000 +bocha bochar VMM02S0 +bochad bochar VMM02P0 +bochando bochar VMG0000 +bochar bochar VMN0000 +boche bochar VMM03S0 +bochemos bochar VMM01P0 +bochen bochar VMM03P0 +bocina bocinar VMM02S0 +bocinad bocinar VMM02P0 +bocinando bocinar VMG0000 +bocinar bocinar VMN0000 +bocine bocinar VMM03S0 +bocinemos bocinar VMM01P0 +bocinen bocinar VMM03P0 +boga bogar VMM02S0 +bogad bogar VMM02P0 +bogando bogar VMG0000 +bogar bogar VMN0000 +bogue bogar VMM03S0 +boguemos bogar VMM01P0 +boguen bogar VMM03P0 +boicotea boicotear VMM02S0 +boicotead boicotear VMM02P0 +boicoteando boicotear VMG0000 +boicotear boicotear VMN0000 +boicotee boicotear VMM03S0 +boicoteemos boicotear VMM01P0 +boicoteen boicotear VMM03P0 +boja bojar VMM02S0 +bojad bojar VMM02P0 +bojando bojar VMG0000 +bojar bojar VMN0000 +boje bojar VMM03S0 +bojea bojear VMM02S0 +bojead bojear VMM02P0 +bojeando bojear VMG0000 +bojear bojear VMN0000 +bojee bojear VMM03S0 +bojeemos bojear VMM01P0 +bojeen bojear VMM03P0 +bojemos bojar VMM01P0 +bojen bojar VMM03P0 +bolea bolear VMM02S0 +bolead bolear VMM02P0 +boleando bolear VMG0000 +bolear bolear VMN0000 +bolee bolear VMM03S0 +boleemos bolear VMM01P0 +boleen bolear VMM03P0 +bolla bollar VMM02S0 +bollad bollar VMM02P0 +bollando bollar VMG0000 +bollar bollar VMN0000 +bolle bollar VMM03S0 +bollemos bollar VMM01P0 +bollen bollar VMM03P0 +bolsea bolsear VMM02S0 +bolsead bolsear VMM02P0 +bolseando bolsear VMG0000 +bolsear bolsear VMN0000 +bolsee bolsear VMM03S0 +bolseemos bolsear VMM01P0 +bolseen bolsear VMM03P0 +bolsiquea bolsiquear VMM02S0 +bolsiquead bolsiquear VMM02P0 +bolsiqueando bolsiquear VMG0000 +bolsiquear bolsiquear VMN0000 +bolsiquee bolsiquear VMM03S0 +bolsiqueemos bolsiquear VMM01P0 +bolsiqueen bolsiquear VMM03P0 +bombardea bombardear VMM02S0 +bombardead bombardear VMM02P0 +bombardeando bombardear VMG0000 +bombardear bombardear VMN0000 +bombardee bombardear VMM03S0 +bombardeemos bombardear VMM01P0 +bombardeen bombardear VMM03P0 +bombea bombear VMM02S0 +bombead bombear VMM02P0 +bombeando bombear VMG0000 +bombear bombear VMN0000 +bombee bombear VMM03S0 +bombeemos bombear VMM01P0 +bombeen bombear VMM03P0 +bonifica bonificar VMM02S0 +bonificad bonificar VMM02P0 +bonificando bonificar VMG0000 +bonificar bonificar VMN0000 +bonifique bonificar VMM03S0 +bonifiquemos bonificar VMM01P0 +bonifiquen bonificar VMM03P0 +boquea boquear VMM02S0 +boquead boquear VMM02P0 +boqueando boquear VMG0000 +boquear boquear VMN0000 +boquee boquear VMM03S0 +boqueemos boquear VMM01P0 +boqueen boquear VMM03P0 +borbolea borbolear VMM02S0 +borbolead borbolear VMM02P0 +borboleando borbolear VMG0000 +borbolear borbolear VMN0000 +borbolla borbollar VMM02S0 +borbollad borbollar VMM02P0 +borbollando borbollar VMG0000 +borbollar borbollar VMN0000 +borbolle borbollar VMM03S0 +borbollemos borbollar VMM01P0 +borbollen borbollar VMM03P0 +borbollonea borbollonear VMM02S0 +borbollonead borbollonear VMM02P0 +borbolloneando borbollonear VMG0000 +borbollonear borbollonear VMN0000 +borbollonee borbollonear VMM03S0 +borbolloneemos borbollonear VMM01P0 +borbolloneen borbollonear VMM03P0 +borborita borboritar VMM02S0 +borboritad borboritar VMM02P0 +borboritando borboritar VMG0000 +borboritar borboritar VMN0000 +borborite borboritar VMM03S0 +borboritemos borboritar VMM01P0 +borboriten borboritar VMM03P0 +borbota borbotar VMM02S0 +borbotad borbotar VMM02P0 +borbotando borbotar VMG0000 +borbotar borbotar VMN0000 +borbote borbotar VMM03S0 +borbotea borbotear VMM02S0 +borbotead borbotear VMM02P0 +borboteando borbotear VMG0000 +borbotear borbotear VMN0000 +borbotee borbotear VMM03S0 +borboteemos borbotear VMM01P0 +borboteen borbotear VMM03P0 +borbotemos borbotar VMM01P0 +borboten borbotar VMM03P0 +borda bordar VMM02S0 +bordad bordar VMM02P0 +bordando bordar VMG0000 +bordar bordar VMN0000 +borde bordar VMM03S0 +bordea bordear VMM02S0 +bordead bordear VMM02P0 +bordeando bordear VMG0000 +bordear bordear VMN0000 +bordee bordear VMM03S0 +bordeemos bordear VMM01P0 +bordeen bordear VMM03P0 +bordemos bordar VMM01P0 +borden bordar VMM03P0 +bordonea bordonear VMM02S0 +bordonead bordonear VMM02P0 +bordoneando bordonear VMG0000 +bordonear bordonear VMN0000 +bordonee bordonear VMM03S0 +bordoneemos bordonear VMM01P0 +bordoneen bordonear VMM03P0 +bornea bornear VMM02S0 +bornead bornear VMM02P0 +borneando bornear VMG0000 +bornear bornear VMN0000 +bornee bornear VMM03S0 +borneemos bornear VMM01P0 +borneen bornear VMM03P0 +borra borrar VMM02S0 +borrachea borrachear VMM02S0 +borrachead borrachear VMM02P0 +borracheando borrachear VMG0000 +borrachear borrachear VMN0000 +borrachee borrachear VMM03S0 +borracheemos borrachear VMM01P0 +borracheen borrachear VMM03P0 +borrad borrar VMM02P0 +borrajea borrajear VMM02S0 +borrajead borrajear VMM02P0 +borrajeando borrajear VMG0000 +borrajear borrajear VMN0000 +borrajee borrajear VMM03S0 +borrajeemos borrajear VMM01P0 +borrajeen borrajear VMM03P0 +borrando borrar VMG0000 +borrar borrar VMN0000 +borre borrar VMM03S0 +borremos borrar VMM01P0 +borren borrar VMM03P0 +borronea borronear VMM02S0 +borronead borronear VMM02P0 +borroneando borronear VMG0000 +borronear borronear VMN0000 +borronee borronear VMM03S0 +borroneemos borronear VMM01P0 +borroneen borronear VMM03P0 +bosqueja bosquejar VMM02S0 +bosquejad bosquejar VMM02P0 +bosquejando bosquejar VMG0000 +bosquejar bosquejar VMN0000 +bosqueje bosquejar VMM03S0 +bosquejemos bosquejar VMM01P0 +bosquejen bosquejar VMM03P0 +bostece bostezar VMM03S0 +bostecemos bostezar VMM01P0 +bostecen bostezar VMM03P0 +bosteza bostezar VMM02S0 +bostezad bostezar VMM02P0 +bostezando bostezar VMG0000 +bostezar bostezar VMN0000 +bota botar VMM02S0 +botad botar VMM02P0 +botando botar VMG0000 +botar botar VMN0000 +bote botar VMM03S0 +botemos botar VMM01P0 +boten botar VMM03P0 +botona botonar VMM02S0 +botonad botonar VMM02P0 +botonando botonar VMG0000 +botonar botonar VMN0000 +botone botonar VMM03S0 +botonemos botonar VMM01P0 +botonen botonar VMM03P0 +boxea boxear VMM02S0 +boxead boxear VMM02P0 +boxeando boxear VMG0000 +boxear boxear VMN0000 +boxee boxear VMM03S0 +boxeemos boxear VMM01P0 +boxeen boxear VMM03P0 +boya boyar VMM02S0 +boyad boyar VMM02P0 +boyando boyar VMG0000 +boyar boyar VMN0000 +boye boyar VMM03S0 +boyemos boyar VMM01P0 +boyen boyar VMM03P0 +bracea bracear VMM02S0 +bracead bracear VMM02P0 +braceando bracear VMG0000 +bracear bracear VMN0000 +bracee bracear VMM03S0 +braceemos bracear VMM01P0 +braceen bracear VMM03P0 +brama bramar VMM02S0 +bramad bramar VMM02P0 +bramando bramar VMG0000 +bramar bramar VMN0000 +brame bramar VMM03S0 +bramemos bramar VMM01P0 +bramen bramar VMM03P0 +branda brandar VMM02S0 +brandad brandar VMM02P0 +brandando brandar VMG0000 +brandar brandar VMN0000 +brande brandar VMM03S0 +brandemos brandar VMM01P0 +branden brandar VMM03P0 +bravea bravear VMM02S0 +bravead bravear VMM02P0 +braveando bravear VMG0000 +bravear bravear VMN0000 +bravee bravear VMM03S0 +braveemos bravear VMM01P0 +braveen bravear VMM03P0 +bravuconea bravuconear VMM02S0 +bravuconead bravuconear VMM02P0 +bravuconeando bravuconear VMG0000 +bravuconear bravuconear VMN0000 +bravuconee bravuconear VMM03S0 +bravuconeemos bravuconear VMM01P0 +bravuconeen bravuconear VMM03P0 +brea brear VMM02S0 +bread brear VMM02P0 +breando brear VMG0000 +brear brear VMN0000 +bree brear VMM03S0 +breemos brear VMM01P0 +breen brear VMM03P0 +brega bregar VMM02S0 +bregad bregar VMM02P0 +bregando bregar VMG0000 +bregar bregar VMN0000 +bregue bregar VMM03S0 +breguemos bregar VMM01P0 +breguen bregar VMM03P0 +bresca brescar VMM02S0 +brescad brescar VMM02P0 +brescando brescar VMG0000 +brescar brescar VMN0000 +bresque brescar VMM03S0 +bresquemos brescar VMM01P0 +bresquen brescar VMM03P0 +briba bribar VMM02S0 +bribad bribar VMM02P0 +bribando bribar VMG0000 +bribar bribar VMN0000 +bribia bribiar VMM02S0 +bribiad bribiar VMM02P0 +bribiando bribiar VMG0000 +bribiar bribiar VMN0000 +bribonea bribonear VMM02S0 +bribonead bribonear VMM02P0 +briboneando bribonear VMG0000 +bribonear bribonear VMN0000 +bribonee bribonear VMM03S0 +briboneemos bribonear VMM01P0 +briboneen bribonear VMM03P0 +brida bridar VMM02S0 +bridad bridar VMM02P0 +bridando bridar VMG0000 +bridar bridar VMN0000 +bride bridar VMM03S0 +bridemos bridar VMM01P0 +briden bridar VMM03P0 +brilla brillar VMM02S0 +brillad brillar VMM02P0 +brillando brillar VMG0000 +brillar brillar VMN0000 +brille brillar VMM03S0 +brillemos brillar VMM01P0 +brillen brillar VMM03P0 +brinca brincar VMM02S0 +brincad brincar VMM02P0 +brincando brincar VMG0000 +brincar brincar VMN0000 +brinda brindar VMM02S0 +brindad brindar VMM02P0 +brindando brindar VMG0000 +brindar brindar VMN0000 +brinde brindar VMM03S0 +brindemos brindar VMM01P0 +brinden brindar VMM03P0 +brinque brincar VMM03S0 +brinquemos brincar VMM01P0 +brinquen brincar VMM03P0 +brocea brocear VMM02S0 +brocead brocear VMM02P0 +broceando brocear VMG0000 +brocear brocear VMN0000 +brocee brocear VMM03S0 +broceemos brocear VMM01P0 +broceen brocear VMM03P0 +broma bromar VMM02S0 +bromad bromar VMM02P0 +bromando bromar VMG0000 +bromar bromar VMN0000 +brome bromar VMM03S0 +bromea bromear VMM02S0 +bromead bromear VMM02P0 +bromeando bromear VMG0000 +bromear bromear VMN0000 +bromee bromear VMM03S0 +bromeemos bromear VMM01P0 +bromeen bromear VMM03P0 +bromemos bromar VMM01P0 +bromen bromar VMM03P0 +broncea broncear VMM02S0 +broncead broncear VMM02P0 +bronceando broncear VMG0000 +broncear broncear VMN0000 +broncee broncear VMM03S0 +bronceemos broncear VMM01P0 +bronceen broncear VMM03P0 +broquela broquelar VMM02S0 +broquelad broquelar VMM02P0 +broquelando broquelar VMG0000 +broquelar broquelar VMN0000 +broquele broquelar VMM03S0 +broquelemos broquelar VMM01P0 +broquelen broquelar VMM03P0 +brota brotar VMM02S0 +brotad brotar VMM02P0 +brotando brotar VMG0000 +brotar brotar VMN0000 +brote brotar VMM03S0 +brotemos brotar VMM01P0 +broten brotar VMM03P0 +bruce bruzar VMM03S0 +brucemos bruzar VMM01P0 +brucen bruzar VMM03P0 +bruja brujir VMM03S0 +brujamos brujir VMM01P0 +brujan brujir VMM03P0 +bruje brujir VMM02S0 +brujea brujear VMM02S0 +brujead brujear VMM02P0 +brujeando brujear VMG0000 +brujear brujear VMN0000 +brujee brujear VMM03S0 +brujeemos brujear VMM01P0 +brujeen brujear VMM03P0 +brujid brujir VMM02P0 +brujiendo brujir VMG0000 +brujir brujir VMN0000 +brujulea brujulear VMM02S0 +brujulead brujulear VMM02P0 +brujuleando brujulear VMG0000 +brujulear brujulear VMN0000 +brujulee brujulear VMM03S0 +brujuleemos brujulear VMM01P0 +brujuleen brujulear VMM03P0 +bruma brumar VMM02S0 +brumad brumar VMM02P0 +brumando brumar VMG0000 +brumar brumar VMN0000 +brume brumar VMM03S0 +brumemos brumar VMM01P0 +brumen brumar VMM03P0 +brutalice brutalizar VMM03S0 +brutalicemos brutalizar VMM01P0 +brutalicen brutalizar VMM03P0 +brutaliza brutalizar VMM02S0 +brutalizad brutalizar VMM02P0 +brutalizando brutalizar VMG0000 +brutalizar brutalizar VMN0000 +bruza bruzar VMM02S0 +bruzad bruzar VMM02P0 +bruzando bruzar VMG0000 +bruzar bruzar VMN0000 +bruña bruñir VMM03S0 +bruñamos bruñir VMM01P0 +bruñan bruñir VMM03P0 +bruñe bruñir VMM02S0 +bruñendo bruñir VMG0000 +bruñid bruñir VMM02P0 +bruñir bruñir VMN0000 +buce buzar VMM03S0 +bucea bucear VMM02S0 +bucead bucear VMM02P0 +buceando bucear VMG0000 +bucear bucear VMN0000 +bucee bucear VMM03S0 +buceemos bucear VMM01P0 +buceen bucear VMM03P0 +bucemos buzar VMM01P0 +bucen buzar VMM03P0 +bufa bufar VMM02S0 +bufad bufar VMM02P0 +bufando bufar VMG0000 +bufar bufar VMN0000 +bufe bufar VMM03S0 +bufemos bufar VMM01P0 +bufen bufar VMM03P0 +bufonea bufonear VMM02S0 +bufonead bufonear VMM02P0 +bufoneando bufonear VMG0000 +bufonear bufonear VMN0000 +bufonee bufonear VMM03S0 +bufoneemos bufonear VMM01P0 +bufoneen bufonear VMM03P0 +buge bugir VMM02S0 +bugid bugir VMM02P0 +bugiendo bugir VMG0000 +bugir bugir VMN0000 +buitrea buitrear VMM02S0 +buitread buitrear VMM02P0 +buitreando buitrear VMG0000 +buitrear buitrear VMN0000 +buitree buitrear VMM03S0 +buitreemos buitrear VMM01P0 +buitreen buitrear VMM03P0 +buja bugir VMM03S0 +bujamos bugir VMM01P0 +bujan bugir VMM03P0 +bulla bullir VMM03S0 +bullamos bullir VMM01P0 +bullan bullir VMM03P0 +bulle bullir VMM02S0 +bullendo bullir VMG0000 +bullid bullir VMM02P0 +bullir bullir VMN0000 +burbujea burbujear VMM02S0 +burbujead burbujear VMM02P0 +burbujeando burbujear VMG0000 +burbujear burbujear VMN0000 +burbujee burbujear VMM03S0 +burbujeemos burbujear VMM01P0 +burbujeen burbujear VMM03P0 +burila burilar VMM02S0 +burilad burilar VMM02P0 +burilando burilar VMG0000 +burilar burilar VMN0000 +burile burilar VMM03S0 +burilemos burilar VMM01P0 +burilen burilar VMM03P0 +burla burlar VMM02S0 +burlad burlar VMM02P0 +burlando burlar VMG0000 +burlar burlar VMN0000 +burle burlar VMM03S0 +burlemos burlar VMM01P0 +burlen burlar VMM03P0 +busca buscar VMM02S0 +buscad buscar VMM02P0 +buscando buscar VMG0000 +buscar buscar VMN0000 +busque buscar VMM03S0 +busquemos buscar VMM01P0 +busquen buscar VMM03P0 +buza buzar VMM02S0 +buzad buzar VMM02P0 +buzando buzar VMG0000 +buzar buzar VMN0000 +cabalga cabalgar VMM02S0 +cabalgad cabalgar VMM02P0 +cabalgando cabalgar VMG0000 +cabalgar cabalgar VMN0000 +cabalgue cabalgar VMM03S0 +cabalguemos cabalgar VMM01P0 +cabalguen cabalgar VMM03P0 +caballea caballear VMM02S0 +caballead caballear VMM02P0 +caballeando caballear VMG0000 +caballear caballear VMN0000 +caballee caballear VMM03S0 +caballeemos caballear VMM01P0 +caballeen caballear VMM03P0 +caballerea caballerear VMM02S0 +caballeread caballerear VMM02P0 +caballereando caballerear VMG0000 +caballerear caballerear VMN0000 +caballeree caballerear VMM03S0 +caballereemos caballerear VMM01P0 +caballereen caballerear VMM03P0 +cabe caber VMM02S0 +cabecea cabecear VMM02S0 +cabecead cabecear VMM02P0 +cabeceando cabecear VMG0000 +cabecear cabecear VMN0000 +cabecee cabecear VMM03S0 +cabeceemos cabecear VMM01P0 +cabeceen cabecear VMM03P0 +cabed caber VMM02P0 +cabella cabellar VMM02S0 +cabellad cabellar VMM02P0 +cabellando cabellar VMG0000 +cabellar cabellar VMN0000 +cabelle cabellar VMM03S0 +cabellemos cabellar VMM01P0 +cabellen cabellar VMM03P0 +caber caber VMN0000 +cabestra cabestrar VMM02S0 +cabestrad cabestrar VMM02P0 +cabestrando cabestrar VMG0000 +cabestrar cabestrar VMN0000 +cabestre cabestrar VMM03S0 +cabestrea cabestrear VMM02S0 +cabestread cabestrear VMM02P0 +cabestreando cabestrear VMG0000 +cabestrear cabestrear VMN0000 +cabestree cabestrear VMM03S0 +cabestreemos cabestrear VMM01P0 +cabestreen cabestrear VMM03P0 +cabestremos cabestrar VMM01P0 +cabestren cabestrar VMM03P0 +cabiendo caber VMG0000 +cabildea cabildear VMM02S0 +cabildead cabildear VMM02P0 +cabildeando cabildear VMG0000 +cabildear cabildear VMN0000 +cabildee cabildear VMM03S0 +cabildeemos cabildear VMM01P0 +cabildeen cabildear VMM03P0 +cablea cablear VMM02S0 +cablead cablear VMM02P0 +cableando cablear VMG0000 +cablear cablear VMN0000 +cablee cablear VMM03S0 +cableemos cablear VMM01P0 +cableen cablear VMM03P0 +cablegrafiad cablegrafiar VMM02P0 +cablegrafiando cablegrafiar VMG0000 +cablegrafiar cablegrafiar VMN0000 +cablegrafiemos cablegrafiar VMM01P0 +cablegrafía cablegrafiar VMM02S0 +cablegrafíe cablegrafiar VMM03S0 +cablegrafíen cablegrafiar VMM03P0 +cabrahigad cabrahigar VMM02P0 +cabrahigando cabrahigar VMG0000 +cabrahigar cabrahigar VMN0000 +cabrahiguemos cabrahigar VMM01P0 +cabrahíga cabrahigar VMM02S0 +cabrahígue cabrahigar VMM03S0 +cabrahíguen cabrahigar VMM03P0 +cabrea cabrear VMM02S0 +cabread cabrear VMM02P0 +cabreando cabrear VMG0000 +cabrear cabrear VMN0000 +cabree cabrear VMM03S0 +cabreemos cabrear VMM01P0 +cabreen cabrear VMM03P0 +cabrillea cabrillear VMM02S0 +cabrillead cabrillear VMM02P0 +cabrilleando cabrillear VMG0000 +cabrillear cabrillear VMN0000 +cabrillee cabrillear VMM03S0 +cabrilleemos cabrillear VMM01P0 +cabrilleen cabrillear VMM03P0 +cabriola cabriolar VMM02S0 +cabriolad cabriolar VMM02P0 +cabriolando cabriolar VMG0000 +cabriolar cabriolar VMN0000 +cabriole cabriolar VMM03S0 +cabriolea cabriolear VMM02S0 +cabriolead cabriolear VMM02P0 +cabrioleando cabriolear VMG0000 +cabriolear cabriolear VMN0000 +cabriolee cabriolear VMM03S0 +cabrioleemos cabriolear VMM01P0 +cabrioleen cabriolear VMM03P0 +cabriolemos cabriolar VMM01P0 +cabriolen cabriolar VMM03P0 +cacaraña cacarañar VMM02S0 +cacarañad cacarañar VMM02P0 +cacarañando cacarañar VMG0000 +cacarañar cacarañar VMN0000 +cacarañe cacarañar VMM03S0 +cacarañemos cacarañar VMM01P0 +cacarañen cacarañar VMM03P0 +cacarea cacarear VMM02S0 +cacaread cacarear VMM02P0 +cacareando cacarear VMG0000 +cacarear cacarear VMN0000 +cacaree cacarear VMM03S0 +cacareemos cacarear VMM01P0 +cacareen cacarear VMM03P0 +cace cazar VMM03S0 +cacea cacear VMM02S0 +cacead cacear VMM02P0 +caceando cacear VMG0000 +cacear cacear VMN0000 +cacee cacear VMM03S0 +caceemos cacear VMM01P0 +caceen cacear VMM03P0 +cacemos cazar VMM01P0 +cacen cazar VMM03P0 +cacha cachar VMM02S0 +cachad cachar VMM02P0 +cachando cachar VMG0000 +cachar cachar VMN0000 +cache cachar VMM03S0 +cachea cachear VMM02S0 +cachead cachear VMM02P0 +cacheando cachear VMG0000 +cachear cachear VMN0000 +cachee cachear VMM03S0 +cacheemos cachear VMM01P0 +cacheen cachear VMM03P0 +cachemos cachar VMM01P0 +cachen cachar VMM03P0 +cachetea cachetear VMM02S0 +cachetead cachetear VMM02P0 +cacheteando cachetear VMG0000 +cachetear cachetear VMN0000 +cachetee cachetear VMM03S0 +cacheteemos cachetear VMM01P0 +cacheteen cachetear VMM03P0 +cachifolla cachifollar VMM02S0 +cachifollad cachifollar VMM02P0 +cachifollando cachifollar VMG0000 +cachifollar cachifollar VMN0000 +cachifolle cachifollar VMM03S0 +cachifollemos cachifollar VMM01P0 +cachifollen cachifollar VMM03P0 +cachipoda cachipodar VMM02S0 +cachipodad cachipodar VMM02P0 +cachipodando cachipodar VMG0000 +cachipodar cachipodar VMN0000 +cachipode cachipodar VMM03S0 +cachipodemos cachipodar VMM01P0 +cachipoden cachipodar VMM03P0 +cachondea cachondear VMM02S0 +cachondead cachondear VMM02P0 +cachondeando cachondear VMG0000 +cachondear cachondear VMN0000 +cachondee cachondear VMM03S0 +cachondeemos cachondear VMM01P0 +cachondeen cachondear VMM03P0 +cadmia cadmiar VMM02S0 +cadmiad cadmiar VMM02P0 +cadmiando cadmiar VMG0000 +cadmiar cadmiar VMN0000 +cadmie cadmiar VMM03S0 +cadmiemos cadmiar VMM01P0 +cadmien cadmiar VMM03P0 +caduca caducar VMM02S0 +caducad caducar VMM02P0 +caducando caducar VMG0000 +caducar caducar VMN0000 +caduque caducar VMM03S0 +caduquemos caducar VMM01P0 +caduquen caducar VMM03P0 +cae caer VMM02S0 +caed caer VMM02P0 +caer caer VMN0000 +caga cagar VMM02S0 +cagad cagar VMM02P0 +cagando cagar VMG0000 +cagar cagar VMN0000 +cague cagar VMM03S0 +caguemos cagar VMM01P0 +caguen cagar VMM03P0 +caiga caer VMM03S0 +caigamos caer VMM01P0 +caigan caer VMM03P0 +cajea cajear VMM02S0 +cajead cajear VMM02P0 +cajeando cajear VMG0000 +cajear cajear VMN0000 +cajee cajear VMM03S0 +cajeemos cajear VMM01P0 +cajeen cajear VMM03P0 +cala calar VMM02S0 +calabacea calabacear VMM02S0 +calabacead calabacear VMM02P0 +calabaceando calabacear VMG0000 +calabacear calabacear VMN0000 +calabacee calabacear VMM03S0 +calabaceemos calabacear VMM01P0 +calabaceen calabacear VMM03P0 +calad calar VMM02P0 +calafatea calafatear VMM02S0 +calafatead calafatear VMM02P0 +calafateando calafatear VMG0000 +calafatear calafatear VMN0000 +calafatee calafatear VMM03S0 +calafateemos calafatear VMM01P0 +calafateen calafatear VMM03P0 +calando calar VMG0000 +calandra calandrar VMM02S0 +calandrad calandrar VMM02P0 +calandrando calandrar VMG0000 +calandrar calandrar VMN0000 +calandre calandrar VMM03S0 +calandremos calandrar VMM01P0 +calandren calandrar VMM03P0 +calar calar VMN0000 +calca calcar VMM02S0 +calcad calcar VMM02P0 +calcando calcar VMG0000 +calcar calcar VMN0000 +calce calzar VMM03S0 +calcemos calzar VMM01P0 +calcen calzar VMM03P0 +calceta calcetar VMM02S0 +calcetad calcetar VMM02P0 +calcetando calcetar VMG0000 +calcetar calcetar VMN0000 +calcete calcetar VMM03S0 +calcetemos calcetar VMM01P0 +calceten calcetar VMM03P0 +calcifica calcificar VMM02S0 +calcificad calcificar VMM02P0 +calcificando calcificar VMG0000 +calcificar calcificar VMN0000 +calcifique calcificar VMM03S0 +calcifiquemos calcificar VMM01P0 +calcifiquen calcificar VMM03P0 +calcina calcinar VMM02S0 +calcinad calcinar VMM02P0 +calcinando calcinar VMG0000 +calcinar calcinar VMN0000 +calcine calcinar VMM03S0 +calcinemos calcinar VMM01P0 +calcinen calcinar VMM03P0 +calcula calcular VMM02S0 +calculad calcular VMM02P0 +calculando calcular VMG0000 +calcular calcular VMN0000 +calcule calcular VMM03S0 +calculemos calcular VMM01P0 +calculen calcular VMM03P0 +caldea caldear VMM02S0 +caldead caldear VMM02P0 +caldeando caldear VMG0000 +caldear caldear VMN0000 +caldee caldear VMM03S0 +caldeemos caldear VMM01P0 +caldeen caldear VMM03P0 +cale calar VMM03S0 +calece calecer VMM02S0 +caleced calecer VMM02P0 +calecer calecer VMN0000 +caleciendo calecer VMG0000 +calefacciona calefaccionar VMM02S0 +calefaccionad calefaccionar VMM02P0 +calefaccionando calefaccionar VMG0000 +calefaccionar calefaccionar VMN0000 +calemos calar VMM01P0 +calen calar VMM03P0 +calenda calendar VMM02S0 +calendad calendar VMM02P0 +calendando calendar VMG0000 +calendar calendar VMN0000 +calende calendar VMM03S0 +calendemos calendar VMM01P0 +calenden calendar VMM03P0 +calentad calentar VMM02P0 +calentando calentar VMG0000 +calentar calentar VMN0000 +calentemos calentar VMM01P0 +calezca calecer VMM03S0 +calezcamos calecer VMM01P0 +calezcan calecer VMM03P0 +calibra calibrar VMM02S0 +calibrad calibrar VMM02P0 +calibrando calibrar VMG0000 +calibrar calibrar VMN0000 +calibre calibrar VMM03S0 +calibremos calibrar VMM01P0 +calibren calibrar VMM03P0 +calienta calentar VMM02S0 +caliente calentar VMM03S0 +calienten calentar VMM03P0 +califica calificar VMM02S0 +calificad calificar VMM02P0 +calificando calificar VMG0000 +calificar calificar VMN0000 +califique calificar VMM03S0 +califiquemos calificar VMM01P0 +califiquen calificar VMM03P0 +caligrafiad caligrafiar VMM02P0 +caligrafiando caligrafiar VMG0000 +caligrafiar caligrafiar VMN0000 +caligrafiemos caligrafiar VMM01P0 +caligrafía caligrafiar VMM02S0 +caligrafíe caligrafiar VMM03S0 +caligrafíen caligrafiar VMM03P0 +calimba calimbar VMM02S0 +calimbad calimbar VMM02P0 +calimbando calimbar VMG0000 +calimbar calimbar VMN0000 +calimbe calimbar VMM03S0 +calimbemos calimbar VMM01P0 +calimben calimbar VMM03P0 +calla callar VMM02S0 +callad callar VMM02P0 +callando callar VMG0000 +callanta callantar VMM02S0 +callantad callantar VMM02P0 +callantando callantar VMG0000 +callantar callantar VMN0000 +callante callantar VMM03S0 +callantemos callantar VMM01P0 +callanten callantar VMM03P0 +callar callar VMN0000 +calle callar VMM03S0 +callea callear VMM02S0 +callead callear VMM02P0 +calleando callear VMG0000 +callear callear VMN0000 +callee callear VMM03S0 +calleemos callear VMM01P0 +calleen callear VMM03P0 +callejea callejear VMM02S0 +callejead callejear VMM02P0 +callejeando callejear VMG0000 +callejear callejear VMN0000 +callejee callejear VMM03S0 +callejeemos callejear VMM01P0 +callejeen callejear VMM03P0 +callemos callar VMM01P0 +callen callar VMM03P0 +calma calmar VMM02S0 +calmad calmar VMM02P0 +calmando calmar VMG0000 +calmar calmar VMN0000 +calme calmar VMM03S0 +calmemos calmar VMM01P0 +calmen calmar VMM03P0 +calofriad calofriar VMM02P0 +calofriando calofriar VMG0000 +calofriar calofriar VMN0000 +calofriemos calofriar VMM01P0 +calofría calofriar VMM02S0 +calofríe calofriar VMM03S0 +calofríen calofriar VMM03P0 +calorice calorizar VMM03S0 +caloricemos calorizar VMM01P0 +caloricen calorizar VMM03P0 +caloriza calorizar VMM02S0 +calorizad calorizar VMM02P0 +calorizando calorizar VMG0000 +calorizar calorizar VMN0000 +calque calcar VMM03S0 +calquemos calcar VMM01P0 +calquen calcar VMM03P0 +calumnia calumniar VMM02S0 +calumniad calumniar VMM02P0 +calumniando calumniar VMG0000 +calumniar calumniar VMN0000 +calumnie calumniar VMM03S0 +calumniemos calumniar VMM01P0 +calumnien calumniar VMM03P0 +calza calzar VMM02S0 +calzad calzar VMM02P0 +calzando calzar VMG0000 +calzar calzar VMN0000 +camandulea camandulear VMM02S0 +camandulead camandulear VMM02P0 +camanduleando camandulear VMG0000 +camandulear camandulear VMN0000 +camandulee camandulear VMM03S0 +camanduleemos camandulear VMM01P0 +camanduleen camandulear VMM03P0 +cambalachea cambalachear VMM02S0 +cambalachead cambalachear VMM02P0 +cambalacheando cambalachear VMG0000 +cambalachear cambalachear VMN0000 +cambalachee cambalachear VMM03S0 +cambalacheemos cambalachear VMM01P0 +cambalacheen cambalachear VMM03P0 +cambia cambiar VMM02S0 +cambiad cambiar VMM02P0 +cambiando cambiar VMG0000 +cambiar cambiar VMN0000 +cambie cambiar VMM03S0 +cambiemos cambiar VMM01P0 +cambien cambiar VMM03P0 +camela camelar VMM02S0 +camelad camelar VMM02P0 +camelando camelar VMG0000 +camelar camelar VMN0000 +camele camelar VMM03S0 +camelemos camelar VMM01P0 +camelen camelar VMM03P0 +camina caminar VMM02S0 +caminad caminar VMM02P0 +caminando caminar VMG0000 +caminar caminar VMN0000 +camine caminar VMM03S0 +caminemos caminar VMM01P0 +caminen caminar VMM03P0 +camocha camochar VMM02S0 +camochad camochar VMM02P0 +camochando camochar VMG0000 +camochar camochar VMN0000 +camoche camochar VMM03S0 +camochemos camochar VMM01P0 +camochen camochar VMM03P0 +campa campar VMM02S0 +campad campar VMM02P0 +campando campar VMG0000 +campanillea campanillear VMM02S0 +campanillead campanillear VMM02P0 +campanilleando campanillear VMG0000 +campanillear campanillear VMN0000 +campanillee campanillear VMM03S0 +campanilleemos campanillear VMM01P0 +campanilleen campanillear VMM03P0 +campar campar VMN0000 +campe campar VMM03S0 +campea campear VMM02S0 +campead campear VMM02P0 +campeando campear VMG0000 +campear campear VMN0000 +campee campear VMM03S0 +campeemos campear VMM01P0 +campeen campear VMM03P0 +campemos campar VMM01P0 +campen campar VMM03P0 +camufla camuflar VMM02S0 +camuflad camuflar VMM02P0 +camuflando camuflar VMG0000 +camuflar camuflar VMN0000 +camufle camuflar VMM03S0 +camuflemos camuflar VMM01P0 +camuflen camuflar VMM03P0 +canalice canalizar VMM03S0 +canalicemos canalizar VMM01P0 +canalicen canalizar VMM03P0 +canaliza canalizar VMM02S0 +canalizad canalizar VMM02P0 +canalizando canalizar VMG0000 +canalizar canalizar VMN0000 +cancanea cancanear VMM02S0 +cancanead cancanear VMM02P0 +cancaneando cancanear VMG0000 +cancanear cancanear VMN0000 +cancanee cancanear VMM03S0 +cancaneemos cancanear VMM01P0 +cancaneen cancanear VMM03P0 +cancela cancelar VMM02S0 +cancelad cancelar VMM02P0 +cancelando cancelar VMG0000 +cancelar cancelar VMN0000 +cancele cancelar VMM03S0 +cancelemos cancelar VMM01P0 +cancelen cancelar VMM03P0 +cancera cancerar VMM02S0 +cancerad cancerar VMM02P0 +cancerando cancerar VMG0000 +cancerar cancerar VMN0000 +cancere cancerar VMM03S0 +canceremos cancerar VMM01P0 +canceren cancerar VMM03P0 +canchea canchear VMM02S0 +canchead canchear VMM02P0 +cancheando canchear VMG0000 +canchear canchear VMN0000 +canchee canchear VMM03S0 +cancheemos canchear VMM01P0 +cancheen canchear VMM03P0 +canda candar VMM02S0 +candad candar VMM02P0 +candando candar VMG0000 +candar candar VMN0000 +cande candar VMM03S0 +candemos candar VMM01P0 +canden candar VMM03P0 +candonguea candonguear VMM02S0 +candonguead candonguear VMM02P0 +candongueando candonguear VMG0000 +candonguear candonguear VMN0000 +candonguee candonguear VMM03S0 +candongueemos candonguear VMM01P0 +candongueen candonguear VMM03P0 +cangrena cangrenar VMM02S0 +cangrenad cangrenar VMM02P0 +cangrenando cangrenar VMG0000 +cangrenar cangrenar VMN0000 +cangrene cangrenar VMM03S0 +cangrenemos cangrenar VMM01P0 +cangrenen cangrenar VMM03P0 +canjea canjear VMM02S0 +canjead canjear VMM02P0 +canjeando canjear VMG0000 +canjear canjear VMN0000 +canjee canjear VMM03S0 +canjeemos canjear VMM01P0 +canjeen canjear VMM03P0 +canonice canonizar VMM03S0 +canonicemos canonizar VMM01P0 +canonicen canonizar VMM03P0 +canoniza canonizar VMM02S0 +canonizad canonizar VMM02P0 +canonizando canonizar VMG0000 +canonizar canonizar VMN0000 +cansa cansar VMM02S0 +cansad cansar VMM02P0 +cansando cansar VMG0000 +cansar cansar VMN0000 +canse cansar VMM03S0 +cansemos cansar VMM01P0 +cansen cansar VMM03P0 +canta cantar VMM02S0 +cantad cantar VMM02P0 +cantaletea cantaletear VMM02S0 +cantaletead cantaletear VMM02P0 +cantaleteando cantaletear VMG0000 +cantaletear cantaletear VMN0000 +cantaletee cantaletear VMM03S0 +cantaleteemos cantaletear VMM01P0 +cantaleteen cantaletear VMM03P0 +cantando cantar VMG0000 +cantar cantar VMN0000 +cante cantar VMM03S0 +cantea cantear VMM02S0 +cantead cantear VMM02P0 +canteando cantear VMG0000 +cantear cantear VMN0000 +cantee cantear VMM03S0 +canteemos cantear VMM01P0 +canteen cantear VMM03P0 +cantemos cantar VMM01P0 +canten cantar VMM03P0 +cantona cantonar VMM02S0 +cantonad cantonar VMM02P0 +cantonando cantonar VMG0000 +cantonar cantonar VMN0000 +cantone cantonar VMM03S0 +cantonea cantonear VMM02S0 +cantonead cantonear VMM02P0 +cantoneando cantonear VMG0000 +cantonear cantonear VMN0000 +cantonee cantonear VMM03S0 +cantoneemos cantonear VMM01P0 +cantoneen cantonear VMM03P0 +cantonemos cantonar VMM01P0 +cantonen cantonar VMM03P0 +canturrea canturrear VMM02S0 +canturread canturrear VMM02P0 +canturreando canturrear VMG0000 +canturrear canturrear VMN0000 +canturree canturrear VMM03S0 +canturreemos canturrear VMM01P0 +canturreen canturrear VMM03P0 +canturria canturriar VMM02S0 +canturriad canturriar VMM02P0 +canturriando canturriar VMG0000 +canturriar canturriar VMN0000 +canturrie canturriar VMM03S0 +canturriemos canturriar VMM01P0 +canturrien canturriar VMM03P0 +capa capar VMM02S0 +capacita capacitar VMM02S0 +capacitad capacitar VMM02P0 +capacitando capacitar VMG0000 +capacitar capacitar VMN0000 +capacite capacitar VMM03S0 +capacitemos capacitar VMM01P0 +capaciten capacitar VMM03P0 +capad capar VMM02P0 +capando capar VMG0000 +capar capar VMN0000 +capciona capcionar VMM02S0 +capcionad capcionar VMM02P0 +capcionando capcionar VMG0000 +capcionar capcionar VMN0000 +cape capar VMM03S0 +capea capear VMM02S0 +capead capear VMM02P0 +capeando capear VMG0000 +capear capear VMN0000 +capee capear VMM03S0 +capeemos capear VMM01P0 +capeen capear VMM03P0 +capemos capar VMM01P0 +capen capar VMM03P0 +capialce capialzar VMM03S0 +capialcemos capialzar VMM01P0 +capialcen capialzar VMM03P0 +capialza capialzar VMM02S0 +capialzad capialzar VMM02P0 +capialzando capialzar VMG0000 +capialzar capialzar VMN0000 +capitalice capitalizar VMM03S0 +capitalicemos capitalizar VMM01P0 +capitalicen capitalizar VMM03P0 +capitaliza capitalizar VMM02S0 +capitalizad capitalizar VMM02P0 +capitalizando capitalizar VMG0000 +capitalizar capitalizar VMN0000 +capitanea capitanear VMM02S0 +capitanead capitanear VMM02P0 +capitaneando capitanear VMG0000 +capitanear capitanear VMN0000 +capitanee capitanear VMM03S0 +capitaneemos capitanear VMM01P0 +capitaneen capitanear VMM03P0 +capitula capitular VMM02S0 +capitulad capitular VMM02P0 +capitulando capitular VMG0000 +capitular capitular VMN0000 +capitule capitular VMM03S0 +capitulemos capitular VMM01P0 +capitulen capitular VMM03P0 +capola capolar VMM02S0 +capolad capolar VMM02P0 +capolando capolar VMG0000 +capolar capolar VMN0000 +capole capolar VMM03S0 +capolemos capolar VMM01P0 +capolen capolar VMM03P0 +capona caponar VMM02S0 +caponad caponar VMM02P0 +caponando caponar VMG0000 +caponar caponar VMN0000 +capone caponar VMM03S0 +caponemos caponar VMM01P0 +caponen caponar VMM03P0 +capota capotar VMM02S0 +capotad capotar VMM02P0 +capotando capotar VMG0000 +capotar capotar VMN0000 +capote capotar VMM03S0 +capotea capotear VMM02S0 +capotead capotear VMM02P0 +capoteando capotear VMG0000 +capotear capotear VMN0000 +capotee capotear VMM03S0 +capoteemos capotear VMM01P0 +capoteen capotear VMM03P0 +capotemos capotar VMM01P0 +capoten capotar VMM03P0 +capsula capsular VMM02S0 +capsulad capsular VMM02P0 +capsulando capsular VMG0000 +capsular capsular VMN0000 +capsule capsular VMM03S0 +capsulemos capsular VMM01P0 +capsulen capsular VMM03P0 +capta captar VMM02S0 +captad captar VMM02P0 +captando captar VMG0000 +captar captar VMN0000 +capte captar VMM03S0 +captemos captar VMM01P0 +capten captar VMM03P0 +captura capturar VMM02S0 +capturad capturar VMM02P0 +capturando capturar VMG0000 +capturar capturar VMN0000 +capture capturar VMM03S0 +capturemos capturar VMM01P0 +capturen capturar VMM03P0 +capuce capuzar VMM03S0 +capucemos capuzar VMM01P0 +capucen capuzar VMM03P0 +capuza capuzar VMM02S0 +capuzad capuzar VMM02P0 +capuzando capuzar VMG0000 +capuzar capuzar VMN0000 +caracolea caracolear VMM02S0 +caracolead caracolear VMM02P0 +caracoleando caracolear VMG0000 +caracolear caracolear VMN0000 +caracolee caracolear VMM03S0 +caracoleemos caracolear VMM01P0 +caracoleen caracolear VMM03P0 +caracterice caracterizar VMM03S0 +caractericemos caracterizar VMM01P0 +caractericen caracterizar VMM03P0 +caracteriza caracterizar VMM02S0 +caracterizad caracterizar VMM02P0 +caracterizando caracterizar VMG0000 +caracterizar caracterizar VMN0000 +caramelea caramelear VMM02S0 +caramelead caramelear VMM02P0 +carameleando caramelear VMG0000 +caramelear caramelear VMN0000 +caramelee caramelear VMM03S0 +carameleemos caramelear VMM01P0 +carameleen caramelear VMM03P0 +caramelice caramelizar VMM03S0 +caramelicemos caramelizar VMM01P0 +caramelicen caramelizar VMM03P0 +carameliza caramelizar VMM02S0 +caramelizad caramelizar VMM02P0 +caramelizando caramelizar VMG0000 +caramelizar caramelizar VMN0000 +carbona carbonar VMM02S0 +carbonad carbonar VMM02P0 +carbonando carbonar VMG0000 +carbonar carbonar VMN0000 +carbonata carbonatar VMM02S0 +carbonatad carbonatar VMM02P0 +carbonatando carbonatar VMG0000 +carbonatar carbonatar VMN0000 +carbonate carbonatar VMM03S0 +carbonatemos carbonatar VMM01P0 +carbonaten carbonatar VMM03P0 +carbone carbonar VMM03S0 +carbonea carbonear VMM02S0 +carbonead carbonear VMM02P0 +carboneando carbonear VMG0000 +carbonear carbonear VMN0000 +carbonee carbonear VMM03S0 +carboneemos carbonear VMM01P0 +carboneen carbonear VMM03P0 +carbonemos carbonar VMM01P0 +carbonen carbonar VMM03P0 +carbonice carbonizar VMM03S0 +carbonicemos carbonizar VMM01P0 +carbonicen carbonizar VMM03P0 +carboniza carbonizar VMM02S0 +carbonizad carbonizar VMM02P0 +carbonizando carbonizar VMG0000 +carbonizar carbonizar VMN0000 +carbura carburar VMM02S0 +carburad carburar VMM02P0 +carburando carburar VMG0000 +carburar carburar VMN0000 +carbure carburar VMM03S0 +carburemos carburar VMM01P0 +carburen carburar VMM03P0 +carcajea carcajear VMM02S0 +carcajead carcajear VMM02P0 +carcajeando carcajear VMG0000 +carcajear carcajear VMN0000 +carcajee carcajear VMM03S0 +carcajeemos carcajear VMM01P0 +carcajeen carcajear VMM03P0 +carcoma carcomer VMM03S0 +carcomamos carcomer VMM01P0 +carcoman carcomer VMM03P0 +carcome carcomer VMM02S0 +carcomed carcomer VMM02P0 +carcomer carcomer VMN0000 +carcomiendo carcomer VMG0000 +carda cardar VMM02S0 +cardad cardar VMM02P0 +cardando cardar VMG0000 +cardar cardar VMN0000 +carde cardar VMM03S0 +cardemos cardar VMM01P0 +carden cardar VMM03P0 +carduce carduzar VMM03S0 +carducemos carduzar VMM01P0 +carducen carduzar VMM03P0 +carduza carduzar VMM02S0 +carduzad carduzar VMM02P0 +carduzando carduzar VMG0000 +carduzar carduzar VMN0000 +carea carear VMM02S0 +caread carear VMM02P0 +careando carear VMG0000 +carear carear VMN0000 +carece carecer VMM02S0 +careced carecer VMM02P0 +carecer carecer VMN0000 +careciendo carecer VMG0000 +caree carear VMM03S0 +careemos carear VMM01P0 +careen carear VMM03P0 +carena carenar VMM02S0 +carenad carenar VMM02P0 +carenando carenar VMG0000 +carenar carenar VMN0000 +carene carenar VMM03S0 +carenemos carenar VMM01P0 +carenen carenar VMM03P0 +carezca carecer VMM03S0 +carezcamos carecer VMM01P0 +carezcan carecer VMM03P0 +carga cargar VMM02S0 +cargad cargar VMM02P0 +cargando cargar VMG0000 +cargar cargar VMN0000 +cargosea cargosear VMM02S0 +cargosead cargosear VMM02P0 +cargoseando cargosear VMG0000 +cargosear cargosear VMN0000 +cargosee cargosear VMM03S0 +cargoseemos cargosear VMM01P0 +cargoseen cargosear VMM03P0 +cargue cargar VMM03S0 +carguemos cargar VMM01P0 +carguen cargar VMM03P0 +caria cariar VMM02S0 +cariad cariar VMM02P0 +cariando cariar VMG0000 +cariar cariar VMN0000 +caricatura caricaturar VMM02S0 +caricaturad caricaturar VMM02P0 +caricaturando caricaturar VMG0000 +caricaturar caricaturar VMN0000 +caricature caricaturar VMM03S0 +caricaturemos caricaturar VMM01P0 +caricaturen caricaturar VMM03P0 +caricaturice caricaturizar VMM03S0 +caricaturicemos caricaturizar VMM01P0 +caricaturicen caricaturizar VMM03P0 +caricaturiza caricaturizar VMM02S0 +caricaturizad caricaturizar VMM02P0 +caricaturizando caricaturizar VMG0000 +caricaturizar caricaturizar VMN0000 +carie cariar VMM03S0 +cariemos cariar VMM01P0 +carien cariar VMM03P0 +carlea carlear VMM02S0 +carlead carlear VMM02P0 +carleando carlear VMG0000 +carlear carlear VMN0000 +carlee carlear VMM03S0 +carleemos carlear VMM01P0 +carleen carlear VMM03P0 +carmena carmenar VMM02S0 +carmenad carmenar VMM02P0 +carmenando carmenar VMG0000 +carmenar carmenar VMN0000 +carmene carmenar VMM03S0 +carmenemos carmenar VMM01P0 +carmenen carmenar VMM03P0 +carnea carnear VMM02S0 +carnead carnear VMM02P0 +carneando carnear VMG0000 +carnear carnear VMN0000 +carnee carnear VMM03S0 +carneemos carnear VMM01P0 +carneen carnear VMM03P0 +carnerea carnerear VMM02S0 +carneread carnerear VMM02P0 +carnereando carnerear VMG0000 +carnerear carnerear VMN0000 +carneree carnerear VMM03S0 +carnereemos carnerear VMM01P0 +carnereen carnerear VMM03P0 +carnifica carnificar VMM02S0 +carnificad carnificar VMM02P0 +carnificando carnificar VMG0000 +carnificar carnificar VMN0000 +carnifique carnificar VMM03S0 +carnifiquemos carnificar VMM01P0 +carnifiquen carnificar VMM03P0 +carpa carpir VMM03S0 +carpamos carpir VMM01P0 +carpan carpir VMM03P0 +carpe carpir VMM02S0 +carpid carpir VMM02P0 +carpiendo carpir VMG0000 +carpintea carpintear VMM02S0 +carpintead carpintear VMM02P0 +carpinteando carpintear VMG0000 +carpintear carpintear VMN0000 +carpintee carpintear VMM03S0 +carpinteemos carpintear VMM01P0 +carpinteen carpintear VMM03P0 +carpir carpir VMN0000 +carraspea carraspear VMM02S0 +carraspead carraspear VMM02P0 +carraspeando carraspear VMG0000 +carraspear carraspear VMN0000 +carraspee carraspear VMM03S0 +carraspeemos carraspear VMM01P0 +carraspeen carraspear VMM03P0 +carretea carretear VMM02S0 +carretead carretear VMM02P0 +carreteando carretear VMG0000 +carretear carretear VMN0000 +carretee carretear VMM03S0 +carreteemos carretear VMM01P0 +carreteen carretear VMM03P0 +carrocha carrochar VMM02S0 +carrochad carrochar VMM02P0 +carrochando carrochar VMG0000 +carrochar carrochar VMN0000 +carroche carrochar VMM03S0 +carrochemos carrochar VMM01P0 +carrochen carrochar VMM03P0 +cartea cartear VMM02S0 +cartead cartear VMM02P0 +carteando cartear VMG0000 +cartear cartear VMN0000 +cartee cartear VMM03S0 +carteemos cartear VMM01P0 +carteen cartear VMM03P0 +cartografiad cartografiar VMM02P0 +cartografiando cartografiar VMG0000 +cartografiar cartografiar VMN0000 +cartografiemos cartografiar VMM01P0 +cartografía cartografiar VMM02S0 +cartografíe cartografiar VMM03S0 +cartografíen cartografiar VMM03P0 +casa casar VMM02S0 +casad casar VMM02P0 +casando casar VMG0000 +casar casar VMN0000 +casca cascar VMM02S0 +cascabelea cascabelear VMM02S0 +cascabelead cascabelear VMM02P0 +cascabeleando cascabelear VMG0000 +cascabelear cascabelear VMN0000 +cascabelee cascabelear VMM03S0 +cascabeleemos cascabelear VMM01P0 +cascabeleen cascabelear VMM03P0 +cascad cascar VMM02P0 +cascamaja cascamajar VMM02S0 +cascamajad cascamajar VMM02P0 +cascamajando cascamajar VMG0000 +cascamajar cascamajar VMN0000 +cascamaje cascamajar VMM03S0 +cascamajemos cascamajar VMM01P0 +cascamajen cascamajar VMM03P0 +cascando cascar VMG0000 +cascar cascar VMN0000 +case casar VMM03S0 +caseifica caseificar VMM02S0 +caseificad caseificar VMM02P0 +caseificando caseificar VMG0000 +caseificar caseificar VMN0000 +caseifique caseificar VMM03S0 +caseifiquemos caseificar VMM01P0 +caseifiquen caseificar VMM03P0 +casemos casar VMM01P0 +casen casar VMM03P0 +casque cascar VMM03S0 +casquemos cascar VMM01P0 +casquen cascar VMM03P0 +castañetea castañetear VMM02S0 +castañetead castañetear VMM02P0 +castañeteando castañetear VMG0000 +castañetear castañetear VMN0000 +castañetee castañetear VMM03S0 +castañeteemos castañetear VMM01P0 +castañeteen castañetear VMM03P0 +castellanice castellanizar VMM03S0 +castellanicemos castellanizar VMM01P0 +castellanicen castellanizar VMM03P0 +castellaniza castellanizar VMM02S0 +castellanizad castellanizar VMM02P0 +castellanizando castellanizar VMG0000 +castellanizar castellanizar VMN0000 +castiga castigar VMM02S0 +castigad castigar VMM02P0 +castigando castigar VMG0000 +castigar castigar VMN0000 +castigue castigar VMM03S0 +castiguemos castigar VMM01P0 +castiguen castigar VMM03P0 +castra castrar VMM02S0 +castrad castrar VMM02P0 +castrando castrar VMG0000 +castrar castrar VMN0000 +castre castrar VMM03S0 +castremos castrar VMM01P0 +castren castrar VMM03P0 +cata catar VMM02S0 +catad catar VMM02P0 +catalice catalizar VMM03S0 +catalicemos catalizar VMM01P0 +catalicen catalizar VMM03P0 +cataliza catalizar VMM02S0 +catalizad catalizar VMM02P0 +catalizando catalizar VMG0000 +catalizar catalizar VMN0000 +cataloga catalogar VMM02S0 +catalogad catalogar VMM02P0 +catalogando catalogar VMG0000 +catalogar catalogar VMN0000 +catalogue catalogar VMM03S0 +cataloguemos catalogar VMM01P0 +cataloguen catalogar VMM03P0 +catando catar VMG0000 +catapulta catapultar VMM02S0 +catapultad catapultar VMM02P0 +catapultando catapultar VMG0000 +catapultar catapultar VMN0000 +catapulte catapultar VMM03S0 +catapultemos catapultar VMM01P0 +catapulten catapultar VMM03P0 +catar catar VMN0000 +catastra catastrar VMM02S0 +catastrad catastrar VMM02P0 +catastrando catastrar VMG0000 +catastrar catastrar VMN0000 +catata catatar VMM02S0 +catatad catatar VMM02P0 +catatando catatar VMG0000 +catatar catatar VMN0000 +catate catatar VMM03S0 +catatemos catatar VMM01P0 +cataten catatar VMM03P0 +cate catar VMM03S0 +catea catear VMM02S0 +catead catear VMM02P0 +cateando catear VMG0000 +catear catear VMN0000 +catee catear VMM03S0 +cateemos catear VMM01P0 +cateen catear VMM03P0 +categorice categorizar VMM03S0 +categoricemos categorizar VMM01P0 +categoricen categorizar VMM03P0 +categoriza categorizar VMM02S0 +categorizad categorizar VMM02P0 +categorizando categorizar VMG0000 +categorizar categorizar VMN0000 +catemos catar VMM01P0 +caten catar VMM03P0 +catequice catequizar VMM03S0 +catequicemos catequizar VMM01P0 +catequicen catequizar VMM03P0 +catequiza catequizar VMM02S0 +catequizad catequizar VMM02P0 +catequizando catequizar VMG0000 +catequizar catequizar VMN0000 +catitea catitear VMM02S0 +catitead catitear VMM02P0 +catiteando catitear VMG0000 +catitear catitear VMN0000 +catitee catitear VMM03S0 +catiteemos catitear VMM01P0 +catiteen catitear VMM03P0 +catonice catonizar VMM03S0 +catonicemos catonizar VMM01P0 +catonicen catonizar VMM03P0 +catoniza catonizar VMM02S0 +catonizad catonizar VMM02P0 +catonizando catonizar VMG0000 +catonizar catonizar VMN0000 +cauciona caucionar VMM02S0 +caucionad caucionar VMM02P0 +caucionando caucionar VMG0000 +caucionar caucionar VMN0000 +caucione caucionar VMM03S0 +caucionemos caucionar VMM01P0 +caucionen caucionar VMM03P0 +causa causar VMM02S0 +causad causar VMM02P0 +causando causar VMG0000 +causar causar VMN0000 +cause causar VMM03S0 +causea causear VMM02S0 +causead causear VMM02P0 +causeando causear VMG0000 +causear causear VMN0000 +causee causear VMM03S0 +causeemos causear VMM01P0 +causeen causear VMM03P0 +causemos causar VMM01P0 +causen causar VMM03P0 +cautela cautelar VMM02S0 +cautelad cautelar VMM02P0 +cautelando cautelar VMG0000 +cautelar cautelar VMN0000 +cautele cautelar VMM03S0 +cautelemos cautelar VMM01P0 +cautelen cautelar VMM03P0 +cauterice cauterizar VMM03S0 +cautericemos cauterizar VMM01P0 +cautericen cauterizar VMM03P0 +cauteriza cauterizar VMM02S0 +cauterizad cauterizar VMM02P0 +cauterizando cauterizar VMG0000 +cauterizar cauterizar VMN0000 +cautiva cautivar VMM02S0 +cautivad cautivar VMM02P0 +cautivando cautivar VMG0000 +cautivar cautivar VMN0000 +cautive cautivar VMM03S0 +cautivemos cautivar VMM01P0 +cautiven cautivar VMM03P0 +cava cavar VMM02S0 +cavad cavar VMM02P0 +cavando cavar VMG0000 +cavar cavar VMN0000 +cave cavar VMM03S0 +cavemos cavar VMM01P0 +caven cavar VMM03P0 +cavila cavilar VMM02S0 +cavilad cavilar VMM02P0 +cavilando cavilar VMG0000 +cavilar cavilar VMN0000 +cavile cavilar VMM03S0 +cavilemos cavilar VMM01P0 +cavilen cavilar VMM03P0 +cayapea cayapear VMM02S0 +cayapead cayapear VMM02P0 +cayapeando cayapear VMG0000 +cayapear cayapear VMN0000 +cayapee cayapear VMM03S0 +cayapeemos cayapear VMM01P0 +cayapeen cayapear VMM03P0 +cayendo caer VMG0000 +caza cazar VMM02S0 +cazad cazar VMM02P0 +cazando cazar VMG0000 +cazar cazar VMN0000 +cazcalea cazcalear VMM02S0 +cazcalead cazcalear VMM02P0 +cazcaleando cazcalear VMG0000 +cazcalear cazcalear VMN0000 +cazcalee cazcalear VMM03S0 +cazcaleemos cazcalear VMM01P0 +cazcaleen cazcalear VMM03P0 +cazoletea cazoletear VMM02S0 +cazoletead cazoletear VMM02P0 +cazoleteando cazoletear VMG0000 +cazoletear cazoletear VMN0000 +cazoletee cazoletear VMM03S0 +cazoleteemos cazoletear VMM01P0 +cazoleteen cazoletear VMM03P0 +cazumbra cazumbrar VMM02S0 +cazumbrad cazumbrar VMM02P0 +cazumbrando cazumbrar VMG0000 +cazumbrar cazumbrar VMN0000 +cazumbre cazumbrar VMM03S0 +cazumbremos cazumbrar VMM01P0 +cazumbren cazumbrar VMM03P0 +cañonea cañonear VMM02S0 +cañonead cañonear VMM02P0 +cañoneando cañonear VMG0000 +cañonear cañonear VMN0000 +cañonee cañonear VMM03S0 +cañoneemos cañonear VMM01P0 +cañoneen cañonear VMM03P0 +ceba cebar VMM02S0 +cebad cebar VMM02P0 +cebada cebadar VMM02S0 +cebadad cebadar VMM02P0 +cebadando cebadar VMG0000 +cebadar cebadar VMN0000 +cebade cebadar VMM03S0 +cebademos cebadar VMM01P0 +cebaden cebadar VMM03P0 +cebando cebar VMG0000 +cebar cebar VMN0000 +cebe cebar VMM03S0 +cebemos cebar VMM01P0 +ceben cebar VMM03P0 +cecea cecear VMM02S0 +cecead cecear VMM02P0 +ceceando cecear VMG0000 +cecear cecear VMN0000 +cecee cecear VMM03S0 +ceceemos cecear VMM01P0 +ceceen cecear VMM03P0 +ceda ceder VMM03S0 +cedacea cedacear VMM02S0 +cedacead cedacear VMM02P0 +cedaceando cedacear VMG0000 +cedacear cedacear VMN0000 +cedacee cedacear VMM03S0 +cedaceemos cedacear VMM01P0 +cedaceen cedacear VMM03P0 +cedamos ceder VMM01P0 +cedan ceder VMM03P0 +cede ceder VMM02S0 +ceded ceder VMM02P0 +ceder ceder VMN0000 +cediendo ceder VMG0000 +cegad cegar VMM02P0 +cegando cegar VMG0000 +cegar cegar VMN0000 +ceguemos cegar VMM01P0 +ceja cejar VMM02S0 +cejad cejar VMM02P0 +cejando cejar VMG0000 +cejar cejar VMN0000 +ceje cejar VMM03S0 +cejemos cejar VMM01P0 +cejen cejar VMM03P0 +cela celar VMM02S0 +celad celar VMM02P0 +celando celar VMG0000 +celar celar VMN0000 +cele celar VMM03S0 +celebra celebrar VMM02S0 +celebrad celebrar VMM02P0 +celebrando celebrar VMG0000 +celebrar celebrar VMN0000 +celebre celebrar VMM03S0 +celebremos celebrar VMM01P0 +celebren celebrar VMM03P0 +celemos celar VMM01P0 +celen celar VMM03P0 +cellisquea cellisquear VMM02S0 +cellisquead cellisquear VMM02P0 +cellisqueando cellisquear VMG0000 +cellisquear cellisquear VMN0000 +cellisquee cellisquear VMM03S0 +cellisqueemos cellisquear VMM01P0 +cellisqueen cellisquear VMM03P0 +cementa cementar VMM02S0 +cementad cementar VMM02P0 +cementando cementar VMG0000 +cementar cementar VMN0000 +cemente cementar VMM03S0 +cementemos cementar VMM01P0 +cementen cementar VMM03P0 +cena cenar VMM02S0 +cenad cenar VMM02P0 +cenando cenar VMG0000 +cenar cenar VMN0000 +cencerrea cencerrear VMM02S0 +cencerread cencerrear VMM02P0 +cencerreando cencerrear VMG0000 +cencerrear cencerrear VMN0000 +cencerree cencerrear VMM03S0 +cencerreemos cencerrear VMM01P0 +cencerreen cencerrear VMM03P0 +cendra cendrar VMM02S0 +cendrad cendrar VMM02P0 +cendrando cendrar VMG0000 +cendrar cendrar VMN0000 +cendre cendrar VMM03S0 +cendremos cendrar VMM01P0 +cendren cendrar VMM03P0 +cene cenar VMM03S0 +cenemos cenar VMM01P0 +cenen cenar VMM03P0 +censa censar VMM02S0 +censad censar VMM02P0 +censando censar VMG0000 +censar censar VMN0000 +cense censar VMM03S0 +censemos censar VMM01P0 +censen censar VMM03P0 +censura censurar VMM02S0 +censurad censurar VMM02P0 +censurando censurar VMG0000 +censurar censurar VMN0000 +censure censurar VMM03S0 +censuremos censurar VMM01P0 +censuren censurar VMM03P0 +centella centellar VMM02S0 +centellad centellar VMM02P0 +centellando centellar VMG0000 +centellar centellar VMN0000 +centelle centellar VMM03S0 +centellea centellear VMM02S0 +centellead centellear VMM02P0 +centelleando centellear VMG0000 +centellear centellear VMN0000 +centellee centellear VMM03S0 +centelleemos centellear VMM01P0 +centelleen centellear VMM03P0 +centellemos centellar VMM01P0 +centellen centellar VMM03P0 +centona centonar VMM02S0 +centonad centonar VMM02P0 +centonando centonar VMG0000 +centonar centonar VMN0000 +centone centonar VMM03S0 +centonemos centonar VMM01P0 +centonen centonar VMM03P0 +centra centrar VMM02S0 +centrad centrar VMM02P0 +centralice centralizar VMM03S0 +centralicemos centralizar VMM01P0 +centralicen centralizar VMM03P0 +centraliza centralizar VMM02S0 +centralizad centralizar VMM02P0 +centralizando centralizar VMG0000 +centralizar centralizar VMN0000 +centrando centrar VMG0000 +centrar centrar VMN0000 +centre centrar VMM03S0 +centremos centrar VMM01P0 +centren centrar VMM03P0 +centrifuga centrifugar VMM02S0 +centrifugad centrifugar VMM02P0 +centrifugando centrifugar VMG0000 +centrifugar centrifugar VMN0000 +centrifugue centrifugar VMM03S0 +centrifuguemos centrifugar VMM01P0 +centrifuguen centrifugar VMM03P0 +centuplica centuplicar VMM02S0 +centuplicad centuplicar VMM02P0 +centuplicando centuplicar VMG0000 +centuplicar centuplicar VMN0000 +centuplique centuplicar VMM03S0 +centupliquemos centuplicar VMM01P0 +centupliquen centuplicar VMM03P0 +cepilla cepillar VMM02S0 +cepillad cepillar VMM02P0 +cepillando cepillar VMG0000 +cepillar cepillar VMN0000 +cepille cepillar VMM03S0 +cepillemos cepillar VMM01P0 +cepillen cepillar VMM03P0 +cerca cercar VMM02S0 +cercad cercar VMM02P0 +cercando cercar VMG0000 +cercar cercar VMN0000 +cercea cercear VMM02S0 +cercead cercear VMM02P0 +cerceando cercear VMG0000 +cercear cercear VMN0000 +cercena cercenar VMM02S0 +cercenad cercenar VMM02P0 +cercenando cercenar VMG0000 +cercenar cercenar VMN0000 +cercene cercenar VMM03S0 +cercenemos cercenar VMM01P0 +cercenen cercenar VMM03P0 +cercha cerchar VMM02S0 +cerchad cerchar VMM02P0 +cerchando cerchar VMG0000 +cerchar cerchar VMN0000 +cerche cerchar VMM03S0 +cerchea cerchear VMM02S0 +cerchead cerchear VMM02P0 +cercheando cerchear VMG0000 +cerchear cerchear VMN0000 +cerchee cerchear VMM03S0 +cercheemos cerchear VMM01P0 +cercheen cerchear VMM03P0 +cerchemos cerchar VMM01P0 +cerchen cerchar VMM03P0 +cerciora cerciorar VMM02S0 +cerciorad cerciorar VMM02P0 +cerciorando cerciorar VMG0000 +cerciorar cerciorar VMN0000 +cerciore cerciorar VMM03S0 +cercioremos cerciorar VMM01P0 +cercioren cerciorar VMM03P0 +cerdea cerdear VMM02S0 +cerdead cerdear VMM02P0 +cerdeando cerdear VMG0000 +cerdear cerdear VMN0000 +cerdee cerdear VMM03S0 +cerdeemos cerdear VMM01P0 +cerdeen cerdear VMM03P0 +cernamos cerner VMM01P0 +cernamos cernir VMM01P0 +cerned cerner VMM02P0 +cerner cerner VMN0000 +cernid cernir VMM02P0 +cerniendo cerner VMG0000 +cerniendo cernir VMG0000 +cernir cernir VMN0000 +cerotea cerotear VMM02S0 +cerotead cerotear VMM02P0 +ceroteando cerotear VMG0000 +cerotear cerotear VMN0000 +cerotee cerotear VMM03S0 +ceroteemos cerotear VMM01P0 +ceroteen cerotear VMM03P0 +cerque cercar VMM03S0 +cerquemos cercar VMM01P0 +cerquen cercar VMM03P0 +cerrad cerrar VMM02P0 +cerrajea cerrajear VMM02S0 +cerrajead cerrajear VMM02P0 +cerrajeando cerrajear VMG0000 +cerrajear cerrajear VMN0000 +cerrajee cerrajear VMM03S0 +cerrajeemos cerrajear VMM01P0 +cerrajeen cerrajear VMM03P0 +cerrando cerrar VMG0000 +cerrar cerrar VMN0000 +cerremos cerrar VMM01P0 +certifica certificar VMM02S0 +certificad certificar VMM02P0 +certificando certificar VMG0000 +certificar certificar VMN0000 +certifique certificar VMM03S0 +certifiquemos certificar VMM01P0 +certifiquen certificar VMM03P0 +cesa cesar VMM02S0 +cesad cesar VMM02P0 +cesando cesar VMG0000 +cesar cesar VMN0000 +cese cesar VMM03S0 +cesemos cesar VMM01P0 +cesen cesar VMM03P0 +cespita cespitar VMM02S0 +cespitad cespitar VMM02P0 +cespitando cespitar VMG0000 +cespitar cespitar VMN0000 +cespite cespitar VMM03S0 +cespitemos cespitar VMM01P0 +cespiten cespitar VMM03P0 +ceñid ceñir VMM02P0 +ceñir ceñir VMN0000 +chacanea chacanear VMM02S0 +chacanead chacanear VMM02P0 +chacaneando chacanear VMG0000 +chacanear chacanear VMN0000 +chacanee chacanear VMM03S0 +chacaneemos chacanear VMM01P0 +chacaneen chacanear VMM03P0 +chace chazar VMM03S0 +chacemos chazar VMM01P0 +chacen chazar VMM03P0 +chacharea chacharear VMM02S0 +chacharead chacharear VMM02P0 +chachareando chacharear VMG0000 +chacharear chacharear VMN0000 +chacharee chacharear VMM03S0 +chachareemos chacharear VMM01P0 +chachareen chacharear VMM03P0 +chacolotea chacolotear VMM02S0 +chacolotead chacolotear VMM02P0 +chacoloteando chacolotear VMG0000 +chacolotear chacolotear VMN0000 +chacolotee chacolotear VMM03S0 +chacoloteemos chacolotear VMM01P0 +chacoloteen chacolotear VMM03P0 +chacotea chacotear VMM02S0 +chacotead chacotear VMM02P0 +chacoteando chacotear VMG0000 +chacotear chacotear VMN0000 +chacotee chacotear VMM03S0 +chacoteemos chacotear VMM01P0 +chacoteen chacotear VMM03P0 +chafa chafar VMM02S0 +chafad chafar VMM02P0 +chafalla chafallar VMM02S0 +chafallad chafallar VMM02P0 +chafallando chafallar VMG0000 +chafallar chafallar VMN0000 +chafalle chafallar VMM03S0 +chafallemos chafallar VMM01P0 +chafallen chafallar VMM03P0 +chafando chafar VMG0000 +chafar chafar VMN0000 +chafarrina chafarrinar VMM02S0 +chafarrinad chafarrinar VMM02P0 +chafarrinando chafarrinar VMG0000 +chafarrinar chafarrinar VMN0000 +chafarrine chafarrinar VMM03S0 +chafarrinemos chafarrinar VMM01P0 +chafarrinen chafarrinar VMM03P0 +chafe chafar VMM03S0 +chafemos chafar VMM01P0 +chafen chafar VMM03P0 +chaflana chaflanar VMM02S0 +chaflanad chaflanar VMM02P0 +chaflanando chaflanar VMG0000 +chaflanar chaflanar VMN0000 +chaflane chaflanar VMM03S0 +chaflanemos chaflanar VMM01P0 +chaflanen chaflanar VMM03P0 +chala chalar VMM02S0 +chalad chalar VMM02P0 +chalando chalar VMG0000 +chalanea chalanear VMM02S0 +chalanead chalanear VMM02P0 +chalaneando chalanear VMG0000 +chalanear chalanear VMN0000 +chalanee chalanear VMM03S0 +chalaneemos chalanear VMM01P0 +chalaneen chalanear VMM03P0 +chalar chalar VMN0000 +chale chalar VMM03S0 +chalemos chalar VMM01P0 +chalen chalar VMM03P0 +chamarilea chamarilear VMM02S0 +chamarilead chamarilear VMM02P0 +chamarileando chamarilear VMG0000 +chamarilear chamarilear VMN0000 +chamarilee chamarilear VMM03S0 +chamarileemos chamarilear VMM01P0 +chamarileen chamarilear VMM03P0 +champurra champurrar VMM02S0 +champurrad champurrar VMM02P0 +champurrando champurrar VMG0000 +champurrar champurrar VMN0000 +champurre champurrar VMM03S0 +champurremos champurrar VMM01P0 +champurren champurrar VMM03P0 +chamusca chamuscar VMM02S0 +chamuscad chamuscar VMM02P0 +chamuscando chamuscar VMG0000 +chamuscar chamuscar VMN0000 +chamusque chamuscar VMM03S0 +chamusquemos chamuscar VMM01P0 +chamusquen chamuscar VMM03P0 +chanca chancar VMM02S0 +chancad chancar VMM02P0 +chancando chancar VMG0000 +chancar chancar VMN0000 +chancea chancear VMM02S0 +chancead chancear VMM02P0 +chanceando chancear VMG0000 +chancear chancear VMN0000 +chancee chancear VMM03S0 +chanceemos chancear VMM01P0 +chanceen chancear VMM03P0 +chancletea chancletear VMM02S0 +chancletead chancletear VMM02P0 +chancleteando chancletear VMG0000 +chancletear chancletear VMN0000 +chancletee chancletear VMM03S0 +chancleteemos chancletear VMM01P0 +chancleteen chancletear VMM03P0 +changa changar VMM02S0 +changad changar VMM02P0 +changando changar VMG0000 +changar changar VMN0000 +changue changar VMM03S0 +changuemos changar VMM01P0 +changuen changar VMM03P0 +chanque chancar VMM03S0 +chanquemos chancar VMM01P0 +chanquen chancar VMM03P0 +chantajea chantajear VMM02S0 +chantajead chantajear VMM02P0 +chantajeando chantajear VMG0000 +chantajear chantajear VMN0000 +chantajee chantajear VMM03S0 +chantajeemos chantajear VMM01P0 +chantajeen chantajear VMM03P0 +chapa chapar VMM02S0 +chapad chapar VMM02P0 +chapalea chapalear VMM02S0 +chapalead chapalear VMM02P0 +chapaleando chapalear VMG0000 +chapalear chapalear VMN0000 +chapalee chapalear VMM03S0 +chapaleemos chapalear VMM01P0 +chapaleen chapalear VMM03P0 +chapando chapar VMG0000 +chapar chapar VMN0000 +chaparrea chaparrear VMM02S0 +chaparread chaparrear VMM02P0 +chaparreando chaparrear VMG0000 +chaparrear chaparrear VMN0000 +chaparree chaparrear VMM03S0 +chaparreemos chaparrear VMM01P0 +chaparreen chaparrear VMM03P0 +chape chapar VMM03S0 +chapea chapear VMM02S0 +chapead chapear VMM02P0 +chapeando chapear VMG0000 +chapear chapear VMN0000 +chapeca chapecar VMM02S0 +chapecad chapecar VMM02P0 +chapecando chapecar VMG0000 +chapecar chapecar VMN0000 +chapee chapear VMM03S0 +chapeemos chapear VMM01P0 +chapeen chapear VMM03P0 +chapemos chapar VMM01P0 +chapen chapar VMM03P0 +chapeque chapecar VMM03S0 +chapequemos chapecar VMM01P0 +chapequen chapecar VMM03P0 +chapoda chapodar VMM02S0 +chapodad chapodar VMM02P0 +chapodando chapodar VMG0000 +chapodar chapodar VMN0000 +chapode chapodar VMM03S0 +chapodemos chapodar VMM01P0 +chapoden chapodar VMM03P0 +chapotea chapotear VMM02S0 +chapotead chapotear VMM02P0 +chapoteando chapotear VMG0000 +chapotear chapotear VMN0000 +chapotee chapotear VMM03S0 +chapoteemos chapotear VMM01P0 +chapoteen chapotear VMM03P0 +chapuce chapuzar VMM03S0 +chapucea chapucear VMM02S0 +chapucead chapucear VMM02P0 +chapuceando chapucear VMG0000 +chapucear chapucear VMN0000 +chapucee chapucear VMM03S0 +chapuceemos chapucear VMM01P0 +chapuceen chapucear VMM03P0 +chapucemos chapuzar VMM01P0 +chapucen chapuzar VMM03P0 +chapurra chapurrar VMM02S0 +chapurrad chapurrar VMM02P0 +chapurrando chapurrar VMG0000 +chapurrar chapurrar VMN0000 +chapurre chapurrar VMM03S0 +chapurrea chapurrear VMM02S0 +chapurread chapurrear VMM02P0 +chapurreando chapurrear VMG0000 +chapurrear chapurrear VMN0000 +chapurree chapurrear VMM03S0 +chapurreemos chapurrear VMM01P0 +chapurreen chapurrear VMM03P0 +chapurremos chapurrar VMM01P0 +chapurren chapurrar VMM03P0 +chapuza chapuzar VMM02S0 +chapuzad chapuzar VMM02P0 +chapuzando chapuzar VMG0000 +chapuzar chapuzar VMN0000 +chaquetea chaquetear VMM02S0 +chaquetead chaquetear VMM02P0 +chaqueteando chaquetear VMG0000 +chaquetear chaquetear VMN0000 +chaquetee chaquetear VMM03S0 +chaqueteemos chaquetear VMM01P0 +chaqueteen chaquetear VMM03P0 +charla charlar VMM02S0 +charlad charlar VMM02P0 +charlando charlar VMG0000 +charlar charlar VMN0000 +charlatanea charlatanear VMM02S0 +charlatanead charlatanear VMM02P0 +charlataneando charlatanear VMG0000 +charlatanear charlatanear VMN0000 +charlatanee charlatanear VMM03S0 +charlataneemos charlatanear VMM01P0 +charlataneen charlatanear VMM03P0 +charle charlar VMM03S0 +charlemos charlar VMM01P0 +charlen charlar VMM03P0 +charlotea charlotear VMM02S0 +charlotead charlotear VMM02P0 +charloteando charlotear VMG0000 +charlotear charlotear VMN0000 +charlotee charlotear VMM03S0 +charloteemos charlotear VMM01P0 +charloteen charlotear VMM03P0 +charola charolar VMM02S0 +charolad charolar VMM02P0 +charolando charolar VMG0000 +charolar charolar VMN0000 +charole charolar VMM03S0 +charolemos charolar VMM01P0 +charolen charolar VMM03P0 +charquea charquear VMM02S0 +charquead charquear VMM02P0 +charqueando charquear VMG0000 +charquear charquear VMN0000 +charquee charquear VMM03S0 +charqueemos charquear VMM01P0 +charqueen charquear VMM03P0 +charranea charranear VMM02S0 +charranead charranear VMM02P0 +charraneando charranear VMG0000 +charranear charranear VMN0000 +charranee charranear VMM03S0 +charraneemos charranear VMM01P0 +charraneen charranear VMM03P0 +chasca chascar VMM02S0 +chascad chascar VMM02P0 +chascando chascar VMG0000 +chascar chascar VMN0000 +chasque chascar VMM03S0 +chasquea chasquear VMM02S0 +chasquead chasquear VMM02P0 +chasqueando chasquear VMG0000 +chasquear chasquear VMN0000 +chasquee chasquear VMM03S0 +chasqueemos chasquear VMM01P0 +chasqueen chasquear VMM03P0 +chasquemos chascar VMM01P0 +chasquen chascar VMM03P0 +chaza chazar VMM02S0 +chazad chazar VMM02P0 +chazando chazar VMG0000 +chazar chazar VMN0000 +chercha cherchar VMM02S0 +cherchad cherchar VMM02P0 +cherchando cherchar VMG0000 +cherchar cherchar VMN0000 +cherche cherchar VMM03S0 +cherchemos cherchar VMM01P0 +cherchen cherchar VMM03P0 +chicanea chicanear VMM02S0 +chicanead chicanear VMM02P0 +chicaneando chicanear VMG0000 +chicanear chicanear VMN0000 +chicanee chicanear VMM03S0 +chicaneemos chicanear VMM01P0 +chicaneen chicanear VMM03P0 +chichea chichear VMM02S0 +chichead chichear VMM02P0 +chicheando chichear VMG0000 +chichear chichear VMN0000 +chichee chichear VMM03S0 +chicheemos chichear VMM01P0 +chicheen chichear VMM03P0 +chiclea chiclear VMM02S0 +chiclead chiclear VMM02P0 +chicleando chiclear VMG0000 +chiclear chiclear VMN0000 +chiclee chiclear VMM03S0 +chicleemos chiclear VMM01P0 +chicleen chiclear VMM03P0 +chicolea chicolear VMM02S0 +chicolead chicolear VMM02P0 +chicoleando chicolear VMG0000 +chicolear chicolear VMN0000 +chicolee chicolear VMM03S0 +chicoleemos chicolear VMM01P0 +chicoleen chicolear VMM03P0 +chicotea chicotear VMM02S0 +chicotead chicotear VMM02P0 +chicoteando chicotear VMG0000 +chicotear chicotear VMN0000 +chicotee chicotear VMM03S0 +chicoteemos chicotear VMM01P0 +chicoteen chicotear VMM03P0 +chifla chiflar VMM02S0 +chiflad chiflar VMM02P0 +chiflando chiflar VMG0000 +chiflar chiflar VMN0000 +chifle chiflar VMM03S0 +chiflemos chiflar VMM01P0 +chiflen chiflar VMM03P0 +chilla chillar VMM02S0 +chillad chillar VMM02P0 +chillando chillar VMG0000 +chillar chillar VMN0000 +chille chillar VMM03S0 +chillemos chillar VMM01P0 +chillen chillar VMM03P0 +chincha chinchar VMM02S0 +chinchad chinchar VMM02P0 +chinchando chinchar VMG0000 +chinchar chinchar VMN0000 +chinche chinchar VMM03S0 +chinchemos chinchar VMM01P0 +chinchen chinchar VMM03P0 +chinea chinear VMM02S0 +chinead chinear VMM02P0 +chineando chinear VMG0000 +chinear chinear VMN0000 +chinee chinear VMM03S0 +chineemos chinear VMM01P0 +chineen chinear VMM03P0 +chinga chingar VMM02S0 +chingad chingar VMM02P0 +chingando chingar VMG0000 +chingar chingar VMN0000 +chingue chingar VMM03S0 +chinguemos chingar VMM01P0 +chinguen chingar VMM03P0 +chiquea chiquear VMM02S0 +chiquead chiquear VMM02P0 +chiqueando chiquear VMG0000 +chiquear chiquear VMN0000 +chiquee chiquear VMM03S0 +chiqueemos chiquear VMM01P0 +chiqueen chiquear VMM03P0 +chiripea chiripear VMM02S0 +chiripead chiripear VMM02P0 +chiripeando chiripear VMG0000 +chiripear chiripear VMN0000 +chiripee chiripear VMM03S0 +chiripeemos chiripear VMM01P0 +chiripeen chiripear VMM03P0 +chirla chirlar VMM02S0 +chirlad chirlar VMM02P0 +chirlando chirlar VMG0000 +chirlar chirlar VMN0000 +chirle chirlar VMM03S0 +chirlemos chirlar VMM01P0 +chirlen chirlar VMM03P0 +chirriad chirriar VMM02P0 +chirriando chirriar VMG0000 +chirriar chirriar VMN0000 +chirriemos chirriar VMM01P0 +chirría chirriar VMM02S0 +chirríe chirriar VMM03S0 +chirríen chirriar VMM03P0 +chisguetea chisguetear VMM02S0 +chisguetead chisguetear VMM02P0 +chisgueteando chisguetear VMG0000 +chisguetear chisguetear VMN0000 +chisguetee chisguetear VMM03S0 +chisgueteemos chisguetear VMM01P0 +chisgueteen chisguetear VMM03P0 +chismea chismear VMM02S0 +chismead chismear VMM02P0 +chismeando chismear VMG0000 +chismear chismear VMN0000 +chismee chismear VMM03S0 +chismeemos chismear VMM01P0 +chismeen chismear VMM03P0 +chismorrea chismorrear VMM02S0 +chismorread chismorrear VMM02P0 +chismorreando chismorrear VMG0000 +chismorrear chismorrear VMN0000 +chismorree chismorrear VMM03S0 +chismorreemos chismorrear VMM01P0 +chismorreen chismorrear VMM03P0 +chispea chispear VMM02S0 +chispead chispear VMM02P0 +chispeando chispear VMG0000 +chispear chispear VMN0000 +chispee chispear VMM03S0 +chispeemos chispear VMM01P0 +chispeen chispear VMM03P0 +chisporrotea chisporrotear VMM02S0 +chisporrotead chisporrotear VMM02P0 +chisporroteando chisporrotear VMG0000 +chisporrotear chisporrotear VMN0000 +chisporrotee chisporrotear VMM03S0 +chisporroteemos chisporrotear VMM01P0 +chisporroteen chisporrotear VMM03P0 +chista chistar VMM02S0 +chistad chistar VMM02P0 +chistando chistar VMG0000 +chistar chistar VMN0000 +chiste chistar VMM03S0 +chistemos chistar VMM01P0 +chisten chistar VMM03P0 +chiva chivar VMM02S0 +chivad chivar VMM02P0 +chivando chivar VMG0000 +chivar chivar VMN0000 +chivatea chivatear VMM02S0 +chivatead chivatear VMM02P0 +chivateando chivatear VMG0000 +chivatear chivatear VMN0000 +chivatee chivatear VMM03S0 +chivateemos chivatear VMM01P0 +chivateen chivatear VMM03P0 +chive chivar VMM03S0 +chivemos chivar VMM01P0 +chiven chivar VMM03P0 +choca chocar VMM02S0 +chocad chocar VMM02P0 +chocando chocar VMG0000 +chocar chocar VMN0000 +chocarrea chocarrear VMM02S0 +chocarread chocarrear VMM02P0 +chocarreando chocarrear VMG0000 +chocarrear chocarrear VMN0000 +chocarree chocarrear VMM03S0 +chocarreemos chocarrear VMM01P0 +chocarreen chocarrear VMM03P0 +chochea chochear VMM02S0 +chochead chochear VMM02P0 +chocheando chochear VMG0000 +chochear chochear VMN0000 +chochee chochear VMM03S0 +chocheemos chochear VMM01P0 +chocheen chochear VMM03P0 +chonguea chonguear VMM02S0 +chonguead chonguear VMM02P0 +chongueando chonguear VMG0000 +chonguear chonguear VMN0000 +chonguee chonguear VMM03S0 +chongueemos chonguear VMM01P0 +chongueen chonguear VMM03P0 +choque chocar VMM03S0 +choquemos chocar VMM01P0 +choquen chocar VMM03P0 +chorrea chorrear VMM02S0 +chorread chorrear VMM02P0 +chorreando chorrear VMG0000 +chorrear chorrear VMN0000 +chorree chorrear VMM03S0 +chorreemos chorrear VMM01P0 +chorreen chorrear VMM03P0 +chotea chotear VMM02S0 +chotead chotear VMM02P0 +choteando chotear VMG0000 +chotear chotear VMN0000 +chotee chotear VMM03S0 +choteemos chotear VMM01P0 +choteen chotear VMM03P0 +chozpa chozpar VMM02S0 +chozpad chozpar VMM02P0 +chozpando chozpar VMG0000 +chozpar chozpar VMN0000 +chozpe chozpar VMM03S0 +chozpemos chozpar VMM01P0 +chozpen chozpar VMM03P0 +chuchea chuchear VMM02S0 +chuchead chuchear VMM02P0 +chucheando chuchear VMG0000 +chuchear chuchear VMN0000 +chuchee chuchear VMM03S0 +chucheemos chuchear VMM01P0 +chucheen chuchear VMM03P0 +chufletea chufletear VMM02S0 +chufletead chufletear VMM02P0 +chufleteando chufletear VMG0000 +chufletear chufletear VMN0000 +chufletee chufletear VMM03S0 +chufleteemos chufletear VMM01P0 +chufleteen chufletear VMM03P0 +chulea chulear VMM02S0 +chulead chulear VMM02P0 +chuleando chulear VMG0000 +chulear chulear VMN0000 +chulee chulear VMM03S0 +chuleemos chulear VMM01P0 +chuleen chulear VMM03P0 +chuma chumar VMM02S0 +chumad chumar VMM02P0 +chumando chumar VMG0000 +chumar chumar VMN0000 +chume chumar VMM03S0 +chumemos chumar VMM01P0 +chumen chumar VMM03P0 +chunguea chunguear VMM02S0 +chunguead chunguear VMM02P0 +chungueando chunguear VMG0000 +chunguear chunguear VMN0000 +chunguee chunguear VMM03S0 +chungueemos chunguear VMM01P0 +chungueen chunguear VMM03P0 +chupa chupar VMM02S0 +chupad chupar VMM02P0 +chupando chupar VMG0000 +chupar chupar VMN0000 +chupe chupar VMM03S0 +chupemos chupar VMM01P0 +chupen chupar VMM03P0 +chupetea chupetear VMM02S0 +chupetead chupetear VMM02P0 +chupeteando chupetear VMG0000 +chupetear chupetear VMN0000 +chupetee chupetear VMM03S0 +chupeteemos chupetear VMM01P0 +chupeteen chupetear VMM03P0 +churrusca churruscar VMM02S0 +churruscad churruscar VMM02P0 +churruscando churruscar VMG0000 +churruscar churruscar VMN0000 +churrusque churruscar VMM03S0 +churrusquemos churruscar VMM01P0 +churrusquen churruscar VMM03P0 +chuta chutar VMM02S0 +chutad chutar VMM02P0 +chutando chutar VMG0000 +chutar chutar VMN0000 +chute chutar VMM03S0 +chutemos chutar VMM01P0 +chuten chutar VMM03P0 +ciad ciar VMM02P0 +ciando ciar VMG0000 +ciar ciar VMN0000 +cicatea cicatear VMM02S0 +cicatead cicatear VMM02P0 +cicateando cicatear VMG0000 +cicatear cicatear VMN0000 +cicatee cicatear VMM03S0 +cicateemos cicatear VMM01P0 +cicateen cicatear VMM03P0 +cicatrice cicatrizar VMM03S0 +cicatricemos cicatrizar VMM01P0 +cicatricen cicatrizar VMM03P0 +cicatriza cicatrizar VMM02S0 +cicatrizad cicatrizar VMM02P0 +cicatrizando cicatrizar VMG0000 +cicatrizar cicatrizar VMN0000 +cicla ciclar VMM02S0 +ciclad ciclar VMM02P0 +ciclando ciclar VMG0000 +ciclar ciclar VMN0000 +cicle ciclar VMM03S0 +ciclemos ciclar VMM01P0 +ciclen ciclar VMM03P0 +ciega cegar VMM02S0 +ciegue cegar VMM03S0 +cieguen cegar VMM03P0 +ciemos ciar VMM01P0 +cierna cerner VMM03S0 +cierna cernir VMM03S0 +ciernan cerner VMM03P0 +ciernan cernir VMM03P0 +cierne cerner VMM02S0 +cierne cernir VMM02S0 +cierra cerrar VMM02S0 +cierre cerrar VMM03S0 +cierren cerrar VMM03P0 +cifra cifrar VMM02S0 +cifrad cifrar VMM02P0 +cifrando cifrar VMG0000 +cifrar cifrar VMN0000 +cifre cifrar VMM03S0 +cifremos cifrar VMM01P0 +cifren cifrar VMM03P0 +ciguata ciguatar VMM02S0 +ciguatad ciguatar VMM02P0 +ciguatando ciguatar VMG0000 +ciguatar ciguatar VMN0000 +ciguate ciguatar VMM03S0 +ciguatemos ciguatar VMM01P0 +ciguaten ciguatar VMM03P0 +cilindra cilindrar VMM02S0 +cilindrad cilindrar VMM02P0 +cilindrando cilindrar VMG0000 +cilindrar cilindrar VMN0000 +cilindre cilindrar VMM03S0 +cilindremos cilindrar VMM01P0 +cilindren cilindrar VMM03P0 +cimbra cimbrar VMM02S0 +cimbrad cimbrar VMM02P0 +cimbrando cimbrar VMG0000 +cimbrar cimbrar VMN0000 +cimbre cimbrar VMM03S0 +cimbrea cimbrear VMM02S0 +cimbread cimbrear VMM02P0 +cimbreando cimbrear VMG0000 +cimbrear cimbrear VMN0000 +cimbree cimbrear VMM03S0 +cimbreemos cimbrear VMM01P0 +cimbreen cimbrear VMM03P0 +cimbremos cimbrar VMM01P0 +cimbren cimbrar VMM03P0 +cimentad cimentar VMM02P0 +cimentando cimentar VMG0000 +cimentar cimentar VMN0000 +cimentemos cimentar VMM01P0 +cimienta cimentar VMM02S0 +cimiente cimentar VMM03S0 +cimienten cimentar VMM03P0 +cinca cincar VMM02S0 +cincad cincar VMM02P0 +cincando cincar VMG0000 +cincar cincar VMN0000 +cincela cincelar VMM02S0 +cincelad cincelar VMM02P0 +cincelando cincelar VMG0000 +cincelar cincelar VMN0000 +cincele cincelar VMM03S0 +cincelemos cincelar VMM01P0 +cincelen cincelar VMM03P0 +cincha cinchar VMM02S0 +cinchad cinchar VMM02P0 +cinchando cinchar VMG0000 +cinchar cinchar VMN0000 +cinche cinchar VMM03S0 +cinchemos cinchar VMM01P0 +cinchen cinchar VMM03P0 +cingla cinglar VMM02S0 +cinglad cinglar VMM02P0 +cinglando cinglar VMG0000 +cinglar cinglar VMN0000 +cingle cinglar VMM03S0 +cinglemos cinglar VMM01P0 +cinglen cinglar VMM03P0 +cinque cincar VMM03S0 +cinquemos cincar VMM01P0 +cinquen cincar VMM03P0 +cinta cintar VMM02S0 +cintad cintar VMM02P0 +cintando cintar VMG0000 +cintar cintar VMN0000 +cintarea cintarear VMM02S0 +cintaread cintarear VMM02P0 +cintareando cintarear VMG0000 +cintarear cintarear VMN0000 +cintaree cintarear VMM03S0 +cintareemos cintarear VMM01P0 +cintareen cintarear VMM03P0 +cinte cintar VMM03S0 +cintemos cintar VMM01P0 +cinten cintar VMM03P0 +cintila cintilar VMM02S0 +cintilad cintilar VMM02P0 +cintilando cintilar VMG0000 +cintilar cintilar VMN0000 +cintile cintilar VMM03S0 +cintilemos cintilar VMM01P0 +cintilen cintilar VMM03P0 +circula circular VMM02S0 +circulad circular VMM02P0 +circulando circular VMG0000 +circular circular VMN0000 +circule circular VMM03S0 +circulemos circular VMM01P0 +circulen circular VMM03P0 +circuncida circuncidar VMM02S0 +circuncidad circuncidar VMM02P0 +circuncidando circuncidar VMG0000 +circuncidar circuncidar VMN0000 +circuncide circuncidar VMM03S0 +circuncidemos circuncidar VMM01P0 +circunciden circuncidar VMM03P0 +circunda circundar VMM02S0 +circundad circundar VMM02P0 +circundando circundar VMG0000 +circundar circundar VMN0000 +circunde circundar VMM03S0 +circundemos circundar VMM01P0 +circunden circundar VMM03P0 +circunferid circunferir VMM02P0 +circunferir circunferir VMN0000 +circunfiera circunferir VMM03S0 +circunfieran circunferir VMM03P0 +circunfiere circunferir VMM02S0 +circunfiramos circunferir VMM01P0 +circunfiriendo circunferir VMG0000 +circunnavega circunnavegar VMM02S0 +circunnavegad circunnavegar VMM02P0 +circunnavegando circunnavegar VMG0000 +circunnavegar circunnavegar VMN0000 +circunnavegue circunnavegar VMM03S0 +circunnaveguemos circunnavegar VMM01P0 +circunnaveguen circunnavegar VMM03P0 +circunscriba circunscribir VMM03S0 +circunscribamos circunscribir VMM01P0 +circunscriban circunscribir VMM03P0 +circunscribe circunscribir VMM02S0 +circunscribid circunscribir VMM02P0 +circunscribiendo circunscribir VMG0000 +circunscribir circunscribir VMN0000 +circunvala circunvalar VMM02S0 +circunvalad circunvalar VMM02P0 +circunvalando circunvalar VMG0000 +circunvalar circunvalar VMN0000 +circunvale circunvalar VMM03S0 +circunvalemos circunvalar VMM01P0 +circunvalen circunvalar VMM03P0 +circunvolad circunvolar VMM02P0 +circunvolando circunvolar VMG0000 +circunvolar circunvolar VMN0000 +circunvolemos circunvolar VMM01P0 +circunvuela circunvolar VMM02S0 +circunvuele circunvolar VMM03S0 +circunvuelen circunvolar VMM03P0 +cisca ciscar VMM02S0 +ciscad ciscar VMM02P0 +ciscando ciscar VMG0000 +ciscar ciscar VMN0000 +cisque ciscar VMM03S0 +cisquemos ciscar VMM01P0 +cisquen ciscar VMM03P0 +cita citar VMM02S0 +citad citar VMM02P0 +citando citar VMG0000 +citar citar VMN0000 +cite citar VMM03S0 +citemos citar VMM01P0 +citen citar VMM03P0 +civilice civilizar VMM03S0 +civilicemos civilizar VMM01P0 +civilicen civilizar VMM03P0 +civiliza civilizar VMM02S0 +civilizad civilizar VMM02P0 +civilizando civilizar VMG0000 +civilizar civilizar VMN0000 +cizalla cizallar VMM02S0 +cizallad cizallar VMM02P0 +cizallando cizallar VMG0000 +cizallar cizallar VMN0000 +cizalle cizallar VMM03S0 +cizallemos cizallar VMM01P0 +cizallen cizallar VMM03P0 +cizaña cizañar VMM02S0 +cizañad cizañar VMM02P0 +cizañando cizañar VMG0000 +cizañar cizañar VMN0000 +cizañe cizañar VMM03S0 +cizañea cizañear VMM02S0 +cizañead cizañear VMM02P0 +cizañeando cizañear VMG0000 +cizañear cizañear VMN0000 +cizañemos cizañar VMM01P0 +cizañen cizañar VMM03P0 +ciña ceñir VMM03S0 +ciñamos ceñir VMM01P0 +ciñan ceñir VMM03P0 +ciñe ceñir VMM02S0 +ciñendo ceñir VMG0000 +clama clamar VMM02S0 +clamad clamar VMM02P0 +clamando clamar VMG0000 +clamar clamar VMN0000 +clame clamar VMM03S0 +clamemos clamar VMM01P0 +clamen clamar VMM03P0 +clamorea clamorear VMM02S0 +clamoread clamorear VMM02P0 +clamoreando clamorear VMG0000 +clamorear clamorear VMN0000 +clamoree clamorear VMM03S0 +clamoreemos clamorear VMM01P0 +clamoreen clamorear VMM03P0 +clarea clarear VMM02S0 +claread clarear VMM02P0 +clareando clarear VMG0000 +clarear clarear VMN0000 +clarece clarecer VMM02S0 +clareced clarecer VMM02P0 +clarecer clarecer VMN0000 +clareciendo clarecer VMG0000 +claree clarear VMM03S0 +clareemos clarear VMM01P0 +clareen clarear VMM03P0 +clarezca clarecer VMM03S0 +clarezcamos clarecer VMM01P0 +clarezcan clarecer VMM03P0 +clarifica clarificar VMM02S0 +clarificad clarificar VMM02P0 +clarificando clarificar VMG0000 +clarificar clarificar VMN0000 +clarifique clarificar VMM03S0 +clarifiquemos clarificar VMM01P0 +clarifiquen clarificar VMM03P0 +clasifica clasificar VMM02S0 +clasificad clasificar VMM02P0 +clasificando clasificar VMG0000 +clasificar clasificar VMN0000 +clasifique clasificar VMM03S0 +clasifiquemos clasificar VMM01P0 +clasifiquen clasificar VMM03P0 +claudica claudicar VMM02S0 +claudicad claudicar VMM02P0 +claudicando claudicar VMG0000 +claudicar claudicar VMN0000 +claudique claudicar VMM03S0 +claudiquemos claudicar VMM01P0 +claudiquen claudicar VMM03P0 +clausula clausular VMM02S0 +clausulad clausular VMM02P0 +clausulando clausular VMG0000 +clausular clausular VMN0000 +clausule clausular VMM03S0 +clausulemos clausular VMM01P0 +clausulen clausular VMM03P0 +clausura clausurar VMM02S0 +clausurad clausurar VMM02P0 +clausurando clausurar VMG0000 +clausurar clausurar VMN0000 +clausure clausurar VMM03S0 +clausuremos clausurar VMM01P0 +clausuren clausurar VMM03P0 +clava clavar VMM02S0 +clavad clavar VMM02P0 +clavando clavar VMG0000 +clavar clavar VMN0000 +clave clavar VMM03S0 +clavemos clavar VMM01P0 +claven clavar VMM03P0 +clavetea clavetear VMM02S0 +clavetead clavetear VMM02P0 +claveteando clavetear VMG0000 +clavetear clavetear VMN0000 +clavetee clavetear VMM03S0 +claveteemos clavetear VMM01P0 +claveteen clavetear VMM03P0 +climatice climatizar VMM03S0 +climaticemos climatizar VMM01P0 +climaticen climatizar VMM03P0 +climatiza climatizar VMM02S0 +climatizad climatizar VMM02P0 +climatizando climatizar VMG0000 +climatizar climatizar VMN0000 +clisa clisar VMM02S0 +clisad clisar VMM02P0 +clisando clisar VMG0000 +clisar clisar VMN0000 +clise clisar VMM03S0 +clisemos clisar VMM01P0 +clisen clisar VMM03P0 +clocad clocar VMM02P0 +clocando clocar VMG0000 +clocar clocar VMN0000 +clona clonar VMM02S0 +clonad clonar VMM02P0 +clonando clonar VMG0000 +clonar clonar VMN0000 +clone clonar VMM03S0 +clonemos clonar VMM01P0 +clonen clonar VMM03P0 +cloquea cloquear VMM02S0 +cloquead cloquear VMM02P0 +cloqueando cloquear VMG0000 +cloquear cloquear VMN0000 +cloquee cloquear VMM03S0 +cloqueemos cloquear VMM01P0 +cloqueen cloquear VMM03P0 +cloquemos clocar VMM01P0 +cloroformice cloroformizar VMM03S0 +cloroformicemos cloroformizar VMM01P0 +cloroformicen cloroformizar VMM03P0 +cloroformiza cloroformizar VMM02S0 +cloroformizad cloroformizar VMM02P0 +cloroformizando cloroformizar VMG0000 +cloroformizar cloroformizar VMN0000 +clorura clorurar VMM02S0 +clorurad clorurar VMM02P0 +clorurando clorurar VMG0000 +clorurar clorurar VMN0000 +clorure clorurar VMM03S0 +cloruremos clorurar VMM01P0 +cloruren clorurar VMM03P0 +clueca clocar VMM02S0 +clueque clocar VMM03S0 +cluequen clocar VMM03P0 +coacciona coaccionar VMM02S0 +coaccionad coaccionar VMM02P0 +coaccionando coaccionar VMG0000 +coaccionar coaccionar VMN0000 +coaccione coaccionar VMM03S0 +coaccionemos coaccionar VMM01P0 +coaccionen coaccionar VMM03P0 +coacerva coacervar VMM02S0 +coacervad coacervar VMM02P0 +coacervando coacervar VMG0000 +coacervar coacervar VMN0000 +coacerve coacervar VMM03S0 +coacervemos coacervar VMM01P0 +coacerven coacervar VMM03P0 +coaduna coadunar VMM02S0 +coadunad coadunar VMM02P0 +coadunando coadunar VMG0000 +coadunar coadunar VMN0000 +coadune coadunar VMM03S0 +coadunemos coadunar VMM01P0 +coadunen coadunar VMM03P0 +coadyuva coadyuvar VMM02S0 +coadyuvad coadyuvar VMM02P0 +coadyuvando coadyuvar VMG0000 +coadyuvar coadyuvar VMN0000 +coadyuve coadyuvar VMM03S0 +coadyuvemos coadyuvar VMM01P0 +coadyuven coadyuvar VMM03P0 +coagula coagular VMM02S0 +coagulad coagular VMM02P0 +coagulando coagular VMG0000 +coagular coagular VMN0000 +coagule coagular VMM03S0 +coagulemos coagular VMM01P0 +coagulen coagular VMM03P0 +coarta coartar VMM02S0 +coartad coartar VMM02P0 +coartando coartar VMG0000 +coartar coartar VMN0000 +coarte coartar VMM03S0 +coartemos coartar VMM01P0 +coarten coartar VMM03P0 +cobalta cobaltar VMM02S0 +cobaltad cobaltar VMM02P0 +cobaltando cobaltar VMG0000 +cobaltar cobaltar VMN0000 +cobalte cobaltar VMM03S0 +cobaltemos cobaltar VMM01P0 +cobalten cobaltar VMM03P0 +cobija cobijar VMM02S0 +cobijad cobijar VMM02P0 +cobijando cobijar VMG0000 +cobijar cobijar VMN0000 +cobije cobijar VMM03S0 +cobijemos cobijar VMM01P0 +cobijen cobijar VMM03P0 +cobra cobrar VMM02S0 +cobrad cobrar VMM02P0 +cobrando cobrar VMG0000 +cobrar cobrar VMN0000 +cobre cobrar VMM03S0 +cobrea cobrear VMM02S0 +cobread cobrear VMM02P0 +cobreando cobrear VMG0000 +cobrear cobrear VMN0000 +cobree cobrear VMM03S0 +cobreemos cobrear VMM01P0 +cobreen cobrear VMM03P0 +cobremos cobrar VMM01P0 +cobren cobrar VMM03P0 +coca cocar VMM02S0 +cocad cocar VMM02P0 +cocando cocar VMG0000 +cocar cocar VMN0000 +cocara cocarar VMM02S0 +cocarad cocarar VMM02P0 +cocarando cocarar VMG0000 +cocarar cocarar VMN0000 +cocare cocarar VMM03S0 +cocaremos cocarar VMM01P0 +cocaren cocarar VMM03P0 +cocea cocear VMM02S0 +cocead cocear VMM02P0 +coceando cocear VMG0000 +cocear cocear VMN0000 +coced cocer VMM02P0 +cocee cocear VMM03S0 +coceemos cocear VMM01P0 +coceen cocear VMM03P0 +cocer cocer VMN0000 +cochea cochear VMM02S0 +cochead cochear VMM02P0 +cocheando cochear VMG0000 +cochear cochear VMN0000 +cochee cochear VMM03S0 +cocheemos cochear VMM01P0 +cocheen cochear VMM03P0 +cociendo cocer VMG0000 +cocina cocinar VMM02S0 +cocinad cocinar VMM02P0 +cocinando cocinar VMG0000 +cocinar cocinar VMN0000 +cocine cocinar VMM03S0 +cocinemos cocinar VMM01P0 +cocinen cocinar VMM03P0 +codea codear VMM02S0 +codead codear VMM02P0 +codeando codear VMG0000 +codear codear VMN0000 +codee codear VMM03S0 +codeemos codear VMM01P0 +codeen codear VMM03P0 +codicia codiciar VMM02S0 +codiciad codiciar VMM02P0 +codiciando codiciar VMG0000 +codiciar codiciar VMN0000 +codicie codiciar VMM03S0 +codiciemos codiciar VMM01P0 +codicien codiciar VMM03P0 +codifica codificar VMM02S0 +codificad codificar VMM02P0 +codificando codificar VMG0000 +codificar codificar VMN0000 +codifique codificar VMM03S0 +codifiquemos codificar VMM01P0 +codifiquen codificar VMM03P0 +codirige codirigir VMM02S0 +codirigid codirigir VMM02P0 +codirigiendo codirigir VMG0000 +codirigir codirigir VMN0000 +codirija codirigir VMM03S0 +codirijamos codirigir VMM01P0 +codirijan codirigir VMM03P0 +coerce coercer VMM02S0 +coerced coercer VMM02P0 +coercer coercer VMN0000 +coerciendo coercer VMG0000 +coerza coercer VMM03S0 +coerzamos coercer VMM01P0 +coerzan coercer VMM03P0 +coexista coexistir VMM03S0 +coexistamos coexistir VMM01P0 +coexistan coexistir VMM03P0 +coexiste coexistir VMM02S0 +coexistid coexistir VMM02P0 +coexistiendo coexistir VMG0000 +coexistir coexistir VMN0000 +coge coger VMM02S0 +coged coger VMM02P0 +coger coger VMN0000 +cogiendo coger VMG0000 +cogita cogitar VMM02S0 +cogitad cogitar VMM02P0 +cogitando cogitar VMG0000 +cogitar cogitar VMN0000 +cogite cogitar VMM03S0 +cogitemos cogitar VMM01P0 +cogiten cogitar VMM03P0 +cogoberna cogobernar VMM02S0 +cogobernad cogobernar VMM02P0 +cogobernando cogobernar VMG0000 +cogobernar cogobernar VMN0000 +cogoberne cogobernar VMM03S0 +cogobernemos cogobernar VMM01P0 +cogobernen cogobernar VMM03P0 +cohabita cohabitar VMM02S0 +cohabitad cohabitar VMM02P0 +cohabitando cohabitar VMG0000 +cohabitar cohabitar VMN0000 +cohabite cohabitar VMM03S0 +cohabitemos cohabitar VMM01P0 +cohabiten cohabitar VMM03P0 +cohecha cohechar VMM02S0 +cohechad cohechar VMM02P0 +cohechando cohechar VMG0000 +cohechar cohechar VMN0000 +coheche cohechar VMM03S0 +cohechemos cohechar VMM01P0 +cohechen cohechar VMM03P0 +cohesiona cohesionar VMM02S0 +cohesionad cohesionar VMM02P0 +cohesionando cohesionar VMG0000 +cohesionar cohesionar VMN0000 +cohesione cohesionar VMM03S0 +cohesionemos cohesionar VMM01P0 +cohesionen cohesionar VMM03P0 +cohibamos cohibir VMM01P0 +cohibid cohibir VMM02P0 +cohibiendo cohibir VMG0000 +cohibir cohibir VMN0000 +cohoba cohobar VMM02S0 +cohobad cohobar VMM02P0 +cohobando cohobar VMG0000 +cohobar cohobar VMN0000 +cohobe cohobar VMM03S0 +cohobemos cohobar VMM01P0 +cohoben cohobar VMM03P0 +cohonesta cohonestar VMM02S0 +cohonestad cohonestar VMM02P0 +cohonestando cohonestar VMG0000 +cohonestar cohonestar VMN0000 +cohoneste cohonestar VMM03S0 +cohonestemos cohonestar VMM01P0 +cohonesten cohonestar VMM03P0 +cohíba cohibir VMM03S0 +cohíban cohibir VMM03P0 +cohíbe cohibir VMM02S0 +coincida coincidir VMM03S0 +coincidamos coincidir VMM01P0 +coincidan coincidir VMM03P0 +coincide coincidir VMM02S0 +coincidid coincidir VMM02P0 +coincidiendo coincidir VMG0000 +coincidir coincidir VMN0000 +coja coger VMM03S0 +cojamos coger VMM01P0 +cojan coger VMM03P0 +cojea cojear VMM02S0 +cojead cojear VMM02P0 +cojeando cojear VMG0000 +cojear cojear VMN0000 +cojee cojear VMM03S0 +cojeemos cojear VMM01P0 +cojeen cojear VMM03P0 +colabora colaborar VMM02S0 +colaborad colaborar VMM02P0 +colaborando colaborar VMG0000 +colaborar colaborar VMN0000 +colabore colaborar VMM03S0 +colaboremos colaborar VMM01P0 +colaboren colaborar VMM03P0 +colaciona colacionar VMM02S0 +colacionad colacionar VMM02P0 +colacionando colacionar VMG0000 +colacionar colacionar VMN0000 +colacione colacionar VMM03S0 +colacionemos colacionar VMM01P0 +colacionen colacionar VMM03P0 +colad colar VMM02P0 +colando colar VMG0000 +colapsa colapsar VMM02S0 +colapsad colapsar VMM02P0 +colapsando colapsar VMG0000 +colapsar colapsar VMN0000 +colapse colapsar VMM03S0 +colapsemos colapsar VMM01P0 +colapsen colapsar VMM03P0 +colar colar VMN0000 +colcha colchar VMM02S0 +colchad colchar VMM02P0 +colchando colchar VMG0000 +colchar colchar VMN0000 +colche colchar VMM03S0 +colchemos colchar VMM01P0 +colchen colchar VMM03P0 +colea colear VMM02S0 +colead colear VMM02P0 +coleando colear VMG0000 +colear colear VMN0000 +colecciona coleccionar VMM02S0 +coleccionad coleccionar VMM02P0 +coleccionando coleccionar VMG0000 +coleccionar coleccionar VMN0000 +coleccione coleccionar VMM03S0 +coleccionemos coleccionar VMM01P0 +coleccionen coleccionar VMM03P0 +colecta colectar VMM02S0 +colectad colectar VMM02P0 +colectando colectar VMG0000 +colectar colectar VMN0000 +colecte colectar VMM03S0 +colectemos colectar VMM01P0 +colecten colectar VMM03P0 +colectivice colectivizar VMM03S0 +colectivicemos colectivizar VMM01P0 +colectivicen colectivizar VMM03P0 +colectiviza colectivizar VMM02S0 +colectivizad colectivizar VMM02P0 +colectivizando colectivizar VMG0000 +colectivizar colectivizar VMN0000 +colee colear VMM03S0 +coleemos colear VMM01P0 +coleen colear VMM03P0 +colegia colegiar VMM02S0 +colegiad colegiar VMM02P0 +colegiando colegiar VMG0000 +colegiar colegiar VMN0000 +colegid colegir VMM02P0 +colegie colegiar VMM03S0 +colegiemos colegiar VMM01P0 +colegien colegiar VMM03P0 +colegir colegir VMN0000 +colemos colar VMM01P0 +colgad colgar VMM02P0 +colgando colgar VMG0000 +colgar colgar VMN0000 +colguemos colgar VMM01P0 +coliga coligar VMM02S0 +coligad coligar VMM02P0 +coligando coligar VMG0000 +coligar coligar VMN0000 +colige colegir VMM02S0 +coligiendo colegir VMG0000 +coligue coligar VMM03S0 +coliguemos coligar VMM01P0 +coliguen coligar VMM03P0 +colija colegir VMM03S0 +colijamos colegir VMM01P0 +colijan colegir VMM03P0 +colima colimar VMM02S0 +colimad colimar VMM02P0 +colimando colimar VMG0000 +colimar colimar VMN0000 +colime colimar VMM03S0 +colimemos colimar VMM01P0 +colimen colimar VMM03P0 +colinda colindar VMM02S0 +colindad colindar VMM02P0 +colindando colindar VMG0000 +colindar colindar VMN0000 +colinde colindar VMM03S0 +colindemos colindar VMM01P0 +colinden colindar VMM03P0 +colisiona colisionar VMM02S0 +colisionad colisionar VMM02P0 +colisionando colisionar VMG0000 +colisionar colisionar VMN0000 +colisione colisionar VMM03S0 +colisionemos colisionar VMM01P0 +colisionen colisionar VMM03P0 +colma colmar VMM02S0 +colmad colmar VMM02P0 +colmando colmar VMG0000 +colmar colmar VMN0000 +colme colmar VMM03S0 +colmemos colmar VMM01P0 +colmen colmar VMM03P0 +coloca colocar VMM02S0 +colocad colocar VMM02P0 +colocando colocar VMG0000 +colocar colocar VMN0000 +colonice colonizar VMM03S0 +colonicemos colonizar VMM01P0 +colonicen colonizar VMM03P0 +coloniza colonizar VMM02S0 +colonizad colonizar VMM02P0 +colonizando colonizar VMG0000 +colonizar colonizar VMN0000 +coloque colocar VMM03S0 +coloquemos colocar VMM01P0 +coloquen colocar VMM03P0 +colora colorar VMM02S0 +colora colorir VMM03S0 +colorad colorar VMM02P0 +coloramos colorir VMM01P0 +coloran colorir VMM03P0 +colorando colorar VMG0000 +colorar colorar VMN0000 +colore colorar VMM03S0 +colore colorir VMM02S0 +colorea colorear VMM02S0 +coloread colorear VMM02P0 +coloreando colorear VMG0000 +colorear colorear VMN0000 +coloree colorear VMM03S0 +coloreemos colorear VMM01P0 +coloreen colorear VMM03P0 +coloremos colorar VMM01P0 +coloren colorar VMM03P0 +colorid colorir VMM02P0 +coloriendo colorir VMG0000 +colorir colorir VMN0000 +coluda coludir VMM03S0 +coludamos coludir VMM01P0 +coludan coludir VMM03P0 +colude coludir VMM02S0 +coludid coludir VMM02P0 +coludiendo coludir VMG0000 +coludir coludir VMN0000 +columbra columbrar VMM02S0 +columbrad columbrar VMM02P0 +columbrando columbrar VMG0000 +columbrar columbrar VMN0000 +columbre columbrar VMM03S0 +columbremos columbrar VMM01P0 +columbren columbrar VMM03P0 +columpia columpiar VMM02S0 +columpiad columpiar VMM02P0 +columpiando columpiar VMG0000 +columpiar columpiar VMN0000 +columpie columpiar VMM03S0 +columpiemos columpiar VMM01P0 +columpien columpiar VMM03P0 +coma comer VMM03S0 +comadrea comadrear VMM02S0 +comadread comadrear VMM02P0 +comadreando comadrear VMG0000 +comadrear comadrear VMN0000 +comadree comadrear VMM03S0 +comadreemos comadrear VMM01P0 +comadreen comadrear VMM03P0 +comamos comer VMM01P0 +coman comer VMM03P0 +comanda comandar VMM02S0 +comandad comandar VMM02P0 +comandando comandar VMG0000 +comandar comandar VMN0000 +comande comandar VMM03S0 +comandemos comandar VMM01P0 +comanden comandar VMM03P0 +comandita comanditar VMM02S0 +comanditad comanditar VMM02P0 +comanditando comanditar VMG0000 +comanditar comanditar VMN0000 +comandite comanditar VMM03S0 +comanditemos comanditar VMM01P0 +comanditen comanditar VMM03P0 +comarca comarcar VMM02S0 +comarcad comarcar VMM02P0 +comarcando comarcar VMG0000 +comarcar comarcar VMN0000 +comarque comarcar VMM03S0 +comarquemos comarcar VMM01P0 +comarquen comarcar VMM03P0 +comba combar VMM02S0 +combad combar VMM02P0 +combando combar VMG0000 +combar combar VMN0000 +combata combatir VMM03S0 +combatamos combatir VMM01P0 +combatan combatir VMM03P0 +combate combatir VMM02S0 +combatid combatir VMM02P0 +combatiendo combatir VMG0000 +combatir combatir VMN0000 +combe combar VMM03S0 +combemos combar VMM01P0 +comben combar VMM03P0 +combina combinar VMM02S0 +combinad combinar VMM02P0 +combinando combinar VMG0000 +combinar combinar VMN0000 +combine combinar VMM03S0 +combinemos combinar VMM01P0 +combinen combinar VMM03P0 +come comer VMM02S0 +comed comer VMM02P0 +comedia comediar VMM02S0 +comediad comediar VMM02P0 +comediando comediar VMG0000 +comediar comediar VMN0000 +comedid comedir VMM02P0 +comedie comediar VMM03S0 +comediemos comediar VMM01P0 +comedien comediar VMM03P0 +comedir comedir VMN0000 +comencemos comenzar VMM01P0 +comenta comentar VMM02S0 +comentad comentar VMM02P0 +comentando comentar VMG0000 +comentar comentar VMN0000 +comente comentar VMM03S0 +comentemos comentar VMM01P0 +comenten comentar VMM03P0 +comenzad comenzar VMM02P0 +comenzando comenzar VMG0000 +comenzar comenzar VMN0000 +comer comer VMN0000 +comercia comerciar VMM02S0 +comerciad comerciar VMM02P0 +comercialice comercializar VMM03S0 +comercialicemos comercializar VMM01P0 +comercialicen comercializar VMM03P0 +comercializa comercializar VMM02S0 +comercializad comercializar VMM02P0 +comercializando comercializar VMG0000 +comercializar comercializar VMN0000 +comerciando comerciar VMG0000 +comerciar comerciar VMN0000 +comercie comerciar VMM03S0 +comerciemos comerciar VMM01P0 +comercien comerciar VMM03P0 +cometa cometer VMM03S0 +cometamos cometer VMM01P0 +cometan cometer VMM03P0 +comete cometer VMM02S0 +cometed cometer VMM02P0 +cometer cometer VMN0000 +cometiendo cometer VMG0000 +comida comedir VMM03S0 +comidamos comedir VMM01P0 +comidan comedir VMM03P0 +comide comedir VMM02S0 +comidiendo comedir VMG0000 +comience comenzar VMM03S0 +comiencen comenzar VMM03P0 +comiendo comer VMG0000 +comienza comenzar VMM02S0 +cominea cominear VMM02S0 +cominead cominear VMM02P0 +comineando cominear VMG0000 +cominear cominear VMN0000 +cominee cominear VMM03S0 +comineemos cominear VMM01P0 +comineen cominear VMM03P0 +comisa comisar VMM02S0 +comisad comisar VMM02P0 +comisando comisar VMG0000 +comisar comisar VMN0000 +comisca comiscar VMM02S0 +comiscad comiscar VMM02P0 +comiscando comiscar VMG0000 +comiscar comiscar VMN0000 +comise comisar VMM03S0 +comisemos comisar VMM01P0 +comisen comisar VMM03P0 +comisiona comisionar VMM02S0 +comisionad comisionar VMM02P0 +comisionando comisionar VMG0000 +comisionar comisionar VMN0000 +comisione comisionar VMM03S0 +comisionemos comisionar VMM01P0 +comisionen comisionar VMM03P0 +comisque comiscar VMM03S0 +comisquea comisquear VMM02S0 +comisquead comisquear VMM02P0 +comisqueando comisquear VMG0000 +comisquear comisquear VMN0000 +comisquee comisquear VMM03S0 +comisqueemos comisquear VMM01P0 +comisqueen comisquear VMM03P0 +comisquemos comiscar VMM01P0 +comisquen comiscar VMM03P0 +compacta compactar VMM02S0 +compactad compactar VMM02P0 +compactando compactar VMG0000 +compactar compactar VMN0000 +compacte compactar VMM03S0 +compactemos compactar VMM01P0 +compacten compactar VMM03P0 +compadece compadecer VMM02S0 +compadeced compadecer VMM02P0 +compadecer compadecer VMN0000 +compadeciendo compadecer VMG0000 +compadezca compadecer VMM03S0 +compadezcamos compadecer VMM01P0 +compadezcan compadecer VMM03P0 +compadra compadrar VMM02S0 +compadrad compadrar VMM02P0 +compadrando compadrar VMG0000 +compadrar compadrar VMN0000 +compadre compadrar VMM03S0 +compadrea compadrear VMM02S0 +compadread compadrear VMM02P0 +compadreando compadrear VMG0000 +compadrear compadrear VMN0000 +compadree compadrear VMM03S0 +compadreemos compadrear VMM01P0 +compadreen compadrear VMM03P0 +compadremos compadrar VMM01P0 +compadren compadrar VMM03P0 +compagina compaginar VMM02S0 +compaginad compaginar VMM02P0 +compaginando compaginar VMG0000 +compaginar compaginar VMN0000 +compagine compaginar VMM03S0 +compaginemos compaginar VMM01P0 +compaginen compaginar VMM03P0 +compara comparar VMM02S0 +comparad comparar VMM02P0 +comparando comparar VMG0000 +comparar comparar VMN0000 +compare comparar VMM03S0 +comparece comparecer VMM02S0 +compareced comparecer VMM02P0 +comparecer comparecer VMN0000 +compareciendo comparecer VMG0000 +comparemos comparar VMM01P0 +comparen comparar VMM03P0 +comparezca comparecer VMM03S0 +comparezcamos comparecer VMM01P0 +comparezcan comparecer VMM03P0 +comparta compartir VMM03S0 +compartamos compartir VMM01P0 +compartan compartir VMM03P0 +comparte compartir VMM02S0 +compartid compartir VMM02P0 +compartiendo compartir VMG0000 +compartimenta compartimentar VMM02S0 +compartimentad compartimentar VMM02P0 +compartimentando compartimentar VMG0000 +compartimentar compartimentar VMN0000 +compartimente compartimentar VMM03S0 +compartimentemos compartimentar VMM01P0 +compartimenten compartimentar VMM03P0 +compartir compartir VMN0000 +compasa compasar VMM02S0 +compasad compasar VMM02P0 +compasando compasar VMG0000 +compasar compasar VMN0000 +compase compasar VMM03S0 +compasemos compasar VMM01P0 +compasen compasar VMM03P0 +compatibilice compatibilizar VMM03S0 +compatibilicemos compatibilizar VMM01P0 +compatibilicen compatibilizar VMM03P0 +compatibiliza compatibilizar VMM02S0 +compatibilizad compatibilizar VMM02P0 +compatibilizando compatibilizar VMG0000 +compatibilizar compatibilizar VMN0000 +compela compeler VMM03S0 +compelamos compeler VMM01P0 +compelan compeler VMM03P0 +compele compeler VMM02S0 +compeled compeler VMM02P0 +compeler compeler VMN0000 +compeliendo compeler VMG0000 +compendia compendiar VMM02S0 +compendiad compendiar VMM02P0 +compendiando compendiar VMG0000 +compendiar compendiar VMN0000 +compendice compendizar VMM03S0 +compendicemos compendizar VMM01P0 +compendicen compendizar VMM03P0 +compendie compendiar VMM03S0 +compendiemos compendiar VMM01P0 +compendien compendiar VMM03P0 +compendiza compendizar VMM02S0 +compendizad compendizar VMM02P0 +compendizando compendizar VMG0000 +compendizar compendizar VMN0000 +compenetra compenetrar VMM02S0 +compenetrad compenetrar VMM02P0 +compenetrando compenetrar VMG0000 +compenetrar compenetrar VMN0000 +compenetre compenetrar VMM03S0 +compenetremos compenetrar VMM01P0 +compenetren compenetrar VMM03P0 +compensa compensar VMM02S0 +compensad compensar VMM02P0 +compensando compensar VMG0000 +compensar compensar VMN0000 +compense compensar VMM03S0 +compensemos compensar VMM01P0 +compensen compensar VMM03P0 +competa competer VMM03S0 +competamos competer VMM01P0 +competan competer VMM03P0 +compete competer VMM02S0 +competed competer VMM02P0 +competer competer VMN0000 +competid competir VMM02P0 +competiendo competer VMG0000 +competir competir VMN0000 +compila compilar VMM02S0 +compilad compilar VMM02P0 +compilando compilar VMG0000 +compilar compilar VMN0000 +compile compilar VMM03S0 +compilemos compilar VMM01P0 +compilen compilar VMM03P0 +compita competir VMM03S0 +compitamos competir VMM01P0 +compitan competir VMM03P0 +compite competir VMM02S0 +compitiendo competir VMG0000 +complace complacer VMM02S0 +complaced complacer VMM02P0 +complacer complacer VMN0000 +complaciendo complacer VMG0000 +complazca complacer VMM03S0 +complazcamos complacer VMM01P0 +complazcan complacer VMM03P0 +complementa complementar VMM02S0 +complementad complementar VMM02P0 +complementando complementar VMG0000 +complementar complementar VMN0000 +complemente complementar VMM03S0 +complementemos complementar VMM01P0 +complementen complementar VMM03P0 +completa completar VMM02S0 +completad completar VMM02P0 +completando completar VMG0000 +completar completar VMN0000 +complete completar VMM03S0 +completemos completar VMM01P0 +completen completar VMM03P0 +complica complicar VMM02S0 +complicad complicar VMM02P0 +complicando complicar VMG0000 +complicar complicar VMN0000 +complique complicar VMM03S0 +compliquemos complicar VMM01P0 +compliquen complicar VMM03P0 +complota complotar VMM02S0 +complotad complotar VMM02P0 +complotando complotar VMG0000 +complotar complotar VMN0000 +complote complotar VMM03S0 +complotemos complotar VMM01P0 +comploten complotar VMM03P0 +componed componer VMM02P0 +componer componer VMN0000 +componga componer VMM03S0 +compongamos componer VMM01P0 +compongan componer VMM03P0 +componiendo componer VMG0000 +comporta comportar VMM02S0 +comportad comportar VMM02P0 +comportando comportar VMG0000 +comportar comportar VMN0000 +comporte comportar VMM03S0 +comportemos comportar VMM01P0 +comporten comportar VMM03P0 +compra comprar VMM02S0 +comprad comprar VMM02P0 +comprando comprar VMG0000 +comprar comprar VMN0000 +compre comprar VMM03S0 +compremos comprar VMM01P0 +compren comprar VMM03P0 +comprenda comprender VMM03S0 +comprendamos comprender VMM01P0 +comprendan comprender VMM03P0 +comprende comprender VMM02S0 +comprended comprender VMM02P0 +comprender comprender VMN0000 +comprendiendo comprender VMG0000 +comprima comprimir VMM03S0 +comprimamos comprimir VMM01P0 +compriman comprimir VMM03P0 +comprime comprimir VMM02S0 +comprimid comprimir VMM02P0 +comprimiendo comprimir VMG0000 +comprimir comprimir VMN0000 +comprobad comprobar VMM02P0 +comprobando comprobar VMG0000 +comprobar comprobar VMN0000 +comprobemos comprobar VMM01P0 +comprometa comprometer VMM03S0 +comprometamos comprometer VMM01P0 +comprometan comprometer VMM03P0 +compromete comprometer VMM02S0 +comprometed comprometer VMM02P0 +comprometer comprometer VMN0000 +comprometiendo comprometer VMG0000 +comprueba comprobar VMM02S0 +compruebe comprobar VMM03S0 +comprueben comprobar VMM03P0 +compulsa compulsar VMM02S0 +compulsad compulsar VMM02P0 +compulsando compulsar VMG0000 +compulsar compulsar VMN0000 +compulse compulsar VMM03S0 +compulsemos compulsar VMM01P0 +compulsen compulsar VMM03P0 +compunge compungir VMM02S0 +compungid compungir VMM02P0 +compungiendo compungir VMG0000 +compungir compungir VMN0000 +compunja compungir VMM03S0 +compunjamos compungir VMM01P0 +compunjan compungir VMM03P0 +computa computar VMM02S0 +computad computar VMM02P0 +computando computar VMG0000 +computar computar VMN0000 +compute computar VMM03S0 +computemos computar VMM01P0 +computen computar VMM03P0 +compón componer VMM02S0 +comulga comulgar VMM02S0 +comulgad comulgar VMM02P0 +comulgando comulgar VMG0000 +comulgar comulgar VMN0000 +comulgue comulgar VMM03S0 +comulguemos comulgar VMM01P0 +comulguen comulgar VMM03P0 +comunica comunicar VMM02S0 +comunicad comunicar VMM02P0 +comunicando comunicar VMG0000 +comunicar comunicar VMN0000 +comunique comunicar VMM03S0 +comuniquemos comunicar VMM01P0 +comuniquen comunicar VMM03P0 +concadena concadenar VMM02S0 +concadenad concadenar VMM02P0 +concadenando concadenar VMG0000 +concadenar concadenar VMN0000 +concadene concadenar VMM03S0 +concadenemos concadenar VMM01P0 +concadenen concadenar VMM03P0 +concatena concatenar VMM02S0 +concatenad concatenar VMM02P0 +concatenando concatenar VMG0000 +concatenar concatenar VMN0000 +concatene concatenar VMM03S0 +concatenemos concatenar VMM01P0 +concatenen concatenar VMM03P0 +concebid concebir VMM02P0 +concebir concebir VMN0000 +conceda conceder VMM03S0 +concedamos conceder VMM01P0 +concedan conceder VMM03P0 +concede conceder VMM02S0 +conceded conceder VMM02P0 +conceder conceder VMN0000 +concediendo conceder VMG0000 +concelebra concelebrar VMM02S0 +concelebrad concelebrar VMM02P0 +concelebrando concelebrar VMG0000 +concelebrar concelebrar VMN0000 +concelebre concelebrar VMM03S0 +concelebremos concelebrar VMM01P0 +concelebren concelebrar VMM03P0 +concentra concentrar VMM02S0 +concentrad concentrar VMM02P0 +concentrando concentrar VMG0000 +concentrar concentrar VMN0000 +concentre concentrar VMM03S0 +concentremos concentrar VMM01P0 +concentren concentrar VMM03P0 +conceptuad conceptuar VMM02P0 +conceptualice conceptualizar VMM03S0 +conceptualicemos conceptualizar VMM01P0 +conceptualicen conceptualizar VMM03P0 +conceptualiza conceptualizar VMM02S0 +conceptualizad conceptualizar VMM02P0 +conceptualizando conceptualizar VMG0000 +conceptualizar conceptualizar VMN0000 +conceptuando conceptuar VMG0000 +conceptuar conceptuar VMN0000 +conceptuemos conceptuar VMM01P0 +conceptúa conceptuar VMM02S0 +conceptúe conceptuar VMM03S0 +conceptúen conceptuar VMM03P0 +concernamos concernir VMM01P0 +concernid concernir VMM02P0 +concerniendo concernir VMG0000 +concernir concernir VMN0000 +concertad concertar VMM02P0 +concertando concertar VMG0000 +concertar concertar VMN0000 +concertemos concertar VMM01P0 +conchaba conchabar VMM02S0 +conchabad conchabar VMM02P0 +conchabando conchabar VMG0000 +conchabar conchabar VMN0000 +conchabe conchabar VMM03S0 +conchabemos conchabar VMM01P0 +conchaben conchabar VMM03P0 +conciba concebir VMM03S0 +concibamos concebir VMM01P0 +conciban concebir VMM03P0 +concibe concebir VMM02S0 +concibiendo concebir VMG0000 +conciencia concienciar VMM02S0 +concienciad concienciar VMM02P0 +concienciando concienciar VMG0000 +concienciar concienciar VMN0000 +conciencie concienciar VMM03S0 +concienciemos concienciar VMM01P0 +conciencien concienciar VMM03P0 +concierna concernir VMM03S0 +conciernan concernir VMM03P0 +concierne concernir VMM02S0 +concierta concertar VMM02S0 +concierte concertar VMM03S0 +concierten concertar VMM03P0 +concilia conciliar VMM02S0 +conciliad conciliar VMM02P0 +conciliando conciliar VMG0000 +conciliar conciliar VMN0000 +concilie conciliar VMM03S0 +conciliemos conciliar VMM01P0 +concilien conciliar VMM03P0 +concita concitar VMM02S0 +concitad concitar VMM02P0 +concitando concitar VMG0000 +concitar concitar VMN0000 +concite concitar VMM03S0 +concitemos concitar VMM01P0 +conciten concitar VMM03P0 +concluid concluir VMM02P0 +concluir concluir VMN0000 +concluya concluir VMM03S0 +concluyamos concluir VMM01P0 +concluyan concluir VMM03P0 +concluye concluir VMM02S0 +concluyendo concluir VMG0000 +concoma concomer VMM03S0 +concomamos concomer VMM01P0 +concoman concomer VMM03P0 +concome concomer VMM02S0 +concomed concomer VMM02P0 +concomer concomer VMN0000 +concomiendo concomer VMG0000 +concomita concomitar VMM02S0 +concomitad concomitar VMM02P0 +concomitando concomitar VMG0000 +concomitar concomitar VMN0000 +concomite concomitar VMM03S0 +concomitemos concomitar VMM01P0 +concomiten concomitar VMM03P0 +concordad concordar VMM02P0 +concordando concordar VMG0000 +concordar concordar VMN0000 +concordemos concordar VMM01P0 +concreta concretar VMM02S0 +concretad concretar VMM02P0 +concretando concretar VMG0000 +concretar concretar VMN0000 +concrete concretar VMM03S0 +concretemos concretar VMM01P0 +concreten concretar VMM03P0 +concuerda concordar VMM02S0 +concuerde concordar VMM03S0 +concuerden concordar VMM03P0 +conculca conculcar VMM02S0 +conculcad conculcar VMM02P0 +conculcando conculcar VMG0000 +conculcar conculcar VMN0000 +conculque conculcar VMM03S0 +conculquemos conculcar VMM01P0 +conculquen conculcar VMM03P0 +concurra concurrir VMM03S0 +concurramos concurrir VMM01P0 +concurran concurrir VMM03P0 +concurre concurrir VMM02S0 +concurrid concurrir VMM02P0 +concurriendo concurrir VMG0000 +concurrir concurrir VMN0000 +concursa concursar VMM02S0 +concursad concursar VMM02P0 +concursando concursar VMG0000 +concursar concursar VMN0000 +concurse concursar VMM03S0 +concursemos concursar VMM01P0 +concursen concursar VMM03P0 +condecid condecir VMM02P0 +condecir condecir VMN0000 +condecora condecorar VMM02S0 +condecorad condecorar VMM02P0 +condecorando condecorar VMG0000 +condecorar condecorar VMN0000 +condecore condecorar VMM03S0 +condecoremos condecorar VMM01P0 +condecoren condecorar VMM03P0 +condena condenar VMM02S0 +condenad condenar VMM02P0 +condenando condenar VMG0000 +condenar condenar VMN0000 +condene condenar VMM03S0 +condenemos condenar VMM01P0 +condenen condenar VMM03P0 +condensa condensar VMM02S0 +condensad condensar VMM02P0 +condensando condensar VMG0000 +condensar condensar VMN0000 +condense condensar VMM03S0 +condensemos condensar VMM01P0 +condensen condensar VMM03P0 +condescendamos condescender VMM01P0 +condescended condescender VMM02P0 +condescender condescender VMN0000 +condescendiendo condescender VMG0000 +condescienda condescender VMM03S0 +condesciendan condescender VMM03P0 +condesciende condescender VMM02S0 +condice condecir VMM02S0 +condiciendo condecir VMG0000 +condiciona condicionar VMM02S0 +condicionad condicionar VMM02P0 +condicionando condicionar VMG0000 +condicionar condicionar VMN0000 +condicione condicionar VMM03S0 +condicionemos condicionar VMM01P0 +condicionen condicionar VMM03P0 +condiga condecir VMM03S0 +condigamos condecir VMM01P0 +condigan condecir VMM03P0 +condimenta condimentar VMM02S0 +condimentad condimentar VMM02P0 +condimentando condimentar VMG0000 +condimentar condimentar VMN0000 +condimente condimentar VMM03S0 +condimentemos condimentar VMM01P0 +condimenten condimentar VMM03P0 +condolamos condoler VMM01P0 +condoled condoler VMM02P0 +condoler condoler VMN0000 +condoliendo condoler VMG0000 +condona condonar VMM02S0 +condonad condonar VMM02P0 +condonando condonar VMG0000 +condonar condonar VMN0000 +condone condonar VMM03S0 +condonemos condonar VMM01P0 +condonen condonar VMM03P0 +conduce conducir VMM02S0 +conducid conducir VMM02P0 +conduciendo conducir VMG0000 +conducir conducir VMN0000 +conduela condoler VMM03S0 +conduelan condoler VMM03P0 +conduele condoler VMM02S0 +conduzca conducir VMM03S0 +conduzcamos conducir VMM01P0 +conduzcan conducir VMM03P0 +conecta conectar VMM02S0 +conectad conectar VMM02P0 +conectando conectar VMG0000 +conectar conectar VMN0000 +conecte conectar VMM03S0 +conectemos conectar VMM01P0 +conecten conectar VMM03P0 +conexiona conexionar VMM02S0 +conexionad conexionar VMM02P0 +conexionando conexionar VMG0000 +conexionar conexionar VMN0000 +conexione conexionar VMM03S0 +conexionemos conexionar VMM01P0 +conexionen conexionar VMM03P0 +confabula confabular VMM02S0 +confabulad confabular VMM02P0 +confabulando confabular VMG0000 +confabular confabular VMN0000 +confabule confabular VMM03S0 +confabulemos confabular VMM01P0 +confabulen confabular VMM03P0 +confecciona confeccionar VMM02S0 +confeccionad confeccionar VMM02P0 +confeccionando confeccionar VMG0000 +confeccionar confeccionar VMN0000 +confeccione confeccionar VMM03S0 +confeccionemos confeccionar VMM01P0 +confeccionen confeccionar VMM03P0 +confedera confederar VMM02S0 +confederad confederar VMM02P0 +confederando confederar VMG0000 +confederar confederar VMN0000 +confedere confederar VMM03S0 +confederemos confederar VMM01P0 +confederen confederar VMM03P0 +conferencia conferenciar VMM02S0 +conferenciad conferenciar VMM02P0 +conferenciando conferenciar VMG0000 +conferenciar conferenciar VMN0000 +conferencie conferenciar VMM03S0 +conferenciemos conferenciar VMM01P0 +conferencien conferenciar VMM03P0 +conferid conferir VMM02P0 +conferir conferir VMN0000 +confesad confesar VMM02P0 +confesando confesar VMG0000 +confesar confesar VMN0000 +confesemos confesar VMM01P0 +confiad confiar VMM02P0 +confiando confiar VMG0000 +confiar confiar VMN0000 +confiemos confiar VMM01P0 +confiera conferir VMM03S0 +confieran conferir VMM03P0 +confiere conferir VMM02S0 +confiesa confesar VMM02S0 +confiese confesar VMM03S0 +confiesen confesar VMM03P0 +configura configurar VMM02S0 +configurad configurar VMM02P0 +configurando configurar VMG0000 +configurar configurar VMN0000 +configure configurar VMM03S0 +configuremos configurar VMM01P0 +configuren configurar VMM03P0 +confina confinar VMM02S0 +confinad confinar VMM02P0 +confinando confinar VMG0000 +confinar confinar VMN0000 +confine confinar VMM03S0 +confinemos confinar VMM01P0 +confinen confinar VMM03P0 +confiramos conferir VMM01P0 +confiriendo conferir VMG0000 +confirma confirmar VMM02S0 +confirmad confirmar VMM02P0 +confirmando confirmar VMG0000 +confirmar confirmar VMN0000 +confirme confirmar VMM03S0 +confirmemos confirmar VMM01P0 +confirmen confirmar VMM03P0 +confisca confiscar VMM02S0 +confiscad confiscar VMM02P0 +confiscando confiscar VMG0000 +confiscar confiscar VMN0000 +confisque confiscar VMM03S0 +confisquemos confiscar VMM01P0 +confisquen confiscar VMM03P0 +confita confitar VMM02S0 +confitad confitar VMM02P0 +confitando confitar VMG0000 +confitar confitar VMN0000 +confite confitar VMM03S0 +confitemos confitar VMM01P0 +confiten confitar VMM03P0 +conflagra conflagrar VMM02S0 +conflagrad conflagrar VMM02P0 +conflagrando conflagrar VMG0000 +conflagrar conflagrar VMN0000 +conflagre conflagrar VMM03S0 +conflagremos conflagrar VMM01P0 +conflagren conflagrar VMM03P0 +confluid confluir VMM02P0 +confluir confluir VMN0000 +confluya confluir VMM03S0 +confluyamos confluir VMM01P0 +confluyan confluir VMM03P0 +confluye confluir VMM02S0 +confluyendo confluir VMG0000 +conforma conformar VMM02S0 +conformad conformar VMM02P0 +conformando conformar VMG0000 +conformar conformar VMN0000 +conforme conformar VMM03S0 +conformemos conformar VMM01P0 +conformen conformar VMM03P0 +conforta confortar VMM02S0 +confortad confortar VMM02P0 +confortando confortar VMG0000 +confortar confortar VMN0000 +conforte confortar VMM03S0 +confortemos confortar VMM01P0 +conforten confortar VMM03P0 +confraterna confraternar VMM02S0 +confraternad confraternar VMM02P0 +confraternando confraternar VMG0000 +confraternar confraternar VMN0000 +confraterne confraternar VMM03S0 +confraternemos confraternar VMM01P0 +confraternen confraternar VMM03P0 +confraternice confraternizar VMM03S0 +confraternicemos confraternizar VMM01P0 +confraternicen confraternizar VMM03P0 +confraterniza confraternizar VMM02S0 +confraternizad confraternizar VMM02P0 +confraternizando confraternizar VMG0000 +confraternizar confraternizar VMN0000 +confronta confrontar VMM02S0 +confrontad confrontar VMM02P0 +confrontando confrontar VMG0000 +confrontar confrontar VMN0000 +confronte confrontar VMM03S0 +confrontemos confrontar VMM01P0 +confronten confrontar VMM03P0 +confunda confundir VMM03S0 +confundamos confundir VMM01P0 +confundan confundir VMM03P0 +confunde confundir VMM02S0 +confundid confundir VMM02P0 +confundiendo confundir VMG0000 +confundir confundir VMN0000 +confuta confutar VMM02S0 +confutad confutar VMM02P0 +confutando confutar VMG0000 +confutar confutar VMN0000 +confute confutar VMM03S0 +confutemos confutar VMM01P0 +confuten confutar VMM03P0 +confía confiar VMM02S0 +confíe confiar VMM03S0 +confíen confiar VMM03P0 +congela congelar VMM02S0 +congelad congelar VMM02P0 +congelando congelar VMG0000 +congelar congelar VMN0000 +congele congelar VMM03S0 +congelemos congelar VMM01P0 +congelen congelar VMM03P0 +congenia congeniar VMM02S0 +congeniad congeniar VMM02P0 +congeniando congeniar VMG0000 +congeniar congeniar VMN0000 +congenie congeniar VMM03S0 +congeniemos congeniar VMM01P0 +congenien congeniar VMM03P0 +congestiona congestionar VMM02S0 +congestionad congestionar VMM02P0 +congestionando congestionar VMG0000 +congestionar congestionar VMN0000 +congestione congestionar VMM03S0 +congestionemos congestionar VMM01P0 +congestionen congestionar VMM03P0 +congloba conglobar VMM02S0 +conglobad conglobar VMM02P0 +conglobando conglobar VMG0000 +conglobar conglobar VMN0000 +conglobe conglobar VMM03S0 +conglobemos conglobar VMM01P0 +congloben conglobar VMM03P0 +conglomera conglomerar VMM02S0 +conglomerad conglomerar VMM02P0 +conglomerando conglomerar VMG0000 +conglomerar conglomerar VMN0000 +conglomere conglomerar VMM03S0 +conglomeremos conglomerar VMM01P0 +conglomeren conglomerar VMM03P0 +conglutina conglutinar VMM02S0 +conglutinad conglutinar VMM02P0 +conglutinando conglutinar VMG0000 +conglutinar conglutinar VMN0000 +conglutine conglutinar VMM03S0 +conglutinemos conglutinar VMM01P0 +conglutinen conglutinar VMM03P0 +congoja congojar VMM02S0 +congojad congojar VMM02P0 +congojando congojar VMG0000 +congojar congojar VMN0000 +congoje congojar VMM03S0 +congojemos congojar VMM01P0 +congojen congojar VMM03P0 +congracia congraciar VMM02S0 +congraciad congraciar VMM02P0 +congraciando congraciar VMG0000 +congraciar congraciar VMN0000 +congracie congraciar VMM03S0 +congraciemos congraciar VMM01P0 +congracien congraciar VMM03P0 +congratula congratular VMM02S0 +congratulad congratular VMM02P0 +congratulando congratular VMG0000 +congratular congratular VMN0000 +congratule congratular VMM03S0 +congratulemos congratular VMM01P0 +congratulen congratular VMM03P0 +congrega congregar VMM02S0 +congregad congregar VMM02P0 +congregando congregar VMG0000 +congregar congregar VMN0000 +congregue congregar VMM03S0 +congreguemos congregar VMM01P0 +congreguen congregar VMM03P0 +conjetura conjeturar VMM02S0 +conjeturad conjeturar VMM02P0 +conjeturando conjeturar VMG0000 +conjeturar conjeturar VMN0000 +conjeture conjeturar VMM03S0 +conjeturemos conjeturar VMM01P0 +conjeturen conjeturar VMM03P0 +conjuga conjugar VMM02S0 +conjugad conjugar VMM02P0 +conjugando conjugar VMG0000 +conjugar conjugar VMN0000 +conjugue conjugar VMM03S0 +conjuguemos conjugar VMM01P0 +conjuguen conjugar VMM03P0 +conjunta conjuntar VMM02S0 +conjuntad conjuntar VMM02P0 +conjuntando conjuntar VMG0000 +conjuntar conjuntar VMN0000 +conjunte conjuntar VMM03S0 +conjuntemos conjuntar VMM01P0 +conjunten conjuntar VMM03P0 +conjura conjurar VMM02S0 +conjurad conjurar VMM02P0 +conjuramenta conjuramentar VMM02S0 +conjuramentad conjuramentar VMM02P0 +conjuramentando conjuramentar VMG0000 +conjuramentar conjuramentar VMN0000 +conjuramente conjuramentar VMM03S0 +conjuramentemos conjuramentar VMM01P0 +conjuramenten conjuramentar VMM03P0 +conjurando conjurar VMG0000 +conjurar conjurar VMN0000 +conjure conjurar VMM03S0 +conjuremos conjurar VMM01P0 +conjuren conjurar VMM03P0 +conlleva conllevar VMM02S0 +conllevad conllevar VMM02P0 +conllevando conllevar VMG0000 +conllevar conllevar VMN0000 +conlleve conllevar VMM03S0 +conllevemos conllevar VMM01P0 +conlleven conllevar VMM03P0 +conmemora conmemorar VMM02S0 +conmemorad conmemorar VMM02P0 +conmemorando conmemorar VMG0000 +conmemorar conmemorar VMN0000 +conmemore conmemorar VMM03S0 +conmemoremos conmemorar VMM01P0 +conmemoren conmemorar VMM03P0 +conmensura conmensurar VMM02S0 +conmensurad conmensurar VMM02P0 +conmensurando conmensurar VMG0000 +conmensurar conmensurar VMN0000 +conmensure conmensurar VMM03S0 +conmensuremos conmensurar VMM01P0 +conmensuren conmensurar VMM03P0 +conmina conminar VMM02S0 +conminad conminar VMM02P0 +conminando conminar VMG0000 +conminar conminar VMN0000 +conmine conminar VMM03S0 +conminemos conminar VMM01P0 +conminen conminar VMM03P0 +conmociona conmocionar VMM02S0 +conmocionad conmocionar VMM02P0 +conmocionando conmocionar VMG0000 +conmocionar conmocionar VMN0000 +conmocione conmocionar VMM03S0 +conmocionemos conmocionar VMM01P0 +conmocionen conmocionar VMM03P0 +conmovamos conmover VMM01P0 +conmoved conmover VMM02P0 +conmover conmover VMN0000 +conmoviendo conmover VMG0000 +conmueva conmover VMM03S0 +conmuevan conmover VMM03P0 +conmueve conmover VMM02S0 +conmuta conmutar VMM02S0 +conmutad conmutar VMM02P0 +conmutando conmutar VMG0000 +conmutar conmutar VMN0000 +conmute conmutar VMM03S0 +conmutemos conmutar VMM01P0 +conmuten conmutar VMM03P0 +connaturalice connaturalizar VMM03S0 +connaturalicemos connaturalizar VMM01P0 +connaturalicen connaturalizar VMM03P0 +connaturaliza connaturalizar VMM02S0 +connaturalizad connaturalizar VMM02P0 +connaturalizando connaturalizar VMG0000 +connaturalizar connaturalizar VMN0000 +connota connotar VMM02S0 +connotad connotar VMM02P0 +connotando connotar VMG0000 +connotar connotar VMN0000 +connote connotar VMM03S0 +connotemos connotar VMM01P0 +connoten connotar VMM03P0 +conoce conocer VMM02S0 +conoced conocer VMM02P0 +conocer conocer VMN0000 +conociendo conocer VMG0000 +conozca conocer VMM03S0 +conozcamos conocer VMM01P0 +conozcan conocer VMM03P0 +conquista conquistar VMM02S0 +conquistad conquistar VMM02P0 +conquistando conquistar VMG0000 +conquistar conquistar VMN0000 +conquiste conquistar VMM03S0 +conquistemos conquistar VMM01P0 +conquisten conquistar VMM03P0 +consagra consagrar VMM02S0 +consagrad consagrar VMM02P0 +consagrando consagrar VMG0000 +consagrar consagrar VMN0000 +consagre consagrar VMM03S0 +consagremos consagrar VMM01P0 +consagren consagrar VMM03P0 +conseguid conseguir VMM02P0 +conseguir conseguir VMN0000 +consensua consensuar VMM02S0 +consensuad consensuar VMM02P0 +consensuando consensuar VMG0000 +consensuar consensuar VMN0000 +consensue consensuar VMM03S0 +consensuemos consensuar VMM01P0 +consensuen consensuar VMM03P0 +consentid consentir VMM02P0 +consentir consentir VMN0000 +conserva conservar VMM02S0 +conservad conservar VMM02P0 +conservando conservar VMG0000 +conservar conservar VMN0000 +conserve conservar VMM03S0 +conservemos conservar VMM01P0 +conserven conservar VMM03P0 +considera considerar VMM02S0 +considerad considerar VMM02P0 +considerando considerar VMG0000 +considerar considerar VMN0000 +considere considerar VMM03S0 +consideremos considerar VMM01P0 +consideren considerar VMM03P0 +consienta consentir VMM03S0 +consientan consentir VMM03P0 +consiente consentir VMM02S0 +consiga conseguir VMM03S0 +consigamos conseguir VMM01P0 +consigan conseguir VMM03P0 +consigna consignar VMM02S0 +consignad consignar VMM02P0 +consignando consignar VMG0000 +consignar consignar VMN0000 +consigne consignar VMM03S0 +consignemos consignar VMM01P0 +consignen consignar VMM03P0 +consigue conseguir VMM02S0 +consiguiendo conseguir VMG0000 +consintamos consentir VMM01P0 +consintiendo consentir VMG0000 +consista consistir VMM03S0 +consistamos consistir VMM01P0 +consistan consistir VMM03P0 +consiste consistir VMM02S0 +consistid consistir VMM02P0 +consistiendo consistir VMG0000 +consistir consistir VMN0000 +consolad consolar VMM02P0 +consolando consolar VMG0000 +consolar consolar VMN0000 +consolemos consolar VMM01P0 +consolida consolidar VMM02S0 +consolidad consolidar VMM02P0 +consolidando consolidar VMG0000 +consolidar consolidar VMN0000 +consolide consolidar VMM03S0 +consolidemos consolidar VMM01P0 +consoliden consolidar VMM03P0 +conspira conspirar VMM02S0 +conspirad conspirar VMM02P0 +conspirando conspirar VMG0000 +conspirar conspirar VMN0000 +conspire conspirar VMM03S0 +conspiremos conspirar VMM01P0 +conspiren conspirar VMM03P0 +consta constar VMM02S0 +constad constar VMM02P0 +constando constar VMG0000 +constar constar VMN0000 +constata constatar VMM02S0 +constatad constatar VMM02P0 +constatando constatar VMG0000 +constatar constatar VMN0000 +constate constatar VMM03S0 +constatemos constatar VMM01P0 +constaten constatar VMM03P0 +conste constar VMM03S0 +constela constelar VMM02S0 +constelad constelar VMM02P0 +constelando constelar VMG0000 +constelar constelar VMN0000 +constele constelar VMM03S0 +constelemos constelar VMM01P0 +constelen constelar VMM03P0 +constemos constar VMM01P0 +consten constar VMM03P0 +consterna consternar VMM02S0 +consternad consternar VMM02P0 +consternando consternar VMG0000 +consternar consternar VMN0000 +consterne consternar VMM03S0 +consternemos consternar VMM01P0 +consternen consternar VMM03P0 +constipa constipar VMM02S0 +constipad constipar VMM02P0 +constipando constipar VMG0000 +constipar constipar VMN0000 +constipe constipar VMM03S0 +constipemos constipar VMM01P0 +constipen constipar VMM03P0 +constitucionalice constitucionalizar VMM03S0 +constitucionalicemos constitucionalizar VMM01P0 +constitucionalicen constitucionalizar VMM03P0 +constitucionaliza constitucionalizar VMM02S0 +constitucionalizad constitucionalizar VMM02P0 +constitucionalizando constitucionalizar VMG0000 +constitucionalizar constitucionalizar VMN0000 +constituid constituir VMM02P0 +constituir constituir VMN0000 +constituya constituir VMM03S0 +constituyamos constituir VMM01P0 +constituyan constituir VMM03P0 +constituye constituir VMM02S0 +constituyendo constituir VMG0000 +constreñid constreñir VMM02P0 +constreñir constreñir VMN0000 +constriña constreñir VMM03S0 +constriñamos constreñir VMM01P0 +constriñan constreñir VMM03P0 +constriñe constreñir VMM02S0 +constriñendo constreñir VMG0000 +construid construir VMM02P0 +construir construir VMN0000 +construya construir VMM03S0 +construyamos construir VMM01P0 +construyan construir VMM03P0 +construye construir VMM02S0 +construyendo construir VMG0000 +consuegra consuegrar VMM02S0 +consuegrad consuegrar VMM02P0 +consuegrando consuegrar VMG0000 +consuegrar consuegrar VMN0000 +consuegre consuegrar VMM03S0 +consuegremos consuegrar VMM01P0 +consuegren consuegrar VMM03P0 +consuela consolar VMM02S0 +consuele consolar VMM03S0 +consuelen consolar VMM03P0 +consulta consultar VMM02S0 +consultad consultar VMM02P0 +consultando consultar VMG0000 +consultar consultar VMN0000 +consulte consultar VMM03S0 +consultemos consultar VMM01P0 +consulten consultar VMM03P0 +consuma consumar VMM02S0 +consuma consumir VMM03S0 +consumad consumar VMM02P0 +consumamos consumir VMM01P0 +consuman consumir VMM03P0 +consumando consumar VMG0000 +consumar consumar VMN0000 +consume consumar VMM03S0 +consume consumir VMM02S0 +consumemos consumar VMM01P0 +consumen consumar VMM03P0 +consumid consumir VMM02P0 +consumiendo consumir VMG0000 +consumir consumir VMN0000 +contabilice contabilizar VMM03S0 +contabilicemos contabilizar VMM01P0 +contabilicen contabilizar VMM03P0 +contabiliza contabilizar VMM02S0 +contabilizad contabilizar VMM02P0 +contabilizando contabilizar VMG0000 +contabilizar contabilizar VMN0000 +contacta contactar VMM02S0 +contactad contactar VMM02P0 +contactando contactar VMG0000 +contactar contactar VMN0000 +contacte contactar VMM03S0 +contactemos contactar VMM01P0 +contacten contactar VMM03P0 +contad contar VMM02P0 +contagia contagiar VMM02S0 +contagiad contagiar VMM02P0 +contagiando contagiar VMG0000 +contagiar contagiar VMN0000 +contagie contagiar VMM03S0 +contagiemos contagiar VMM01P0 +contagien contagiar VMM03P0 +contamina contaminar VMM02S0 +contaminad contaminar VMM02P0 +contaminando contaminar VMG0000 +contaminar contaminar VMN0000 +contamine contaminar VMM03S0 +contaminemos contaminar VMM01P0 +contaminen contaminar VMM03P0 +contando contar VMG0000 +contar contar VMN0000 +contemos contar VMM01P0 +contempera contemperar VMM02S0 +contemperad contemperar VMM02P0 +contemperando contemperar VMG0000 +contemperar contemperar VMN0000 +contempere contemperar VMM03S0 +contemperemos contemperar VMM01P0 +contemperen contemperar VMM03P0 +contempla contemplar VMM02S0 +contemplad contemplar VMM02P0 +contemplando contemplar VMG0000 +contemplar contemplar VMN0000 +contemple contemplar VMM03S0 +contemplemos contemplar VMM01P0 +contemplen contemplar VMM03P0 +contemporice contemporizar VMM03S0 +contemporicemos contemporizar VMM01P0 +contemporicen contemporizar VMM03P0 +contemporiza contemporizar VMM02S0 +contemporizad contemporizar VMM02P0 +contemporizando contemporizar VMG0000 +contemporizar contemporizar VMN0000 +contendamos contender VMM01P0 +contended contender VMM02P0 +contender contender VMN0000 +contendiendo contender VMG0000 +contened contener VMM02P0 +contener contener VMN0000 +contenga contener VMM03S0 +contengamos contener VMM01P0 +contengan contener VMM03P0 +conteniendo contener VMG0000 +contenta contentar VMM02S0 +contentad contentar VMM02P0 +contentando contentar VMG0000 +contentar contentar VMN0000 +contente contentar VMM03S0 +contentemos contentar VMM01P0 +contenten contentar VMM03P0 +contesta contestar VMM02S0 +contestad contestar VMM02P0 +contestando contestar VMG0000 +contestar contestar VMN0000 +conteste contestar VMM03S0 +contestemos contestar VMM01P0 +contesten contestar VMM03P0 +contextuad contextuar VMM02P0 +contextualice contextualizar VMM03S0 +contextualicemos contextualizar VMM01P0 +contextualicen contextualizar VMM03P0 +contextualiza contextualizar VMM02S0 +contextualizad contextualizar VMM02P0 +contextualizando contextualizar VMG0000 +contextualizar contextualizar VMN0000 +contextuando contextuar VMG0000 +contextuar contextuar VMN0000 +contextuemos contextuar VMM01P0 +contextúa contextuar VMM02S0 +contextúe contextuar VMM03S0 +contextúen contextuar VMM03P0 +contienda contender VMM03S0 +contiendan contender VMM03P0 +contiende contender VMM02S0 +continuad continuar VMM02P0 +continuando continuar VMG0000 +continuar continuar VMN0000 +continuemos continuar VMM01P0 +continúa continuar VMM02S0 +continúe continuar VMM03S0 +continúen continuar VMM03P0 +contonea contonear VMM02S0 +contonead contonear VMM02P0 +contoneando contonear VMG0000 +contonear contonear VMN0000 +contonee contonear VMM03S0 +contoneemos contonear VMM01P0 +contoneen contonear VMM03P0 +contorna contornar VMM02S0 +contornad contornar VMM02P0 +contornando contornar VMG0000 +contornar contornar VMN0000 +contorne contornar VMM03S0 +contornea contornear VMM02S0 +contornead contornear VMM02P0 +contorneando contornear VMG0000 +contornear contornear VMN0000 +contornee contornear VMM03S0 +contorneemos contornear VMM01P0 +contorneen contornear VMM03P0 +contornemos contornar VMM01P0 +contornen contornar VMM03P0 +contorsiona contorsionar VMM02S0 +contorsionad contorsionar VMM02P0 +contorsionando contorsionar VMG0000 +contorsionar contorsionar VMN0000 +contorsione contorsionar VMM03S0 +contorsionemos contorsionar VMM01P0 +contorsionen contorsionar VMM03P0 +contraataca contraatacar VMM02S0 +contraatacad contraatacar VMM02P0 +contraatacando contraatacar VMG0000 +contraatacar contraatacar VMN0000 +contraataque contraatacar VMM03S0 +contraataquemos contraatacar VMM01P0 +contraataquen contraatacar VMM03P0 +contrabalancea contrabalancear VMM02S0 +contrabalancead contrabalancear VMM02P0 +contrabalanceando contrabalancear VMG0000 +contrabalancear contrabalancear VMN0000 +contrabalancee contrabalancear VMM03S0 +contrabalanceemos contrabalancear VMM01P0 +contrabalanceen contrabalancear VMM03P0 +contrabandea contrabandear VMM02S0 +contrabandead contrabandear VMM02P0 +contrabandeando contrabandear VMG0000 +contrabandear contrabandear VMN0000 +contrabandee contrabandear VMM03S0 +contrabandeemos contrabandear VMM01P0 +contrabandeen contrabandear VMM03P0 +contrabata contrabatir VMM03S0 +contrabatamos contrabatir VMM01P0 +contrabatan contrabatir VMM03P0 +contrabate contrabatir VMM02S0 +contrabatid contrabatir VMM02P0 +contrabatiendo contrabatir VMG0000 +contrabatir contrabatir VMN0000 +contrachapa contrachapar VMM02S0 +contrachapad contrachapar VMM02P0 +contrachapando contrachapar VMG0000 +contrachapar contrachapar VMN0000 +contrachape contrachapar VMM03S0 +contrachapea contrachapear VMM02S0 +contrachapead contrachapear VMM02P0 +contrachapeando contrachapear VMG0000 +contrachapear contrachapear VMN0000 +contrachapee contrachapear VMM03S0 +contrachapeemos contrachapear VMM01P0 +contrachapeen contrachapear VMM03P0 +contrachapemos contrachapar VMM01P0 +contrachapen contrachapar VMM03P0 +contradecid contradecir VMM02P0 +contradecir contradecir VMN0000 +contradice contradecir VMM02S0 +contradiciendo contradecir VMG0000 +contradiga contradecir VMM03S0 +contradigamos contradecir VMM01P0 +contradigan contradecir VMM03P0 +contrae contraer VMM02S0 +contraed contraer VMM02P0 +contraendosa contraendosar VMM02S0 +contraendosad contraendosar VMM02P0 +contraendosando contraendosar VMG0000 +contraendosar contraendosar VMN0000 +contraendose contraendosar VMM03S0 +contraendosemos contraendosar VMM01P0 +contraendosen contraendosar VMM03P0 +contraer contraer VMN0000 +contrafalla contrafallar VMM02S0 +contrafallad contrafallar VMM02P0 +contrafallando contrafallar VMG0000 +contrafallar contrafallar VMN0000 +contrafalle contrafallar VMM03S0 +contrafallemos contrafallar VMM01P0 +contrafallen contrafallar VMM03P0 +contrafirma contrafirmar VMM02S0 +contrafirmad contrafirmar VMM02P0 +contrafirmando contrafirmar VMG0000 +contrafirmar contrafirmar VMN0000 +contrafirme contrafirmar VMM03S0 +contrafirmemos contrafirmar VMM01P0 +contrafirmen contrafirmar VMM03P0 +contraguiña contraguiñar VMM02S0 +contraguiñad contraguiñar VMM02P0 +contraguiñando contraguiñar VMG0000 +contraguiñar contraguiñar VMN0000 +contraguiñe contraguiñar VMM03S0 +contraguiñemos contraguiñar VMM01P0 +contraguiñen contraguiñar VMM03P0 +contrahaced contrahacer VMM02P0 +contrahacer contrahacer VMN0000 +contrahaciendo contrahacer VMG0000 +contrahaga contrahacer VMM03S0 +contrahagamos contrahacer VMM01P0 +contrahagan contrahacer VMM03P0 +contrahaz contrahacer VMM02S0 +contraiga contraer VMM03S0 +contraigamos contraer VMM01P0 +contraigan contraer VMM03P0 +contraindica contraindicar VMM02S0 +contraindicad contraindicar VMM02P0 +contraindicando contraindicar VMG0000 +contraindicar contraindicar VMN0000 +contraindique contraindicar VMM03S0 +contraindiquemos contraindicar VMM01P0 +contraindiquen contraindicar VMM03P0 +contramalla contramallar VMM02S0 +contramallad contramallar VMM02P0 +contramallando contramallar VMG0000 +contramallar contramallar VMN0000 +contramalle contramallar VMM03S0 +contramallemos contramallar VMM01P0 +contramallen contramallar VMM03P0 +contramanda contramandar VMM02S0 +contramandad contramandar VMM02P0 +contramandando contramandar VMG0000 +contramandar contramandar VMN0000 +contramande contramandar VMM03S0 +contramandemos contramandar VMM01P0 +contramanden contramandar VMM03P0 +contramarca contramarcar VMM02S0 +contramarcad contramarcar VMM02P0 +contramarcando contramarcar VMG0000 +contramarcar contramarcar VMN0000 +contramarcha contramarchar VMM02S0 +contramarchad contramarchar VMM02P0 +contramarchando contramarchar VMG0000 +contramarchar contramarchar VMN0000 +contramarche contramarchar VMM03S0 +contramarchemos contramarchar VMM01P0 +contramarchen contramarchar VMM03P0 +contramarque contramarcar VMM03S0 +contramarquemos contramarcar VMM01P0 +contramarquen contramarcar VMM03P0 +contramina contraminar VMM02S0 +contraminad contraminar VMM02P0 +contraminando contraminar VMG0000 +contraminar contraminar VMN0000 +contramine contraminar VMM03S0 +contraminemos contraminar VMM01P0 +contraminen contraminar VMM03P0 +contraordena contraordenar VMM02S0 +contraordenad contraordenar VMM02P0 +contraordenando contraordenar VMG0000 +contraordenar contraordenar VMN0000 +contrapasa contrapasar VMM02S0 +contrapasad contrapasar VMM02P0 +contrapasando contrapasar VMG0000 +contrapasar contrapasar VMN0000 +contrapase contrapasar VMM03S0 +contrapasemos contrapasar VMM01P0 +contrapasen contrapasar VMM03P0 +contrapea contrapear VMM02S0 +contrapead contrapear VMM02P0 +contrapeando contrapear VMG0000 +contrapear contrapear VMN0000 +contrapee contrapear VMM03S0 +contrapeemos contrapear VMM01P0 +contrapeen contrapear VMM03P0 +contrapesa contrapesar VMM02S0 +contrapesad contrapesar VMM02P0 +contrapesando contrapesar VMG0000 +contrapesar contrapesar VMN0000 +contrapese contrapesar VMM03S0 +contrapesemos contrapesar VMM01P0 +contrapesen contrapesar VMM03P0 +contraponed contraponer VMM02P0 +contraponer contraponer VMN0000 +contraponga contraponer VMM03S0 +contrapongamos contraponer VMM01P0 +contrapongan contraponer VMM03P0 +contraponiendo contraponer VMG0000 +contrapunce contrapunzar VMM03S0 +contrapuncemos contrapunzar VMM01P0 +contrapuncen contrapunzar VMM03P0 +contrapunta contrapuntar VMM02S0 +contrapuntad contrapuntar VMM02P0 +contrapuntando contrapuntar VMG0000 +contrapuntar contrapuntar VMN0000 +contrapunte contrapuntar VMM03S0 +contrapuntea contrapuntear VMM02S0 +contrapuntead contrapuntear VMM02P0 +contrapunteando contrapuntear VMG0000 +contrapuntear contrapuntear VMN0000 +contrapuntee contrapuntear VMM03S0 +contrapunteemos contrapuntear VMM01P0 +contrapunteen contrapuntear VMM03P0 +contrapuntemos contrapuntar VMM01P0 +contrapunten contrapuntar VMM03P0 +contrapunza contrapunzar VMM02S0 +contrapunzad contrapunzar VMM02P0 +contrapunzando contrapunzar VMG0000 +contrapunzar contrapunzar VMN0000 +contrapón contraponer VMM02S0 +contrariad contrariar VMM02P0 +contrariando contrariar VMG0000 +contrariar contrariar VMN0000 +contrariemos contrariar VMM01P0 +contrarresta contrarrestar VMM02S0 +contrarrestad contrarrestar VMM02P0 +contrarrestando contrarrestar VMG0000 +contrarrestar contrarrestar VMN0000 +contrarreste contrarrestar VMM03S0 +contrarrestemos contrarrestar VMM01P0 +contrarresten contrarrestar VMM03P0 +contraría contrariar VMM02S0 +contraríe contrariar VMM03S0 +contraríen contrariar VMM03P0 +contrasella contrasellar VMM02S0 +contrasellad contrasellar VMM02P0 +contrasellando contrasellar VMG0000 +contrasellar contrasellar VMN0000 +contraselle contrasellar VMM03S0 +contrasellemos contrasellar VMM01P0 +contrasellen contrasellar VMM03P0 +contrasta contrastar VMM02S0 +contrastad contrastar VMM02P0 +contrastando contrastar VMG0000 +contrastar contrastar VMN0000 +contraste contrastar VMM03S0 +contrastemos contrastar VMM01P0 +contrasten contrastar VMM03P0 +contrata contratar VMM02S0 +contratad contratar VMM02P0 +contratando contratar VMG0000 +contratar contratar VMN0000 +contrate contratar VMM03S0 +contratemos contratar VMM01P0 +contraten contratar VMM03P0 +contravala contravalar VMM02S0 +contravalad contravalar VMM02P0 +contravalando contravalar VMG0000 +contravalar contravalar VMN0000 +contravale contravalar VMM03S0 +contravalemos contravalar VMM01P0 +contravalen contravalar VMM03P0 +contraven contravenir VMM02S0 +contravenga contravenir VMM03S0 +contravengamos contravenir VMM01P0 +contravengan contravenir VMM03P0 +contravenid contravenir VMM02P0 +contravenir contravenir VMN0000 +contraviniendo contravenir VMG0000 +contrayendo contraer VMG0000 +contribuid contribuir VMM02P0 +contribuir contribuir VMN0000 +contribuya contribuir VMM03S0 +contribuyamos contribuir VMM01P0 +contribuyan contribuir VMM03P0 +contribuye contribuir VMM02S0 +contribuyendo contribuir VMG0000 +contrista contristar VMM02S0 +contristad contristar VMM02P0 +contristando contristar VMG0000 +contristar contristar VMN0000 +contriste contristar VMM03S0 +contristemos contristar VMM01P0 +contristen contristar VMM03P0 +controla controlar VMM02S0 +controlad controlar VMM02P0 +controlando controlar VMG0000 +controlar controlar VMN0000 +controle controlar VMM03S0 +controlemos controlar VMM01P0 +controlen controlar VMM03P0 +controvertid controvertir VMM02P0 +controvertir controvertir VMN0000 +controvierta controvertir VMM03S0 +controviertan controvertir VMM03P0 +controvierte controvertir VMM02S0 +controvirtamos controvertir VMM01P0 +controvirtiendo controvertir VMG0000 +contunda contundir VMM03S0 +contundamos contundir VMM01P0 +contundan contundir VMM03P0 +contunde contundir VMM02S0 +contundid contundir VMM02P0 +contundiendo contundir VMG0000 +contundir contundir VMN0000 +conturba conturbar VMM02S0 +conturbad conturbar VMM02P0 +conturbando conturbar VMG0000 +conturbar conturbar VMN0000 +conturbe conturbar VMM03S0 +conturbemos conturbar VMM01P0 +conturben conturbar VMM03P0 +contén contener VMM02S0 +convalece convalecer VMM02S0 +convaleced convalecer VMM02P0 +convalecer convalecer VMN0000 +convaleciendo convalecer VMG0000 +convalezca convalecer VMM03S0 +convalezcamos convalecer VMM01P0 +convalezcan convalecer VMM03P0 +convalida convalidar VMM02S0 +convalidad convalidar VMM02P0 +convalidando convalidar VMG0000 +convalidar convalidar VMN0000 +convalide convalidar VMM03S0 +convalidemos convalidar VMM01P0 +convaliden convalidar VMM03P0 +conven convenir VMM02S0 +convence convencer VMM02S0 +convenced convencer VMM02P0 +convencer convencer VMN0000 +convenciendo convencer VMG0000 +convenga convenir VMM03S0 +convengamos convenir VMM01P0 +convengan convenir VMM03P0 +convenid convenir VMM02P0 +convenir convenir VMN0000 +convenza convencer VMM03S0 +convenzamos convencer VMM01P0 +convenzan convencer VMM03P0 +converge converger VMM02S0 +converge convergir VMM02S0 +converged converger VMM02P0 +converger converger VMN0000 +convergid convergir VMM02P0 +convergiendo converger VMG0000 +convergiendo convergir VMG0000 +convergir convergir VMN0000 +converja converger VMM03S0 +converja convergir VMM03S0 +converjamos converger VMM01P0 +converjamos convergir VMM01P0 +converjan converger VMM03P0 +converjan convergir VMM03P0 +conversa conversar VMM02S0 +conversad conversar VMM02P0 +conversando conversar VMG0000 +conversar conversar VMN0000 +converse conversar VMM03S0 +conversemos conversar VMM01P0 +conversen conversar VMM03P0 +convertid convertir VMM02P0 +convertir convertir VMN0000 +convida convidar VMM02S0 +convidad convidar VMM02P0 +convidando convidar VMG0000 +convidar convidar VMN0000 +convide convidar VMM03S0 +convidemos convidar VMM01P0 +conviden convidar VMM03P0 +convierta convertir VMM03S0 +conviertan convertir VMM03P0 +convierte convertir VMM02S0 +conviniendo convenir VMG0000 +convirtamos convertir VMM01P0 +convirtiendo convertir VMG0000 +conviva convivir VMM03S0 +convivamos convivir VMM01P0 +convivan convivir VMM03P0 +convive convivir VMM02S0 +convivid convivir VMM02P0 +conviviendo convivir VMG0000 +convivir convivir VMN0000 +convoca convocar VMM02S0 +convocad convocar VMM02P0 +convocando convocar VMG0000 +convocar convocar VMN0000 +convoque convocar VMM03S0 +convoquemos convocar VMM01P0 +convoquen convocar VMM03P0 +convoya convoyar VMM02S0 +convoyad convoyar VMM02P0 +convoyando convoyar VMG0000 +convoyar convoyar VMN0000 +convoye convoyar VMM03S0 +convoyemos convoyar VMM01P0 +convoyen convoyar VMM03P0 +convulsiona convulsionar VMM02S0 +convulsionad convulsionar VMM02P0 +convulsionando convulsionar VMG0000 +convulsionar convulsionar VMN0000 +convulsione convulsionar VMM03S0 +convulsionemos convulsionar VMM01P0 +convulsionen convulsionar VMM03P0 +coopera cooperar VMM02S0 +cooperad cooperar VMM02P0 +cooperando cooperar VMG0000 +cooperar cooperar VMN0000 +coopere cooperar VMM03S0 +cooperemos cooperar VMM01P0 +cooperen cooperar VMM03P0 +coopta cooptar VMM02S0 +cooptad cooptar VMM02P0 +cooptando cooptar VMG0000 +cooptar cooptar VMN0000 +coopte cooptar VMM03S0 +cooptemos cooptar VMM01P0 +coopten cooptar VMM03P0 +coordina coordinar VMM02S0 +coordinad coordinar VMM02P0 +coordinando coordinar VMG0000 +coordinar coordinar VMN0000 +coordine coordinar VMM03S0 +coordinemos coordinar VMM01P0 +coordinen coordinar VMM03P0 +copa copar VMM02S0 +copad copar VMM02P0 +copando copar VMG0000 +copar copar VMN0000 +cope copar VMM03S0 +copea copear VMM02S0 +copead copear VMM02P0 +copeando copear VMG0000 +copear copear VMN0000 +copee copear VMM03S0 +copeemos copear VMM01P0 +copeen copear VMM03P0 +copela copelar VMM02S0 +copelad copelar VMM02P0 +copelando copelar VMG0000 +copelar copelar VMN0000 +copele copelar VMM03S0 +copelemos copelar VMM01P0 +copelen copelar VMM03P0 +copemos copar VMM01P0 +copen copar VMM03P0 +copia copiar VMM02S0 +copiad copiar VMM02P0 +copiando copiar VMG0000 +copiar copiar VMN0000 +copie copiar VMM03S0 +copiemos copiar VMM01P0 +copien copiar VMM03P0 +copina copinar VMM02S0 +copinad copinar VMM02P0 +copinando copinar VMG0000 +copinar copinar VMN0000 +copine copinar VMM03S0 +copinemos copinar VMM01P0 +copinen copinar VMM03P0 +coplea coplear VMM02S0 +coplead coplear VMM02P0 +copleando coplear VMG0000 +coplear coplear VMN0000 +coplee coplear VMM03S0 +copleemos coplear VMM01P0 +copleen coplear VMM03P0 +copula copular VMM02S0 +copulad copular VMM02P0 +copulando copular VMG0000 +copular copular VMN0000 +copule copular VMM03S0 +copulemos copular VMM01P0 +copulen copular VMM03P0 +coque cocar VMM03S0 +coquemos cocar VMM01P0 +coquen cocar VMM03P0 +coquetea coquetear VMM02S0 +coquetead coquetear VMM02P0 +coqueteando coquetear VMG0000 +coquetear coquetear VMN0000 +coquetee coquetear VMM03S0 +coqueteemos coquetear VMM01P0 +coqueteen coquetear VMM03P0 +coquice coquizar VMM03S0 +coquicemos coquizar VMM01P0 +coquicen coquizar VMM03P0 +coquiza coquizar VMM02S0 +coquizad coquizar VMM02P0 +coquizando coquizar VMG0000 +coquizar coquizar VMN0000 +corcha corchar VMM02S0 +corchad corchar VMM02P0 +corchando corchar VMG0000 +corchar corchar VMN0000 +corche corchar VMM03S0 +corchemos corchar VMM01P0 +corchen corchar VMM03P0 +corcova corcovar VMM02S0 +corcovad corcovar VMM02P0 +corcovando corcovar VMG0000 +corcovar corcovar VMN0000 +corcove corcovar VMM03S0 +corcovea corcovear VMM02S0 +corcovead corcovear VMM02P0 +corcoveando corcovear VMG0000 +corcovear corcovear VMN0000 +corcovee corcovear VMM03S0 +corcoveemos corcovear VMM01P0 +corcoveen corcovear VMM03P0 +corcovemos corcovar VMM01P0 +corcoven corcovar VMM03P0 +corcusa corcusir VMM03S0 +corcusamos corcusir VMM01P0 +corcusan corcusir VMM03P0 +corcuse corcusir VMM02S0 +corcusid corcusir VMM02P0 +corcusiendo corcusir VMG0000 +corcusir corcusir VMN0000 +corea corear VMM02S0 +coread corear VMM02P0 +coreando corear VMG0000 +corear corear VMN0000 +coree corear VMM03S0 +coreemos corear VMM01P0 +coreen corear VMM03P0 +corla corlar VMM02S0 +corlad corlar VMM02P0 +corlando corlar VMG0000 +corlar corlar VMN0000 +corle corlar VMM03S0 +corlea corlear VMM02S0 +corlead corlear VMM02P0 +corleando corlear VMG0000 +corlear corlear VMN0000 +corlee corlear VMM03S0 +corleemos corlear VMM01P0 +corleen corlear VMM03P0 +corlemos corlar VMM01P0 +corlen corlar VMM03P0 +cornea cornear VMM02S0 +cornead cornear VMM02P0 +corneando cornear VMG0000 +cornear cornear VMN0000 +cornee cornear VMM03S0 +corneemos cornear VMM01P0 +corneen cornear VMM03P0 +corona coronar VMM02S0 +coronad coronar VMM02P0 +coronando coronar VMG0000 +coronar coronar VMN0000 +corone coronar VMM03S0 +coronemos coronar VMM01P0 +coronen coronar VMM03P0 +corporifica corporificar VMM02S0 +corporificad corporificar VMM02P0 +corporificando corporificar VMG0000 +corporificar corporificar VMN0000 +corporifique corporificar VMM03S0 +corporifiquemos corporificar VMM01P0 +corporifiquen corporificar VMM03P0 +corra correr VMM03S0 +corramos correr VMM01P0 +corran correr VMM03P0 +corre correr VMM02S0 +correa correar VMM02S0 +corread correar VMM02P0 +correando correar VMG0000 +correar correar VMN0000 +corred correr VMM02P0 +corree correar VMM03S0 +correemos correar VMM01P0 +correen correar VMM03P0 +corregid corregir VMM02P0 +corregir corregir VMN0000 +correlaciona correlacionar VMM02S0 +correlacionad correlacionar VMM02P0 +correlacionando correlacionar VMG0000 +correlacionar correlacionar VMN0000 +correlacione correlacionar VMM03S0 +correlacionemos correlacionar VMM01P0 +correlacionen correlacionar VMM03P0 +correr correr VMN0000 +corresponda corresponder VMM03S0 +correspondamos corresponder VMM01P0 +correspondan corresponder VMM03P0 +corresponde corresponder VMM02S0 +corresponded corresponder VMM02P0 +corresponder corresponder VMN0000 +correspondiendo corresponder VMG0000 +corretea corretear VMM02S0 +corretead corretear VMM02P0 +correteando corretear VMG0000 +corretear corretear VMN0000 +corretee corretear VMM03S0 +correteemos corretear VMM01P0 +correteen corretear VMM03P0 +corriendo correr VMG0000 +corrige corregir VMM02S0 +corrigiendo corregir VMG0000 +corrija corregir VMM03S0 +corrijamos corregir VMM01P0 +corrijan corregir VMM03P0 +corroa corroer VMM03S0 +corroamos corroer VMM01P0 +corroan corroer VMM03P0 +corrobora corroborar VMM02S0 +corroborad corroborar VMM02P0 +corroborando corroborar VMG0000 +corroborar corroborar VMN0000 +corrobore corroborar VMM03S0 +corroboremos corroborar VMM01P0 +corroboren corroborar VMM03P0 +corroe corroer VMM02S0 +corroed corroer VMM02P0 +corroer corroer VMN0000 +corroiga corroer VMM03S0 +corroigamos corroer VMM01P0 +corroigan corroer VMM03P0 +corrompa corromper VMM03S0 +corrompamos corromper VMM01P0 +corrompan corromper VMM03P0 +corrompe corromper VMM02S0 +corromped corromper VMM02P0 +corromper corromper VMN0000 +corrompiendo corromper VMG0000 +corroya corroer VMM03S0 +corroyamos corroer VMM01P0 +corroyan corroer VMM03P0 +corroyendo corroer VMG0000 +corruga corrugar VMM02S0 +corrugad corrugar VMM02P0 +corrugando corrugar VMG0000 +corrugar corrugar VMN0000 +corrugue corrugar VMM03S0 +corruguemos corrugar VMM01P0 +corruguen corrugar VMM03P0 +corta cortar VMM02S0 +cortad cortar VMM02P0 +cortando cortar VMG0000 +cortar cortar VMN0000 +corte cortar VMM03S0 +corteja cortejar VMM02S0 +cortejad cortejar VMM02P0 +cortejando cortejar VMG0000 +cortejar cortejar VMN0000 +corteje cortejar VMM03S0 +cortejemos cortejar VMM01P0 +cortejen cortejar VMM03P0 +cortemos cortar VMM01P0 +corten cortar VMM03P0 +cortocircuita cortocircuitar VMM02S0 +cortocircuitad cortocircuitar VMM02P0 +cortocircuitando cortocircuitar VMG0000 +cortocircuitar cortocircuitar VMN0000 +cortocircuite cortocircuitar VMM03S0 +cortocircuitemos cortocircuitar VMM01P0 +cortocircuiten cortocircuitar VMM03P0 +corusca coruscar VMM02S0 +coruscad coruscar VMM02P0 +coruscando coruscar VMG0000 +coruscar coruscar VMN0000 +corusque coruscar VMM03S0 +corusquemos coruscar VMM01P0 +corusquen coruscar VMM03P0 +corvetea corvetear VMM02S0 +corvetead corvetear VMM02P0 +corveteando corvetear VMG0000 +corvetear corvetear VMN0000 +corvetee corvetear VMM03S0 +corveteemos corvetear VMM01P0 +corveteen corvetear VMM03P0 +cosa coser VMM03S0 +cosamos coser VMM01P0 +cosan coser VMM03P0 +cosca coscar VMM02S0 +coscad coscar VMM02P0 +coscando coscar VMG0000 +coscar coscar VMN0000 +cose coser VMM02S0 +cosecha cosechar VMM02S0 +cosechad cosechar VMM02P0 +cosechando cosechar VMG0000 +cosechar cosechar VMN0000 +coseche cosechar VMM03S0 +cosechemos cosechar VMM01P0 +cosechen cosechar VMM03P0 +cosed coser VMM02P0 +coser coser VMN0000 +cosiendo coser VMG0000 +cosque coscar VMM03S0 +cosquemos coscar VMM01P0 +cosquen coscar VMM03P0 +cosquilla cosquillar VMM02S0 +cosquillad cosquillar VMM02P0 +cosquillando cosquillar VMG0000 +cosquillar cosquillar VMN0000 +cosquille cosquillar VMM03S0 +cosquillea cosquillear VMM02S0 +cosquillead cosquillear VMM02P0 +cosquilleando cosquillear VMG0000 +cosquillear cosquillear VMN0000 +cosquillee cosquillear VMM03S0 +cosquilleemos cosquillear VMM01P0 +cosquilleen cosquillear VMM03P0 +cosquillemos cosquillar VMM01P0 +cosquillen cosquillar VMM03P0 +costad costar VMM02P0 +costando costar VMG0000 +costar costar VMN0000 +costea costear VMM02S0 +costead costear VMM02P0 +costeando costear VMG0000 +costear costear VMN0000 +costee costear VMM03S0 +costeemos costear VMM01P0 +costeen costear VMM03P0 +costemos costar VMM01P0 +costreñid costreñir VMM02P0 +costreñir costreñir VMN0000 +costriñe costreñir VMM02S0 +costriñendo costreñir VMG0000 +cota cotar VMM02S0 +cotad cotar VMM02P0 +cotando cotar VMG0000 +cotar cotar VMN0000 +cote cotar VMM03S0 +coteja cotejar VMM02S0 +cotejad cotejar VMM02P0 +cotejando cotejar VMG0000 +cotejar cotejar VMN0000 +coteje cotejar VMM03S0 +cotejemos cotejar VMM01P0 +cotejen cotejar VMM03P0 +cotemos cotar VMM01P0 +coten cotar VMM03P0 +cotice cotizar VMM03S0 +coticemos cotizar VMM01P0 +coticen cotizar VMM03P0 +cotillea cotillear VMM02S0 +cotillead cotillear VMM02P0 +cotilleando cotillear VMG0000 +cotillear cotillear VMN0000 +cotillee cotillear VMM03S0 +cotilleemos cotillear VMM01P0 +cotilleen cotillear VMM03P0 +cotiza cotizar VMM02S0 +cotizad cotizar VMM02P0 +cotizando cotizar VMG0000 +cotizar cotizar VMN0000 +cotorrea cotorrear VMM02S0 +cotorread cotorrear VMM02P0 +cotorreando cotorrear VMG0000 +cotorrear cotorrear VMN0000 +cotorree cotorrear VMM03S0 +cotorreemos cotorrear VMM01P0 +cotorreen cotorrear VMM03P0 +cozamos cocer VMM01P0 +coñea coñear VMM02S0 +coñead coñear VMM02P0 +coñeando coñear VMG0000 +coñear coñear VMN0000 +coñee coñear VMM03S0 +coñeemos coñear VMM01P0 +coñeen coñear VMM03P0 +crascita crascitar VMM02S0 +crascitad crascitar VMM02P0 +crascitando crascitar VMG0000 +crascitar crascitar VMN0000 +crascite crascitar VMM03S0 +crascitemos crascitar VMM01P0 +crasciten crascitar VMM03P0 +crea crear VMM02S0 +crea creer VMM03S0 +cread crear VMM02P0 +creamos creer VMM01P0 +crean creer VMM03P0 +creando crear VMG0000 +crear crear VMN0000 +crece crecer VMM02S0 +creced crecer VMM02P0 +crecer crecer VMN0000 +creciendo crecer VMG0000 +cree crear VMM03S0 +cree creer VMM02S0 +creed creer VMM02P0 +creemos crear VMM01P0 +creen crear VMM03P0 +creer creer VMN0000 +creosota creosotar VMM02S0 +creosotad creosotar VMM02P0 +creosotando creosotar VMG0000 +creosotar creosotar VMN0000 +creosote creosotar VMM03S0 +creosotemos creosotar VMM01P0 +creosoten creosotar VMM03P0 +crepita crepitar VMM02S0 +crepitad crepitar VMM02P0 +crepitando crepitar VMG0000 +crepitar crepitar VMN0000 +crepite crepitar VMM03S0 +crepitemos crepitar VMM01P0 +crepiten crepitar VMM03P0 +creyendo creer VMG0000 +crezca crecer VMM03S0 +crezcamos crecer VMM01P0 +crezcan crecer VMM03P0 +criad criar VMM02P0 +criando criar VMG0000 +criar criar VMN0000 +criba cribar VMM02S0 +cribad cribar VMM02P0 +cribando cribar VMG0000 +cribar cribar VMN0000 +cribe cribar VMM03S0 +cribemos cribar VMM01P0 +criben cribar VMM03P0 +criemos criar VMM01P0 +crimina criminar VMM02S0 +criminad criminar VMM02P0 +criminalice criminalizar VMM03S0 +criminalicemos criminalizar VMM01P0 +criminalicen criminalizar VMM03P0 +criminaliza criminalizar VMM02S0 +criminalizad criminalizar VMM02P0 +criminalizando criminalizar VMG0000 +criminalizar criminalizar VMN0000 +criminando criminar VMG0000 +criminar criminar VMN0000 +crimine criminar VMM03S0 +criminemos criminar VMM01P0 +criminen criminar VMM03P0 +crispa crispar VMM02S0 +crispad crispar VMM02P0 +crispando crispar VMG0000 +crispar crispar VMN0000 +crispe crispar VMM03S0 +crispemos crispar VMM01P0 +crispen crispar VMM03P0 +cristalice cristalizar VMM03S0 +cristalicemos cristalizar VMM01P0 +cristalicen cristalizar VMM03P0 +cristaliza cristalizar VMM02S0 +cristalizad cristalizar VMM02P0 +cristalizando cristalizar VMG0000 +cristalizar cristalizar VMN0000 +cristiana cristianar VMM02S0 +cristianad cristianar VMM02P0 +cristianando cristianar VMG0000 +cristianar cristianar VMN0000 +cristiane cristianar VMM03S0 +cristianemos cristianar VMM01P0 +cristianen cristianar VMM03P0 +cristianice cristianizar VMM03S0 +cristianicemos cristianizar VMM01P0 +cristianicen cristianizar VMM03P0 +cristianiza cristianizar VMM02S0 +cristianizad cristianizar VMM02P0 +cristianizando cristianizar VMG0000 +cristianizar cristianizar VMN0000 +critica criticar VMM02S0 +criticad criticar VMM02P0 +criticando criticar VMG0000 +criticar criticar VMN0000 +critique criticar VMM03S0 +critiquemos criticar VMM01P0 +critiquen criticar VMM03P0 +croa croar VMM02S0 +croad croar VMM02P0 +croando croar VMG0000 +croar croar VMN0000 +crocita crocitar VMM02S0 +crocitad crocitar VMM02P0 +crocitando crocitar VMG0000 +crocitar crocitar VMN0000 +crocite crocitar VMM03S0 +crocitemos crocitar VMM01P0 +crociten crocitar VMM03P0 +croe croar VMM03S0 +croemos croar VMM01P0 +croen croar VMM03P0 +croma cromar VMM02S0 +cromad cromar VMM02P0 +cromando cromar VMG0000 +cromar cromar VMN0000 +crome cromar VMM03S0 +cromemos cromar VMM01P0 +cromen cromar VMM03P0 +cronometra cronometrar VMM02S0 +cronometrad cronometrar VMM02P0 +cronometrando cronometrar VMG0000 +cronometrar cronometrar VMN0000 +cronometre cronometrar VMM03S0 +cronometremos cronometrar VMM01P0 +cronometren cronometrar VMM03P0 +croscita croscitar VMM02S0 +croscitad croscitar VMM02P0 +croscitando croscitar VMG0000 +croscitar croscitar VMN0000 +croscite croscitar VMM03S0 +croscitemos croscitar VMM01P0 +crosciten croscitar VMM03P0 +crotora crotorar VMM02S0 +crotorad crotorar VMM02P0 +crotorando crotorar VMG0000 +crotorar crotorar VMN0000 +crotore crotorar VMM03S0 +crotoremos crotorar VMM01P0 +crotoren crotorar VMM03P0 +cruce cruzar VMM03S0 +crucemos cruzar VMM01P0 +crucen cruzar VMM03P0 +crucifica crucificar VMM02S0 +crucificad crucificar VMM02P0 +crucificando crucificar VMG0000 +crucificar crucificar VMN0000 +crucifique crucificar VMM03S0 +crucifiquemos crucificar VMM01P0 +crucifiquen crucificar VMM03P0 +cruja crujir VMM03S0 +crujamos crujir VMM01P0 +crujan crujir VMM03P0 +cruje crujir VMM02S0 +crujid crujir VMM02P0 +crujiendo crujir VMG0000 +crujir crujir VMN0000 +cruza cruzar VMM02S0 +cruzad cruzar VMM02P0 +cruzando cruzar VMG0000 +cruzar cruzar VMN0000 +cría criar VMM02S0 +críe criar VMM03S0 +críen criar VMM03P0 +cuadra cuadrar VMM02S0 +cuadrad cuadrar VMM02P0 +cuadrando cuadrar VMG0000 +cuadrar cuadrar VMN0000 +cuadre cuadrar VMM03S0 +cuadremos cuadrar VMM01P0 +cuadren cuadrar VMM03P0 +cuadricula cuadricular VMM02S0 +cuadriculad cuadricular VMM02P0 +cuadriculando cuadricular VMG0000 +cuadricular cuadricular VMN0000 +cuadricule cuadricular VMM03S0 +cuadriculemos cuadricular VMM01P0 +cuadriculen cuadricular VMM03P0 +cuadriplica cuadriplicar VMM02S0 +cuadriplicad cuadriplicar VMM02P0 +cuadriplicando cuadriplicar VMG0000 +cuadriplicar cuadriplicar VMN0000 +cuadriplique cuadriplicar VMM03S0 +cuadripliquemos cuadriplicar VMM01P0 +cuadripliquen cuadriplicar VMM03P0 +cuadruplica cuadruplicar VMM02S0 +cuadruplicad cuadruplicar VMM02P0 +cuadruplicando cuadruplicar VMG0000 +cuadruplicar cuadruplicar VMN0000 +cuadruplique cuadruplicar VMM03S0 +cuadrupliquemos cuadruplicar VMM01P0 +cuadrupliquen cuadruplicar VMM03P0 +cuaja cuajar VMM02S0 +cuajad cuajar VMM02P0 +cuajando cuajar VMG0000 +cuajar cuajar VMN0000 +cuaje cuajar VMM03S0 +cuajemos cuajar VMM01P0 +cuajen cuajar VMM03P0 +cualifica cualificar VMM02S0 +cualificad cualificar VMM02P0 +cualificando cualificar VMG0000 +cualificar cualificar VMN0000 +cualifique cualificar VMM03S0 +cualifiquemos cualificar VMM01P0 +cualifiquen cualificar VMM03P0 +cuantiad cuantiar VMM02P0 +cuantiando cuantiar VMG0000 +cuantiar cuantiar VMN0000 +cuantiemos cuantiar VMM01P0 +cuantifica cuantificar VMM02S0 +cuantificad cuantificar VMM02P0 +cuantificando cuantificar VMG0000 +cuantificar cuantificar VMN0000 +cuantifique cuantificar VMM03S0 +cuantifiquemos cuantificar VMM01P0 +cuantifiquen cuantificar VMM03P0 +cuantía cuantiar VMM02S0 +cuantíe cuantiar VMM03S0 +cuantíen cuantiar VMM03P0 +cuarta cuartar VMM02S0 +cuartad cuartar VMM02P0 +cuartando cuartar VMG0000 +cuartar cuartar VMN0000 +cuarte cuartar VMM03S0 +cuartea cuartear VMM02S0 +cuartead cuartear VMM02P0 +cuarteando cuartear VMG0000 +cuartear cuartear VMN0000 +cuartee cuartear VMM03S0 +cuarteemos cuartear VMM01P0 +cuarteen cuartear VMM03P0 +cuartela cuartelar VMM02S0 +cuartelad cuartelar VMM02P0 +cuartelando cuartelar VMG0000 +cuartelar cuartelar VMN0000 +cuartele cuartelar VMM03S0 +cuartelemos cuartelar VMM01P0 +cuartelen cuartelar VMM03P0 +cuartemos cuartar VMM01P0 +cuarten cuartar VMM03P0 +cubica cubicar VMM02S0 +cubicad cubicar VMM02P0 +cubicando cubicar VMG0000 +cubicar cubicar VMN0000 +cubila cubilar VMM02S0 +cubilad cubilar VMM02P0 +cubilando cubilar VMG0000 +cubilar cubilar VMN0000 +cubile cubilar VMM03S0 +cubilemos cubilar VMM01P0 +cubilen cubilar VMM03P0 +cubiletea cubiletear VMM02S0 +cubiletead cubiletear VMM02P0 +cubileteando cubiletear VMG0000 +cubiletear cubiletear VMN0000 +cubiletee cubiletear VMM03S0 +cubileteemos cubiletear VMM01P0 +cubileteen cubiletear VMM03P0 +cubique cubicar VMM03S0 +cubiquemos cubicar VMM01P0 +cubiquen cubicar VMM03P0 +cubra cubrir VMM03S0 +cubramos cubrir VMM01P0 +cubran cubrir VMM03P0 +cubre cubrir VMM02S0 +cubrid cubrir VMM02P0 +cubriendo cubrir VMG0000 +cubrir cubrir VMN0000 +cuca cucar VMM02S0 +cucad cucar VMM02P0 +cucando cucar VMG0000 +cucar cucar VMN0000 +cucharetea cucharetear VMM02S0 +cucharetead cucharetear VMM02P0 +cuchareteando cucharetear VMG0000 +cucharetear cucharetear VMN0000 +cucharetee cucharetear VMM03S0 +cuchareteemos cucharetear VMM01P0 +cuchareteen cucharetear VMM03P0 +cuchichea cuchichear VMM02S0 +cuchichead cuchichear VMM02P0 +cuchicheando cuchichear VMG0000 +cuchichear cuchichear VMN0000 +cuchichee cuchichear VMM03S0 +cuchicheemos cuchichear VMM01P0 +cuchicheen cuchichear VMM03P0 +cuchichiad cuchichiar VMM02P0 +cuchichiando cuchichiar VMG0000 +cuchichiar cuchichiar VMN0000 +cuchichiemos cuchichiar VMM01P0 +cuchichía cuchichiar VMM02S0 +cuchichíe cuchichiar VMM03S0 +cuchichíen cuchichiar VMM03P0 +cuchuchea cuchuchear VMM02S0 +cuchuchead cuchuchear VMM02P0 +cuchucheando cuchuchear VMG0000 +cuchuchear cuchuchear VMN0000 +cuchuchee cuchuchear VMM03S0 +cuchucheemos cuchuchear VMM01P0 +cuchucheen cuchuchear VMM03P0 +cuchufletea cuchufletear VMM02S0 +cuchufletead cuchufletear VMM02P0 +cuchufleteando cuchufletear VMG0000 +cuchufletear cuchufletear VMN0000 +cuchufletee cuchufletear VMM03S0 +cuchufleteemos cuchufletear VMM01P0 +cuchufleteen cuchufletear VMM03P0 +cuece cocer VMM02S0 +cuela colar VMM02S0 +cuele colar VMM03S0 +cuelen colar VMM03P0 +cuelga colgar VMM02S0 +cuelgue colgar VMM03S0 +cuelguen colgar VMM03P0 +cuenta contar VMM02S0 +cuente contar VMM03S0 +cuenten contar VMM03P0 +cuesta costar VMM02S0 +cueste costar VMM03S0 +cuesten costar VMM03P0 +cuestiona cuestionar VMM02S0 +cuestionad cuestionar VMM02P0 +cuestionando cuestionar VMG0000 +cuestionar cuestionar VMN0000 +cuestione cuestionar VMM03S0 +cuestionemos cuestionar VMM01P0 +cuestionen cuestionar VMM03P0 +cueza cocer VMM03S0 +cuezan cocer VMM03P0 +cuida cuidar VMM02S0 +cuidad cuidar VMM02P0 +cuidando cuidar VMG0000 +cuidar cuidar VMN0000 +cuide cuidar VMM03S0 +cuidemos cuidar VMM01P0 +cuiden cuidar VMM03P0 +culea culear VMM02S0 +culead culear VMM02P0 +culeando culear VMG0000 +culear culear VMN0000 +culebrea culebrear VMM02S0 +culebread culebrear VMM02P0 +culebreando culebrear VMG0000 +culebrear culebrear VMN0000 +culebree culebrear VMM03S0 +culebreemos culebrear VMM01P0 +culebreen culebrear VMM03P0 +culee culear VMM03S0 +culeemos culear VMM01P0 +culeen culear VMM03P0 +culmina culminar VMM02S0 +culminad culminar VMM02P0 +culminando culminar VMG0000 +culminar culminar VMN0000 +culmine culminar VMM03S0 +culminemos culminar VMM01P0 +culminen culminar VMM03P0 +culpa culpar VMM02S0 +culpad culpar VMM02P0 +culpando culpar VMG0000 +culpar culpar VMN0000 +culpe culpar VMM03S0 +culpemos culpar VMM01P0 +culpen culpar VMM03P0 +cultiva cultivar VMM02S0 +cultivad cultivar VMM02P0 +cultivando cultivar VMG0000 +cultivar cultivar VMN0000 +cultive cultivar VMM03S0 +cultivemos cultivar VMM01P0 +cultiven cultivar VMM03P0 +cumpla cumplir VMM03S0 +cumplamos cumplir VMM01P0 +cumplan cumplir VMM03P0 +cumple cumplir VMM02S0 +cumplid cumplir VMM02P0 +cumpliendo cumplir VMG0000 +cumplimenta cumplimentar VMM02S0 +cumplimentad cumplimentar VMM02P0 +cumplimentando cumplimentar VMG0000 +cumplimentar cumplimentar VMN0000 +cumplimente cumplimentar VMM03S0 +cumplimentemos cumplimentar VMM01P0 +cumplimenten cumplimentar VMM03P0 +cumplir cumplir VMN0000 +cuna cunar VMM02S0 +cunad cunar VMM02P0 +cunando cunar VMG0000 +cunar cunar VMN0000 +cunda cundir VMM03S0 +cundamos cundir VMM01P0 +cundan cundir VMM03P0 +cunde cundir VMM02S0 +cundid cundir VMM02P0 +cundiendo cundir VMG0000 +cundir cundir VMN0000 +cune cunar VMM03S0 +cunea cunear VMM02S0 +cunead cunear VMM02P0 +cuneando cunear VMG0000 +cunear cunear VMN0000 +cunee cunear VMM03S0 +cuneemos cunear VMM01P0 +cuneen cunear VMM03P0 +cunemos cunar VMM01P0 +cunen cunar VMM03P0 +cuque cucar VMM03S0 +cuquea cuquear VMM02S0 +cuquead cuquear VMM02P0 +cuqueando cuquear VMG0000 +cuquear cuquear VMN0000 +cuquee cuquear VMM03S0 +cuqueemos cuquear VMM01P0 +cuqueen cuquear VMM03P0 +cuquemos cucar VMM01P0 +cuquen cucar VMM03P0 +cura curar VMM02S0 +curad curar VMM02P0 +curando curar VMG0000 +curar curar VMN0000 +cure curar VMM03S0 +curemos curar VMM01P0 +curen curar VMM03P0 +curiosea curiosear VMM02S0 +curiosead curiosear VMM02P0 +curioseando curiosear VMG0000 +curiosear curiosear VMN0000 +curiosee curiosear VMM03S0 +curioseemos curiosear VMM01P0 +curioseen curiosear VMM03P0 +curra currar VMM02S0 +currad currar VMM02P0 +currando currar VMG0000 +currar currar VMN0000 +curre currar VMM03S0 +currela currelar VMM02S0 +currelad currelar VMM02P0 +currelando currelar VMG0000 +currelar currelar VMN0000 +currele currelar VMM03S0 +currelemos currelar VMM01P0 +currelen currelar VMM03P0 +curremos currar VMM01P0 +curren currar VMM03P0 +cursa cursar VMM02S0 +cursad cursar VMM02P0 +cursando cursar VMG0000 +cursar cursar VMN0000 +curse cursar VMM03S0 +cursemos cursar VMM01P0 +cursen cursar VMM03P0 +curta curtir VMM03S0 +curtamos curtir VMM01P0 +curtan curtir VMM03P0 +curte curtir VMM02S0 +curtid curtir VMM02P0 +curtiendo curtir VMG0000 +curtir curtir VMN0000 +curva curvar VMM02S0 +curvad curvar VMM02P0 +curvando curvar VMG0000 +curvar curvar VMN0000 +curve curvar VMM03S0 +curvemos curvar VMM01P0 +curven curvar VMM03P0 +custodia custodiar VMM02S0 +custodiad custodiar VMM02P0 +custodiando custodiar VMG0000 +custodiar custodiar VMN0000 +custodie custodiar VMM03S0 +custodiemos custodiar VMM01P0 +custodien custodiar VMM03P0 +cía ciar VMM02S0 +cíe ciar VMM03S0 +cíen ciar VMM03P0 +da dar VMM02S0 +dactilografiad dactilografiar VMM02P0 +dactilografiando dactilografiar VMG0000 +dactilografiar dactilografiar VMN0000 +dactilografiemos dactilografiar VMM01P0 +dactilografía dactilografiar VMM02S0 +dactilografíe dactilografiar VMM03S0 +dactilografíen dactilografiar VMM03P0 +dad dar VMM02P0 +dalla dallar VMM02S0 +dallad dallar VMM02P0 +dallando dallar VMG0000 +dallar dallar VMN0000 +dalle dallar VMM03S0 +dallemos dallar VMM01P0 +dallen dallar VMM03P0 +damasquina damasquinar VMM02S0 +damasquinad damasquinar VMM02P0 +damasquinando damasquinar VMG0000 +damasquinar damasquinar VMN0000 +damasquine damasquinar VMM03S0 +damasquinemos damasquinar VMM01P0 +damasquinen damasquinar VMM03P0 +damnifica damnificar VMM02S0 +damnificad damnificar VMM02P0 +damnificando damnificar VMG0000 +damnificar damnificar VMN0000 +damnifique damnificar VMM03S0 +damnifiquemos damnificar VMM01P0 +damnifiquen damnificar VMM03P0 +dance danzar VMM03S0 +dancemos danzar VMM01P0 +dancen danzar VMM03P0 +dando dar VMG0000 +danza danzar VMM02S0 +danzad danzar VMM02P0 +danzando danzar VMG0000 +danzar danzar VMN0000 +dar dar VMN0000 +data datar VMM02S0 +datad datar VMM02P0 +datando datar VMG0000 +datar datar VMN0000 +date datar VMM03S0 +datemos datar VMM01P0 +daten datar VMM03P0 +daña dañar VMM02S0 +dañad dañar VMM02P0 +dañando dañar VMG0000 +dañar dañar VMN0000 +dañe dañar VMM03S0 +dañemos dañar VMM01P0 +dañen dañar VMM03P0 +deambula deambular VMM02S0 +deambulad deambular VMM02P0 +deambulando deambular VMG0000 +deambular deambular VMN0000 +deambule deambular VMM03S0 +deambulemos deambular VMM01P0 +deambulen deambular VMM03P0 +deba deber VMM03S0 +debamos deber VMM01P0 +deban deber VMM03P0 +debata debatir VMM03S0 +debatamos debatir VMM01P0 +debatan debatir VMM03P0 +debate debatir VMM02S0 +debatid debatir VMM02P0 +debatiendo debatir VMG0000 +debatir debatir VMN0000 +debe deber VMM02S0 +debed deber VMM02P0 +debela debelar VMM02S0 +debelad debelar VMM02P0 +debelando debelar VMG0000 +debelar debelar VMN0000 +debele debelar VMM03S0 +debelemos debelar VMM01P0 +debelen debelar VMM03P0 +deber deber VMN0000 +debiendo deber VMG0000 +debilita debilitar VMM02S0 +debilitad debilitar VMM02P0 +debilitando debilitar VMG0000 +debilitar debilitar VMN0000 +debilite debilitar VMM03S0 +debilitemos debilitar VMM01P0 +debiliten debilitar VMM03P0 +debita debitar VMM02S0 +debitad debitar VMM02P0 +debitando debitar VMG0000 +debitar debitar VMN0000 +debite debitar VMM03S0 +debitemos debitar VMM01P0 +debiten debitar VMM03P0 +debuta debutar VMM02S0 +debutad debutar VMM02P0 +debutando debutar VMG0000 +debutar debutar VMN0000 +debute debutar VMM03S0 +debutemos debutar VMM01P0 +debuten debutar VMM03P0 +decae decaer VMM02S0 +decaed decaer VMM02P0 +decaer decaer VMN0000 +decaiga decaer VMM03S0 +decaigamos decaer VMM01P0 +decaigan decaer VMM03P0 +decampa decampar VMM02S0 +decampad decampar VMM02P0 +decampando decampar VMG0000 +decampar decampar VMN0000 +decampe decampar VMM03S0 +decampemos decampar VMM01P0 +decampen decampar VMM03P0 +decanta decantar VMM02S0 +decantad decantar VMM02P0 +decantando decantar VMG0000 +decantar decantar VMN0000 +decante decantar VMM03S0 +decantemos decantar VMM01P0 +decanten decantar VMM03P0 +decapa decapar VMM02S0 +decapad decapar VMM02P0 +decapando decapar VMG0000 +decapar decapar VMN0000 +decape decapar VMM03S0 +decapemos decapar VMM01P0 +decapen decapar VMM03P0 +decapita decapitar VMM02S0 +decapitad decapitar VMM02P0 +decapitando decapitar VMG0000 +decapitar decapitar VMN0000 +decapite decapitar VMM03S0 +decapitemos decapitar VMM01P0 +decapiten decapitar VMM03P0 +decayendo decaer VMG0000 +decentad decentar VMM02P0 +decentando decentar VMG0000 +decentar decentar VMN0000 +decentemos decentar VMM01P0 +decepciona decepcionar VMM02S0 +decepcionad decepcionar VMM02P0 +decepcionando decepcionar VMG0000 +decepcionar decepcionar VMN0000 +decepcione decepcionar VMM03S0 +decepcionemos decepcionar VMM01P0 +decepcionen decepcionar VMM03P0 +decid decir VMM02P0 +decida decidir VMM03S0 +decidamos decidir VMM01P0 +decidan decidir VMM03P0 +decide decidir VMM02S0 +decidid decidir VMM02P0 +decidiendo decidir VMG0000 +decidir decidir VMN0000 +decienta decentar VMM02S0 +deciente decentar VMM03S0 +decienten decentar VMM03P0 +decir decir VMN0000 +declama declamar VMM02S0 +declamad declamar VMM02P0 +declamando declamar VMG0000 +declamar declamar VMN0000 +declame declamar VMM03S0 +declamemos declamar VMM01P0 +declamen declamar VMM03P0 +declara declarar VMM02S0 +declarad declarar VMM02P0 +declarando declarar VMG0000 +declarar declarar VMN0000 +declare declarar VMM03S0 +declaremos declarar VMM01P0 +declaren declarar VMM03P0 +declina declinar VMM02S0 +declinad declinar VMM02P0 +declinando declinar VMG0000 +declinar declinar VMN0000 +decline declinar VMM03S0 +declinemos declinar VMM01P0 +declinen declinar VMM03P0 +decodifica decodificar VMM02S0 +decodificad decodificar VMM02P0 +decodificando decodificar VMG0000 +decodificar decodificar VMN0000 +decodifique decodificar VMM03S0 +decodifiquemos decodificar VMM01P0 +decodifiquen decodificar VMM03P0 +decolora decolorar VMM02S0 +decolorad decolorar VMM02P0 +decolorando decolorar VMG0000 +decolorar decolorar VMN0000 +decolore decolorar VMM03S0 +decoloremos decolorar VMM01P0 +decoloren decolorar VMM03P0 +decomisa decomisar VMM02S0 +decomisad decomisar VMM02P0 +decomisando decomisar VMG0000 +decomisar decomisar VMN0000 +decomise decomisar VMM03S0 +decomisemos decomisar VMM01P0 +decomisen decomisar VMM03P0 +decora decorar VMM02S0 +decorad decorar VMM02P0 +decorando decorar VMG0000 +decorar decorar VMN0000 +decore decorar VMM03S0 +decoremos decorar VMM01P0 +decoren decorar VMM03P0 +decrece decrecer VMM02S0 +decreced decrecer VMM02P0 +decrecer decrecer VMN0000 +decreciendo decrecer VMG0000 +decrementa decrementar VMM02S0 +decrementad decrementar VMM02P0 +decrementando decrementar VMG0000 +decrementar decrementar VMN0000 +decremente decrementar VMM03S0 +decrementemos decrementar VMM01P0 +decrementen decrementar VMM03P0 +decrepita decrepitar VMM02S0 +decrepitad decrepitar VMM02P0 +decrepitando decrepitar VMG0000 +decrepitar decrepitar VMN0000 +decrepite decrepitar VMM03S0 +decrepitemos decrepitar VMM01P0 +decrepiten decrepitar VMM03P0 +decreta decretar VMM02S0 +decretad decretar VMM02P0 +decretando decretar VMG0000 +decretar decretar VMN0000 +decrete decretar VMM03S0 +decretemos decretar VMM01P0 +decreten decretar VMM03P0 +decrezca decrecer VMM03S0 +decrezcamos decrecer VMM01P0 +decrezcan decrecer VMM03P0 +decuplica decuplicar VMM02S0 +decuplicad decuplicar VMM02P0 +decuplicando decuplicar VMG0000 +decuplicar decuplicar VMN0000 +decuplique decuplicar VMM03S0 +decupliquemos decuplicar VMM01P0 +decupliquen decuplicar VMM03P0 +dedica dedicar VMM02S0 +dedicad dedicar VMM02P0 +dedicando dedicar VMG0000 +dedicar dedicar VMN0000 +dedique dedicar VMM03S0 +dediquemos dedicar VMM01P0 +dediquen dedicar VMM03P0 +deduce deducir VMM02S0 +deducid deducir VMM02P0 +deduciendo deducir VMG0000 +deducir deducir VMN0000 +deduzca deducir VMM03S0 +deduzcamos deducir VMM01P0 +deduzcan deducir VMM03P0 +defalca defalcar VMM02S0 +defalcad defalcar VMM02P0 +defalcando defalcar VMG0000 +defalcar defalcar VMN0000 +defalque defalcar VMM03S0 +defalquemos defalcar VMM01P0 +defalquen defalcar VMM03P0 +defeca defecar VMM02S0 +defecad defecar VMM02P0 +defecando defecar VMG0000 +defecar defecar VMN0000 +defendamos defender VMM01P0 +defended defender VMM02P0 +defender defender VMN0000 +defendiendo defender VMG0000 +defenestra defenestrar VMM02S0 +defenestrad defenestrar VMM02P0 +defenestrando defenestrar VMG0000 +defenestrar defenestrar VMN0000 +defenestre defenestrar VMM03S0 +defenestremos defenestrar VMM01P0 +defenestren defenestrar VMM03P0 +defeque defecar VMM03S0 +defequemos defecar VMM01P0 +defequen defecar VMM03P0 +deferid deferir VMM02P0 +deferir deferir VMN0000 +defienda defender VMM03S0 +defiendan defender VMM03P0 +defiende defender VMM02S0 +defiera deferir VMM03S0 +defieran deferir VMM03P0 +defiere deferir VMM02S0 +defina definir VMM03S0 +definamos definir VMM01P0 +definan definir VMM03P0 +define definir VMM02S0 +definid definir VMM02P0 +definiendo definir VMG0000 +definir definir VMN0000 +defiramos deferir VMM01P0 +defiriendo deferir VMG0000 +deflagra deflagrar VMM02S0 +deflagrad deflagrar VMM02P0 +deflagrando deflagrar VMG0000 +deflagrar deflagrar VMN0000 +deflagre deflagrar VMM03S0 +deflagremos deflagrar VMM01P0 +deflagren deflagrar VMM03P0 +deflegma deflegmar VMM02S0 +deflegmad deflegmar VMM02P0 +deflegmando deflegmar VMG0000 +deflegmar deflegmar VMN0000 +deflegme deflegmar VMM03S0 +deflegmemos deflegmar VMM01P0 +deflegmen deflegmar VMM03P0 +deforesta deforestar VMM02S0 +deforestad deforestar VMM02P0 +deforestando deforestar VMG0000 +deforestar deforestar VMN0000 +deforeste deforestar VMM03S0 +deforestemos deforestar VMM01P0 +deforesten deforestar VMM03P0 +deforma deformar VMM02S0 +deformad deformar VMM02P0 +deformando deformar VMG0000 +deformar deformar VMN0000 +deforme deformar VMM03S0 +deformemos deformar VMM01P0 +deformen deformar VMM03P0 +defrauda defraudar VMM02S0 +defraudad defraudar VMM02P0 +defraudando defraudar VMG0000 +defraudar defraudar VMN0000 +defraude defraudar VMM03S0 +defraudemos defraudar VMM01P0 +defrauden defraudar VMM03P0 +degenera degenerar VMM02S0 +degenerad degenerar VMM02P0 +degenerando degenerar VMG0000 +degenerar degenerar VMN0000 +degenere degenerar VMM03S0 +degeneremos degenerar VMM01P0 +degeneren degenerar VMM03P0 +degluta deglutir VMM03S0 +deglutamos deglutir VMM01P0 +deglutan deglutir VMM03P0 +deglute deglutir VMM02S0 +deglutid deglutir VMM02P0 +deglutiendo deglutir VMG0000 +deglutir deglutir VMN0000 +degollad degollar VMM02P0 +degollando degollar VMG0000 +degollar degollar VMN0000 +degollemos degollar VMM01P0 +degrada degradar VMM02S0 +degradad degradar VMM02P0 +degradando degradar VMG0000 +degradar degradar VMN0000 +degrade degradar VMM03S0 +degrademos degradar VMM01P0 +degraden degradar VMM03P0 +degusta degustar VMM02S0 +degustad degustar VMM02P0 +degustando degustar VMG0000 +degustar degustar VMN0000 +deguste degustar VMM03S0 +degustemos degustar VMM01P0 +degusten degustar VMM03P0 +degüella degollar VMM02S0 +degüelle degollar VMM03S0 +degüellen degollar VMM03P0 +deifica deificar VMM02S0 +deificad deificar VMM02P0 +deificando deificar VMG0000 +deificar deificar VMN0000 +deifique deificar VMM03S0 +deifiquemos deificar VMM01P0 +deifiquen deificar VMM03P0 +deja dejar VMM02S0 +dejad dejar VMM02P0 +dejando dejar VMG0000 +dejar dejar VMN0000 +deje dejar VMM03S0 +dejemos dejar VMM01P0 +dejen dejar VMM03P0 +delata delatar VMM02S0 +delatad delatar VMM02P0 +delatando delatar VMG0000 +delatar delatar VMN0000 +delate delatar VMM03S0 +delatemos delatar VMM01P0 +delaten delatar VMM03P0 +delega delegar VMM02S0 +delegad delegar VMM02P0 +delegando delegar VMG0000 +delegar delegar VMN0000 +delegue delegar VMM03S0 +deleguemos delegar VMM01P0 +deleguen delegar VMM03P0 +deleita deleitar VMM02S0 +deleitad deleitar VMM02P0 +deleitando deleitar VMG0000 +deleitar deleitar VMN0000 +deleite deleitar VMM03S0 +deleitemos deleitar VMM01P0 +deleiten deleitar VMM03P0 +deletrea deletrear VMM02S0 +deletread deletrear VMM02P0 +deletreando deletrear VMG0000 +deletrear deletrear VMN0000 +deletree deletrear VMM03S0 +deletreemos deletrear VMM01P0 +deletreen deletrear VMM03P0 +delibera deliberar VMM02S0 +deliberad deliberar VMM02P0 +deliberando deliberar VMG0000 +deliberar deliberar VMN0000 +delibere deliberar VMM03S0 +deliberemos deliberar VMM01P0 +deliberen deliberar VMM03P0 +delimita delimitar VMM02S0 +delimitad delimitar VMM02P0 +delimitando delimitar VMG0000 +delimitar delimitar VMN0000 +delimite delimitar VMM03S0 +delimitemos delimitar VMM01P0 +delimiten delimitar VMM03P0 +delinca delinquir VMM03S0 +delincamos delinquir VMM01P0 +delincan delinquir VMM03P0 +delinea delinear VMM02S0 +delinead delinear VMM02P0 +delineando delinear VMG0000 +delinear delinear VMN0000 +delinee delinear VMM03S0 +delineemos delinear VMM01P0 +delineen delinear VMM03P0 +delinque delinquir VMM02S0 +delinquid delinquir VMM02P0 +delinquiendo delinquir VMG0000 +delinquir delinquir VMN0000 +delira delirar VMM02S0 +delirad delirar VMM02P0 +delirando delirar VMG0000 +delirar delirar VMN0000 +delire delirar VMM03S0 +deliremos delirar VMM01P0 +deliren delirar VMM03P0 +demacra demacrar VMM02S0 +demacrad demacrar VMM02P0 +demacrando demacrar VMG0000 +demacrar demacrar VMN0000 +demacre demacrar VMM03S0 +demacremos demacrar VMM01P0 +demacren demacrar VMM03P0 +demanda demandar VMM02S0 +demandad demandar VMM02P0 +demandando demandar VMG0000 +demandar demandar VMN0000 +demande demandar VMM03S0 +demandemos demandar VMM01P0 +demanden demandar VMM03P0 +demarca demarcar VMM02S0 +demarcad demarcar VMM02P0 +demarcando demarcar VMG0000 +demarcar demarcar VMN0000 +demarque demarcar VMM03S0 +demarquemos demarcar VMM01P0 +demarquen demarcar VMM03P0 +demasia demasiar VMM02S0 +demasiad demasiar VMM02P0 +demasiando demasiar VMG0000 +demasiar demasiar VMN0000 +demasie demasiar VMM03S0 +demasiemos demasiar VMM01P0 +demasien demasiar VMM03P0 +democratice democratizar VMM03S0 +democraticemos democratizar VMM01P0 +democraticen democratizar VMM03P0 +democratiza democratizar VMM02S0 +democratizad democratizar VMM02P0 +democratizando democratizar VMG0000 +democratizar democratizar VMN0000 +demodula demodular VMM02S0 +demodulad demodular VMM02P0 +demodulando demodular VMG0000 +demodular demodular VMN0000 +demodule demodular VMM03S0 +demodulemos demodular VMM01P0 +demodulen demodular VMM03P0 +demolamos demoler VMM01P0 +demoled demoler VMM02P0 +demoler demoler VMN0000 +demoliendo demoler VMG0000 +demora demorar VMM02S0 +demorad demorar VMM02P0 +demorando demorar VMG0000 +demorar demorar VMN0000 +demore demorar VMM03S0 +demoremos demorar VMM01P0 +demoren demorar VMM03P0 +demos dar VMM01P0 +demostrad demostrar VMM02P0 +demostrando demostrar VMG0000 +demostrar demostrar VMN0000 +demostremos demostrar VMM01P0 +demuda demudar VMM02S0 +demudad demudar VMM02P0 +demudando demudar VMG0000 +demudar demudar VMN0000 +demude demudar VMM03S0 +demudemos demudar VMM01P0 +demuden demudar VMM03P0 +demuela demoler VMM03S0 +demuelan demoler VMM03P0 +demuele demoler VMM02S0 +demuestra demostrar VMM02S0 +demuestre demostrar VMM03S0 +demuestren demostrar VMM03P0 +den dar VMM03P0 +denegad denegar VMM02P0 +denegando denegar VMG0000 +denegar denegar VMN0000 +denegrece denegrecer VMM02S0 +denegreced denegrecer VMM02P0 +denegrecer denegrecer VMN0000 +denegreciendo denegrecer VMG0000 +denegrezca denegrecer VMM03S0 +denegrezcamos denegrecer VMM01P0 +denegrezcan denegrecer VMM03P0 +deneguemos denegar VMM01P0 +denguea denguear VMM02S0 +denguead denguear VMM02P0 +dengueando denguear VMG0000 +denguear denguear VMN0000 +denguee denguear VMM03S0 +dengueemos denguear VMM01P0 +dengueen denguear VMM03P0 +deniega denegar VMM02S0 +deniegue denegar VMM03S0 +denieguen denegar VMM03P0 +denigra denigrar VMM02S0 +denigrad denigrar VMM02P0 +denigrando denigrar VMG0000 +denigrar denigrar VMN0000 +denigre denigrar VMM03S0 +denigremos denigrar VMM01P0 +denigren denigrar VMM03P0 +denomina denominar VMM02S0 +denominad denominar VMM02P0 +denominando denominar VMG0000 +denominar denominar VMN0000 +denomine denominar VMM03S0 +denominemos denominar VMM01P0 +denominen denominar VMM03P0 +denostad denostar VMM02P0 +denostando denostar VMG0000 +denostar denostar VMN0000 +denostemos denostar VMM01P0 +denota denotar VMM02S0 +denotad denotar VMM02P0 +denotando denotar VMG0000 +denotar denotar VMN0000 +denote denotar VMM03S0 +denotemos denotar VMM01P0 +denoten denotar VMM03P0 +densifica densificar VMM02S0 +densificad densificar VMM02P0 +densificando densificar VMG0000 +densificar densificar VMN0000 +densifique densificar VMM03S0 +densifiquemos densificar VMM01P0 +densifiquen densificar VMM03P0 +dentad dentar VMM02P0 +dentando dentar VMG0000 +dentar dentar VMN0000 +dentella dentellar VMM02S0 +dentellad dentellar VMM02P0 +dentellando dentellar VMG0000 +dentellar dentellar VMN0000 +dentelle dentellar VMM03S0 +dentellea dentellear VMM02S0 +dentellead dentellear VMM02P0 +dentelleando dentellear VMG0000 +dentellear dentellear VMN0000 +dentellee dentellear VMM03S0 +dentelleemos dentellear VMM01P0 +dentelleen dentellear VMM03P0 +dentellemos dentellar VMM01P0 +dentellen dentellar VMM03P0 +dentemos dentar VMM01P0 +denuda denudar VMM02S0 +denudad denudar VMM02P0 +denudando denudar VMG0000 +denudar denudar VMN0000 +denude denudar VMM03S0 +denudemos denudar VMM01P0 +denuden denudar VMM03P0 +denuesta denostar VMM02S0 +denueste denostar VMM03S0 +denuesten denostar VMM03P0 +denuncia denunciar VMM02S0 +denunciad denunciar VMM02P0 +denunciando denunciar VMG0000 +denunciar denunciar VMN0000 +denuncie denunciar VMM03S0 +denunciemos denunciar VMM01P0 +denuncien denunciar VMM03P0 +depara deparar VMM02S0 +deparad deparar VMM02P0 +deparando deparar VMG0000 +deparar deparar VMN0000 +depare deparar VMM03S0 +deparemos deparar VMM01P0 +deparen deparar VMM03P0 +departa departir VMM03S0 +departamos departir VMM01P0 +departan departir VMM03P0 +departe departir VMM02S0 +departid departir VMM02P0 +departiendo departir VMG0000 +departir departir VMN0000 +depaupera depauperar VMM02S0 +depauperad depauperar VMM02P0 +depauperando depauperar VMG0000 +depauperar depauperar VMN0000 +depaupere depauperar VMM03S0 +depauperemos depauperar VMM01P0 +depauperen depauperar VMM03P0 +dependa depender VMM03S0 +dependamos depender VMM01P0 +dependan depender VMM03P0 +depende depender VMM02S0 +depended depender VMM02P0 +depender depender VMN0000 +dependiendo depender VMG0000 +depila depilar VMM02S0 +depilad depilar VMM02P0 +depilando depilar VMG0000 +depilar depilar VMN0000 +depile depilar VMM03S0 +depilemos depilar VMM01P0 +depilen depilar VMM03P0 +deplora deplorar VMM02S0 +deplorad deplorar VMM02P0 +deplorando deplorar VMG0000 +deplorar deplorar VMN0000 +deplore deplorar VMM03S0 +deploremos deplorar VMM01P0 +deploren deplorar VMM03P0 +deponed deponer VMM02P0 +deponer deponer VMN0000 +deponga deponer VMM03S0 +depongamos deponer VMM01P0 +depongan deponer VMM03P0 +deponiendo deponer VMG0000 +deporta deportar VMM02S0 +deportad deportar VMM02P0 +deportando deportar VMG0000 +deportar deportar VMN0000 +deporte deportar VMM03S0 +deportemos deportar VMM01P0 +deporten deportar VMM03P0 +deposita depositar VMM02S0 +depositad depositar VMM02P0 +depositando depositar VMG0000 +depositar depositar VMN0000 +deposite depositar VMM03S0 +depositemos depositar VMM01P0 +depositen depositar VMM03P0 +deprava depravar VMM02S0 +depravad depravar VMM02P0 +depravando depravar VMG0000 +depravar depravar VMN0000 +deprave depravar VMM03S0 +depravemos depravar VMM01P0 +depraven depravar VMM03P0 +depreca deprecar VMM02S0 +deprecad deprecar VMM02P0 +deprecando deprecar VMG0000 +deprecar deprecar VMN0000 +deprecia depreciar VMM02S0 +depreciad depreciar VMM02P0 +depreciando depreciar VMG0000 +depreciar depreciar VMN0000 +deprecie depreciar VMM03S0 +depreciemos depreciar VMM01P0 +deprecien depreciar VMM03P0 +depreda depredar VMM02S0 +depredad depredar VMM02P0 +depredando depredar VMG0000 +depredar depredar VMN0000 +deprede depredar VMM03S0 +depredemos depredar VMM01P0 +depreden depredar VMM03P0 +depreque deprecar VMM03S0 +deprequemos deprecar VMM01P0 +deprequen deprecar VMM03P0 +deprima deprimir VMM03S0 +deprimamos deprimir VMM01P0 +depriman deprimir VMM03P0 +deprime deprimir VMM02S0 +deprimid deprimir VMM02P0 +deprimiendo deprimir VMG0000 +deprimir deprimir VMN0000 +depura depurar VMM02S0 +depurad depurar VMM02P0 +depurando depurar VMG0000 +depurar depurar VMN0000 +depure depurar VMM03S0 +depuremos depurar VMM01P0 +depuren depurar VMM03P0 +depón deponer VMM02S0 +deriva derivar VMM02S0 +derivad derivar VMM02P0 +derivando derivar VMG0000 +derivar derivar VMN0000 +derive derivar VMM03S0 +derivemos derivar VMM01P0 +deriven derivar VMM03P0 +deroga derogar VMM02S0 +derogad derogar VMM02P0 +derogando derogar VMG0000 +derogar derogar VMN0000 +derogue derogar VMM03S0 +deroguemos derogar VMM01P0 +deroguen derogar VMM03P0 +derrama derramar VMM02S0 +derramad derramar VMM02P0 +derramando derramar VMG0000 +derramar derramar VMN0000 +derrame derramar VMM03S0 +derramemos derramar VMM01P0 +derramen derramar VMM03P0 +derrapa derrapar VMM02S0 +derrapad derrapar VMM02P0 +derrapando derrapar VMG0000 +derrapar derrapar VMN0000 +derrape derrapar VMM03S0 +derrapemos derrapar VMM01P0 +derrapen derrapar VMM03P0 +derrelinca derrelinquir VMM03S0 +derrelincamos derrelinquir VMM01P0 +derrelincan derrelinquir VMM03P0 +derrelinque derrelinquir VMM02S0 +derrelinquid derrelinquir VMM02P0 +derrelinquiendo derrelinquir VMG0000 +derrelinquir derrelinquir VMN0000 +derrengad derrengar VMM02P0 +derrengando derrengar VMG0000 +derrengar derrengar VMN0000 +derrenguemos derrengar VMM01P0 +derretid derretir VMM02P0 +derretir derretir VMN0000 +derriba derribar VMM02S0 +derribad derribar VMM02P0 +derribando derribar VMG0000 +derribar derribar VMN0000 +derribe derribar VMM03S0 +derribemos derribar VMM01P0 +derriben derribar VMM03P0 +derrienga derrengar VMM02S0 +derriengue derrengar VMM03S0 +derrienguen derrengar VMM03P0 +derrita derretir VMM03S0 +derritamos derretir VMM01P0 +derritan derretir VMM03P0 +derrite derretir VMM02S0 +derritiendo derretir VMG0000 +derroca derrocar VMM02S0 +derrocad derrocar VMM02P0 +derrocando derrocar VMG0000 +derrocar derrocar VMN0000 +derrocha derrochar VMM02S0 +derrochad derrochar VMM02P0 +derrochando derrochar VMG0000 +derrochar derrochar VMN0000 +derroche derrochar VMM03S0 +derrochemos derrochar VMM01P0 +derrochen derrochar VMM03P0 +derroque derrocar VMM03S0 +derroquemos derrocar VMM01P0 +derroquen derrocar VMM03P0 +derrota derrotar VMM02S0 +derrotad derrotar VMM02P0 +derrotando derrotar VMG0000 +derrotar derrotar VMN0000 +derrote derrotar VMM03S0 +derrotemos derrotar VMM01P0 +derroten derrotar VMM03P0 +derrubia derrubiar VMM02S0 +derrubiad derrubiar VMM02P0 +derrubiando derrubiar VMG0000 +derrubiar derrubiar VMN0000 +derrubie derrubiar VMM03S0 +derrubiemos derrubiar VMM01P0 +derrubien derrubiar VMM03P0 +derruid derruir VMM02P0 +derruir derruir VMN0000 +derrumba derrumbar VMM02S0 +derrumbad derrumbar VMM02P0 +derrumbando derrumbar VMG0000 +derrumbar derrumbar VMN0000 +derrumbe derrumbar VMM03S0 +derrumbemos derrumbar VMM01P0 +derrumben derrumbar VMM03P0 +derruya derruir VMM03S0 +derruyamos derruir VMM01P0 +derruyan derruir VMM03P0 +derruye derruir VMM02S0 +derruyendo derruir VMG0000 +desabarranca desabarrancar VMM02S0 +desabarrancad desabarrancar VMM02P0 +desabarrancando desabarrancar VMG0000 +desabarrancar desabarrancar VMN0000 +desabarranque desabarrancar VMM03S0 +desabarranquemos desabarrancar VMM01P0 +desabarranquen desabarrancar VMM03P0 +desabastece desabastecer VMM02S0 +desabasteced desabastecer VMM02P0 +desabastecer desabastecer VMN0000 +desabasteciendo desabastecer VMG0000 +desabastezca desabastecer VMM03S0 +desabastezcamos desabastecer VMM01P0 +desabastezcan desabastecer VMM03P0 +desabolla desabollar VMM02S0 +desabollad desabollar VMM02P0 +desabollando desabollar VMG0000 +desabollar desabollar VMN0000 +desabolle desabollar VMM03S0 +desabollemos desabollar VMM01P0 +desabollen desabollar VMM03P0 +desabona desabonar VMM02S0 +desabonad desabonar VMM02P0 +desabonando desabonar VMG0000 +desabonar desabonar VMN0000 +desabone desabonar VMM03S0 +desabonemos desabonar VMM01P0 +desabonen desabonar VMM03P0 +desabotona desabotonar VMM02S0 +desabotonad desabotonar VMM02P0 +desabotonando desabotonar VMG0000 +desabotonar desabotonar VMN0000 +desabotone desabotonar VMM03S0 +desabotonemos desabotonar VMM01P0 +desabotonen desabotonar VMM03P0 +desabra desabrir VMM03S0 +desabramos desabrir VMM01P0 +desabran desabrir VMM03P0 +desabre desabrir VMM02S0 +desabrid desabrir VMM02P0 +desabriendo desabrir VMG0000 +desabriga desabrigar VMM02S0 +desabrigad desabrigar VMM02P0 +desabrigando desabrigar VMG0000 +desabrigar desabrigar VMN0000 +desabrigue desabrigar VMM03S0 +desabriguemos desabrigar VMM01P0 +desabriguen desabrigar VMM03P0 +desabrir desabrir VMN0000 +desabrocha desabrochar VMM02S0 +desabrochad desabrochar VMM02P0 +desabrochando desabrochar VMG0000 +desabrochar desabrochar VMN0000 +desabroche desabrochar VMM03S0 +desabrochemos desabrochar VMM01P0 +desabrochen desabrochar VMM03P0 +desacalora desacalorar VMM02S0 +desacalorad desacalorar VMM02P0 +desacalorando desacalorar VMG0000 +desacalorar desacalorar VMN0000 +desacalore desacalorar VMM03S0 +desacaloremos desacalorar VMM01P0 +desacaloren desacalorar VMM03P0 +desacata desacatar VMM02S0 +desacatad desacatar VMM02P0 +desacatando desacatar VMG0000 +desacatar desacatar VMN0000 +desacate desacatar VMM03S0 +desacatemos desacatar VMM01P0 +desacaten desacatar VMM03P0 +desaceita desaceitar VMM02S0 +desaceitad desaceitar VMM02P0 +desaceitando desaceitar VMG0000 +desaceitar desaceitar VMN0000 +desaceite desaceitar VMM03S0 +desaceitemos desaceitar VMM01P0 +desaceiten desaceitar VMM03P0 +desacelera desacelerar VMM02S0 +desacelerad desacelerar VMM02P0 +desacelerando desacelerar VMG0000 +desacelerar desacelerar VMN0000 +desacelere desacelerar VMM03S0 +desaceleremos desacelerar VMM01P0 +desaceleren desacelerar VMM03P0 +desacera desacerar VMM02S0 +desacerad desacerar VMM02P0 +desacerando desacerar VMG0000 +desacerar desacerar VMN0000 +desacere desacerar VMM03S0 +desaceremos desacerar VMM01P0 +desaceren desacerar VMM03P0 +desacertad desacertar VMM02P0 +desacertando desacertar VMG0000 +desacertar desacertar VMN0000 +desacertemos desacertar VMM01P0 +desacierta desacertar VMM02S0 +desacierte desacertar VMM03S0 +desacierten desacertar VMM03P0 +desacobarda desacobardar VMM02S0 +desacobardad desacobardar VMM02P0 +desacobardando desacobardar VMG0000 +desacobardar desacobardar VMN0000 +desacobarde desacobardar VMM03S0 +desacobardemos desacobardar VMM01P0 +desacobarden desacobardar VMM03P0 +desacomoda desacomodar VMM02S0 +desacomodad desacomodar VMM02P0 +desacomodando desacomodar VMG0000 +desacomodar desacomodar VMN0000 +desacomode desacomodar VMM03S0 +desacomodemos desacomodar VMM01P0 +desacomoden desacomodar VMM03P0 +desacompaña desacompañar VMM02S0 +desacompañad desacompañar VMM02P0 +desacompañando desacompañar VMG0000 +desacompañar desacompañar VMN0000 +desacompañe desacompañar VMM03S0 +desacompañemos desacompañar VMM01P0 +desacompañen desacompañar VMM03P0 +desacondiciona desacondicionar VMM02S0 +desacondicionad desacondicionar VMM02P0 +desacondicionando desacondicionar VMG0000 +desacondicionar desacondicionar VMN0000 +desacondicione desacondicionar VMM03S0 +desacondicionemos desacondicionar VMM01P0 +desacondicionen desacondicionar VMM03P0 +desaconseja desaconsejar VMM02S0 +desaconsejad desaconsejar VMM02P0 +desaconsejando desaconsejar VMG0000 +desaconsejar desaconsejar VMN0000 +desaconseje desaconsejar VMM03S0 +desaconsejemos desaconsejar VMM01P0 +desaconsejen desaconsejar VMM03P0 +desacopla desacoplar VMM02S0 +desacoplad desacoplar VMM02P0 +desacoplando desacoplar VMG0000 +desacoplar desacoplar VMN0000 +desacople desacoplar VMM03S0 +desacoplemos desacoplar VMM01P0 +desacoplen desacoplar VMM03P0 +desacordad desacordar VMM02P0 +desacordando desacordar VMG0000 +desacordar desacordar VMN0000 +desacordemos desacordar VMM01P0 +desacostumbra desacostumbrar VMM02S0 +desacostumbrad desacostumbrar VMM02P0 +desacostumbrando desacostumbrar VMG0000 +desacostumbrar desacostumbrar VMN0000 +desacostumbre desacostumbrar VMM03S0 +desacostumbremos desacostumbrar VMM01P0 +desacostumbren desacostumbrar VMM03P0 +desacota desacotar VMM02S0 +desacotad desacotar VMM02P0 +desacotando desacotar VMG0000 +desacotar desacotar VMN0000 +desacote desacotar VMM03S0 +desacotemos desacotar VMM01P0 +desacoten desacotar VMM03P0 +desacredita desacreditar VMM02S0 +desacreditad desacreditar VMM02P0 +desacreditando desacreditar VMG0000 +desacreditar desacreditar VMN0000 +desacredite desacreditar VMM03S0 +desacreditemos desacreditar VMM01P0 +desacrediten desacreditar VMM03P0 +desactiva desactivar VMM02S0 +desactivad desactivar VMM02P0 +desactivando desactivar VMG0000 +desactivar desactivar VMN0000 +desactive desactivar VMM03S0 +desactivemos desactivar VMM01P0 +desactiven desactivar VMM03P0 +desacuerda desacordar VMM02S0 +desacuerde desacordar VMM03S0 +desacuerden desacordar VMM03P0 +desadeuda desadeudar VMM02S0 +desadeudad desadeudar VMM02P0 +desadeudando desadeudar VMG0000 +desadeudar desadeudar VMN0000 +desadeude desadeudar VMM03S0 +desadeudemos desadeudar VMM01P0 +desadeuden desadeudar VMM03P0 +desadormece desadormecer VMM02S0 +desadormeced desadormecer VMM02P0 +desadormecer desadormecer VMN0000 +desadormeciendo desadormecer VMG0000 +desadormezca desadormecer VMM03S0 +desadormezcamos desadormecer VMM01P0 +desadormezcan desadormecer VMM03P0 +desadorna desadornar VMM02S0 +desadornad desadornar VMM02P0 +desadornando desadornar VMG0000 +desadornar desadornar VMN0000 +desadorne desadornar VMM03S0 +desadornemos desadornar VMM01P0 +desadornen desadornar VMM03P0 +desadvertid desadvertir VMM02P0 +desadvertir desadvertir VMN0000 +desadvierta desadvertir VMM03S0 +desadviertan desadvertir VMM03P0 +desadvierte desadvertir VMM02S0 +desadvirtamos desadvertir VMM01P0 +desadvirtiendo desadvertir VMG0000 +desafea desafear VMM02S0 +desafead desafear VMM02P0 +desafeando desafear VMG0000 +desafear desafear VMN0000 +desafee desafear VMM03S0 +desafeemos desafear VMM01P0 +desafeen desafear VMM03P0 +desaferra desaferrar VMM02S0 +desaferrad desaferrar VMM02P0 +desaferrando desaferrar VMG0000 +desaferrar desaferrar VMN0000 +desaferre desaferrar VMM03S0 +desaferremos desaferrar VMM01P0 +desaferren desaferrar VMM03P0 +desafiad desafiar VMM02P0 +desafiando desafiar VMG0000 +desafiar desafiar VMN0000 +desaficiona desaficionar VMM02S0 +desaficionad desaficionar VMM02P0 +desaficionando desaficionar VMG0000 +desaficionar desaficionar VMN0000 +desaficione desaficionar VMM03S0 +desaficionemos desaficionar VMM01P0 +desaficionen desaficionar VMM03P0 +desafiemos desafiar VMM01P0 +desafila desafilar VMM02S0 +desafilad desafilar VMM02P0 +desafilando desafilar VMG0000 +desafilar desafilar VMN0000 +desafile desafilar VMM03S0 +desafilemos desafilar VMM01P0 +desafilen desafilar VMM03P0 +desafina desafinar VMM02S0 +desafinad desafinar VMM02P0 +desafinando desafinar VMG0000 +desafinar desafinar VMN0000 +desafine desafinar VMM03S0 +desafinemos desafinar VMM01P0 +desafinen desafinar VMM03P0 +desaforad desaforar VMM02P0 +desaforando desaforar VMG0000 +desaforar desaforar VMN0000 +desaforemos desaforar VMM01P0 +desaforra desaforrar VMM02S0 +desaforrad desaforrar VMM02P0 +desaforrando desaforrar VMG0000 +desaforrar desaforrar VMN0000 +desaforre desaforrar VMM03S0 +desaforremos desaforrar VMM01P0 +desaforren desaforrar VMM03P0 +desafuera desaforar VMM02S0 +desafuere desaforar VMM03S0 +desafueren desaforar VMM03P0 +desafía desafiar VMM02S0 +desafíe desafiar VMM03S0 +desafíen desafiar VMM03P0 +desagarra desagarrar VMM02S0 +desagarrad desagarrar VMM02P0 +desagarrando desagarrar VMG0000 +desagarrar desagarrar VMN0000 +desagarre desagarrar VMM03S0 +desagarremos desagarrar VMM01P0 +desagarren desagarrar VMM03P0 +desagracia desagraciar VMM02S0 +desagraciad desagraciar VMM02P0 +desagraciando desagraciar VMG0000 +desagraciar desagraciar VMN0000 +desagracie desagraciar VMM03S0 +desagraciemos desagraciar VMM01P0 +desagracien desagraciar VMM03P0 +desagrada desagradar VMM02S0 +desagradad desagradar VMM02P0 +desagradando desagradar VMG0000 +desagradar desagradar VMN0000 +desagrade desagradar VMM03S0 +desagradece desagradecer VMM02S0 +desagradeced desagradecer VMM02P0 +desagradecer desagradecer VMN0000 +desagradeciendo desagradecer VMG0000 +desagrademos desagradar VMM01P0 +desagraden desagradar VMM03P0 +desagradezca desagradecer VMM03S0 +desagradezcamos desagradecer VMM01P0 +desagradezcan desagradecer VMM03P0 +desagravia desagraviar VMM02S0 +desagraviad desagraviar VMM02P0 +desagraviando desagraviar VMG0000 +desagraviar desagraviar VMN0000 +desagravie desagraviar VMM03S0 +desagraviemos desagraviar VMM01P0 +desagravien desagraviar VMM03P0 +desagrega desagregar VMM02S0 +desagregad desagregar VMM02P0 +desagregando desagregar VMG0000 +desagregar desagregar VMN0000 +desagregue desagregar VMM03S0 +desagreguemos desagregar VMM01P0 +desagreguen desagregar VMM03P0 +desagua desaguar VMM02S0 +desaguace desaguazar VMM03S0 +desaguacemos desaguazar VMM01P0 +desaguacen desaguazar VMM03P0 +desaguad desaguar VMM02P0 +desaguando desaguar VMG0000 +desaguar desaguar VMN0000 +desaguaza desaguazar VMM02S0 +desaguazad desaguazar VMM02P0 +desaguazando desaguazar VMG0000 +desaguazar desaguazar VMN0000 +desagüe desaguar VMM03S0 +desagüemos desaguar VMM01P0 +desagüen desaguar VMM03P0 +desaherroja desaherrojar VMM02S0 +desaherrojad desaherrojar VMM02P0 +desaherrojando desaherrojar VMG0000 +desaherrojar desaherrojar VMN0000 +desaherroje desaherrojar VMM03S0 +desaherrojemos desaherrojar VMM01P0 +desaherrojen desaherrojar VMM03P0 +desahijad desahijar VMM02P0 +desahijando desahijar VMG0000 +desahijar desahijar VMN0000 +desahijemos desahijar VMM01P0 +desahoga desahogar VMM02S0 +desahogad desahogar VMM02P0 +desahogando desahogar VMG0000 +desahogar desahogar VMN0000 +desahogue desahogar VMM03S0 +desahoguemos desahogar VMM01P0 +desahoguen desahogar VMM03P0 +desahucia desahuciar VMM02S0 +desahuciad desahuciar VMM02P0 +desahuciando desahuciar VMG0000 +desahuciar desahuciar VMN0000 +desahucie desahuciar VMM03S0 +desahuciemos desahuciar VMM01P0 +desahucien desahuciar VMM03P0 +desahíja desahijar VMM02S0 +desahíje desahijar VMM03S0 +desahíjen desahijar VMM03P0 +desainad desainar VMM02P0 +desainando desainar VMG0000 +desainar desainar VMN0000 +desainemos desainar VMM01P0 +desaira desairar VMM02S0 +desairad desairar VMM02P0 +desairando desairar VMG0000 +desairar desairar VMN0000 +desaire desairar VMM03S0 +desairemos desairar VMM01P0 +desairen desairar VMM03P0 +desajusta desajustar VMM02S0 +desajustad desajustar VMM02P0 +desajustando desajustar VMG0000 +desajustar desajustar VMN0000 +desajuste desajustar VMM03S0 +desajustemos desajustar VMM01P0 +desajusten desajustar VMM03P0 +desala desalar VMM02S0 +desalaba desalabar VMM02S0 +desalabad desalabar VMM02P0 +desalabando desalabar VMG0000 +desalabar desalabar VMN0000 +desalabe desalabar VMM03S0 +desalabea desalabear VMM02S0 +desalabead desalabear VMM02P0 +desalabeando desalabear VMG0000 +desalabear desalabear VMN0000 +desalabee desalabear VMM03S0 +desalabeemos desalabear VMM01P0 +desalabeen desalabear VMM03P0 +desalabemos desalabar VMM01P0 +desalaben desalabar VMM03P0 +desalad desalar VMM02P0 +desalando desalar VMG0000 +desalar desalar VMN0000 +desalbarda desalbardar VMM02S0 +desalbardad desalbardar VMM02P0 +desalbardando desalbardar VMG0000 +desalbardar desalbardar VMN0000 +desalbarde desalbardar VMM03S0 +desalbardemos desalbardar VMM01P0 +desalbarden desalbardar VMM03P0 +desale desalar VMM03S0 +desalemos desalar VMM01P0 +desalen desalar VMM03P0 +desalentad desalentar VMM02P0 +desalentando desalentar VMG0000 +desalentar desalentar VMN0000 +desalentemos desalentar VMM01P0 +desalfombra desalfombrar VMM02S0 +desalfombrad desalfombrar VMM02P0 +desalfombrando desalfombrar VMG0000 +desalfombrar desalfombrar VMN0000 +desalfombre desalfombrar VMM03S0 +desalfombremos desalfombrar VMM01P0 +desalfombren desalfombrar VMM03P0 +desalforja desalforjar VMM02S0 +desalforjad desalforjar VMM02P0 +desalforjando desalforjar VMG0000 +desalforjar desalforjar VMN0000 +desalforje desalforjar VMM03S0 +desalforjemos desalforjar VMM01P0 +desalforjen desalforjar VMM03P0 +desalhaja desalhajar VMM02S0 +desalhajad desalhajar VMM02P0 +desalhajando desalhajar VMG0000 +desalhajar desalhajar VMN0000 +desalhaje desalhajar VMM03S0 +desalhajemos desalhajar VMM01P0 +desalhajen desalhajar VMM03P0 +desalienta desalentar VMM02S0 +desaliente desalentar VMM03S0 +desalienten desalentar VMM03P0 +desalinea desalinear VMM02S0 +desalinead desalinear VMM02P0 +desalineando desalinear VMG0000 +desalinear desalinear VMN0000 +desalinee desalinear VMM03S0 +desalineemos desalinear VMM01P0 +desalineen desalinear VMM03P0 +desalinice desalinizar VMM03S0 +desalinicemos desalinizar VMM01P0 +desalinicen desalinizar VMM03P0 +desaliniza desalinizar VMM02S0 +desalinizad desalinizar VMM02P0 +desalinizando desalinizar VMG0000 +desalinizar desalinizar VMN0000 +desaliña desaliñar VMM02S0 +desaliñad desaliñar VMM02P0 +desaliñando desaliñar VMG0000 +desaliñar desaliñar VMN0000 +desaliñe desaliñar VMM03S0 +desaliñemos desaliñar VMM01P0 +desaliñen desaliñar VMM03P0 +desalma desalmar VMM02S0 +desalmad desalmar VMM02P0 +desalmando desalmar VMG0000 +desalmar desalmar VMN0000 +desalme desalmar VMM03S0 +desalmemos desalmar VMM01P0 +desalmen desalmar VMM03P0 +desalmidona desalmidonar VMM02S0 +desalmidonad desalmidonar VMM02P0 +desalmidonando desalmidonar VMG0000 +desalmidonar desalmidonar VMN0000 +desalmidone desalmidonar VMM03S0 +desalmidonemos desalmidonar VMM01P0 +desalmidonen desalmidonar VMM03P0 +desaloja desalojar VMM02S0 +desalojad desalojar VMM02P0 +desalojando desalojar VMG0000 +desalojar desalojar VMN0000 +desaloje desalojar VMM03S0 +desalojemos desalojar VMM01P0 +desalojen desalojar VMM03P0 +desalquila desalquilar VMM02S0 +desalquilad desalquilar VMM02P0 +desalquilando desalquilar VMG0000 +desalquilar desalquilar VMN0000 +desalquile desalquilar VMM03S0 +desalquilemos desalquilar VMM01P0 +desalquilen desalquilar VMM03P0 +desalquitrana desalquitranar VMM02S0 +desalquitranad desalquitranar VMM02P0 +desalquitranando desalquitranar VMG0000 +desalquitranar desalquitranar VMN0000 +desaltera desalterar VMM02S0 +desalterad desalterar VMM02P0 +desalterando desalterar VMG0000 +desalterar desalterar VMN0000 +desaltere desalterar VMM03S0 +desalteremos desalterar VMM01P0 +desalteren desalterar VMM03P0 +desama desamar VMM02S0 +desamad desamar VMM02P0 +desamando desamar VMG0000 +desamar desamar VMN0000 +desamarra desamarrar VMM02S0 +desamarrad desamarrar VMM02P0 +desamarrando desamarrar VMG0000 +desamarrar desamarrar VMN0000 +desamarre desamarrar VMM03S0 +desamarremos desamarrar VMM01P0 +desamarren desamarrar VMM03P0 +desame desamar VMM03S0 +desamelga desamelgar VMM02S0 +desamelgad desamelgar VMM02P0 +desamelgando desamelgar VMG0000 +desamelgar desamelgar VMN0000 +desamemos desamar VMM01P0 +desamen desamar VMM03P0 +desamista desamistar VMM02S0 +desamistad desamistar VMM02P0 +desamistando desamistar VMG0000 +desamistar desamistar VMN0000 +desamiste desamistar VMM03S0 +desamistemos desamistar VMM01P0 +desamisten desamistar VMM03P0 +desamoblad desamoblar VMM02P0 +desamoblando desamoblar VMG0000 +desamoblar desamoblar VMN0000 +desamoblemos desamoblar VMM01P0 +desamolda desamoldar VMM02S0 +desamoldad desamoldar VMM02P0 +desamoldando desamoldar VMG0000 +desamoldar desamoldar VMN0000 +desamolde desamoldar VMM03S0 +desamoldemos desamoldar VMM01P0 +desamolden desamoldar VMM03P0 +desamontona desamontonar VMM02S0 +desamontonad desamontonar VMM02P0 +desamontonando desamontonar VMG0000 +desamontonar desamontonar VMN0000 +desamontone desamontonar VMM03S0 +desamontonemos desamontonar VMM01P0 +desamontonen desamontonar VMM03P0 +desamora desamorar VMM02S0 +desamorad desamorar VMM02P0 +desamorando desamorar VMG0000 +desamorar desamorar VMN0000 +desamore desamorar VMM03S0 +desamoremos desamorar VMM01P0 +desamoren desamorar VMM03P0 +desamortice desamortizar VMM03S0 +desamorticemos desamortizar VMM01P0 +desamorticen desamortizar VMM03P0 +desamortiza desamortizar VMM02S0 +desamortizad desamortizar VMM02P0 +desamortizando desamortizar VMG0000 +desamortizar desamortizar VMN0000 +desampara desamparar VMM02S0 +desamparad desamparar VMM02P0 +desamparando desamparar VMG0000 +desamparar desamparar VMN0000 +desampare desamparar VMM03S0 +desamparemos desamparar VMM01P0 +desamparen desamparar VMM03P0 +desamuebla desamoblar VMM02S0 +desamuebla desamueblar VMM02S0 +desamueblad desamueblar VMM02P0 +desamueblando desamueblar VMG0000 +desamueblar desamueblar VMN0000 +desamueble desamoblar VMM03S0 +desamueble desamueblar VMM03S0 +desamueblemos desamueblar VMM01P0 +desamueblen desamoblar VMM03P0 +desamueblen desamueblar VMM03P0 +desancla desanclar VMM02S0 +desanclad desanclar VMM02P0 +desanclando desanclar VMG0000 +desanclar desanclar VMN0000 +desancle desanclar VMM03S0 +desanclemos desanclar VMM01P0 +desanclen desanclar VMM03P0 +desancora desancorar VMM02S0 +desancorad desancorar VMM02P0 +desancorando desancorar VMG0000 +desancorar desancorar VMN0000 +desancore desancorar VMM03S0 +desancoremos desancorar VMM01P0 +desancoren desancorar VMM03P0 +desanda desandar VMM02S0 +desandad desandar VMM02P0 +desandando desandar VMG0000 +desandar desandar VMN0000 +desande desandar VMM03S0 +desandemos desandar VMM01P0 +desanden desandar VMM03P0 +desangra desangrar VMM02S0 +desangrad desangrar VMM02P0 +desangrando desangrar VMG0000 +desangrar desangrar VMN0000 +desangre desangrar VMM03S0 +desangremos desangrar VMM01P0 +desangren desangrar VMM03P0 +desanida desanidar VMM02S0 +desanidad desanidar VMM02P0 +desanidando desanidar VMG0000 +desanidar desanidar VMN0000 +desanide desanidar VMM03S0 +desanidemos desanidar VMM01P0 +desaniden desanidar VMM03P0 +desanima desanimar VMM02S0 +desanimad desanimar VMM02P0 +desanimando desanimar VMG0000 +desanimar desanimar VMN0000 +desanime desanimar VMM03S0 +desanimemos desanimar VMM01P0 +desanimen desanimar VMM03P0 +desanubla desanublar VMM02S0 +desanublad desanublar VMM02P0 +desanublando desanublar VMG0000 +desanublar desanublar VMN0000 +desanuble desanublar VMM03S0 +desanublemos desanublar VMM01P0 +desanublen desanublar VMM03P0 +desanuda desanudar VMM02S0 +desanudad desanudar VMM02P0 +desanudando desanudar VMG0000 +desanudar desanudar VMN0000 +desanude desanudar VMM03S0 +desanudemos desanudar VMM01P0 +desanuden desanudar VMM03P0 +desapadrina desapadrinar VMM02S0 +desapadrinad desapadrinar VMM02P0 +desapadrinando desapadrinar VMG0000 +desapadrinar desapadrinar VMN0000 +desapadrine desapadrinar VMM03S0 +desapadrinemos desapadrinar VMM01P0 +desapadrinen desapadrinar VMM03P0 +desaparea desaparear VMM02S0 +desaparead desaparear VMM02P0 +desapareando desaparear VMG0000 +desaparear desaparear VMN0000 +desaparece desaparecer VMM02S0 +desapareced desaparecer VMM02P0 +desaparecer desaparecer VMN0000 +desapareciendo desaparecer VMG0000 +desaparee desaparear VMM03S0 +desapareemos desaparear VMM01P0 +desapareen desaparear VMM03P0 +desapareja desaparejar VMM02S0 +desaparejad desaparejar VMM02P0 +desaparejando desaparejar VMG0000 +desaparejar desaparejar VMN0000 +desapareje desaparejar VMM03S0 +desaparejemos desaparejar VMM01P0 +desaparejen desaparejar VMM03P0 +desaparezca desaparecer VMM03S0 +desaparezcamos desaparecer VMM01P0 +desaparezcan desaparecer VMM03P0 +desapasiona desapasionar VMM02S0 +desapasionad desapasionar VMM02P0 +desapasionando desapasionar VMG0000 +desapasionar desapasionar VMN0000 +desapasione desapasionar VMM03S0 +desapasionemos desapasionar VMM01P0 +desapasionen desapasionar VMM03P0 +desapega desapegar VMM02S0 +desapegad desapegar VMM02P0 +desapegando desapegar VMG0000 +desapegar desapegar VMN0000 +desapegue desapegar VMM03S0 +desapeguemos desapegar VMM01P0 +desapeguen desapegar VMM03P0 +desapesta desapestar VMM02S0 +desapestad desapestar VMM02P0 +desapestando desapestar VMG0000 +desapestar desapestar VMN0000 +desapeste desapestar VMM03S0 +desapestemos desapestar VMM01P0 +desapesten desapestar VMM03P0 +desaploma desaplomar VMM02S0 +desaplomad desaplomar VMM02P0 +desaplomando desaplomar VMG0000 +desaplomar desaplomar VMN0000 +desaplome desaplomar VMM03S0 +desaplomemos desaplomar VMM01P0 +desaplomen desaplomar VMM03P0 +desapodera desapoderar VMM02S0 +desapoderad desapoderar VMM02P0 +desapoderando desapoderar VMG0000 +desapoderar desapoderar VMN0000 +desapodere desapoderar VMM03S0 +desapoderemos desapoderar VMM01P0 +desapoderen desapoderar VMM03P0 +desapolilla desapolillar VMM02S0 +desapolillad desapolillar VMM02P0 +desapolillando desapolillar VMG0000 +desapolillar desapolillar VMN0000 +desapolille desapolillar VMM03S0 +desapolillemos desapolillar VMM01P0 +desapolillen desapolillar VMM03P0 +desaporcad desaporcar VMM02P0 +desaporcando desaporcar VMG0000 +desaporcar desaporcar VMN0000 +desaporquemos desaporcar VMM01P0 +desaposenta desaposentar VMM02S0 +desaposentad desaposentar VMM02P0 +desaposentando desaposentar VMG0000 +desaposentar desaposentar VMN0000 +desaposente desaposentar VMM03S0 +desaposentemos desaposentar VMM01P0 +desaposenten desaposentar VMM03P0 +desapoya desapoyar VMM02S0 +desapoyad desapoyar VMM02P0 +desapoyando desapoyar VMG0000 +desapoyar desapoyar VMN0000 +desapoye desapoyar VMM03S0 +desapoyemos desapoyar VMM01P0 +desapoyen desapoyar VMM03P0 +desaprecia desapreciar VMM02S0 +desapreciad desapreciar VMM02P0 +desapreciando desapreciar VMG0000 +desapreciar desapreciar VMN0000 +desaprecie desapreciar VMM03S0 +desapreciemos desapreciar VMM01P0 +desaprecien desapreciar VMM03P0 +desaprenda desaprender VMM03S0 +desaprendamos desaprender VMM01P0 +desaprendan desaprender VMM03P0 +desaprende desaprender VMM02S0 +desaprended desaprender VMM02P0 +desaprender desaprender VMN0000 +desaprendiendo desaprender VMG0000 +desaprensa desaprensar VMM02S0 +desaprensad desaprensar VMM02P0 +desaprensando desaprensar VMG0000 +desaprensar desaprensar VMN0000 +desaprense desaprensar VMM03S0 +desaprensemos desaprensar VMM01P0 +desaprensen desaprensar VMM03P0 +desapretad desapretar VMM02P0 +desapretando desapretar VMG0000 +desapretar desapretar VMN0000 +desapretemos desapretar VMM01P0 +desaprieta desapretar VMM02S0 +desapriete desapretar VMM03S0 +desaprieten desapretar VMM03P0 +desaprobad desaprobar VMM02P0 +desaprobando desaprobar VMG0000 +desaprobar desaprobar VMN0000 +desaprobemos desaprobar VMM01P0 +desapropia desapropiar VMM02S0 +desapropiad desapropiar VMM02P0 +desapropiando desapropiar VMG0000 +desapropiar desapropiar VMN0000 +desapropie desapropiar VMM03S0 +desapropiemos desapropiar VMM01P0 +desapropien desapropiar VMM03P0 +desaprovecha desaprovechar VMM02S0 +desaprovechad desaprovechar VMM02P0 +desaprovechando desaprovechar VMG0000 +desaprovechar desaprovechar VMN0000 +desaproveche desaprovechar VMM03S0 +desaprovechemos desaprovechar VMM01P0 +desaprovechen desaprovechar VMM03P0 +desaprueba desaprobar VMM02S0 +desapruebe desaprobar VMM03S0 +desaprueben desaprobar VMM03P0 +desapuerca desaporcar VMM02S0 +desapuerque desaporcar VMM03S0 +desapuerquen desaporcar VMM03P0 +desapunta desapuntar VMM02S0 +desapuntad desapuntar VMM02P0 +desapuntala desapuntalar VMM02S0 +desapuntalad desapuntalar VMM02P0 +desapuntalando desapuntalar VMG0000 +desapuntalar desapuntalar VMN0000 +desapuntale desapuntalar VMM03S0 +desapuntalemos desapuntalar VMM01P0 +desapuntalen desapuntalar VMM03P0 +desapuntando desapuntar VMG0000 +desapuntar desapuntar VMN0000 +desapunte desapuntar VMM03S0 +desapuntemos desapuntar VMM01P0 +desapunten desapuntar VMM03P0 +desarbola desarbolar VMM02S0 +desarbolad desarbolar VMM02P0 +desarbolando desarbolar VMG0000 +desarbolar desarbolar VMN0000 +desarbole desarbolar VMM03S0 +desarbolemos desarbolar VMM01P0 +desarbolen desarbolar VMM03P0 +desarena desarenar VMM02S0 +desarenad desarenar VMM02P0 +desarenando desarenar VMG0000 +desarenar desarenar VMN0000 +desarene desarenar VMM03S0 +desarenemos desarenar VMM01P0 +desarenen desarenar VMM03P0 +desarma desarmar VMM02S0 +desarmad desarmar VMM02P0 +desarmando desarmar VMG0000 +desarmar desarmar VMN0000 +desarme desarmar VMM03S0 +desarmemos desarmar VMM01P0 +desarmen desarmar VMM03P0 +desarmonice desarmonizar VMM03S0 +desarmonicemos desarmonizar VMM01P0 +desarmonicen desarmonizar VMM03P0 +desarmoniza desarmonizar VMM02S0 +desarmonizad desarmonizar VMM02P0 +desarmonizando desarmonizar VMG0000 +desarmonizar desarmonizar VMN0000 +desarraiga desarraigar VMM02S0 +desarraigad desarraigar VMM02P0 +desarraigando desarraigar VMG0000 +desarraigar desarraigar VMN0000 +desarraigue desarraigar VMM03S0 +desarraiguemos desarraigar VMM01P0 +desarraiguen desarraigar VMM03P0 +desarreboce desarrebozar VMM03S0 +desarrebocemos desarrebozar VMM01P0 +desarrebocen desarrebozar VMM03P0 +desarreboza desarrebozar VMM02S0 +desarrebozad desarrebozar VMM02P0 +desarrebozando desarrebozar VMG0000 +desarrebozar desarrebozar VMN0000 +desarregla desarreglar VMM02S0 +desarreglad desarreglar VMM02P0 +desarreglando desarreglar VMG0000 +desarreglar desarreglar VMN0000 +desarregle desarreglar VMM03S0 +desarreglemos desarreglar VMM01P0 +desarreglen desarreglar VMM03P0 +desarremanga desarremangar VMM02S0 +desarremangad desarremangar VMM02P0 +desarremangando desarremangar VMG0000 +desarrendad desarrendar VMM02P0 +desarrendando desarrendar VMG0000 +desarrendar desarrendar VMN0000 +desarrendemos desarrendar VMM01P0 +desarrienda desarrendar VMM02S0 +desarriende desarrendar VMM03S0 +desarrienden desarrendar VMM03P0 +desarrima desarrimar VMM02S0 +desarrimad desarrimar VMM02P0 +desarrimando desarrimar VMG0000 +desarrimar desarrimar VMN0000 +desarrime desarrimar VMM03S0 +desarrimemos desarrimar VMM01P0 +desarrimen desarrimar VMM03P0 +desarrolla desarrollar VMM02S0 +desarrollad desarrollar VMM02P0 +desarrollando desarrollar VMG0000 +desarrollar desarrollar VMN0000 +desarrolle desarrollar VMM03S0 +desarrollemos desarrollar VMM01P0 +desarrollen desarrollar VMM03P0 +desarropa desarropar VMM02S0 +desarropad desarropar VMM02P0 +desarropando desarropar VMG0000 +desarropar desarropar VMN0000 +desarrope desarropar VMM03S0 +desarropemos desarropar VMM01P0 +desarropen desarropar VMM03P0 +desarruga desarrugar VMM02S0 +desarrugad desarrugar VMM02P0 +desarrugando desarrugar VMG0000 +desarrugar desarrugar VMN0000 +desarrugue desarrugar VMM03S0 +desarruguemos desarrugar VMM01P0 +desarruguen desarrugar VMM03P0 +desarruma desarrumar VMM02S0 +desarrumad desarrumar VMM02P0 +desarrumando desarrumar VMG0000 +desarrumar desarrumar VMN0000 +desarrume desarrumar VMM03S0 +desarrumemos desarrumar VMM01P0 +desarrumen desarrumar VMM03P0 +desarticula desarticular VMM02S0 +desarticulad desarticular VMM02P0 +desarticulando desarticular VMG0000 +desarticular desarticular VMN0000 +desarticule desarticular VMM03S0 +desarticulemos desarticular VMM01P0 +desarticulen desarticular VMM03P0 +desartilla desartillar VMM02S0 +desartillad desartillar VMM02P0 +desartillando desartillar VMG0000 +desartillar desartillar VMN0000 +desartille desartillar VMM03S0 +desartillemos desartillar VMM01P0 +desartillen desartillar VMM03P0 +desarzona desarzonar VMM02S0 +desarzonad desarzonar VMM02P0 +desarzonando desarzonar VMG0000 +desarzonar desarzonar VMN0000 +desarzone desarzonar VMM03S0 +desarzonemos desarzonar VMM01P0 +desarzonen desarzonar VMM03P0 +desase desasir VMM02S0 +desasea desasear VMM02S0 +desasead desasear VMM02P0 +desaseando desasear VMG0000 +desasear desasear VMN0000 +desasee desasear VMM03S0 +desaseemos desasear VMM01P0 +desaseen desasear VMM03P0 +desasentad desasentar VMM02P0 +desasentando desasentar VMG0000 +desasentar desasentar VMN0000 +desasentemos desasentar VMM01P0 +desasga desasir VMM03S0 +desasgamos desasir VMM01P0 +desasgan desasir VMM03P0 +desasid desasir VMM02P0 +desasiendo desasir VMG0000 +desasienta desasentar VMM02S0 +desasiente desasentar VMM03S0 +desasienten desasentar VMM03P0 +desasimila desasimilar VMM02S0 +desasimilad desasimilar VMM02P0 +desasimilando desasimilar VMG0000 +desasimilar desasimilar VMN0000 +desasimile desasimilar VMM03S0 +desasimilemos desasimilar VMM01P0 +desasimilen desasimilar VMM03P0 +desasir desasir VMN0000 +desasista desasistir VMM03S0 +desasistamos desasistir VMM01P0 +desasistan desasistir VMM03P0 +desasiste desasistir VMM02S0 +desasistid desasistir VMM02P0 +desasistiendo desasistir VMG0000 +desasistir desasistir VMN0000 +desasna desasnar VMM02S0 +desasnad desasnar VMM02P0 +desasnando desasnar VMG0000 +desasnar desasnar VMN0000 +desasne desasnar VMM03S0 +desasnemos desasnar VMM01P0 +desasnen desasnar VMM03P0 +desasocia desasociar VMM02S0 +desasociad desasociar VMM02P0 +desasociando desasociar VMG0000 +desasociar desasociar VMN0000 +desasocie desasociar VMM03S0 +desasociemos desasociar VMM01P0 +desasocien desasociar VMM03P0 +desasosegad desasosegar VMM02P0 +desasosegando desasosegar VMG0000 +desasosegar desasosegar VMN0000 +desasoseguemos desasosegar VMM01P0 +desasosiega desasosegar VMM02S0 +desasosiegue desasosegar VMM03S0 +desasosieguen desasosegar VMM03P0 +desata desatar VMM02S0 +desataca desatacar VMM02S0 +desatacad desatacar VMM02P0 +desatacando desatacar VMG0000 +desatacar desatacar VMN0000 +desatad desatar VMM02P0 +desatando desatar VMG0000 +desataque desatacar VMM03S0 +desataquemos desatacar VMM01P0 +desataquen desatacar VMM03P0 +desatar desatar VMN0000 +desatasca desatascar VMM02S0 +desatascad desatascar VMM02P0 +desatascando desatascar VMG0000 +desatascar desatascar VMN0000 +desatasque desatascar VMM03S0 +desatasquemos desatascar VMM01P0 +desatasquen desatascar VMM03P0 +desataviad desataviar VMM02P0 +desataviando desataviar VMG0000 +desataviar desataviar VMN0000 +desataviemos desataviar VMM01P0 +desatavía desataviar VMM02S0 +desatavíe desataviar VMM03S0 +desatavíen desataviar VMM03P0 +desate desatar VMM03S0 +desatemos desatar VMM01P0 +desaten desatar VMM03P0 +desatendamos desatender VMM01P0 +desatended desatender VMM02P0 +desatender desatender VMN0000 +desatendiendo desatender VMG0000 +desatentad desatentar VMM02P0 +desatentando desatentar VMG0000 +desatentar desatentar VMN0000 +desatentemos desatentar VMM01P0 +desaterrad desaterrar VMM02P0 +desaterrando desaterrar VMG0000 +desaterrar desaterrar VMN0000 +desaterremos desaterrar VMM01P0 +desatienda desatender VMM03S0 +desatiendan desatender VMM03P0 +desatiende desatender VMM02S0 +desatienta desatentar VMM02S0 +desatiente desatentar VMM03S0 +desatienten desatentar VMM03P0 +desatierra desaterrar VMM02S0 +desatierre desaterrar VMM03S0 +desatierren desaterrar VMM03P0 +desatina desatinar VMM02S0 +desatinad desatinar VMM02P0 +desatinando desatinar VMG0000 +desatinar desatinar VMN0000 +desatine desatinar VMM03S0 +desatinemos desatinar VMM01P0 +desatinen desatinar VMM03P0 +desatolla desatollar VMM02S0 +desatollad desatollar VMM02P0 +desatollando desatollar VMG0000 +desatollar desatollar VMN0000 +desatolle desatollar VMM03S0 +desatollemos desatollar VMM01P0 +desatollen desatollar VMM03P0 +desatolondra desatolondrar VMM02S0 +desatolondrad desatolondrar VMM02P0 +desatolondrando desatolondrar VMG0000 +desatolondrar desatolondrar VMN0000 +desatolondre desatolondrar VMM03S0 +desatolondremos desatolondrar VMM01P0 +desatolondren desatolondrar VMM03P0 +desatonta desatontar VMM02S0 +desatontad desatontar VMM02P0 +desatontando desatontar VMG0000 +desatontar desatontar VMN0000 +desatonte desatontar VMM03S0 +desatontemos desatontar VMM01P0 +desatonten desatontar VMM03P0 +desatora desatorar VMM02S0 +desatorad desatorar VMM02P0 +desatorando desatorar VMG0000 +desatorar desatorar VMN0000 +desatore desatorar VMM03S0 +desatoremos desatorar VMM01P0 +desatoren desatorar VMM03P0 +desatornilla desatornillar VMM02S0 +desatornillad desatornillar VMM02P0 +desatornillando desatornillar VMG0000 +desatornillar desatornillar VMN0000 +desatornille desatornillar VMM03S0 +desatornillemos desatornillar VMM01P0 +desatornillen desatornillar VMM03P0 +desatraca desatracar VMM02S0 +desatracad desatracar VMM02P0 +desatracando desatracar VMG0000 +desatracar desatracar VMN0000 +desatraganta desatragantar VMM02S0 +desatragantad desatragantar VMM02P0 +desatragantando desatragantar VMG0000 +desatragantar desatragantar VMN0000 +desatrailla desatraillar VMM02S0 +desatraillad desatraillar VMM02P0 +desatraillando desatraillar VMG0000 +desatraillar desatraillar VMN0000 +desatraille desatraillar VMM03S0 +desatraillemos desatraillar VMM01P0 +desatraillen desatraillar VMM03P0 +desatranca desatrancar VMM02S0 +desatrancad desatrancar VMM02P0 +desatrancando desatrancar VMG0000 +desatrancar desatrancar VMN0000 +desatranque desatrancar VMM03S0 +desatranquemos desatrancar VMM01P0 +desatranquen desatrancar VMM03P0 +desatraque desatracar VMM03S0 +desatraquemos desatracar VMM01P0 +desatraquen desatracar VMM03P0 +desatufa desatufar VMM02S0 +desatufad desatufar VMM02P0 +desatufando desatufar VMG0000 +desatufar desatufar VMN0000 +desatufe desatufar VMM03S0 +desatufemos desatufar VMM01P0 +desatufen desatufar VMM03P0 +desaturda desaturdir VMM03S0 +desaturdamos desaturdir VMM01P0 +desaturdan desaturdir VMM03P0 +desaturde desaturdir VMM02S0 +desaturdid desaturdir VMM02P0 +desaturdiendo desaturdir VMG0000 +desaturdir desaturdir VMN0000 +desautorice desautorizar VMM03S0 +desautoricemos desautorizar VMM01P0 +desautoricen desautorizar VMM03P0 +desautoriza desautorizar VMM02S0 +desautorizad desautorizar VMM02P0 +desautorizando desautorizar VMG0000 +desautorizar desautorizar VMN0000 +desaven desavenir VMM02S0 +desavenga desavenir VMM03S0 +desavengamos desavenir VMM01P0 +desavengan desavenir VMM03P0 +desavenid desavenir VMM02P0 +desavenir desavenir VMN0000 +desaviad desaviar VMM02P0 +desaviando desaviar VMG0000 +desaviar desaviar VMN0000 +desaviemos desaviar VMM01P0 +desaviniendo desavenir VMG0000 +desavía desaviar VMM02S0 +desavíe desaviar VMM03S0 +desavíen desaviar VMM03P0 +desayuna desayunar VMM02S0 +desayunad desayunar VMM02P0 +desayunando desayunar VMG0000 +desayunar desayunar VMN0000 +desayune desayunar VMM03S0 +desayunemos desayunar VMM01P0 +desayunen desayunar VMM03P0 +desazoga desazogar VMM02S0 +desazogad desazogar VMM02P0 +desazogando desazogar VMG0000 +desazogar desazogar VMN0000 +desazogue desazogar VMM03S0 +desazoguemos desazogar VMM01P0 +desazoguen desazogar VMM03P0 +desazona desazonar VMM02S0 +desazonad desazonar VMM02P0 +desazonando desazonar VMG0000 +desazonar desazonar VMN0000 +desazone desazonar VMM03S0 +desazonemos desazonar VMM01P0 +desazonen desazonar VMM03P0 +desaína desainar VMM02S0 +desaíne desainar VMM03S0 +desaínen desainar VMM03P0 +desbaba desbabar VMM02S0 +desbabad desbabar VMM02P0 +desbabando desbabar VMG0000 +desbabar desbabar VMN0000 +desbabe desbabar VMM03S0 +desbabemos desbabar VMM01P0 +desbaben desbabar VMM03P0 +desbaga desbagar VMM02S0 +desbagad desbagar VMM02P0 +desbagando desbagar VMG0000 +desbagar desbagar VMN0000 +desbague desbagar VMM03S0 +desbaguemos desbagar VMM01P0 +desbaguen desbagar VMM03P0 +desbanca desbancar VMM02S0 +desbancad desbancar VMM02P0 +desbancando desbancar VMG0000 +desbancar desbancar VMN0000 +desbanda desbandar VMM02S0 +desbandad desbandar VMM02P0 +desbandando desbandar VMG0000 +desbandar desbandar VMN0000 +desbande desbandar VMM03S0 +desbandemos desbandar VMM01P0 +desbanden desbandar VMM03P0 +desbanque desbancar VMM03S0 +desbanquemos desbancar VMM01P0 +desbanquen desbancar VMM03P0 +desbarajusta desbarajustar VMM02S0 +desbarajustad desbarajustar VMM02P0 +desbarajustando desbarajustar VMG0000 +desbarajustar desbarajustar VMN0000 +desbarajuste desbarajustar VMM03S0 +desbarajustemos desbarajustar VMM01P0 +desbarajusten desbarajustar VMM03P0 +desbarata desbaratar VMM02S0 +desbaratad desbaratar VMM02P0 +desbaratando desbaratar VMG0000 +desbaratar desbaratar VMN0000 +desbarate desbaratar VMM03S0 +desbaratemos desbaratar VMM01P0 +desbaraten desbaratar VMM03P0 +desbarba desbarbar VMM02S0 +desbarbad desbarbar VMM02P0 +desbarbando desbarbar VMG0000 +desbarbar desbarbar VMN0000 +desbarbe desbarbar VMM03S0 +desbarbemos desbarbar VMM01P0 +desbarben desbarbar VMM03P0 +desbarbilla desbarbillar VMM02S0 +desbarbillad desbarbillar VMM02P0 +desbarbillando desbarbillar VMG0000 +desbarbillar desbarbillar VMN0000 +desbarbille desbarbillar VMM03S0 +desbarbillemos desbarbillar VMM01P0 +desbarbillen desbarbillar VMM03P0 +desbarda desbardar VMM02S0 +desbardad desbardar VMM02P0 +desbardando desbardar VMG0000 +desbardar desbardar VMN0000 +desbarde desbardar VMM03S0 +desbardemos desbardar VMM01P0 +desbarden desbardar VMM03P0 +desbarnice desbarnizar VMM03S0 +desbarnicemos desbarnizar VMM01P0 +desbarnicen desbarnizar VMM03P0 +desbarniza desbarnizar VMM02S0 +desbarnizad desbarnizar VMM02P0 +desbarnizando desbarnizar VMG0000 +desbarnizar desbarnizar VMN0000 +desbarra desbarrar VMM02S0 +desbarrad desbarrar VMM02P0 +desbarrando desbarrar VMG0000 +desbarrar desbarrar VMN0000 +desbarre desbarrar VMM03S0 +desbarremos desbarrar VMM01P0 +desbarren desbarrar VMM03P0 +desbasta desbastar VMM02S0 +desbastad desbastar VMM02P0 +desbastando desbastar VMG0000 +desbastar desbastar VMN0000 +desbaste desbastar VMM03S0 +desbastemos desbastar VMM01P0 +desbasten desbastar VMM03P0 +desbecerra desbecerrar VMM02S0 +desbecerrad desbecerrar VMM02P0 +desbecerrando desbecerrar VMG0000 +desbecerrar desbecerrar VMN0000 +desbecerre desbecerrar VMM03S0 +desbecerremos desbecerrar VMM01P0 +desbecerren desbecerrar VMM03P0 +desbloquea desbloquear VMM02S0 +desbloquead desbloquear VMM02P0 +desbloqueando desbloquear VMG0000 +desbloquear desbloquear VMN0000 +desbloquee desbloquear VMM03S0 +desbloqueemos desbloquear VMM01P0 +desbloqueen desbloquear VMM03P0 +desboca desbocar VMM02S0 +desbocad desbocar VMM02P0 +desbocando desbocar VMG0000 +desbocar desbocar VMN0000 +desboque desbocar VMM03S0 +desboquemos desbocar VMM01P0 +desboquen desbocar VMM03P0 +desboquilla desboquillar VMM02S0 +desboquillad desboquillar VMM02P0 +desboquillando desboquillar VMG0000 +desboquillar desboquillar VMN0000 +desboquille desboquillar VMM03S0 +desboquillemos desboquillar VMM01P0 +desboquillen desboquillar VMM03P0 +desborda desbordar VMM02S0 +desbordad desbordar VMM02P0 +desbordando desbordar VMG0000 +desbordar desbordar VMN0000 +desborde desbordar VMM03S0 +desbordemos desbordar VMM01P0 +desborden desbordar VMM03P0 +desborra desborrar VMM02S0 +desborrad desborrar VMM02P0 +desborrando desborrar VMG0000 +desborrar desborrar VMN0000 +desborre desborrar VMM03S0 +desborremos desborrar VMM01P0 +desborren desborrar VMM03P0 +desbotona desbotonar VMM02S0 +desbotonad desbotonar VMM02P0 +desbotonando desbotonar VMG0000 +desbotonar desbotonar VMN0000 +desbotone desbotonar VMM03S0 +desbotonemos desbotonar VMM01P0 +desbotonen desbotonar VMM03P0 +desbrava desbravar VMM02S0 +desbravad desbravar VMM02P0 +desbravando desbravar VMG0000 +desbravar desbravar VMN0000 +desbrave desbravar VMM03S0 +desbravemos desbravar VMM01P0 +desbraven desbravar VMM03P0 +desbrida desbridar VMM02S0 +desbridad desbridar VMM02P0 +desbridando desbridar VMG0000 +desbridar desbridar VMN0000 +desbride desbridar VMM03S0 +desbridemos desbridar VMM01P0 +desbriden desbridar VMM03P0 +desbrizna desbriznar VMM02S0 +desbriznad desbriznar VMM02P0 +desbriznando desbriznar VMG0000 +desbriznar desbriznar VMN0000 +desbrizne desbriznar VMM03S0 +desbriznemos desbriznar VMM01P0 +desbriznen desbriznar VMM03P0 +desbroce desbrozar VMM03S0 +desbrocemos desbrozar VMM01P0 +desbrocen desbrozar VMM03P0 +desbroza desbrozar VMM02S0 +desbrozad desbrozar VMM02P0 +desbrozando desbrozar VMG0000 +desbrozar desbrozar VMN0000 +desbulla desbullar VMM02S0 +desbullad desbullar VMM02P0 +desbullando desbullar VMG0000 +desbullar desbullar VMN0000 +desbulle desbullar VMM03S0 +desbullemos desbullar VMM01P0 +desbullen desbullar VMM03P0 +descabala descabalar VMM02S0 +descabalad descabalar VMM02P0 +descabalando descabalar VMG0000 +descabalar descabalar VMN0000 +descabale descabalar VMM03S0 +descabalemos descabalar VMM01P0 +descabalen descabalar VMM03P0 +descabalga descabalgar VMM02S0 +descabalgad descabalgar VMM02P0 +descabalgando descabalgar VMG0000 +descabalgar descabalgar VMN0000 +descabalgue descabalgar VMM03S0 +descabalguemos descabalgar VMM01P0 +descabalguen descabalgar VMM03P0 +descabece descabezar VMM03S0 +descabecemos descabezar VMM01P0 +descabecen descabezar VMM03P0 +descabella descabellar VMM02S0 +descabellad descabellar VMM02P0 +descabellando descabellar VMG0000 +descabellar descabellar VMN0000 +descabelle descabellar VMM03S0 +descabellemos descabellar VMM01P0 +descabellen descabellar VMM03P0 +descabeza descabezar VMM02S0 +descabezad descabezar VMM02P0 +descabezando descabezar VMG0000 +descabezar descabezar VMN0000 +descabrita descabritar VMM02S0 +descabritad descabritar VMM02P0 +descabritando descabritar VMG0000 +descabritar descabritar VMN0000 +descabrite descabritar VMM03S0 +descabritemos descabritar VMM01P0 +descabriten descabritar VMM03P0 +descadera descaderar VMM02S0 +descaderad descaderar VMM02P0 +descaderando descaderar VMG0000 +descaderar descaderar VMN0000 +descadere descaderar VMM03S0 +descaderemos descaderar VMM01P0 +descaderen descaderar VMM03P0 +descadilla descadillar VMM02S0 +descadillad descadillar VMM02P0 +descadillando descadillar VMG0000 +descadillar descadillar VMN0000 +descadille descadillar VMM03S0 +descadillemos descadillar VMM01P0 +descadillen descadillar VMM03P0 +descaece descaecer VMM02S0 +descaeced descaecer VMM02P0 +descaecer descaecer VMN0000 +descaeciendo descaecer VMG0000 +descaezca descaecer VMM03S0 +descaezcamos descaecer VMM01P0 +descaezcan descaecer VMM03P0 +descafeinad descafeinar VMM02P0 +descafeinando descafeinar VMG0000 +descafeinar descafeinar VMN0000 +descafeinemos descafeinar VMM01P0 +descafeína descafeinar VMM02S0 +descafeíne descafeinar VMM03S0 +descafeínen descafeinar VMM03P0 +descalabace descalabazar VMM03S0 +descalabacemos descalabazar VMM01P0 +descalabacen descalabazar VMM03P0 +descalabaza descalabazar VMM02S0 +descalabazad descalabazar VMM02P0 +descalabazando descalabazar VMG0000 +descalabazar descalabazar VMN0000 +descalabra descalabrar VMM02S0 +descalabrad descalabrar VMM02P0 +descalabrando descalabrar VMG0000 +descalabrar descalabrar VMN0000 +descalabre descalabrar VMM03S0 +descalabremos descalabrar VMM01P0 +descalabren descalabrar VMM03P0 +descalce descalzar VMM03S0 +descalcemos descalzar VMM01P0 +descalcen descalzar VMM03P0 +descalcifica descalcificar VMM02S0 +descalcificad descalcificar VMM02P0 +descalcificando descalcificar VMG0000 +descalcificar descalcificar VMN0000 +descalcifique descalcificar VMM03S0 +descalcifiquemos descalcificar VMM01P0 +descalcifiquen descalcificar VMM03P0 +descalifica descalificar VMM02S0 +descalificad descalificar VMM02P0 +descalificando descalificar VMG0000 +descalificar descalificar VMN0000 +descalifique descalificar VMM03S0 +descalifiquemos descalificar VMM01P0 +descalifiquen descalificar VMM03P0 +descalza descalzar VMM02S0 +descalzad descalzar VMM02P0 +descalzando descalzar VMG0000 +descalzar descalzar VMN0000 +descama descamar VMM02S0 +descamad descamar VMM02P0 +descamando descamar VMG0000 +descamar descamar VMN0000 +descambia descambiar VMM02S0 +descambiad descambiar VMM02P0 +descambiando descambiar VMG0000 +descambiar descambiar VMN0000 +descambie descambiar VMM03S0 +descambiemos descambiar VMM01P0 +descambien descambiar VMM03P0 +descame descamar VMM03S0 +descamemos descamar VMM01P0 +descamen descamar VMM03P0 +descamina descaminar VMM02S0 +descaminad descaminar VMM02P0 +descaminando descaminar VMG0000 +descaminar descaminar VMN0000 +descamine descaminar VMM03S0 +descaminemos descaminar VMM01P0 +descaminen descaminar VMM03P0 +descamisa descamisar VMM02S0 +descamisad descamisar VMM02P0 +descamisando descamisar VMG0000 +descamisar descamisar VMN0000 +descamise descamisar VMM03S0 +descamisemos descamisar VMM01P0 +descamisen descamisar VMM03P0 +descampa descampar VMM02S0 +descampad descampar VMM02P0 +descampando descampar VMG0000 +descampar descampar VMN0000 +descampe descampar VMM03S0 +descampemos descampar VMM01P0 +descampen descampar VMM03P0 +descansa descansar VMM02S0 +descansad descansar VMM02P0 +descansando descansar VMG0000 +descansar descansar VMN0000 +descanse descansar VMM03S0 +descansemos descansar VMM01P0 +descansen descansar VMM03P0 +descantilla descantillar VMM02S0 +descantillad descantillar VMM02P0 +descantillando descantillar VMG0000 +descantillar descantillar VMN0000 +descantille descantillar VMM03S0 +descantillemos descantillar VMM01P0 +descantillen descantillar VMM03P0 +descantona descantonar VMM02S0 +descantonad descantonar VMM02P0 +descantonando descantonar VMG0000 +descantonar descantonar VMN0000 +descantone descantonar VMM03S0 +descantonemos descantonar VMM01P0 +descantonen descantonar VMM03P0 +descaperuce descaperuzar VMM03S0 +descaperucemos descaperuzar VMM01P0 +descaperucen descaperuzar VMM03P0 +descaperuza descaperuzar VMM02S0 +descaperuzad descaperuzar VMM02P0 +descaperuzando descaperuzar VMG0000 +descaperuzar descaperuzar VMN0000 +descapirota descapirotar VMM02S0 +descapirotad descapirotar VMM02P0 +descapirotando descapirotar VMG0000 +descapirotar descapirotar VMN0000 +descapirote descapirotar VMM03S0 +descapirotemos descapirotar VMM01P0 +descapiroten descapirotar VMM03P0 +descapota descapotar VMM02S0 +descapotad descapotar VMM02P0 +descapotando descapotar VMG0000 +descapotar descapotar VMN0000 +descapote descapotar VMM03S0 +descapotemos descapotar VMM01P0 +descapoten descapotar VMM03P0 +descara descarar VMM02S0 +descarad descarar VMM02P0 +descarando descarar VMG0000 +descarar descarar VMN0000 +descarbonata descarbonatar VMM02S0 +descarbonatad descarbonatar VMM02P0 +descarbonatando descarbonatar VMG0000 +descarbonatar descarbonatar VMN0000 +descarbonate descarbonatar VMM03S0 +descarbonatemos descarbonatar VMM01P0 +descarbonaten descarbonatar VMM03P0 +descarbura descarburar VMM02S0 +descarburad descarburar VMM02P0 +descarburando descarburar VMG0000 +descarburar descarburar VMN0000 +descarbure descarburar VMM03S0 +descarburemos descarburar VMM01P0 +descarburen descarburar VMM03P0 +descare descarar VMM03S0 +descaremos descarar VMM01P0 +descaren descarar VMM03P0 +descarga descargar VMM02S0 +descargad descargar VMM02P0 +descargando descargar VMG0000 +descargar descargar VMN0000 +descargue descargar VMM03S0 +descarguemos descargar VMM01P0 +descarguen descargar VMM03P0 +descarna descarnar VMM02S0 +descarnad descarnar VMM02P0 +descarnando descarnar VMG0000 +descarnar descarnar VMN0000 +descarne descarnar VMM03S0 +descarnemos descarnar VMM01P0 +descarnen descarnar VMM03P0 +descaroce descarozar VMM03S0 +descarocemos descarozar VMM01P0 +descarocen descarozar VMM03P0 +descaroza descarozar VMM02S0 +descarozad descarozar VMM02P0 +descarozando descarozar VMG0000 +descarozar descarozar VMN0000 +descarriad descarriar VMM02P0 +descarriando descarriar VMG0000 +descarriar descarriar VMN0000 +descarriemos descarriar VMM01P0 +descarrila descarrilar VMM02S0 +descarrilad descarrilar VMM02P0 +descarrilando descarrilar VMG0000 +descarrilar descarrilar VMN0000 +descarrile descarrilar VMM03S0 +descarrilemos descarrilar VMM01P0 +descarrilen descarrilar VMM03P0 +descarría descarriar VMM02S0 +descarríe descarriar VMM03S0 +descarríen descarriar VMM03P0 +descarta descartar VMM02S0 +descartad descartar VMM02P0 +descartando descartar VMG0000 +descartar descartar VMN0000 +descarte descartar VMM03S0 +descartemos descartar VMM01P0 +descarten descartar VMM03P0 +descasa descasar VMM02S0 +descasad descasar VMM02P0 +descasando descasar VMG0000 +descasar descasar VMN0000 +descasca descascar VMM02S0 +descascad descascar VMM02P0 +descascando descascar VMG0000 +descascar descascar VMN0000 +descascara descascarar VMM02S0 +descascarad descascarar VMM02P0 +descascarando descascarar VMG0000 +descascarar descascarar VMN0000 +descascare descascarar VMM03S0 +descascaremos descascarar VMM01P0 +descascaren descascarar VMM03P0 +descascarilla descascarillar VMM02S0 +descascarillad descascarillar VMM02P0 +descascarillando descascarillar VMG0000 +descascarillar descascarillar VMN0000 +descascarille descascarillar VMM03S0 +descascarillemos descascarillar VMM01P0 +descascarillen descascarillar VMM03P0 +descase descasar VMM03S0 +descasemos descasar VMM01P0 +descasen descasar VMM03P0 +descaspa descaspar VMM02S0 +descaspad descaspar VMM02P0 +descaspando descaspar VMG0000 +descaspar descaspar VMN0000 +descaspe descaspar VMM03S0 +descaspemos descaspar VMM01P0 +descaspen descaspar VMM03P0 +descasque descascar VMM03S0 +descasquemos descascar VMM01P0 +descasquen descascar VMM03P0 +descasta descastar VMM02S0 +descastad descastar VMM02P0 +descastando descastar VMG0000 +descastar descastar VMN0000 +descaste descastar VMM03S0 +descastemos descastar VMM01P0 +descasten descastar VMM03P0 +descatolice descatolizar VMM03S0 +descatolicemos descatolizar VMM01P0 +descatolicen descatolizar VMM03P0 +descatoliza descatolizar VMM02S0 +descatolizad descatolizar VMM02P0 +descatolizando descatolizar VMG0000 +descatolizar descatolizar VMN0000 +descañona descañonar VMM02S0 +descañonad descañonar VMM02P0 +descañonando descañonar VMG0000 +descañonar descañonar VMN0000 +descañone descañonar VMM03S0 +descañonemos descañonar VMM01P0 +descañonen descañonar VMM03P0 +desceba descebar VMM02S0 +descebad descebar VMM02P0 +descebando descebar VMG0000 +descebar descebar VMN0000 +descebe descebar VMM03S0 +descebemos descebar VMM01P0 +desceben descebar VMM03P0 +descendamos descender VMM01P0 +descended descender VMM02P0 +descender descender VMN0000 +descendiendo descender VMG0000 +descentra descentrar VMM02S0 +descentrad descentrar VMM02P0 +descentralice descentralizar VMM03S0 +descentralicemos descentralizar VMM01P0 +descentralicen descentralizar VMM03P0 +descentraliza descentralizar VMM02S0 +descentralizad descentralizar VMM02P0 +descentralizando descentralizar VMG0000 +descentralizar descentralizar VMN0000 +descentrando descentrar VMG0000 +descentrar descentrar VMN0000 +descentre descentrar VMM03S0 +descentremos descentrar VMM01P0 +descentren descentrar VMM03P0 +descepa descepar VMM02S0 +descepad descepar VMM02P0 +descepando descepar VMG0000 +descepar descepar VMN0000 +descepe descepar VMM03S0 +descepemos descepar VMM01P0 +descepen descepar VMM03P0 +descerca descercar VMM02S0 +descercad descercar VMM02P0 +descercando descercar VMG0000 +descercar descercar VMN0000 +descerece descerezar VMM03S0 +descerecemos descerezar VMM01P0 +descerecen descerezar VMM03P0 +descereza descerezar VMM02S0 +descerezad descerezar VMM02P0 +descerezando descerezar VMG0000 +descerezar descerezar VMN0000 +descerque descercar VMM03S0 +descerquemos descercar VMM01P0 +descerquen descercar VMM03P0 +descerraja descerrajar VMM02S0 +descerrajad descerrajar VMM02P0 +descerrajando descerrajar VMG0000 +descerrajar descerrajar VMN0000 +descerraje descerrajar VMM03S0 +descerrajemos descerrajar VMM01P0 +descerrajen descerrajar VMM03P0 +desceñid desceñir VMM02P0 +desceñir desceñir VMN0000 +descienda descender VMM03S0 +desciendan descender VMM03P0 +desciende descender VMM02S0 +descifra descifrar VMM02S0 +descifrad descifrar VMM02P0 +descifrando descifrar VMG0000 +descifrar descifrar VMN0000 +descifre descifrar VMM03S0 +descifremos descifrar VMM01P0 +descifren descifrar VMM03P0 +descimbra descimbrar VMM02S0 +descimbrad descimbrar VMM02P0 +descimbrando descimbrar VMG0000 +descimbrar descimbrar VMN0000 +descimbre descimbrar VMM03S0 +descimbremos descimbrar VMM01P0 +descimbren descimbrar VMM03P0 +descincha descinchar VMM02S0 +descinchad descinchar VMM02P0 +descinchando descinchar VMG0000 +descinchar descinchar VMN0000 +descinche descinchar VMM03S0 +descinchemos descinchar VMM01P0 +descinchen descinchar VMM03P0 +desciña desceñir VMM03S0 +desciñamos desceñir VMM01P0 +desciñan desceñir VMM03P0 +desciñe desceñir VMM02S0 +desciñendo desceñir VMG0000 +desclava desclavar VMM02S0 +desclavad desclavar VMM02P0 +desclavando desclavar VMG0000 +desclavar desclavar VMN0000 +desclave desclavar VMM03S0 +desclavemos desclavar VMM01P0 +desclaven desclavar VMM03P0 +descoagula descoagular VMM02S0 +descoagulad descoagular VMM02P0 +descoagulando descoagular VMG0000 +descoagular descoagular VMN0000 +descoagule descoagular VMM03S0 +descoagulemos descoagular VMM01P0 +descoagulen descoagular VMM03P0 +descobaja descobajar VMM02S0 +descobajad descobajar VMM02P0 +descobajando descobajar VMG0000 +descobajar descobajar VMN0000 +descobaje descobajar VMM03S0 +descobajemos descobajar VMM01P0 +descobajen descobajar VMM03P0 +descobija descobijar VMM02S0 +descobijad descobijar VMM02P0 +descobijando descobijar VMG0000 +descobijar descobijar VMN0000 +descobije descobijar VMM03S0 +descobijemos descobijar VMM01P0 +descobijen descobijar VMM03P0 +descoca descocar VMM02S0 +descocad descocar VMM02P0 +descocando descocar VMG0000 +descocar descocar VMN0000 +descodifica descodificar VMM02S0 +descodificad descodificar VMM02P0 +descodificando descodificar VMG0000 +descodificar descodificar VMN0000 +descodifique descodificar VMM03S0 +descodifiquemos descodificar VMM01P0 +descodifiquen descodificar VMM03P0 +descoge descoger VMM02S0 +descoged descoger VMM02P0 +descoger descoger VMN0000 +descogiendo descoger VMG0000 +descogolla descogollar VMM02S0 +descogollad descogollar VMM02P0 +descogollando descogollar VMG0000 +descogollar descogollar VMN0000 +descogolle descogollar VMM03S0 +descogollemos descogollar VMM01P0 +descogollen descogollar VMM03P0 +descogota descogotar VMM02S0 +descogotad descogotar VMM02P0 +descogotando descogotar VMG0000 +descogotar descogotar VMN0000 +descogote descogotar VMM03S0 +descogotemos descogotar VMM01P0 +descogoten descogotar VMM03P0 +descoja descoger VMM03S0 +descojamos descoger VMM01P0 +descojan descoger VMM03P0 +descola descolar VMM02S0 +descolad descolar VMM02P0 +descolando descolar VMG0000 +descolar descolar VMN0000 +descolcha descolchar VMM02S0 +descolchad descolchar VMM02P0 +descolchando descolchar VMG0000 +descolchar descolchar VMN0000 +descolche descolchar VMM03S0 +descolchemos descolchar VMM01P0 +descolchen descolchar VMM03P0 +descole descolar VMM03S0 +descolemos descolar VMM01P0 +descolen descolar VMM03P0 +descolgad descolgar VMM02P0 +descolgando descolgar VMG0000 +descolgar descolgar VMN0000 +descolguemos descolgar VMM01P0 +descollad descollar VMM02P0 +descollando descollar VMG0000 +descollar descollar VMN0000 +descollemos descollar VMM01P0 +descolmilla descolmillar VMM02S0 +descolmillad descolmillar VMM02P0 +descolmillando descolmillar VMG0000 +descolmillar descolmillar VMN0000 +descolmille descolmillar VMM03S0 +descolmillemos descolmillar VMM01P0 +descolmillen descolmillar VMM03P0 +descoloca descolocar VMM02S0 +descolocad descolocar VMM02P0 +descolocando descolocar VMG0000 +descolocar descolocar VMN0000 +descolonice descolonizar VMM03S0 +descolonicemos descolonizar VMM01P0 +descolonicen descolonizar VMM03P0 +descoloniza descolonizar VMM02S0 +descolonizad descolonizar VMM02P0 +descolonizando descolonizar VMG0000 +descolonizar descolonizar VMN0000 +descoloque descolocar VMM03S0 +descoloquemos descolocar VMM01P0 +descoloquen descolocar VMM03P0 +descolora descolorar VMM02S0 +descolora descolorir VMM03S0 +descolorad descolorar VMM02P0 +descoloramos descolorir VMM01P0 +descoloran descolorir VMM03P0 +descolorando descolorar VMG0000 +descolorar descolorar VMN0000 +descolore descolorar VMM03S0 +descolore descolorir VMM02S0 +descoloremos descolorar VMM01P0 +descoloren descolorar VMM03P0 +descolorid descolorir VMM02P0 +descoloriendo descolorir VMG0000 +descolorir descolorir VMN0000 +descombra descombrar VMM02S0 +descombrad descombrar VMM02P0 +descombrando descombrar VMG0000 +descombrar descombrar VMN0000 +descombre descombrar VMM03S0 +descombremos descombrar VMM01P0 +descombren descombrar VMM03P0 +descomedid descomedir VMM02P0 +descomedir descomedir VMN0000 +descomida descomedir VMM03S0 +descomidamos descomedir VMM01P0 +descomidan descomedir VMM03P0 +descomide descomedir VMM02S0 +descomidiendo descomedir VMG0000 +descompadra descompadrar VMM02S0 +descompadrad descompadrar VMM02P0 +descompadrando descompadrar VMG0000 +descompadrar descompadrar VMN0000 +descompadre descompadrar VMM03S0 +descompadremos descompadrar VMM01P0 +descompadren descompadrar VMM03P0 +descompagina descompaginar VMM02S0 +descompaginad descompaginar VMM02P0 +descompaginando descompaginar VMG0000 +descompaginar descompaginar VMN0000 +descompagine descompaginar VMM03S0 +descompaginemos descompaginar VMM01P0 +descompaginen descompaginar VMM03P0 +descompasa descompasar VMM02S0 +descompasad descompasar VMM02P0 +descompasando descompasar VMG0000 +descompasar descompasar VMN0000 +descompase descompasar VMM03S0 +descompasemos descompasar VMM01P0 +descompasen descompasar VMM03P0 +descompensa descompensar VMM02S0 +descompensad descompensar VMM02P0 +descompensando descompensar VMG0000 +descompensar descompensar VMN0000 +descompense descompensar VMM03S0 +descompensemos descompensar VMM01P0 +descompensen descompensar VMM03P0 +descomponed descomponer VMM02P0 +descomponer descomponer VMN0000 +descomponga descomponer VMM03S0 +descompongamos descomponer VMM01P0 +descompongan descomponer VMM03P0 +descomponiendo descomponer VMG0000 +descomprima descomprimir VMM03S0 +descomprimamos descomprimir VMM01P0 +descompriman descomprimir VMM03P0 +descomprime descomprimir VMM02S0 +descomprimid descomprimir VMM02P0 +descomprimiendo descomprimir VMG0000 +descomprimir descomprimir VMN0000 +descompón descomponer VMM02S0 +desconceptuad desconceptuar VMM02P0 +desconceptuando desconceptuar VMG0000 +desconceptuar desconceptuar VMN0000 +desconceptuemos desconceptuar VMM01P0 +desconceptúa desconceptuar VMM02S0 +desconceptúe desconceptuar VMM03S0 +desconceptúen desconceptuar VMM03P0 +desconcertad desconcertar VMM02P0 +desconcertando desconcertar VMG0000 +desconcertar desconcertar VMN0000 +desconcertemos desconcertar VMM01P0 +desconcha desconchar VMM02S0 +desconchad desconchar VMM02P0 +desconchando desconchar VMG0000 +desconchar desconchar VMN0000 +desconche desconchar VMM03S0 +desconchemos desconchar VMM01P0 +desconchen desconchar VMM03P0 +desconcierta desconcertar VMM02S0 +desconcierte desconcertar VMM03S0 +desconcierten desconcertar VMM03P0 +desconecta desconectar VMM02S0 +desconectad desconectar VMM02P0 +desconectando desconectar VMG0000 +desconectar desconectar VMN0000 +desconecte desconectar VMM03S0 +desconectemos desconectar VMM01P0 +desconecten desconectar VMM03P0 +desconfiad desconfiar VMM02P0 +desconfiando desconfiar VMG0000 +desconfiar desconfiar VMN0000 +desconfiemos desconfiar VMM01P0 +desconforma desconformar VMM02S0 +desconformad desconformar VMM02P0 +desconformando desconformar VMG0000 +desconformar desconformar VMN0000 +desconforme desconformar VMM03S0 +desconformemos desconformar VMM01P0 +desconformen desconformar VMM03P0 +desconfía desconfiar VMM02S0 +desconfíe desconfiar VMM03S0 +desconfíen desconfiar VMM03P0 +descongela descongelar VMM02S0 +descongelad descongelar VMM02P0 +descongelando descongelar VMG0000 +descongelar descongelar VMN0000 +descongele descongelar VMM03S0 +descongelemos descongelar VMM01P0 +descongelen descongelar VMM03P0 +descongestiona descongestionar VMM02S0 +descongestionad descongestionar VMM02P0 +descongestionando descongestionar VMG0000 +descongestionar descongestionar VMN0000 +descongestione descongestionar VMM03S0 +descongestionemos descongestionar VMM01P0 +descongestionen descongestionar VMM03P0 +desconoce desconocer VMM02S0 +desconoced desconocer VMM02P0 +desconocer desconocer VMN0000 +desconociendo desconocer VMG0000 +desconozca desconocer VMM03S0 +desconozcamos desconocer VMM01P0 +desconozcan desconocer VMM03P0 +desconsidera desconsiderar VMM02S0 +desconsiderad desconsiderar VMM02P0 +desconsiderando desconsiderar VMG0000 +desconsiderar desconsiderar VMN0000 +desconsidere desconsiderar VMM03S0 +desconsideremos desconsiderar VMM01P0 +desconsideren desconsiderar VMM03P0 +desconsolad desconsolar VMM02P0 +desconsolando desconsolar VMG0000 +desconsolar desconsolar VMN0000 +desconsolemos desconsolar VMM01P0 +desconsuela desconsolar VMM02S0 +desconsuele desconsolar VMM03S0 +desconsuelen desconsolar VMM03P0 +descontad descontar VMM02P0 +descontamina descontaminar VMM02S0 +descontaminad descontaminar VMM02P0 +descontaminando descontaminar VMG0000 +descontaminar descontaminar VMN0000 +descontamine descontaminar VMM03S0 +descontaminemos descontaminar VMM01P0 +descontaminen descontaminar VMM03P0 +descontando descontar VMG0000 +descontar descontar VMN0000 +descontemos descontar VMM01P0 +descontenta descontentar VMM02S0 +descontentad descontentar VMM02P0 +descontentando descontentar VMG0000 +descontentar descontentar VMN0000 +descontente descontentar VMM03S0 +descontentemos descontentar VMM01P0 +descontenten descontentar VMM03P0 +descontextualice descontextualizar VMM03S0 +descontextualicemos descontextualizar VMM01P0 +descontextualicen descontextualizar VMM03P0 +descontextualiza descontextualizar VMM02S0 +descontextualizad descontextualizar VMM02P0 +descontextualizando descontextualizar VMG0000 +descontextualizar descontextualizar VMN0000 +descontrola descontrolar VMM02S0 +descontrolad descontrolar VMM02P0 +descontrolando descontrolar VMG0000 +descontrolar descontrolar VMN0000 +descontrole descontrolar VMM03S0 +descontrolemos descontrolar VMM01P0 +descontrolen descontrolar VMM03P0 +desconven desconvenir VMM02S0 +desconvenga desconvenir VMM03S0 +desconvengamos desconvenir VMM01P0 +desconvengan desconvenir VMM03P0 +desconvenid desconvenir VMM02P0 +desconvenir desconvenir VMN0000 +desconviniendo desconvenir VMG0000 +desconvoca desconvocar VMM02S0 +desconvocad desconvocar VMM02P0 +desconvocando desconvocar VMG0000 +desconvocar desconvocar VMN0000 +desconvoque desconvocar VMM03S0 +desconvoquemos desconvocar VMM01P0 +desconvoquen desconvocar VMM03P0 +descoque descocar VMM03S0 +descoquemos descocar VMM01P0 +descoquen descocar VMM03P0 +descorazona descorazonar VMM02S0 +descorazonad descorazonar VMM02P0 +descorazonando descorazonar VMG0000 +descorazonar descorazonar VMN0000 +descorazone descorazonar VMM03S0 +descorazonemos descorazonar VMM01P0 +descorazonen descorazonar VMM03P0 +descorcha descorchar VMM02S0 +descorchad descorchar VMM02P0 +descorchando descorchar VMG0000 +descorchar descorchar VMN0000 +descorche descorchar VMM03S0 +descorchemos descorchar VMM01P0 +descorchen descorchar VMM03P0 +descordad descordar VMM02P0 +descordando descordar VMG0000 +descordar descordar VMN0000 +descordemos descordar VMM01P0 +descorita descoritar VMM02S0 +descoritad descoritar VMM02P0 +descoritando descoritar VMG0000 +descoritar descoritar VMN0000 +descorite descoritar VMM03S0 +descoritemos descoritar VMM01P0 +descoriten descoritar VMM03P0 +descornad descornar VMM02P0 +descornando descornar VMG0000 +descornar descornar VMN0000 +descornemos descornar VMM01P0 +descorona descoronar VMM02S0 +descoronad descoronar VMM02P0 +descoronando descoronar VMG0000 +descoronar descoronar VMN0000 +descorone descoronar VMM03S0 +descoronemos descoronar VMM01P0 +descoronen descoronar VMM03P0 +descorra descorrer VMM03S0 +descorramos descorrer VMM01P0 +descorran descorrer VMM03P0 +descorre descorrer VMM02S0 +descorred descorrer VMM02P0 +descorrer descorrer VMN0000 +descorriendo descorrer VMG0000 +descortece descortezar VMM03S0 +descortecemos descortezar VMM01P0 +descortecen descortezar VMM03P0 +descorteza descortezar VMM02S0 +descortezad descortezar VMM02P0 +descortezando descortezar VMG0000 +descortezar descortezar VMN0000 +descosa descoser VMM03S0 +descosamos descoser VMM01P0 +descosan descoser VMM03P0 +descose descoser VMM02S0 +descosed descoser VMM02P0 +descoser descoser VMN0000 +descosiendo descoser VMG0000 +descostad descostar VMM02P0 +descostando descostar VMG0000 +descostar descostar VMN0000 +descostemos descostar VMM01P0 +descostilla descostillar VMM02S0 +descostillad descostillar VMM02P0 +descostillando descostillar VMG0000 +descostillar descostillar VMN0000 +descostille descostillar VMM03S0 +descostillemos descostillar VMM01P0 +descostillen descostillar VMM03P0 +descostra descostrar VMM02S0 +descostrad descostrar VMM02P0 +descostrando descostrar VMG0000 +descostrar descostrar VMN0000 +descostre descostrar VMM03S0 +descostremos descostrar VMM01P0 +descostren descostrar VMM03P0 +descota descotar VMM02S0 +descotad descotar VMM02P0 +descotando descotar VMG0000 +descotar descotar VMN0000 +descote descotar VMM03S0 +descotemos descotar VMM01P0 +descoten descotar VMM03P0 +descoyunta descoyuntar VMM02S0 +descoyuntad descoyuntar VMM02P0 +descoyuntando descoyuntar VMG0000 +descoyuntar descoyuntar VMN0000 +descoyunte descoyuntar VMM03S0 +descoyuntemos descoyuntar VMM01P0 +descoyunten descoyuntar VMM03P0 +descrema descremar VMM02S0 +descremad descremar VMM02P0 +descremando descremar VMG0000 +descremar descremar VMN0000 +descreme descremar VMM03S0 +descrememos descremar VMM01P0 +descremen descremar VMM03P0 +descresta descrestar VMM02S0 +descrestad descrestar VMM02P0 +descrestando descrestar VMG0000 +descrestar descrestar VMN0000 +descreste descrestar VMM03S0 +descrestemos descrestar VMM01P0 +descresten descrestar VMM03P0 +descriad descriar VMM02P0 +descriando descriar VMG0000 +descriar descriar VMN0000 +describa describir VMM03S0 +describamos describir VMM01P0 +describan describir VMM03P0 +describe describir VMM02S0 +describid describir VMM02P0 +describiendo describir VMG0000 +describir describir VMN0000 +descriemos descriar VMM01P0 +descrisma descrismar VMM02S0 +descrismad descrismar VMM02P0 +descrismando descrismar VMG0000 +descrismar descrismar VMN0000 +descrisme descrismar VMM03S0 +descrismemos descrismar VMM01P0 +descrismen descrismar VMM03P0 +descristiana descristianar VMM02S0 +descristianad descristianar VMM02P0 +descristianando descristianar VMG0000 +descristianar descristianar VMN0000 +descristiane descristianar VMM03S0 +descristianemos descristianar VMM01P0 +descristianen descristianar VMM03P0 +descristianice descristianizar VMM03S0 +descristianicemos descristianizar VMM01P0 +descristianicen descristianizar VMM03P0 +descristianiza descristianizar VMM02S0 +descristianizad descristianizar VMM02P0 +descristianizando descristianizar VMG0000 +descristianizar descristianizar VMN0000 +descruce descruzar VMM03S0 +descrucemos descruzar VMM01P0 +descrucen descruzar VMM03P0 +descruza descruzar VMM02S0 +descruzad descruzar VMM02P0 +descruzando descruzar VMG0000 +descruzar descruzar VMN0000 +descría descriar VMM02S0 +descríe descriar VMM03S0 +descríen descriar VMM03P0 +descuaderna descuadernar VMM02S0 +descuadernad descuadernar VMM02P0 +descuadernando descuadernar VMG0000 +descuadernar descuadernar VMN0000 +descuaderne descuadernar VMM03S0 +descuadernemos descuadernar VMM01P0 +descuadernen descuadernar VMM03P0 +descuadrilla descuadrillar VMM02S0 +descuadrillad descuadrillar VMM02P0 +descuadrillando descuadrillar VMG0000 +descuadrillar descuadrillar VMN0000 +descuadrille descuadrillar VMM03S0 +descuadrillemos descuadrillar VMM01P0 +descuadrillen descuadrillar VMM03P0 +descuaja descuajar VMM02S0 +descuajad descuajar VMM02P0 +descuajando descuajar VMG0000 +descuajar descuajar VMN0000 +descuajaringa descuajaringar VMM02S0 +descuajaringad descuajaringar VMM02P0 +descuajaringando descuajaringar VMG0000 +descuajaringar descuajaringar VMN0000 +descuajaringue descuajaringar VMM03S0 +descuajaringuemos descuajaringar VMM01P0 +descuajaringuen descuajaringar VMM03P0 +descuaje descuajar VMM03S0 +descuajemos descuajar VMM01P0 +descuajen descuajar VMM03P0 +descuartice descuartizar VMM03S0 +descuarticemos descuartizar VMM01P0 +descuarticen descuartizar VMM03P0 +descuartiza descuartizar VMM02S0 +descuartizad descuartizar VMM02P0 +descuartizando descuartizar VMG0000 +descuartizar descuartizar VMN0000 +descubra descubrir VMM03S0 +descubramos descubrir VMM01P0 +descubran descubrir VMM03P0 +descubre descubrir VMM02S0 +descubrid descubrir VMM02P0 +descubriendo descubrir VMG0000 +descubrir descubrir VMN0000 +descuelga descolgar VMM02S0 +descuelgue descolgar VMM03S0 +descuelguen descolgar VMM03P0 +descuella descollar VMM02S0 +descuelle descollar VMM03S0 +descuellen descollar VMM03P0 +descuenta descontar VMM02S0 +descuente descontar VMM03S0 +descuenten descontar VMM03P0 +descuera descuerar VMM02S0 +descuerad descuerar VMM02P0 +descuerando descuerar VMG0000 +descuerar descuerar VMN0000 +descuerda descordar VMM02S0 +descuerde descordar VMM03S0 +descuerden descordar VMM03P0 +descuere descuerar VMM03S0 +descueremos descuerar VMM01P0 +descueren descuerar VMM03P0 +descuerna descornar VMM02S0 +descuerne descornar VMM03S0 +descuernen descornar VMM03P0 +descuesta descostar VMM02S0 +descueste descostar VMM03S0 +descuesten descostar VMM03P0 +descuida descuidar VMM02S0 +descuidad descuidar VMM02P0 +descuidando descuidar VMG0000 +descuidar descuidar VMN0000 +descuide descuidar VMM03S0 +descuidemos descuidar VMM01P0 +descuiden descuidar VMM03P0 +descula descular VMM02S0 +desculad descular VMM02P0 +desculando descular VMG0000 +descular descular VMN0000 +descule descular VMM03S0 +desculemos descular VMM01P0 +desculen descular VMM03P0 +desdecid desdecir VMM02P0 +desdecir desdecir VMN0000 +desdentad desdentar VMM02P0 +desdentando desdentar VMG0000 +desdentar desdentar VMN0000 +desdentemos desdentar VMM01P0 +desdeña desdeñar VMM02S0 +desdeñad desdeñar VMM02P0 +desdeñando desdeñar VMG0000 +desdeñar desdeñar VMN0000 +desdeñe desdeñar VMM03S0 +desdeñemos desdeñar VMM01P0 +desdeñen desdeñar VMM03P0 +desdibuja desdibujar VMM02S0 +desdibujad desdibujar VMM02P0 +desdibujando desdibujar VMG0000 +desdibujar desdibujar VMN0000 +desdibuje desdibujar VMM03S0 +desdibujemos desdibujar VMM01P0 +desdibujen desdibujar VMM03P0 +desdice desdecir VMM02S0 +desdiciendo desdecir VMG0000 +desdienta desdentar VMM02S0 +desdiente desdentar VMM03S0 +desdienten desdentar VMM03P0 +desdiga desdecir VMM03S0 +desdigamos desdecir VMM01P0 +desdigan desdecir VMM03P0 +desdobla desdoblar VMM02S0 +desdoblad desdoblar VMM02P0 +desdoblando desdoblar VMG0000 +desdoblar desdoblar VMN0000 +desdoble desdoblar VMM03S0 +desdoblemos desdoblar VMM01P0 +desdoblen desdoblar VMM03P0 +desdora desdorar VMM02S0 +desdorad desdorar VMM02P0 +desdorando desdorar VMG0000 +desdorar desdorar VMN0000 +desdore desdorar VMM03S0 +desdoremos desdorar VMM01P0 +desdoren desdorar VMM03P0 +desdramatice desdramatizar VMM03S0 +desdramaticemos desdramatizar VMM01P0 +desdramaticen desdramatizar VMM03P0 +desdramatiza desdramatizar VMM02S0 +desdramatizad desdramatizar VMM02P0 +desdramatizando desdramatizar VMG0000 +desdramatizar desdramatizar VMN0000 +desea desear VMM02S0 +desead desear VMM02P0 +deseando desear VMG0000 +desear desear VMN0000 +deseca desecar VMM02S0 +desecad desecar VMM02P0 +desecando desecar VMG0000 +desecar desecar VMN0000 +desecha desechar VMM02S0 +desechad desechar VMM02P0 +desechando desechar VMG0000 +desechar desechar VMN0000 +deseche desechar VMM03S0 +desechemos desechar VMM01P0 +desechen desechar VMM03P0 +desee desear VMM03S0 +deseemos desear VMM01P0 +deseen desear VMM03P0 +deselectrice deselectrizar VMM03S0 +deselectricemos deselectrizar VMM01P0 +deselectricen deselectrizar VMM03P0 +deselectriza deselectrizar VMM02S0 +deselectrizad deselectrizar VMM02P0 +deselectrizando deselectrizar VMG0000 +deselectrizar deselectrizar VMN0000 +desella desellar VMM02S0 +desellad desellar VMM02P0 +desellando desellar VMG0000 +desellar desellar VMN0000 +deselle desellar VMM03S0 +desellemos desellar VMM01P0 +desellen desellar VMM03P0 +desembala desembalar VMM02S0 +desembalad desembalar VMM02P0 +desembalando desembalar VMG0000 +desembalar desembalar VMN0000 +desembaldosa desembaldosar VMM02S0 +desembaldosad desembaldosar VMM02P0 +desembaldosando desembaldosar VMG0000 +desembaldosar desembaldosar VMN0000 +desembaldose desembaldosar VMM03S0 +desembaldosemos desembaldosar VMM01P0 +desembaldosen desembaldosar VMM03P0 +desembale desembalar VMM03S0 +desembalemos desembalar VMM01P0 +desembalen desembalar VMM03P0 +desembanasta desembanastar VMM02S0 +desembanastad desembanastar VMM02P0 +desembanastando desembanastar VMG0000 +desembanastar desembanastar VMN0000 +desembanaste desembanastar VMM03S0 +desembanastemos desembanastar VMM01P0 +desembanasten desembanastar VMM03P0 +desembarace desembarazar VMM03S0 +desembaracemos desembarazar VMM01P0 +desembaracen desembarazar VMM03P0 +desembaraza desembarazar VMM02S0 +desembarazad desembarazar VMM02P0 +desembarazando desembarazar VMG0000 +desembarazar desembarazar VMN0000 +desembarca desembarcar VMM02S0 +desembarcad desembarcar VMM02P0 +desembarcando desembarcar VMG0000 +desembarcar desembarcar VMN0000 +desembarga desembargar VMM02S0 +desembargad desembargar VMM02P0 +desembargando desembargar VMG0000 +desembargar desembargar VMN0000 +desembargue desembargar VMM03S0 +desembarguemos desembargar VMM01P0 +desembarguen desembargar VMM03P0 +desembarque desembarcar VMM03S0 +desembarquemos desembarcar VMM01P0 +desembarquen desembarcar VMM03P0 +desembarra desembarrar VMM02S0 +desembarrad desembarrar VMM02P0 +desembarranca desembarrancar VMM02S0 +desembarrancad desembarrancar VMM02P0 +desembarrancando desembarrancar VMG0000 +desembarrancar desembarrancar VMN0000 +desembarrando desembarrar VMG0000 +desembarranque desembarrancar VMM03S0 +desembarranquemos desembarrancar VMM01P0 +desembarranquen desembarrancar VMM03P0 +desembarrar desembarrar VMN0000 +desembarre desembarrar VMM03S0 +desembarremos desembarrar VMM01P0 +desembarren desembarrar VMM03P0 +desembaulad desembaular VMM02P0 +desembaulando desembaular VMG0000 +desembaular desembaular VMN0000 +desembaulemos desembaular VMM01P0 +desembaúla desembaular VMM02S0 +desembaúle desembaular VMM03S0 +desembaúlen desembaular VMM03P0 +desembelesa desembelesar VMM02S0 +desembelesad desembelesar VMM02P0 +desembelesando desembelesar VMG0000 +desembelesar desembelesar VMN0000 +desembelese desembelesar VMM03S0 +desembelesemos desembelesar VMM01P0 +desembelesen desembelesar VMM03P0 +desemboca desembocar VMM02S0 +desembocad desembocar VMM02P0 +desembocando desembocar VMG0000 +desembocar desembocar VMN0000 +desemboce desembozar VMM03S0 +desembocemos desembozar VMM01P0 +desembocen desembozar VMM03P0 +desemboja desembojar VMM02S0 +desembojad desembojar VMM02P0 +desembojando desembojar VMG0000 +desembojar desembojar VMN0000 +desemboje desembojar VMM03S0 +desembojemos desembojar VMM01P0 +desembojen desembojar VMM03P0 +desembolsa desembolsar VMM02S0 +desembolsad desembolsar VMM02P0 +desembolsando desembolsar VMG0000 +desembolsar desembolsar VMN0000 +desembolse desembolsar VMM03S0 +desembolsemos desembolsar VMM01P0 +desembolsen desembolsar VMM03P0 +desemboque desembocar VMM03S0 +desemboquemos desembocar VMM01P0 +desemboquen desembocar VMM03P0 +desemborracha desemborrachar VMM02S0 +desemborrachad desemborrachar VMM02P0 +desemborrachando desemborrachar VMG0000 +desemborrachar desemborrachar VMN0000 +desemborrache desemborrachar VMM03S0 +desemborrachemos desemborrachar VMM01P0 +desemborrachen desemborrachar VMM03P0 +desembota desembotar VMM02S0 +desembotad desembotar VMM02P0 +desembotando desembotar VMG0000 +desembotar desembotar VMN0000 +desembote desembotar VMM03S0 +desembotemos desembotar VMM01P0 +desemboten desembotar VMM03P0 +desemboza desembozar VMM02S0 +desembozad desembozar VMM02P0 +desembozando desembozar VMG0000 +desembozar desembozar VMN0000 +desembraga desembragar VMM02S0 +desembragad desembragar VMM02P0 +desembragando desembragar VMG0000 +desembragar desembragar VMN0000 +desembrague desembragar VMM03S0 +desembraguemos desembragar VMM01P0 +desembraguen desembragar VMM03P0 +desembravece desembravecer VMM02S0 +desembraveced desembravecer VMM02P0 +desembravecer desembravecer VMN0000 +desembraveciendo desembravecer VMG0000 +desembravezca desembravecer VMM03S0 +desembravezcamos desembravecer VMM01P0 +desembravezcan desembravecer VMM03P0 +desembriaga desembriagar VMM02S0 +desembriagad desembriagar VMM02P0 +desembriagando desembriagar VMG0000 +desembriagar desembriagar VMN0000 +desembriague desembriagar VMM03S0 +desembriaguemos desembriagar VMM01P0 +desembriaguen desembriagar VMM03P0 +desembrida desembridar VMM02S0 +desembridad desembridar VMM02P0 +desembridando desembridar VMG0000 +desembridar desembridar VMN0000 +desembride desembridar VMM03S0 +desembridemos desembridar VMM01P0 +desembriden desembridar VMM03P0 +desembroce desembrozar VMM03S0 +desembrocemos desembrozar VMM01P0 +desembrocen desembrozar VMM03P0 +desembrolla desembrollar VMM02S0 +desembrollad desembrollar VMM02P0 +desembrollando desembrollar VMG0000 +desembrollar desembrollar VMN0000 +desembrolle desembrollar VMM03S0 +desembrollemos desembrollar VMM01P0 +desembrollen desembrollar VMM03P0 +desembroza desembrozar VMM02S0 +desembrozad desembrozar VMM02P0 +desembrozando desembrozar VMG0000 +desembrozar desembrozar VMN0000 +desembruja desembrujar VMM02S0 +desembrujad desembrujar VMM02P0 +desembrujando desembrujar VMG0000 +desembrujar desembrujar VMN0000 +desembruje desembrujar VMM03S0 +desembrujemos desembrujar VMM01P0 +desembrujen desembrujar VMM03P0 +desembucha desembuchar VMM02S0 +desembuchad desembuchar VMM02P0 +desembuchando desembuchar VMG0000 +desembuchar desembuchar VMN0000 +desembuche desembuchar VMM03S0 +desembuchemos desembuchar VMM01P0 +desembuchen desembuchar VMM03P0 +desemeja desemejar VMM02S0 +desemejad desemejar VMM02P0 +desemejando desemejar VMG0000 +desemejar desemejar VMN0000 +desemeje desemejar VMM03S0 +desemejemos desemejar VMM01P0 +desemejen desemejar VMM03P0 +desempaca desempacar VMM02S0 +desempacad desempacar VMM02P0 +desempacando desempacar VMG0000 +desempacar desempacar VMN0000 +desempacha desempachar VMM02S0 +desempachad desempachar VMM02P0 +desempachando desempachar VMG0000 +desempachar desempachar VMN0000 +desempache desempachar VMM03S0 +desempachemos desempachar VMM01P0 +desempachen desempachar VMM03P0 +desempalaga desempalagar VMM02S0 +desempalagad desempalagar VMM02P0 +desempalagando desempalagar VMG0000 +desempalagar desempalagar VMN0000 +desempalague desempalagar VMM03S0 +desempalaguemos desempalagar VMM01P0 +desempalaguen desempalagar VMM03P0 +desempalma desempalmar VMM02S0 +desempalmad desempalmar VMM02P0 +desempalmando desempalmar VMG0000 +desempalmar desempalmar VMN0000 +desempalme desempalmar VMM03S0 +desempalmemos desempalmar VMM01P0 +desempalmen desempalmar VMM03P0 +desempapela desempapelar VMM02S0 +desempapelad desempapelar VMM02P0 +desempapelando desempapelar VMG0000 +desempapelar desempapelar VMN0000 +desempapele desempapelar VMM03S0 +desempapelemos desempapelar VMM01P0 +desempapelen desempapelar VMM03P0 +desempaque desempacar VMM03S0 +desempaquemos desempacar VMM01P0 +desempaquen desempacar VMM03P0 +desempaqueta desempaquetar VMM02S0 +desempaquetad desempaquetar VMM02P0 +desempaquetando desempaquetar VMG0000 +desempaquetar desempaquetar VMN0000 +desempaquete desempaquetar VMM03S0 +desempaquetemos desempaquetar VMM01P0 +desempaqueten desempaquetar VMM03P0 +desempareja desemparejar VMM02S0 +desemparejad desemparejar VMM02P0 +desemparejando desemparejar VMG0000 +desemparejar desemparejar VMN0000 +desempareje desemparejar VMM03S0 +desemparejemos desemparejar VMM01P0 +desemparejen desemparejar VMM03P0 +desemparva desemparvar VMM02S0 +desemparvad desemparvar VMM02P0 +desemparvando desemparvar VMG0000 +desemparvar desemparvar VMN0000 +desemparve desemparvar VMM03S0 +desemparvemos desemparvar VMM01P0 +desemparven desemparvar VMM03P0 +desempasta desempastar VMM02S0 +desempastad desempastar VMM02P0 +desempastando desempastar VMG0000 +desempastar desempastar VMN0000 +desempaste desempastar VMM03S0 +desempastemos desempastar VMM01P0 +desempasten desempastar VMM03P0 +desempata desempatar VMM02S0 +desempatad desempatar VMM02P0 +desempatando desempatar VMG0000 +desempatar desempatar VMN0000 +desempate desempatar VMM03S0 +desempatemos desempatar VMM01P0 +desempaten desempatar VMM03P0 +desempaña desempañar VMM02S0 +desempañad desempañar VMM02P0 +desempañando desempañar VMG0000 +desempañar desempañar VMN0000 +desempañe desempañar VMM03S0 +desempañemos desempañar VMM01P0 +desempañen desempañar VMM03P0 +desempedrad desempedrar VMM02P0 +desempedrando desempedrar VMG0000 +desempedrar desempedrar VMN0000 +desempedremos desempedrar VMM01P0 +desempega desempegar VMM02S0 +desempegad desempegar VMM02P0 +desempegando desempegar VMG0000 +desempegar desempegar VMN0000 +desempegue desempegar VMM03S0 +desempeguemos desempegar VMM01P0 +desempeguen desempegar VMM03P0 +desemperece desemperezar VMM03S0 +desemperecemos desemperezar VMM01P0 +desemperecen desemperezar VMM03P0 +desempereza desemperezar VMM02S0 +desemperezad desemperezar VMM02P0 +desemperezando desemperezar VMG0000 +desemperezar desemperezar VMN0000 +desemperna desempernar VMM02S0 +desempernad desempernar VMM02P0 +desempernando desempernar VMG0000 +desempernar desempernar VMN0000 +desemperne desempernar VMM03S0 +desempernemos desempernar VMM01P0 +desempernen desempernar VMM03P0 +desempeña desempeñar VMM02S0 +desempeñad desempeñar VMM02P0 +desempeñando desempeñar VMG0000 +desempeñar desempeñar VMN0000 +desempeñe desempeñar VMM03S0 +desempeñemos desempeñar VMM01P0 +desempeñen desempeñar VMM03P0 +desempiedra desempedrar VMM02S0 +desempiedre desempedrar VMM03S0 +desempiedren desempedrar VMM03P0 +desempoce desempozar VMM03S0 +desempocemos desempozar VMM01P0 +desempocen desempozar VMM03P0 +desempolva desempolvar VMM02S0 +desempolvad desempolvar VMM02P0 +desempolvando desempolvar VMG0000 +desempolvar desempolvar VMN0000 +desempolve desempolvar VMM03S0 +desempolvemos desempolvar VMM01P0 +desempolven desempolvar VMM03P0 +desemponzoña desemponzoñar VMM02S0 +desemponzoñad desemponzoñar VMM02P0 +desemponzoñando desemponzoñar VMG0000 +desemponzoñar desemponzoñar VMN0000 +desemponzoñe desemponzoñar VMM03S0 +desemponzoñemos desemponzoñar VMM01P0 +desemponzoñen desemponzoñar VMM03P0 +desempotra desempotrar VMM02S0 +desempotrad desempotrar VMM02P0 +desempotrando desempotrar VMG0000 +desempotrar desempotrar VMN0000 +desempotre desempotrar VMM03S0 +desempotremos desempotrar VMM01P0 +desempotren desempotrar VMM03P0 +desempoza desempozar VMM02S0 +desempozad desempozar VMM02P0 +desempozando desempozar VMG0000 +desempozar desempozar VMN0000 +desempuña desempuñar VMM02S0 +desempuñad desempuñar VMM02P0 +desempuñando desempuñar VMG0000 +desempuñar desempuñar VMN0000 +desempuñe desempuñar VMM03S0 +desempuñemos desempuñar VMM01P0 +desempuñen desempuñar VMM03P0 +desenamora desenamorar VMM02S0 +desenamorad desenamorar VMM02P0 +desenamorando desenamorar VMG0000 +desenamorar desenamorar VMN0000 +desenamore desenamorar VMM03S0 +desenamoremos desenamorar VMM01P0 +desenamoren desenamorar VMM03P0 +desencabestra desencabestrar VMM02S0 +desencabestrad desencabestrar VMM02P0 +desencabestrando desencabestrar VMG0000 +desencabestrar desencabestrar VMN0000 +desencabestre desencabestrar VMM03S0 +desencabestremos desencabestrar VMM01P0 +desencabestren desencabestrar VMM03P0 +desencadena desencadenar VMM02S0 +desencadenad desencadenar VMM02P0 +desencadenando desencadenar VMG0000 +desencadenar desencadenar VMN0000 +desencadene desencadenar VMM03S0 +desencadenemos desencadenar VMM01P0 +desencadenen desencadenar VMM03P0 +desencaja desencajar VMM02S0 +desencajad desencajar VMM02P0 +desencajando desencajar VMG0000 +desencajar desencajar VMN0000 +desencaje desencajar VMM03S0 +desencajemos desencajar VMM01P0 +desencajen desencajar VMM03P0 +desencajona desencajonar VMM02S0 +desencajonad desencajonar VMM02P0 +desencajonando desencajonar VMG0000 +desencajonar desencajonar VMN0000 +desencajone desencajonar VMM03S0 +desencajonemos desencajonar VMM01P0 +desencajonen desencajonar VMM03P0 +desencalla desencallar VMM02S0 +desencallad desencallar VMM02P0 +desencallando desencallar VMG0000 +desencallar desencallar VMN0000 +desencalle desencallar VMM03S0 +desencallemos desencallar VMM01P0 +desencallen desencallar VMM03P0 +desencamina desencaminar VMM02S0 +desencaminad desencaminar VMM02P0 +desencaminando desencaminar VMG0000 +desencaminar desencaminar VMN0000 +desencamine desencaminar VMM03S0 +desencaminemos desencaminar VMM01P0 +desencaminen desencaminar VMM03P0 +desencanta desencantar VMM02S0 +desencantad desencantar VMM02P0 +desencantando desencantar VMG0000 +desencantar desencantar VMN0000 +desencante desencantar VMM03S0 +desencantemos desencantar VMM01P0 +desencanten desencantar VMM03P0 +desencapilla desencapillar VMM02S0 +desencapillad desencapillar VMM02P0 +desencapillando desencapillar VMG0000 +desencapillar desencapillar VMN0000 +desencapille desencapillar VMM03S0 +desencapillemos desencapillar VMM01P0 +desencapillen desencapillar VMM03P0 +desencapota desencapotar VMM02S0 +desencapotad desencapotar VMM02P0 +desencapotando desencapotar VMG0000 +desencapotar desencapotar VMN0000 +desencapote desencapotar VMM03S0 +desencapotemos desencapotar VMM01P0 +desencapoten desencapotar VMM03P0 +desencapricha desencaprichar VMM02S0 +desencaprichad desencaprichar VMM02P0 +desencaprichando desencaprichar VMG0000 +desencaprichar desencaprichar VMN0000 +desencapriche desencaprichar VMM03S0 +desencaprichemos desencaprichar VMM01P0 +desencaprichen desencaprichar VMM03P0 +desencarcela desencarcelar VMM02S0 +desencarcelad desencarcelar VMM02P0 +desencarcelando desencarcelar VMG0000 +desencarcelar desencarcelar VMN0000 +desencarcele desencarcelar VMM03S0 +desencarcelemos desencarcelar VMM01P0 +desencarcelen desencarcelar VMM03P0 +desencarga desencargar VMM02S0 +desencargad desencargar VMM02P0 +desencargando desencargar VMG0000 +desencargar desencargar VMN0000 +desencargue desencargar VMM03S0 +desencarguemos desencargar VMM01P0 +desencarguen desencargar VMM03P0 +desencarna desencarnar VMM02S0 +desencarnad desencarnar VMM02P0 +desencarnando desencarnar VMG0000 +desencarnar desencarnar VMN0000 +desencarne desencarnar VMM03S0 +desencarnemos desencarnar VMM01P0 +desencarnen desencarnar VMM03P0 +desencasquilla desencasquillar VMM02S0 +desencasquillad desencasquillar VMM02P0 +desencasquillando desencasquillar VMG0000 +desencasquillar desencasquillar VMN0000 +desencasquille desencasquillar VMM03S0 +desencasquillemos desencasquillar VMM01P0 +desencasquillen desencasquillar VMM03P0 +desencerrad desencerrar VMM02P0 +desencerrando desencerrar VMG0000 +desencerrar desencerrar VMN0000 +desencerremos desencerrar VMM01P0 +desenchufa desenchufar VMM02S0 +desenchufad desenchufar VMM02P0 +desenchufando desenchufar VMG0000 +desenchufar desenchufar VMN0000 +desenchufe desenchufar VMM03S0 +desenchufemos desenchufar VMM01P0 +desenchufen desenchufar VMM03P0 +desencierra desencerrar VMM02S0 +desencierre desencerrar VMM03S0 +desencierren desencerrar VMM03P0 +desenclava desenclavar VMM02S0 +desenclavad desenclavar VMM02P0 +desenclavando desenclavar VMG0000 +desenclavar desenclavar VMN0000 +desenclave desenclavar VMM03S0 +desenclavemos desenclavar VMM01P0 +desenclaven desenclavar VMM03P0 +desenclavija desenclavijar VMM02S0 +desenclavijad desenclavijar VMM02P0 +desenclavijando desenclavijar VMG0000 +desenclavijar desenclavijar VMN0000 +desenclavije desenclavijar VMM03S0 +desenclavijemos desenclavijar VMM01P0 +desenclavijen desenclavijar VMM03P0 +desencofra desencofrar VMM02S0 +desencofrad desencofrar VMM02P0 +desencofrando desencofrar VMG0000 +desencofrar desencofrar VMN0000 +desencofre desencofrar VMM03S0 +desencofremos desencofrar VMM01P0 +desencofren desencofrar VMM03P0 +desencoge desencoger VMM02S0 +desencoged desencoger VMM02P0 +desencoger desencoger VMN0000 +desencogiendo desencoger VMG0000 +desencoja desencoger VMM03S0 +desencojamos desencoger VMM01P0 +desencojan desencoger VMM03P0 +desencola desencolar VMM02S0 +desencolad desencolar VMM02P0 +desencolando desencolar VMG0000 +desencolar desencolar VMN0000 +desencole desencolar VMM03S0 +desencolemos desencolar VMM01P0 +desencolen desencolar VMM03P0 +desencolerice desencolerizar VMM03S0 +desencolericemos desencolerizar VMM01P0 +desencolericen desencolerizar VMM03P0 +desencoleriza desencolerizar VMM02S0 +desencolerizad desencolerizar VMM02P0 +desencolerizando desencolerizar VMG0000 +desencolerizar desencolerizar VMN0000 +desencona desenconar VMM02S0 +desenconad desenconar VMM02P0 +desenconando desenconar VMG0000 +desenconar desenconar VMN0000 +desencone desenconar VMM03S0 +desenconemos desenconar VMM01P0 +desenconen desenconar VMM03P0 +desencordela desencordelar VMM02S0 +desencordelad desencordelar VMM02P0 +desencordelando desencordelar VMG0000 +desencordelar desencordelar VMN0000 +desencordele desencordelar VMM03S0 +desencordelemos desencordelar VMM01P0 +desencordelen desencordelar VMM03P0 +desencorva desencorvar VMM02S0 +desencorvad desencorvar VMM02P0 +desencorvando desencorvar VMG0000 +desencorvar desencorvar VMN0000 +desencorve desencorvar VMM03S0 +desencorvemos desencorvar VMM01P0 +desencorven desencorvar VMM03P0 +desencrespa desencrespar VMM02S0 +desencrespad desencrespar VMM02P0 +desencrespando desencrespar VMG0000 +desencrespar desencrespar VMN0000 +desencrespe desencrespar VMM03S0 +desencrespemos desencrespar VMM01P0 +desencrespen desencrespar VMM03P0 +desencuaderna desencuadernar VMM02S0 +desencuadernad desencuadernar VMM02P0 +desencuadernando desencuadernar VMG0000 +desencuadernar desencuadernar VMN0000 +desencuaderne desencuadernar VMM03S0 +desencuadernemos desencuadernar VMM01P0 +desencuadernen desencuadernar VMM03P0 +desendemonia desendemoniar VMM02S0 +desendemoniad desendemoniar VMM02P0 +desendemoniando desendemoniar VMG0000 +desendemoniar desendemoniar VMN0000 +desendemonie desendemoniar VMM03S0 +desendemoniemos desendemoniar VMM01P0 +desendemonien desendemoniar VMM03P0 +desendeuda desendeudar VMM02S0 +desendeudad desendeudar VMM02P0 +desendeudando desendeudar VMG0000 +desendeudar desendeudar VMN0000 +desendiabla desendiablar VMM02S0 +desendiablad desendiablar VMM02P0 +desendiablando desendiablar VMG0000 +desendiablar desendiablar VMN0000 +desendiable desendiablar VMM03S0 +desendiablemos desendiablar VMM01P0 +desendiablen desendiablar VMM03P0 +desendiosa desendiosar VMM02S0 +desendiosad desendiosar VMM02P0 +desendiosando desendiosar VMG0000 +desendiosar desendiosar VMN0000 +desendiose desendiosar VMM03S0 +desendiosemos desendiosar VMM01P0 +desendiosen desendiosar VMM03P0 +desenfada desenfadar VMM02S0 +desenfadad desenfadar VMM02P0 +desenfadando desenfadar VMG0000 +desenfadar desenfadar VMN0000 +desenfade desenfadar VMM03S0 +desenfademos desenfadar VMM01P0 +desenfaden desenfadar VMM03P0 +desenfarda desenfardar VMM02S0 +desenfardad desenfardar VMM02P0 +desenfardando desenfardar VMG0000 +desenfardar desenfardar VMN0000 +desenfarde desenfardar VMM03S0 +desenfardela desenfardelar VMM02S0 +desenfardelad desenfardelar VMM02P0 +desenfardelando desenfardelar VMG0000 +desenfardelar desenfardelar VMN0000 +desenfardele desenfardelar VMM03S0 +desenfardelemos desenfardelar VMM01P0 +desenfardelen desenfardelar VMM03P0 +desenfardemos desenfardar VMM01P0 +desenfarden desenfardar VMM03P0 +desenfila desenfilar VMM02S0 +desenfilad desenfilar VMM02P0 +desenfilando desenfilar VMG0000 +desenfilar desenfilar VMN0000 +desenfile desenfilar VMM03S0 +desenfilemos desenfilar VMM01P0 +desenfilen desenfilar VMM03P0 +desenfoca desenfocar VMM02S0 +desenfocad desenfocar VMM02P0 +desenfocando desenfocar VMG0000 +desenfocar desenfocar VMN0000 +desenfoque desenfocar VMM03S0 +desenfoquemos desenfocar VMM01P0 +desenfoquen desenfocar VMM03P0 +desenfrena desenfrenar VMM02S0 +desenfrenad desenfrenar VMM02P0 +desenfrenando desenfrenar VMG0000 +desenfrenar desenfrenar VMN0000 +desenfrene desenfrenar VMM03S0 +desenfrenemos desenfrenar VMM01P0 +desenfrenen desenfrenar VMM03P0 +desenfunda desenfundar VMM02S0 +desenfundad desenfundar VMM02P0 +desenfundando desenfundar VMG0000 +desenfundar desenfundar VMN0000 +desenfunde desenfundar VMM03S0 +desenfundemos desenfundar VMM01P0 +desenfunden desenfundar VMM03P0 +desenfurece desenfurecer VMM02S0 +desenfureced desenfurecer VMM02P0 +desenfurecer desenfurecer VMN0000 +desenfureciendo desenfurecer VMG0000 +desenfurezca desenfurecer VMM03S0 +desenfurezcamos desenfurecer VMM01P0 +desenfurezcan desenfurecer VMM03P0 +desengancha desenganchar VMM02S0 +desenganchad desenganchar VMM02P0 +desenganchando desenganchar VMG0000 +desenganchar desenganchar VMN0000 +desenganche desenganchar VMM03S0 +desenganchemos desenganchar VMM01P0 +desenganchen desenganchar VMM03P0 +desengarce desengarzar VMM03S0 +desengarcemos desengarzar VMM01P0 +desengarcen desengarzar VMM03P0 +desengarza desengarzar VMM02S0 +desengarzad desengarzar VMM02P0 +desengarzando desengarzar VMG0000 +desengarzar desengarzar VMN0000 +desengasta desengastar VMM02S0 +desengastad desengastar VMM02P0 +desengastando desengastar VMG0000 +desengastar desengastar VMN0000 +desengaste desengastar VMM03S0 +desengastemos desengastar VMM01P0 +desengasten desengastar VMM03P0 +desengaña desengañar VMM02S0 +desengañad desengañar VMM02P0 +desengañando desengañar VMG0000 +desengañar desengañar VMN0000 +desengañe desengañar VMM03S0 +desengañemos desengañar VMM01P0 +desengañen desengañar VMM03P0 +desengoma desengomar VMM02S0 +desengomad desengomar VMM02P0 +desengomando desengomar VMG0000 +desengomar desengomar VMN0000 +desengome desengomar VMM03S0 +desengomemos desengomar VMM01P0 +desengomen desengomar VMM03P0 +desengozna desengoznar VMM02S0 +desengoznad desengoznar VMM02P0 +desengoznando desengoznar VMG0000 +desengoznar desengoznar VMN0000 +desengozne desengoznar VMM03S0 +desengoznemos desengoznar VMM01P0 +desengoznen desengoznar VMM03P0 +desengrana desengranar VMM02S0 +desengranad desengranar VMM02P0 +desengranando desengranar VMG0000 +desengranar desengranar VMN0000 +desengrane desengranar VMM03S0 +desengranemos desengranar VMM01P0 +desengranen desengranar VMM03P0 +desengrasa desengrasar VMM02S0 +desengrasad desengrasar VMM02P0 +desengrasando desengrasar VMG0000 +desengrasar desengrasar VMN0000 +desengrase desengrasar VMM03S0 +desengrasemos desengrasar VMM01P0 +desengrasen desengrasar VMM03P0 +desengrosad desengrosar VMM02P0 +desengrosando desengrosar VMG0000 +desengrosar desengrosar VMN0000 +desengrosemos desengrosar VMM01P0 +desengruesa desengrosar VMM02S0 +desengruese desengrosar VMM03S0 +desengruesen desengrosar VMM03P0 +desenguanta desenguantar VMM02S0 +desenguantad desenguantar VMM02P0 +desenguantando desenguantar VMG0000 +desenguantar desenguantar VMN0000 +desenguante desenguantar VMM03S0 +desenguantemos desenguantar VMM01P0 +desenguanten desenguantar VMM03P0 +desenhebra desenhebrar VMM02S0 +desenhebrad desenhebrar VMM02P0 +desenhebrando desenhebrar VMG0000 +desenhebrar desenhebrar VMN0000 +desenhebre desenhebrar VMM03S0 +desenhebremos desenhebrar VMM01P0 +desenhebren desenhebrar VMM03P0 +desenhorna desenhornar VMM02S0 +desenhornad desenhornar VMM02P0 +desenhornando desenhornar VMG0000 +desenhornar desenhornar VMN0000 +desenhorne desenhornar VMM03S0 +desenhornemos desenhornar VMM01P0 +desenhornen desenhornar VMM03P0 +desenjaece desenjaezar VMM03S0 +desenjaecemos desenjaezar VMM01P0 +desenjaecen desenjaezar VMM03P0 +desenjaeza desenjaezar VMM02S0 +desenjaezad desenjaezar VMM02P0 +desenjaezando desenjaezar VMG0000 +desenjaezar desenjaezar VMN0000 +desenjalma desenjalmar VMM02S0 +desenjalmad desenjalmar VMM02P0 +desenjalmando desenjalmar VMG0000 +desenjalmar desenjalmar VMN0000 +desenjalme desenjalmar VMM03S0 +desenjalmemos desenjalmar VMM01P0 +desenjalmen desenjalmar VMM03P0 +desenjaula desenjaular VMM02S0 +desenjaulad desenjaular VMM02P0 +desenjaulando desenjaular VMG0000 +desenjaular desenjaular VMN0000 +desenjaule desenjaular VMM03S0 +desenjaulemos desenjaular VMM01P0 +desenjaulen desenjaular VMM03P0 +desenlace desenlazar VMM03S0 +desenlacemos desenlazar VMM01P0 +desenlacen desenlazar VMM03P0 +desenladrilla desenladrillar VMM02S0 +desenladrillad desenladrillar VMM02P0 +desenladrillando desenladrillar VMG0000 +desenladrillar desenladrillar VMN0000 +desenladrille desenladrillar VMM03S0 +desenladrillemos desenladrillar VMM01P0 +desenladrillen desenladrillar VMM03P0 +desenlaza desenlazar VMM02S0 +desenlazad desenlazar VMM02P0 +desenlazando desenlazar VMG0000 +desenlazar desenlazar VMN0000 +desenloda desenlodar VMM02S0 +desenlodad desenlodar VMM02P0 +desenlodando desenlodar VMG0000 +desenlodar desenlodar VMN0000 +desenlode desenlodar VMM03S0 +desenlodemos desenlodar VMM01P0 +desenloden desenlodar VMM03P0 +desenlosa desenlosar VMM02S0 +desenlosad desenlosar VMM02P0 +desenlosando desenlosar VMG0000 +desenlosar desenlosar VMN0000 +desenlose desenlosar VMM03S0 +desenlosemos desenlosar VMM01P0 +desenlosen desenlosar VMM03P0 +desenluta desenlutar VMM02S0 +desenlutad desenlutar VMM02P0 +desenlutando desenlutar VMG0000 +desenlutar desenlutar VMN0000 +desenlute desenlutar VMM03S0 +desenlutemos desenlutar VMM01P0 +desenluten desenlutar VMM03P0 +desenmaraña desenmarañar VMM02S0 +desenmarañad desenmarañar VMM02P0 +desenmarañando desenmarañar VMG0000 +desenmarañar desenmarañar VMN0000 +desenmarañe desenmarañar VMM03S0 +desenmarañemos desenmarañar VMM01P0 +desenmarañen desenmarañar VMM03P0 +desenmascara desenmascarar VMM02S0 +desenmascarad desenmascarar VMM02P0 +desenmascarando desenmascarar VMG0000 +desenmascarar desenmascarar VMN0000 +desenmascare desenmascarar VMM03S0 +desenmascaremos desenmascarar VMM01P0 +desenmascaren desenmascarar VMM03P0 +desenmohece desenmohecer VMM02S0 +desenmoheced desenmohecer VMM02P0 +desenmohecer desenmohecer VMN0000 +desenmoheciendo desenmohecer VMG0000 +desenmohezca desenmohecer VMM03S0 +desenmohezcamos desenmohecer VMM01P0 +desenmohezcan desenmohecer VMM03P0 +desenmudece desenmudecer VMM02S0 +desenmudeced desenmudecer VMM02P0 +desenmudecer desenmudecer VMN0000 +desenmudeciendo desenmudecer VMG0000 +desenmudezca desenmudecer VMM03S0 +desenmudezcamos desenmudecer VMM01P0 +desenmudezcan desenmudecer VMM03P0 +desenoja desenojar VMM02S0 +desenojad desenojar VMM02P0 +desenojando desenojar VMG0000 +desenojar desenojar VMN0000 +desenoje desenojar VMM03S0 +desenojemos desenojar VMM01P0 +desenojen desenojar VMM03P0 +desenreda desenredar VMM02S0 +desenredad desenredar VMM02P0 +desenredando desenredar VMG0000 +desenredar desenredar VMN0000 +desenrede desenredar VMM03S0 +desenredemos desenredar VMM01P0 +desenreden desenredar VMM03P0 +desenrolla desenrollar VMM02S0 +desenrollad desenrollar VMM02P0 +desenrollando desenrollar VMG0000 +desenrollar desenrollar VMN0000 +desenrolle desenrollar VMM03S0 +desenrollemos desenrollar VMM01P0 +desenrollen desenrollar VMM03P0 +desenrosca desenroscar VMM02S0 +desenroscad desenroscar VMM02P0 +desenroscando desenroscar VMG0000 +desenroscar desenroscar VMN0000 +desenrosque desenroscar VMM03S0 +desenrosquemos desenroscar VMM01P0 +desenrosquen desenroscar VMM03P0 +desensambla desensamblar VMM02S0 +desensamblad desensamblar VMM02P0 +desensamblando desensamblar VMG0000 +desensamblar desensamblar VMN0000 +desensamble desensamblar VMM03S0 +desensamblemos desensamblar VMM01P0 +desensamblen desensamblar VMM03P0 +desensarta desensartar VMM02S0 +desensartad desensartar VMM02P0 +desensartando desensartar VMG0000 +desensartar desensartar VMN0000 +desensarte desensartar VMM03S0 +desensartemos desensartar VMM01P0 +desensarten desensartar VMM03P0 +desensaña desensañar VMM02S0 +desensañad desensañar VMM02P0 +desensañando desensañar VMG0000 +desensañar desensañar VMN0000 +desensañe desensañar VMM03S0 +desensañemos desensañar VMM01P0 +desensañen desensañar VMM03P0 +desensibilice desensibilizar VMM03S0 +desensibilicemos desensibilizar VMM01P0 +desensibilicen desensibilizar VMM03P0 +desensibiliza desensibilizar VMM02S0 +desensibilizad desensibilizar VMM02P0 +desensibilizando desensibilizar VMG0000 +desensibilizar desensibilizar VMN0000 +desensilla desensillar VMM02S0 +desensillad desensillar VMM02P0 +desensillando desensillar VMG0000 +desensillar desensillar VMN0000 +desensille desensillar VMM03S0 +desensillemos desensillar VMM01P0 +desensillen desensillar VMM03P0 +desensoberbece desensoberbecer VMM02S0 +desensoberbeced desensoberbecer VMM02P0 +desensoberbecer desensoberbecer VMN0000 +desensoberbeciendo desensoberbecer VMG0000 +desensoberbezca desensoberbecer VMM03S0 +desensoberbezcamos desensoberbecer VMM01P0 +desensoberbezcan desensoberbecer VMM03P0 +desentabla desentablar VMM02S0 +desentablad desentablar VMM02P0 +desentablando desentablar VMG0000 +desentablar desentablar VMN0000 +desentable desentablar VMM03S0 +desentablemos desentablar VMM01P0 +desentablen desentablar VMM03P0 +desentalinga desentalingar VMM02S0 +desentalingad desentalingar VMM02P0 +desentalingando desentalingar VMG0000 +desentalingar desentalingar VMN0000 +desentalingue desentalingar VMM03S0 +desentalinguemos desentalingar VMM01P0 +desentalinguen desentalingar VMM03P0 +desentarima desentarimar VMM02S0 +desentarimad desentarimar VMM02P0 +desentarimando desentarimar VMG0000 +desentarimar desentarimar VMN0000 +desentarime desentarimar VMM03S0 +desentarimemos desentarimar VMM01P0 +desentarimen desentarimar VMM03P0 +desentendamos desentender VMM01P0 +desentended desentender VMM02P0 +desentender desentender VMN0000 +desentendiendo desentender VMG0000 +desenterrad desenterrar VMM02P0 +desenterrando desenterrar VMG0000 +desenterrar desenterrar VMN0000 +desenterremos desenterrar VMM01P0 +desentienda desentender VMM03S0 +desentiendan desentender VMM03P0 +desentiende desentender VMM02S0 +desentierra desenterrar VMM02S0 +desentierre desenterrar VMM03S0 +desentierren desenterrar VMM03P0 +desentolda desentoldar VMM02S0 +desentoldad desentoldar VMM02P0 +desentoldando desentoldar VMG0000 +desentoldar desentoldar VMN0000 +desentolde desentoldar VMM03S0 +desentoldemos desentoldar VMM01P0 +desentolden desentoldar VMM03P0 +desentona desentonar VMM02S0 +desentonad desentonar VMM02P0 +desentonando desentonar VMG0000 +desentonar desentonar VMN0000 +desentone desentonar VMM03S0 +desentonemos desentonar VMM01P0 +desentonen desentonar VMM03P0 +desentorpece desentorpecer VMM02S0 +desentorpeced desentorpecer VMM02P0 +desentorpecer desentorpecer VMN0000 +desentorpeciendo desentorpecer VMG0000 +desentorpezca desentorpecer VMM03S0 +desentorpezcamos desentorpecer VMM01P0 +desentorpezcan desentorpecer VMM03P0 +desentrampa desentrampar VMM02S0 +desentrampad desentrampar VMM02P0 +desentrampando desentrampar VMG0000 +desentrampar desentrampar VMN0000 +desentrampe desentrampar VMM03S0 +desentrampemos desentrampar VMM01P0 +desentrampen desentrampar VMM03P0 +desentraña desentrañar VMM02S0 +desentrañad desentrañar VMM02P0 +desentrañando desentrañar VMG0000 +desentrañar desentrañar VMN0000 +desentrañe desentrañar VMM03S0 +desentrañemos desentrañar VMM01P0 +desentrañen desentrañar VMM03P0 +desentrena desentrenar VMM02S0 +desentrenad desentrenar VMM02P0 +desentrenando desentrenar VMG0000 +desentrenar desentrenar VMN0000 +desentrene desentrenar VMM03S0 +desentrenemos desentrenar VMM01P0 +desentrenen desentrenar VMM03P0 +desentuma desentumir VMM03S0 +desentumamos desentumir VMM01P0 +desentuman desentumir VMM03P0 +desentume desentumir VMM02S0 +desentumece desentumecer VMM02S0 +desentumeced desentumecer VMM02P0 +desentumecer desentumecer VMN0000 +desentumeciendo desentumecer VMG0000 +desentumezca desentumecer VMM03S0 +desentumezcamos desentumecer VMM01P0 +desentumezcan desentumecer VMM03P0 +desentumid desentumir VMM02P0 +desentumiendo desentumir VMG0000 +desentumir desentumir VMN0000 +desenvaina desenvainar VMM02S0 +desenvainad desenvainar VMM02P0 +desenvainando desenvainar VMG0000 +desenvainar desenvainar VMN0000 +desenvaine desenvainar VMM03S0 +desenvainemos desenvainar VMM01P0 +desenvainen desenvainar VMM03P0 +desenverga desenvergar VMM02S0 +desenvergad desenvergar VMM02P0 +desenvergando desenvergar VMG0000 +desenvergar desenvergar VMN0000 +desenvergue desenvergar VMM03S0 +desenverguemos desenvergar VMM01P0 +desenverguen desenvergar VMM03P0 +desenvolvamos desenvolver VMM01P0 +desenvolved desenvolver VMM02P0 +desenvolver desenvolver VMN0000 +desenvolviendo desenvolver VMG0000 +desenvuelva desenvolver VMM03S0 +desenvuelvan desenvolver VMM03P0 +desenvuelve desenvolver VMM02S0 +desenzarce desenzarzar VMM03S0 +desenzarcemos desenzarzar VMM01P0 +desenzarcen desenzarzar VMM03P0 +desenzarza desenzarzar VMM02S0 +desenzarzad desenzarzar VMM02P0 +desenzarzando desenzarzar VMG0000 +desenzarzar desenzarzar VMN0000 +deseque desecar VMM03S0 +desequemos desecar VMM01P0 +desequen desecar VMM03P0 +desequilibra desequilibrar VMM02S0 +desequilibrad desequilibrar VMM02P0 +desequilibrando desequilibrar VMG0000 +desequilibrar desequilibrar VMN0000 +desequilibre desequilibrar VMM03S0 +desequilibremos desequilibrar VMM01P0 +desequilibren desequilibrar VMM03P0 +deserta desertar VMM02S0 +desertad desertar VMM02P0 +desertando desertar VMG0000 +desertar desertar VMN0000 +deserte desertar VMM03S0 +desertemos desertar VMM01P0 +deserten desertar VMM03P0 +desescombra desescombrar VMM02S0 +desescombrad desescombrar VMM02P0 +desescombrando desescombrar VMG0000 +desescombrar desescombrar VMN0000 +desescombre desescombrar VMM03S0 +desescombremos desescombrar VMM01P0 +desescombren desescombrar VMM03P0 +deseslabona deseslabonar VMM02S0 +deseslabonad deseslabonar VMM02P0 +deseslabonando deseslabonar VMG0000 +deseslabonar deseslabonar VMN0000 +deseslabone deseslabonar VMM03S0 +deseslabonemos deseslabonar VMM01P0 +deseslabonen deseslabonar VMM03P0 +desespalda desespaldar VMM02S0 +desespaldad desespaldar VMM02P0 +desespaldando desespaldar VMG0000 +desespaldar desespaldar VMN0000 +desespalde desespaldar VMM03S0 +desespaldemos desespaldar VMM01P0 +desespalden desespaldar VMM03P0 +desespera desesperar VMM02S0 +desesperad desesperar VMM02P0 +desesperance desesperanzar VMM03S0 +desesperancemos desesperanzar VMM01P0 +desesperancen desesperanzar VMM03P0 +desesperando desesperar VMG0000 +desesperanza desesperanzar VMM02S0 +desesperanzad desesperanzar VMM02P0 +desesperanzando desesperanzar VMG0000 +desesperanzar desesperanzar VMN0000 +desesperar desesperar VMN0000 +desespere desesperar VMM03S0 +desesperemos desesperar VMM01P0 +desesperen desesperar VMM03P0 +desestabilice desestabilizar VMM03S0 +desestabilicemos desestabilizar VMM01P0 +desestabilicen desestabilizar VMM03P0 +desestabiliza desestabilizar VMM02S0 +desestabilizad desestabilizar VMM02P0 +desestabilizando desestabilizar VMG0000 +desestabilizar desestabilizar VMN0000 +desestaña desestañar VMM02S0 +desestañad desestañar VMM02P0 +desestañando desestañar VMG0000 +desestañar desestañar VMN0000 +desestañe desestañar VMM03S0 +desestañemos desestañar VMM01P0 +desestañen desestañar VMM03P0 +desestera desesterar VMM02S0 +desesterad desesterar VMM02P0 +desesterando desesterar VMG0000 +desesterar desesterar VMN0000 +desestere desesterar VMM03S0 +desesteremos desesterar VMM01P0 +desesteren desesterar VMM03P0 +desestima desestimar VMM02S0 +desestimad desestimar VMM02P0 +desestimando desestimar VMG0000 +desestimar desestimar VMN0000 +desestime desestimar VMM03S0 +desestimemos desestimar VMM01P0 +desestimen desestimar VMM03P0 +desfaced desfacer VMM02P0 +desfacer desfacer VMN0000 +desfaciendo desfacer VMG0000 +desfaja desfajar VMM02S0 +desfajad desfajar VMM02P0 +desfajando desfajar VMG0000 +desfajar desfajar VMN0000 +desfaje desfajar VMM03S0 +desfajemos desfajar VMM01P0 +desfajen desfajar VMM03P0 +desfalca desfalcar VMM02S0 +desfalcad desfalcar VMM02P0 +desfalcando desfalcar VMG0000 +desfalcar desfalcar VMN0000 +desfallece desfallecer VMM02S0 +desfalleced desfallecer VMM02P0 +desfallecer desfallecer VMN0000 +desfalleciendo desfallecer VMG0000 +desfallezca desfallecer VMM03S0 +desfallezcamos desfallecer VMM01P0 +desfallezcan desfallecer VMM03P0 +desfalque desfalcar VMM03S0 +desfalquemos desfalcar VMM01P0 +desfalquen desfalcar VMM03P0 +desfasa desfasar VMM02S0 +desfasad desfasar VMM02P0 +desfasando desfasar VMG0000 +desfasar desfasar VMN0000 +desfase desfasar VMM03S0 +desfasemos desfasar VMM01P0 +desfasen desfasar VMM03P0 +desfavorece desfavorecer VMM02S0 +desfavoreced desfavorecer VMM02P0 +desfavorecer desfavorecer VMN0000 +desfavoreciendo desfavorecer VMG0000 +desfavorezca desfavorecer VMM03S0 +desfavorezcamos desfavorecer VMM01P0 +desfavorezcan desfavorecer VMM03P0 +desfaz desfacer VMM02S0 +desfibra desfibrar VMM02S0 +desfibrad desfibrar VMM02P0 +desfibrando desfibrar VMG0000 +desfibrar desfibrar VMN0000 +desfibre desfibrar VMM03S0 +desfibremos desfibrar VMM01P0 +desfibren desfibrar VMM03P0 +desfigura desfigurar VMM02S0 +desfigurad desfigurar VMM02P0 +desfigurando desfigurar VMG0000 +desfigurar desfigurar VMN0000 +desfigure desfigurar VMM03S0 +desfiguremos desfigurar VMM01P0 +desfiguren desfigurar VMM03P0 +desfila desfilar VMM02S0 +desfilacha desfilachar VMM02S0 +desfilachad desfilachar VMM02P0 +desfilachando desfilachar VMG0000 +desfilachar desfilachar VMN0000 +desfilache desfilachar VMM03S0 +desfilachemos desfilachar VMM01P0 +desfilachen desfilachar VMM03P0 +desfilad desfilar VMM02P0 +desfilando desfilar VMG0000 +desfilar desfilar VMN0000 +desfile desfilar VMM03S0 +desfilemos desfilar VMM01P0 +desfilen desfilar VMM03P0 +desfleca desflecar VMM02S0 +desflecad desflecar VMM02P0 +desflecando desflecar VMG0000 +desflecar desflecar VMN0000 +desflema desflemar VMM02S0 +desflemad desflemar VMM02P0 +desflemando desflemar VMG0000 +desflemar desflemar VMN0000 +desfleme desflemar VMM03S0 +desflememos desflemar VMM01P0 +desflemen desflemar VMM03P0 +desfleque desflecar VMM03S0 +desflequemos desflecar VMM01P0 +desflequen desflecar VMM03P0 +desflora desflorar VMM02S0 +desflorad desflorar VMM02P0 +desflorando desflorar VMG0000 +desflorar desflorar VMN0000 +desflore desflorar VMM03S0 +desflorece desflorecer VMM02S0 +desfloreced desflorecer VMM02P0 +desflorecer desflorecer VMN0000 +desfloreciendo desflorecer VMG0000 +desfloremos desflorar VMM01P0 +desfloren desflorar VMM03P0 +desflorezca desflorecer VMM03S0 +desflorezcamos desflorecer VMM01P0 +desflorezcan desflorecer VMM03P0 +desfoga desfogar VMM02S0 +desfogad desfogar VMM02P0 +desfogando desfogar VMG0000 +desfogar desfogar VMN0000 +desfogue desfogar VMM03S0 +desfoguemos desfogar VMM01P0 +desfoguen desfogar VMM03P0 +desfonda desfondar VMM02S0 +desfondad desfondar VMM02P0 +desfondando desfondar VMG0000 +desfondar desfondar VMN0000 +desfonde desfondar VMM03S0 +desfondemos desfondar VMM01P0 +desfonden desfondar VMM03P0 +desforma desformar VMM02S0 +desformad desformar VMM02P0 +desformando desformar VMG0000 +desformar desformar VMN0000 +desforme desformar VMM03S0 +desformemos desformar VMM01P0 +desformen desformar VMM03P0 +desfrena desfrenar VMM02S0 +desfrenad desfrenar VMM02P0 +desfrenando desfrenar VMG0000 +desfrenar desfrenar VMN0000 +desfrene desfrenar VMM03S0 +desfrenemos desfrenar VMM01P0 +desfrenen desfrenar VMM03P0 +desfrunce desfruncir VMM02S0 +desfruncid desfruncir VMM02P0 +desfrunciendo desfruncir VMG0000 +desfruncir desfruncir VMN0000 +desfrunza desfruncir VMM03S0 +desfrunzamos desfruncir VMM01P0 +desfrunzan desfruncir VMM03P0 +desgaja desgajar VMM02S0 +desgajad desgajar VMM02P0 +desgajando desgajar VMG0000 +desgajar desgajar VMN0000 +desgaje desgajar VMM03S0 +desgajemos desgajar VMM01P0 +desgajen desgajar VMM03P0 +desgana desganar VMM02S0 +desganad desganar VMM02P0 +desganando desganar VMG0000 +desganar desganar VMN0000 +desgane desganar VMM03S0 +desganemos desganar VMM01P0 +desganen desganar VMM03P0 +desgarganta desgargantar VMM02S0 +desgargantad desgargantar VMM02P0 +desgargantando desgargantar VMG0000 +desgargantar desgargantar VMN0000 +desgargante desgargantar VMM03S0 +desgargantemos desgargantar VMM01P0 +desgarganten desgargantar VMM03P0 +desgarita desgaritar VMM02S0 +desgaritad desgaritar VMM02P0 +desgaritando desgaritar VMG0000 +desgaritar desgaritar VMN0000 +desgarite desgaritar VMM03S0 +desgaritemos desgaritar VMM01P0 +desgariten desgaritar VMM03P0 +desgarra desgarrar VMM02S0 +desgarrad desgarrar VMM02P0 +desgarrando desgarrar VMG0000 +desgarrar desgarrar VMN0000 +desgarre desgarrar VMM03S0 +desgarremos desgarrar VMM01P0 +desgarren desgarrar VMM03P0 +desgasifica desgasificar VMM02S0 +desgasificad desgasificar VMM02P0 +desgasificando desgasificar VMG0000 +desgasificar desgasificar VMN0000 +desgasifique desgasificar VMM03S0 +desgasifiquemos desgasificar VMM01P0 +desgasifiquen desgasificar VMM03P0 +desgasta desgastar VMM02S0 +desgastad desgastar VMM02P0 +desgastando desgastar VMG0000 +desgastar desgastar VMN0000 +desgaste desgastar VMM03S0 +desgastemos desgastar VMM01P0 +desgasten desgastar VMM03P0 +desgaznata desgaznatar VMM02S0 +desgaznatad desgaznatar VMM02P0 +desgaznatando desgaznatar VMG0000 +desgaznatar desgaznatar VMN0000 +desgaznate desgaznatar VMM03S0 +desgaznatemos desgaznatar VMM01P0 +desgaznaten desgaznatar VMM03P0 +desgañita desgañitar VMM02S0 +desgañitad desgañitar VMM02P0 +desgañitando desgañitar VMG0000 +desgañitar desgañitar VMN0000 +desgañite desgañitar VMM03S0 +desgañitemos desgañitar VMM01P0 +desgañiten desgañitar VMM03P0 +desglosa desglosar VMM02S0 +desglosad desglosar VMM02P0 +desglosando desglosar VMG0000 +desglosar desglosar VMN0000 +desglose desglosar VMM03S0 +desglosemos desglosar VMM01P0 +desglosen desglosar VMM03P0 +desgobernad desgobernar VMM02P0 +desgobernando desgobernar VMG0000 +desgobernar desgobernar VMN0000 +desgobernemos desgobernar VMM01P0 +desgobierna desgobernar VMM02S0 +desgobierne desgobernar VMM03S0 +desgobiernen desgobernar VMM03P0 +desgolleta desgolletar VMM02S0 +desgolletad desgolletar VMM02P0 +desgolletando desgolletar VMG0000 +desgolletar desgolletar VMN0000 +desgollete desgolletar VMM03S0 +desgolletemos desgolletar VMM01P0 +desgolleten desgolletar VMM03P0 +desgoma desgomar VMM02S0 +desgomad desgomar VMM02P0 +desgomando desgomar VMG0000 +desgomar desgomar VMN0000 +desgome desgomar VMM03S0 +desgomemos desgomar VMM01P0 +desgomen desgomar VMM03P0 +desgonce desgonzar VMM03S0 +desgoncemos desgonzar VMM01P0 +desgoncen desgonzar VMM03P0 +desgonza desgonzar VMM02S0 +desgonzad desgonzar VMM02P0 +desgonzando desgonzar VMG0000 +desgonzar desgonzar VMN0000 +desgozna desgoznar VMM02S0 +desgoznad desgoznar VMM02P0 +desgoznando desgoznar VMG0000 +desgoznar desgoznar VMN0000 +desgozne desgoznar VMM03S0 +desgoznemos desgoznar VMM01P0 +desgoznen desgoznar VMM03P0 +desgracia desgraciar VMM02S0 +desgraciad desgraciar VMM02P0 +desgraciando desgraciar VMG0000 +desgraciar desgraciar VMN0000 +desgracie desgraciar VMM03S0 +desgraciemos desgraciar VMM01P0 +desgracien desgraciar VMM03P0 +desgrama desgramar VMM02S0 +desgramad desgramar VMM02P0 +desgramando desgramar VMG0000 +desgramar desgramar VMN0000 +desgrame desgramar VMM03S0 +desgramemos desgramar VMM01P0 +desgramen desgramar VMM03P0 +desgrana desgranar VMM02S0 +desgranad desgranar VMM02P0 +desgranando desgranar VMG0000 +desgranar desgranar VMN0000 +desgrance desgranzar VMM03S0 +desgrancemos desgranzar VMM01P0 +desgrancen desgranzar VMM03P0 +desgrane desgranar VMM03S0 +desgranemos desgranar VMM01P0 +desgranen desgranar VMM03P0 +desgranza desgranzar VMM02S0 +desgranzad desgranzar VMM02P0 +desgranzando desgranzar VMG0000 +desgranzar desgranzar VMN0000 +desgrasa desgrasar VMM02S0 +desgrasad desgrasar VMM02P0 +desgrasando desgrasar VMG0000 +desgrasar desgrasar VMN0000 +desgrase desgrasar VMM03S0 +desgrasemos desgrasar VMM01P0 +desgrasen desgrasar VMM03P0 +desgrava desgravar VMM02S0 +desgravad desgravar VMM02P0 +desgravando desgravar VMG0000 +desgravar desgravar VMN0000 +desgrave desgravar VMM03S0 +desgravemos desgravar VMM01P0 +desgraven desgravar VMM03P0 +desgreña desgreñar VMM02S0 +desgreñad desgreñar VMM02P0 +desgreñando desgreñar VMG0000 +desgreñar desgreñar VMN0000 +desgreñe desgreñar VMM03S0 +desgreñemos desgreñar VMM01P0 +desgreñen desgreñar VMM03P0 +desguace desguazar VMM03S0 +desguacemos desguazar VMM01P0 +desguacen desguazar VMM03P0 +desguarnece desguarnecer VMM02S0 +desguarneced desguarnecer VMM02P0 +desguarnecer desguarnecer VMN0000 +desguarneciendo desguarnecer VMG0000 +desguarnezca desguarnecer VMM03S0 +desguarnezcamos desguarnecer VMM01P0 +desguarnezcan desguarnecer VMM03P0 +desguaza desguazar VMM02S0 +desguazad desguazar VMM02P0 +desguazando desguazar VMG0000 +desguazar desguazar VMN0000 +desguince desguinzar VMM03S0 +desguincemos desguinzar VMM01P0 +desguincen desguinzar VMM03P0 +desguinda desguindar VMM02S0 +desguindad desguindar VMM02P0 +desguindando desguindar VMG0000 +desguindar desguindar VMN0000 +desguinde desguindar VMM03S0 +desguindemos desguindar VMM01P0 +desguinden desguindar VMM03P0 +desguinza desguinzar VMM02S0 +desguinzad desguinzar VMM02P0 +desguinzando desguinzar VMG0000 +desguinzar desguinzar VMN0000 +deshabita deshabitar VMM02S0 +deshabitad deshabitar VMM02P0 +deshabitando deshabitar VMG0000 +deshabitar deshabitar VMN0000 +deshabite deshabitar VMM03S0 +deshabitemos deshabitar VMM01P0 +deshabiten deshabitar VMM03P0 +deshabituad deshabituar VMM02P0 +deshabituando deshabituar VMG0000 +deshabituar deshabituar VMN0000 +deshabituemos deshabituar VMM01P0 +deshabitúa deshabituar VMM02S0 +deshabitúe deshabituar VMM03S0 +deshabitúen deshabituar VMM03P0 +deshaced deshacer VMM02P0 +deshacer deshacer VMN0000 +deshaciendo deshacer VMG0000 +deshaga deshacer VMM03S0 +deshagamos deshacer VMM01P0 +deshagan deshacer VMM03P0 +deshaz deshacer VMM02S0 +deshebilla deshebillar VMM02S0 +deshebillad deshebillar VMM02P0 +deshebillando deshebillar VMG0000 +deshebillar deshebillar VMN0000 +deshebille deshebillar VMM03S0 +deshebillemos deshebillar VMM01P0 +deshebillen deshebillar VMM03P0 +deshebra deshebrar VMM02S0 +deshebrad deshebrar VMM02P0 +deshebrando deshebrar VMG0000 +deshebrar deshebrar VMN0000 +deshebre deshebrar VMM03S0 +deshebremos deshebrar VMM01P0 +deshebren deshebrar VMM03P0 +deshechice deshechizar VMM03S0 +deshechicemos deshechizar VMM01P0 +deshechicen deshechizar VMM03P0 +deshechiza deshechizar VMM02S0 +deshechizad deshechizar VMM02P0 +deshechizando deshechizar VMG0000 +deshechizar deshechizar VMN0000 +deshelad deshelar VMM02P0 +deshelando deshelar VMG0000 +deshelar deshelar VMN0000 +deshelemos deshelar VMM01P0 +desherbad desherbar VMM02P0 +desherbando desherbar VMG0000 +desherbar desherbar VMN0000 +desherbemos desherbar VMM01P0 +deshereda desheredar VMM02S0 +desheredad desheredar VMM02P0 +desheredando desheredar VMG0000 +desheredar desheredar VMN0000 +desherede desheredar VMM03S0 +desheredemos desheredar VMM01P0 +deshereden desheredar VMM03P0 +deshermana deshermanar VMM02S0 +deshermanad deshermanar VMM02P0 +deshermanando deshermanar VMG0000 +deshermanar deshermanar VMN0000 +deshermane deshermanar VMM03S0 +deshermanemos deshermanar VMM01P0 +deshermanen deshermanar VMM03P0 +desherrad desherrar VMM02P0 +desherrando desherrar VMG0000 +desherrar desherrar VMN0000 +desherremos desherrar VMM01P0 +desherrumbra desherrumbrar VMM02S0 +desherrumbrad desherrumbrar VMM02P0 +desherrumbrando desherrumbrar VMG0000 +desherrumbrar desherrumbrar VMN0000 +desherrumbre desherrumbrar VMM03S0 +desherrumbremos desherrumbrar VMM01P0 +desherrumbren desherrumbrar VMM03P0 +deshidrata deshidratar VMM02S0 +deshidratad deshidratar VMM02P0 +deshidratando deshidratar VMG0000 +deshidratar deshidratar VMN0000 +deshidrate deshidratar VMM03S0 +deshidratemos deshidratar VMM01P0 +deshidraten deshidratar VMM03P0 +deshidrogena deshidrogenar VMM02S0 +deshidrogenad deshidrogenar VMM02P0 +deshidrogenando deshidrogenar VMG0000 +deshidrogenar deshidrogenar VMN0000 +deshidrogene deshidrogenar VMM03S0 +deshidrogenemos deshidrogenar VMM01P0 +deshidrogenen deshidrogenar VMM03P0 +deshiela deshelar VMM02S0 +deshiele deshelar VMM03S0 +deshielen deshelar VMM03P0 +deshierba desherbar VMM02S0 +deshierbe desherbar VMM03S0 +deshierben desherbar VMM03P0 +deshierra desherrar VMM02S0 +deshierre desherrar VMM03S0 +deshierren desherrar VMM03P0 +deshija deshijar VMM02S0 +deshijad deshijar VMM02P0 +deshijando deshijar VMG0000 +deshijar deshijar VMN0000 +deshije deshijar VMM03S0 +deshijemos deshijar VMM01P0 +deshijen deshijar VMM03P0 +deshila deshilar VMM02S0 +deshilacha deshilachar VMM02S0 +deshilachad deshilachar VMM02P0 +deshilachando deshilachar VMG0000 +deshilachar deshilachar VMN0000 +deshilache deshilachar VMM03S0 +deshilachemos deshilachar VMM01P0 +deshilachen deshilachar VMM03P0 +deshilad deshilar VMM02P0 +deshilando deshilar VMG0000 +deshilar deshilar VMN0000 +deshile deshilar VMM03S0 +deshilemos deshilar VMM01P0 +deshilen deshilar VMM03P0 +deshilvana deshilvanar VMM02S0 +deshilvanad deshilvanar VMM02P0 +deshilvanando deshilvanar VMG0000 +deshilvanar deshilvanar VMN0000 +deshilvane deshilvanar VMM03S0 +deshilvanemos deshilvanar VMM01P0 +deshilvanen deshilvanar VMM03P0 +deshinca deshincar VMM02S0 +deshincad deshincar VMM02P0 +deshincando deshincar VMG0000 +deshincar deshincar VMN0000 +deshincha deshinchar VMM02S0 +deshinchad deshinchar VMM02P0 +deshinchando deshinchar VMG0000 +deshinchar deshinchar VMN0000 +deshinche deshinchar VMM03S0 +deshinchemos deshinchar VMM01P0 +deshinchen deshinchar VMM03P0 +deshinque deshincar VMM03S0 +deshinquemos deshincar VMM01P0 +deshinquen deshincar VMM03P0 +deshipoteca deshipotecar VMM02S0 +deshipotecad deshipotecar VMM02P0 +deshipotecando deshipotecar VMG0000 +deshipotecar deshipotecar VMN0000 +deshipoteque deshipotecar VMM03S0 +deshipotequemos deshipotecar VMM01P0 +deshipotequen deshipotecar VMM03P0 +deshoja deshojar VMM02S0 +deshojad deshojar VMM02P0 +deshojando deshojar VMG0000 +deshojar deshojar VMN0000 +deshoje deshojar VMM03S0 +deshojemos deshojar VMM01P0 +deshojen deshojar VMM03P0 +desholleja deshollejar VMM02S0 +deshollejad deshollejar VMM02P0 +deshollejando deshollejar VMG0000 +deshollejar deshollejar VMN0000 +desholleje deshollejar VMM03S0 +deshollejemos deshollejar VMM01P0 +deshollejen deshollejar VMM03P0 +deshollina deshollinar VMM02S0 +deshollinad deshollinar VMM02P0 +deshollinando deshollinar VMG0000 +deshollinar deshollinar VMN0000 +desholline deshollinar VMM03S0 +deshollinemos deshollinar VMM01P0 +deshollinen deshollinar VMM03P0 +deshomologa deshomologar VMM02S0 +deshomologad deshomologar VMM02P0 +deshomologando deshomologar VMG0000 +deshomologar deshomologar VMN0000 +deshonora deshonorar VMM02S0 +deshonorad deshonorar VMM02P0 +deshonorando deshonorar VMG0000 +deshonorar deshonorar VMN0000 +deshonore deshonorar VMM03S0 +deshonoremos deshonorar VMM01P0 +deshonoren deshonorar VMM03P0 +deshonra deshonrar VMM02S0 +deshonrad deshonrar VMM02P0 +deshonrando deshonrar VMG0000 +deshonrar deshonrar VMN0000 +deshonre deshonrar VMM03S0 +deshonremos deshonrar VMM01P0 +deshonren deshonrar VMM03P0 +deshorna deshornar VMM02S0 +deshornad deshornar VMM02P0 +deshornando deshornar VMG0000 +deshornar deshornar VMN0000 +deshorne deshornar VMM03S0 +deshornemos deshornar VMM01P0 +deshornen deshornar VMM03P0 +deshuesa deshuesar VMM02S0 +deshuesa desosar VMM02S0 +deshuesad deshuesar VMM02P0 +deshuesando deshuesar VMG0000 +deshuesar deshuesar VMN0000 +deshuese deshuesar VMM03S0 +deshuese desosar VMM03S0 +deshuesemos deshuesar VMM01P0 +deshuesen deshuesar VMM03P0 +deshuesen desosar VMM03P0 +deshumanice deshumanizar VMM03S0 +deshumanicemos deshumanizar VMM01P0 +deshumanicen deshumanizar VMM03P0 +deshumaniza deshumanizar VMM02S0 +deshumanizad deshumanizar VMM02P0 +deshumanizando deshumanizar VMG0000 +deshumanizar deshumanizar VMN0000 +deshumedece deshumedecer VMM02S0 +deshumedeced deshumedecer VMM02P0 +deshumedecer deshumedecer VMN0000 +deshumedeciendo deshumedecer VMG0000 +deshumedezca deshumedecer VMM03S0 +deshumedezcamos deshumedecer VMM01P0 +deshumedezcan deshumedecer VMM03P0 +designa designar VMM02S0 +designad designar VMM02P0 +designando designar VMG0000 +designar designar VMN0000 +designe designar VMM03S0 +designemos designar VMM01P0 +designen designar VMM03P0 +desiguala desigualar VMM02S0 +desigualad desigualar VMM02P0 +desigualando desigualar VMG0000 +desigualar desigualar VMN0000 +desiguale desigualar VMM03S0 +desigualemos desigualar VMM01P0 +desigualen desigualar VMM03P0 +desilusiona desilusionar VMM02S0 +desilusionad desilusionar VMM02P0 +desilusionando desilusionar VMG0000 +desilusionar desilusionar VMN0000 +desilusione desilusionar VMM03S0 +desilusionemos desilusionar VMM01P0 +desilusionen desilusionar VMM03P0 +desimana desimanar VMM02S0 +desimanad desimanar VMM02P0 +desimanando desimanar VMG0000 +desimanar desimanar VMN0000 +desimane desimanar VMM03S0 +desimanemos desimanar VMM01P0 +desimanen desimanar VMM03P0 +desimanta desimantar VMM02S0 +desimantad desimantar VMM02P0 +desimantando desimantar VMG0000 +desimantar desimantar VMN0000 +desimante desimantar VMM03S0 +desimantemos desimantar VMM01P0 +desimanten desimantar VMM03P0 +desimpresiona desimpresionar VMM02S0 +desimpresionad desimpresionar VMM02P0 +desimpresionando desimpresionar VMG0000 +desimpresionar desimpresionar VMN0000 +desimpresione desimpresionar VMM03S0 +desimpresionemos desimpresionar VMM01P0 +desimpresionen desimpresionar VMM03P0 +desincrusta desincrustar VMM02S0 +desincrustad desincrustar VMM02P0 +desincrustando desincrustar VMG0000 +desincrustar desincrustar VMN0000 +desincruste desincrustar VMM03S0 +desincrustemos desincrustar VMM01P0 +desincrusten desincrustar VMM03P0 +desinfecta desinfectar VMM02S0 +desinfectad desinfectar VMM02P0 +desinfectando desinfectar VMG0000 +desinfectar desinfectar VMN0000 +desinfecte desinfectar VMM03S0 +desinfectemos desinfectar VMM01P0 +desinfecten desinfectar VMM03P0 +desinfla desinflar VMM02S0 +desinflad desinflar VMM02P0 +desinflama desinflamar VMM02S0 +desinflamad desinflamar VMM02P0 +desinflamando desinflamar VMG0000 +desinflamar desinflamar VMN0000 +desinflame desinflamar VMM03S0 +desinflamemos desinflamar VMM01P0 +desinflamen desinflamar VMM03P0 +desinflando desinflar VMG0000 +desinflar desinflar VMN0000 +desinfle desinflar VMM03S0 +desinflemos desinflar VMM01P0 +desinflen desinflar VMM03P0 +desinsacula desinsacular VMM02S0 +desinsaculad desinsacular VMM02P0 +desinsaculando desinsacular VMG0000 +desinsacular desinsacular VMN0000 +desinsacule desinsacular VMM03S0 +desinsaculemos desinsacular VMM01P0 +desinsaculen desinsacular VMM03P0 +desinsecta desinsectar VMM02S0 +desinsectad desinsectar VMM02P0 +desinsectando desinsectar VMG0000 +desinsectar desinsectar VMN0000 +desinsecte desinsectar VMM03S0 +desinsectemos desinsectar VMM01P0 +desinsecten desinsectar VMM03P0 +desintegra desintegrar VMM02S0 +desintegrad desintegrar VMM02P0 +desintegrando desintegrar VMG0000 +desintegrar desintegrar VMN0000 +desintegre desintegrar VMM03S0 +desintegremos desintegrar VMM01P0 +desintegren desintegrar VMM03P0 +desinteresa desinteresar VMM02S0 +desinteresad desinteresar VMM02P0 +desinteresando desinteresar VMG0000 +desinteresar desinteresar VMN0000 +desinterese desinteresar VMM03S0 +desinteresemos desinteresar VMM01P0 +desinteresen desinteresar VMM03P0 +desintoxica desintoxicar VMM02S0 +desintoxicad desintoxicar VMM02P0 +desintoxicando desintoxicar VMG0000 +desintoxicar desintoxicar VMN0000 +desintoxique desintoxicar VMM03S0 +desintoxiquemos desintoxicar VMM01P0 +desintoxiquen desintoxicar VMM03P0 +desista desistir VMM03S0 +desistamos desistir VMM01P0 +desistan desistir VMM03P0 +desiste desistir VMM02S0 +desistid desistir VMM02P0 +desistiendo desistir VMG0000 +desistir desistir VMN0000 +desjarreta desjarretar VMM02S0 +desjarretad desjarretar VMM02P0 +desjarretando desjarretar VMG0000 +desjarretar desjarretar VMN0000 +desjarrete desjarretar VMM03S0 +desjarretemos desjarretar VMM01P0 +desjarreten desjarretar VMM03P0 +desjuga desjugar VMM02S0 +desjugad desjugar VMM02P0 +desjugando desjugar VMG0000 +desjugar desjugar VMN0000 +desjugue desjugar VMM03S0 +desjuguemos desjugar VMM01P0 +desjuguen desjugar VMM03P0 +desjunta desjuntar VMM02S0 +desjuntad desjuntar VMM02P0 +desjuntando desjuntar VMG0000 +desjuntar desjuntar VMN0000 +desjunte desjuntar VMM03S0 +desjuntemos desjuntar VMM01P0 +desjunten desjuntar VMM03P0 +deslabona deslabonar VMM02S0 +deslabonad deslabonar VMM02P0 +deslabonando deslabonar VMG0000 +deslabonar deslabonar VMN0000 +deslabone deslabonar VMM03S0 +deslabonemos deslabonar VMM01P0 +deslabonen deslabonar VMM03P0 +deslace deslazar VMM03S0 +deslacemos deslazar VMM01P0 +deslacen deslazar VMM03P0 +desladrilla desladrillar VMM02S0 +desladrillad desladrillar VMM02P0 +desladrillando desladrillar VMG0000 +desladrillar desladrillar VMN0000 +desladrille desladrillar VMM03S0 +desladrillemos desladrillar VMM01P0 +desladrillen desladrillar VMM03P0 +deslamina deslaminar VMM02S0 +deslaminad deslaminar VMM02P0 +deslaminando deslaminar VMG0000 +deslaminar deslaminar VMN0000 +deslamine deslaminar VMM03S0 +deslaminemos deslaminar VMM01P0 +deslaminen deslaminar VMM03P0 +deslastra deslastrar VMM02S0 +deslastrad deslastrar VMM02P0 +deslastrando deslastrar VMG0000 +deslastrar deslastrar VMN0000 +deslastre deslastrar VMM03S0 +deslastremos deslastrar VMM01P0 +deslastren deslastrar VMM03P0 +deslava deslavar VMM02S0 +deslavace deslavazar VMM03S0 +deslavacemos deslavazar VMM01P0 +deslavacen deslavazar VMM03P0 +deslavad deslavar VMM02P0 +deslavando deslavar VMG0000 +deslavar deslavar VMN0000 +deslavaza deslavazar VMM02S0 +deslavazad deslavazar VMM02P0 +deslavazando deslavazar VMG0000 +deslavazar deslavazar VMN0000 +deslave deslavar VMM03S0 +deslavemos deslavar VMM01P0 +deslaven deslavar VMM03P0 +deslaza deslazar VMM02S0 +deslazad deslazar VMM02P0 +deslazando deslazar VMG0000 +deslazar deslazar VMN0000 +deslechuga deslechugar VMM02S0 +deslechugad deslechugar VMM02P0 +deslechugando deslechugar VMG0000 +deslechugar deslechugar VMN0000 +deslechugue deslechugar VMM03S0 +deslechuguemos deslechugar VMM01P0 +deslechuguen deslechugar VMM03P0 +deslechuguilla deslechuguillar VMM02S0 +deslechuguillad deslechuguillar VMM02P0 +deslechuguillando deslechuguillar VMG0000 +deslechuguillar deslechuguillar VMN0000 +deslechuguille deslechuguillar VMM03S0 +deslechuguillemos deslechuguillar VMM01P0 +deslechuguillen deslechuguillar VMM03P0 +deslegitima deslegitimar VMM02S0 +deslegitimad deslegitimar VMM02P0 +deslegitimando deslegitimar VMG0000 +deslegitimar deslegitimar VMN0000 +deslegitime deslegitimar VMM03S0 +deslegitimemos deslegitimar VMM01P0 +deslegitimen deslegitimar VMM03P0 +deslendrad deslendrar VMM02P0 +deslendrando deslendrar VMG0000 +deslendrar deslendrar VMN0000 +deslendremos deslendrar VMM01P0 +deslengua deslenguar VMM02S0 +deslenguad deslenguar VMM02P0 +deslenguando deslenguar VMG0000 +deslenguar deslenguar VMN0000 +deslengüe deslenguar VMM03S0 +deslengüemos deslenguar VMM01P0 +deslengüen deslenguar VMM03P0 +desleíd desleír VMM02P0 +desleír desleír VMN0000 +desliad desliar VMM02P0 +desliamos desleír VMM01P0 +desliando desliar VMG0000 +desliar desliar VMN0000 +deslice deslizar VMM03S0 +deslicemos deslizar VMM01P0 +deslicen deslizar VMM03P0 +desliemos desliar VMM01P0 +desliendo desleír VMG0000 +desliendra deslendrar VMM02S0 +desliendre deslendrar VMM03S0 +desliendren deslendrar VMM03P0 +desliga desligar VMM02S0 +desligad desligar VMM02P0 +desligando desligar VMG0000 +desligar desligar VMN0000 +desligue desligar VMM03S0 +desliguemos desligar VMM01P0 +desliguen desligar VMM03P0 +deslinda deslindar VMM02S0 +deslindad deslindar VMM02P0 +deslindando deslindar VMG0000 +deslindar deslindar VMN0000 +deslinde deslindar VMM03S0 +deslindemos deslindar VMM01P0 +deslinden deslindar VMM03P0 +desliza deslizar VMM02S0 +deslizad deslizar VMM02P0 +deslizando deslizar VMG0000 +deslizar deslizar VMN0000 +desliña desliñar VMM02S0 +desliñad desliñar VMM02P0 +desliñando desliñar VMG0000 +desliñar desliñar VMN0000 +desliñe desliñar VMM03S0 +desliñemos desliñar VMM01P0 +desliñen desliñar VMM03P0 +desloma deslomar VMM02S0 +deslomad deslomar VMM02P0 +deslomando deslomar VMG0000 +deslomar deslomar VMN0000 +deslome deslomar VMM03S0 +deslomemos deslomar VMM01P0 +deslomen deslomar VMM03P0 +desluce deslucir VMM02S0 +deslucid deslucir VMM02P0 +desluciendo deslucir VMG0000 +deslucir deslucir VMN0000 +deslumbra deslumbrar VMM02S0 +deslumbrad deslumbrar VMM02P0 +deslumbrando deslumbrar VMG0000 +deslumbrar deslumbrar VMN0000 +deslumbre deslumbrar VMM03S0 +deslumbremos deslumbrar VMM01P0 +deslumbren deslumbrar VMM03P0 +deslustra deslustrar VMM02S0 +deslustrad deslustrar VMM02P0 +deslustrando deslustrar VMG0000 +deslustrar deslustrar VMN0000 +deslustre deslustrar VMM03S0 +deslustremos deslustrar VMM01P0 +deslustren deslustrar VMM03P0 +desluzca deslucir VMM03S0 +desluzcamos deslucir VMM01P0 +desluzcan deslucir VMM03P0 +deslía desleír VMM03S0 +deslía desliar VMM02S0 +deslían desleír VMM03P0 +deslíe desleír VMM02S0 +deslíe desliar VMM03S0 +deslíen desliar VMM03P0 +desmadeja desmadejar VMM02S0 +desmadejad desmadejar VMM02P0 +desmadejando desmadejar VMG0000 +desmadejar desmadejar VMN0000 +desmadeje desmadejar VMM03S0 +desmadejemos desmadejar VMM01P0 +desmadejen desmadejar VMM03P0 +desmadra desmadrar VMM02S0 +desmadrad desmadrar VMM02P0 +desmadrando desmadrar VMG0000 +desmadrar desmadrar VMN0000 +desmadre desmadrar VMM03S0 +desmadremos desmadrar VMM01P0 +desmadren desmadrar VMM03P0 +desmagnetice desmagnetizar VMM03S0 +desmagneticemos desmagnetizar VMM01P0 +desmagneticen desmagnetizar VMM03P0 +desmagnetiza desmagnetizar VMM02S0 +desmagnetizad desmagnetizar VMM02P0 +desmagnetizando desmagnetizar VMG0000 +desmagnetizar desmagnetizar VMN0000 +desmajolad desmajolar VMM02P0 +desmajolando desmajolar VMG0000 +desmajolar desmajolar VMN0000 +desmajolemos desmajolar VMM01P0 +desmajuela desmajolar VMM02S0 +desmajuele desmajolar VMM03S0 +desmajuelen desmajolar VMM03P0 +desmalece desmalezar VMM03S0 +desmalecemos desmalezar VMM01P0 +desmalecen desmalezar VMM03P0 +desmaleza desmalezar VMM02S0 +desmalezad desmalezar VMM02P0 +desmalezando desmalezar VMG0000 +desmalezar desmalezar VMN0000 +desmalla desmallar VMM02S0 +desmallad desmallar VMM02P0 +desmallando desmallar VMG0000 +desmallar desmallar VMN0000 +desmalle desmallar VMM03S0 +desmallemos desmallar VMM01P0 +desmallen desmallar VMM03P0 +desmama desmamar VMM02S0 +desmamad desmamar VMM02P0 +desmamando desmamar VMG0000 +desmamar desmamar VMN0000 +desmame desmamar VMM03S0 +desmamemos desmamar VMM01P0 +desmamen desmamar VMM03P0 +desmancha desmanchar VMM02S0 +desmanchad desmanchar VMM02P0 +desmanchando desmanchar VMG0000 +desmanchar desmanchar VMN0000 +desmanche desmanchar VMM03S0 +desmanchemos desmanchar VMM01P0 +desmanchen desmanchar VMM03P0 +desmanda desmandar VMM02S0 +desmandad desmandar VMM02P0 +desmandando desmandar VMG0000 +desmandar desmandar VMN0000 +desmande desmandar VMM03S0 +desmandemos desmandar VMM01P0 +desmanden desmandar VMM03P0 +desmanea desmanear VMM02S0 +desmanead desmanear VMM02P0 +desmaneando desmanear VMG0000 +desmanear desmanear VMN0000 +desmanee desmanear VMM03S0 +desmaneemos desmanear VMM01P0 +desmaneen desmanear VMM03P0 +desmanga desmangar VMM02S0 +desmangad desmangar VMM02P0 +desmangando desmangar VMG0000 +desmangar desmangar VMN0000 +desmangue desmangar VMM03S0 +desmanguemos desmangar VMM01P0 +desmanguen desmangar VMM03P0 +desmanteca desmantecar VMM02S0 +desmantecad desmantecar VMM02P0 +desmantecando desmantecar VMG0000 +desmantecar desmantecar VMN0000 +desmantela desmantelar VMM02S0 +desmantelad desmantelar VMM02P0 +desmantelando desmantelar VMG0000 +desmantelar desmantelar VMN0000 +desmantele desmantelar VMM03S0 +desmantelemos desmantelar VMM01P0 +desmantelen desmantelar VMM03P0 +desmanteque desmantecar VMM03S0 +desmantequemos desmantecar VMM01P0 +desmantequen desmantecar VMM03P0 +desmaquilla desmaquillar VMM02S0 +desmaquillad desmaquillar VMM02P0 +desmaquillando desmaquillar VMG0000 +desmaquillar desmaquillar VMN0000 +desmaquille desmaquillar VMM03S0 +desmaquillemos desmaquillar VMM01P0 +desmaquillen desmaquillar VMM03P0 +desmaraña desmarañar VMM02S0 +desmarañad desmarañar VMM02P0 +desmarañando desmarañar VMG0000 +desmarañar desmarañar VMN0000 +desmarañe desmarañar VMM03S0 +desmarañemos desmarañar VMM01P0 +desmarañen desmarañar VMM03P0 +desmarca desmarcar VMM02S0 +desmarcad desmarcar VMM02P0 +desmarcando desmarcar VMG0000 +desmarcar desmarcar VMN0000 +desmarque desmarcar VMM03S0 +desmarquemos desmarcar VMM01P0 +desmarquen desmarcar VMM03P0 +desmata desmatar VMM02S0 +desmatad desmatar VMM02P0 +desmatando desmatar VMG0000 +desmatar desmatar VMN0000 +desmate desmatar VMM03S0 +desmatemos desmatar VMM01P0 +desmaten desmatar VMM03P0 +desmaya desmayar VMM02S0 +desmayad desmayar VMM02P0 +desmayando desmayar VMG0000 +desmayar desmayar VMN0000 +desmaye desmayar VMM03S0 +desmayemos desmayar VMM01P0 +desmayen desmayar VMM03P0 +desmedid desmedir VMM02P0 +desmedir desmedir VMN0000 +desmedra desmedrar VMM02S0 +desmedrad desmedrar VMM02P0 +desmedrando desmedrar VMG0000 +desmedrar desmedrar VMN0000 +desmedre desmedrar VMM03S0 +desmedremos desmedrar VMM01P0 +desmedren desmedrar VMM03P0 +desmejora desmejorar VMM02S0 +desmejorad desmejorar VMM02P0 +desmejorando desmejorar VMG0000 +desmejorar desmejorar VMN0000 +desmejore desmejorar VMM03S0 +desmejoremos desmejorar VMM01P0 +desmejoren desmejorar VMM03P0 +desmelena desmelenar VMM02S0 +desmelenad desmelenar VMM02P0 +desmelenando desmelenar VMG0000 +desmelenar desmelenar VMN0000 +desmelene desmelenar VMM03S0 +desmelenemos desmelenar VMM01P0 +desmelenen desmelenar VMM03P0 +desmembrad desmembrar VMM02P0 +desmembrando desmembrar VMG0000 +desmembrar desmembrar VMN0000 +desmembremos desmembrar VMM01P0 +desmemoria desmemoriar VMM02S0 +desmemoriad desmemoriar VMM02P0 +desmemoriando desmemoriar VMG0000 +desmemoriar desmemoriar VMN0000 +desmemorie desmemoriar VMM03S0 +desmemoriemos desmemoriar VMM01P0 +desmemorien desmemoriar VMM03P0 +desmengua desmenguar VMM02S0 +desmenguad desmenguar VMM02P0 +desmenguando desmenguar VMG0000 +desmenguar desmenguar VMN0000 +desmengüe desmenguar VMM03S0 +desmengüemos desmenguar VMM01P0 +desmengüen desmenguar VMM03P0 +desmentid desmentir VMM02P0 +desmentir desmentir VMN0000 +desmenuce desmenuzar VMM03S0 +desmenucemos desmenuzar VMM01P0 +desmenucen desmenuzar VMM03P0 +desmenuza desmenuzar VMM02S0 +desmenuzad desmenuzar VMM02P0 +desmenuzando desmenuzar VMG0000 +desmenuzar desmenuzar VMN0000 +desmeolla desmeollar VMM02S0 +desmeollad desmeollar VMM02P0 +desmeollando desmeollar VMG0000 +desmeollar desmeollar VMN0000 +desmeolle desmeollar VMM03S0 +desmeollemos desmeollar VMM01P0 +desmeollen desmeollar VMM03P0 +desmerece desmerecer VMM02S0 +desmereced desmerecer VMM02P0 +desmerecer desmerecer VMN0000 +desmereciendo desmerecer VMG0000 +desmerezca desmerecer VMM03S0 +desmerezcamos desmerecer VMM01P0 +desmerezcan desmerecer VMM03P0 +desmesura desmesurar VMM02S0 +desmesurad desmesurar VMM02P0 +desmesurando desmesurar VMG0000 +desmesurar desmesurar VMN0000 +desmesure desmesurar VMM03S0 +desmesuremos desmesurar VMM01P0 +desmesuren desmesurar VMM03P0 +desmida desmedir VMM03S0 +desmidamos desmedir VMM01P0 +desmidan desmedir VMM03P0 +desmide desmedir VMM02S0 +desmidiendo desmedir VMG0000 +desmiembra desmembrar VMM02S0 +desmiembre desmembrar VMM03S0 +desmiembren desmembrar VMM03P0 +desmienta desmentir VMM03S0 +desmientan desmentir VMM03P0 +desmiente desmentir VMM02S0 +desmiga desmigar VMM02S0 +desmigad desmigar VMM02P0 +desmigaja desmigajar VMM02S0 +desmigajad desmigajar VMM02P0 +desmigajando desmigajar VMG0000 +desmigajar desmigajar VMN0000 +desmigaje desmigajar VMM03S0 +desmigajemos desmigajar VMM01P0 +desmigajen desmigajar VMM03P0 +desmigando desmigar VMG0000 +desmigar desmigar VMN0000 +desmigue desmigar VMM03S0 +desmiguemos desmigar VMM01P0 +desmiguen desmigar VMM03P0 +desmilitarice desmilitarizar VMM03S0 +desmilitaricemos desmilitarizar VMM01P0 +desmilitaricen desmilitarizar VMM03P0 +desmilitariza desmilitarizar VMM02S0 +desmilitarizad desmilitarizar VMM02P0 +desmilitarizando desmilitarizar VMG0000 +desmilitarizar desmilitarizar VMN0000 +desmineralice desmineralizar VMM03S0 +desmineralicemos desmineralizar VMM01P0 +desmineralicen desmineralizar VMM03P0 +desmineraliza desmineralizar VMM02S0 +desmineralizad desmineralizar VMM02P0 +desmineralizando desmineralizar VMG0000 +desmineralizar desmineralizar VMN0000 +desmintamos desmentir VMM01P0 +desmintiendo desmentir VMG0000 +desmitifica desmitificar VMM02S0 +desmitificad desmitificar VMM02P0 +desmitificando desmitificar VMG0000 +desmitificar desmitificar VMN0000 +desmitifique desmitificar VMM03S0 +desmitifiquemos desmitificar VMM01P0 +desmitifiquen desmitificar VMM03P0 +desmocha desmochar VMM02S0 +desmochad desmochar VMM02P0 +desmochando desmochar VMG0000 +desmochar desmochar VMN0000 +desmoche desmochar VMM03S0 +desmochemos desmochar VMM01P0 +desmochen desmochar VMM03P0 +desmoga desmogar VMM02S0 +desmogad desmogar VMM02P0 +desmogando desmogar VMG0000 +desmogar desmogar VMN0000 +desmogue desmogar VMM03S0 +desmoguemos desmogar VMM01P0 +desmoguen desmogar VMM03P0 +desmolamos desmoler VMM01P0 +desmolda desmoldar VMM02S0 +desmoldad desmoldar VMM02P0 +desmoldando desmoldar VMG0000 +desmoldar desmoldar VMN0000 +desmolde desmoldar VMM03S0 +desmoldemos desmoldar VMM01P0 +desmolden desmoldar VMM03P0 +desmoled desmoler VMM02P0 +desmoler desmoler VMN0000 +desmoliendo desmoler VMG0000 +desmonetice desmonetizar VMM03S0 +desmoneticemos desmonetizar VMM01P0 +desmoneticen desmonetizar VMM03P0 +desmonetiza desmonetizar VMM02S0 +desmonetizad desmonetizar VMM02P0 +desmonetizando desmonetizar VMG0000 +desmonetizar desmonetizar VMN0000 +desmonta desmontar VMM02S0 +desmontad desmontar VMM02P0 +desmontando desmontar VMG0000 +desmontar desmontar VMN0000 +desmonte desmontar VMM03S0 +desmontemos desmontar VMM01P0 +desmonten desmontar VMM03P0 +desmoralice desmoralizar VMM03S0 +desmoralicemos desmoralizar VMM01P0 +desmoralicen desmoralizar VMM03P0 +desmoraliza desmoralizar VMM02S0 +desmoralizad desmoralizar VMM02P0 +desmoralizando desmoralizar VMG0000 +desmoralizar desmoralizar VMN0000 +desmorece desmorecer VMM02S0 +desmoreced desmorecer VMM02P0 +desmorecer desmorecer VMN0000 +desmoreciendo desmorecer VMG0000 +desmorezca desmorecer VMM03S0 +desmorezcamos desmorecer VMM01P0 +desmorezcan desmorecer VMM03P0 +desmorona desmoronar VMM02S0 +desmoronad desmoronar VMM02P0 +desmoronando desmoronar VMG0000 +desmoronar desmoronar VMN0000 +desmorone desmoronar VMM03S0 +desmoronemos desmoronar VMM01P0 +desmoronen desmoronar VMM03P0 +desmota desmotar VMM02S0 +desmotad desmotar VMM02P0 +desmotando desmotar VMG0000 +desmotar desmotar VMN0000 +desmote desmotar VMM03S0 +desmotemos desmotar VMM01P0 +desmoten desmotar VMM03P0 +desmovilice desmovilizar VMM03S0 +desmovilicemos desmovilizar VMM01P0 +desmovilicen desmovilizar VMM03P0 +desmoviliza desmovilizar VMM02S0 +desmovilizad desmovilizar VMM02P0 +desmovilizando desmovilizar VMG0000 +desmovilizar desmovilizar VMN0000 +desmoña desmoñar VMM02S0 +desmoñad desmoñar VMM02P0 +desmoñando desmoñar VMG0000 +desmoñar desmoñar VMN0000 +desmoñe desmoñar VMM03S0 +desmoñemos desmoñar VMM01P0 +desmoñen desmoñar VMM03P0 +desmuela desmoler VMM03S0 +desmuelan desmoler VMM03P0 +desmuele desmoler VMM02S0 +desmultiplica desmultiplicar VMM02S0 +desmultiplicad desmultiplicar VMM02P0 +desmultiplicando desmultiplicar VMG0000 +desmultiplicar desmultiplicar VMN0000 +desmultiplique desmultiplicar VMM03S0 +desmultipliquemos desmultiplicar VMM01P0 +desmultipliquen desmultiplicar VMM03P0 +desnacionalice desnacionalizar VMM03S0 +desnacionalicemos desnacionalizar VMM01P0 +desnacionalicen desnacionalizar VMM03P0 +desnacionaliza desnacionalizar VMM02S0 +desnacionalizad desnacionalizar VMM02P0 +desnacionalizando desnacionalizar VMG0000 +desnacionalizar desnacionalizar VMN0000 +desnariga desnarigar VMM02S0 +desnarigad desnarigar VMM02P0 +desnarigando desnarigar VMG0000 +desnarigar desnarigar VMN0000 +desnarigue desnarigar VMM03S0 +desnariguemos desnarigar VMM01P0 +desnariguen desnarigar VMM03P0 +desnata desnatar VMM02S0 +desnatad desnatar VMM02P0 +desnatando desnatar VMG0000 +desnatar desnatar VMN0000 +desnate desnatar VMM03S0 +desnatemos desnatar VMM01P0 +desnaten desnatar VMM03P0 +desnaturalice desnaturalizar VMM03S0 +desnaturalicemos desnaturalizar VMM01P0 +desnaturalicen desnaturalizar VMM03P0 +desnaturaliza desnaturalizar VMM02S0 +desnaturalizad desnaturalizar VMM02P0 +desnaturalizando desnaturalizar VMG0000 +desnaturalizar desnaturalizar VMN0000 +desnerva desnervar VMM02S0 +desnervad desnervar VMM02P0 +desnervando desnervar VMG0000 +desnervar desnervar VMN0000 +desnerve desnervar VMM03S0 +desnervemos desnervar VMM01P0 +desnerven desnervar VMM03P0 +desnevad desnevar VMM02P0 +desnevando desnevar VMG0000 +desnevar desnevar VMN0000 +desnevemos desnevar VMM01P0 +desnieva desnevar VMM02S0 +desnieve desnevar VMM03S0 +desnieven desnevar VMM03P0 +desnivela desnivelar VMM02S0 +desnivelad desnivelar VMM02P0 +desnivelando desnivelar VMG0000 +desnivelar desnivelar VMN0000 +desnivele desnivelar VMM03S0 +desnivelemos desnivelar VMM01P0 +desnivelen desnivelar VMM03P0 +desnuca desnucar VMM02S0 +desnucad desnucar VMM02P0 +desnucando desnucar VMG0000 +desnucar desnucar VMN0000 +desnuda desnudar VMM02S0 +desnudad desnudar VMM02P0 +desnudando desnudar VMG0000 +desnudar desnudar VMN0000 +desnude desnudar VMM03S0 +desnudemos desnudar VMM01P0 +desnuden desnudar VMM03P0 +desnuque desnucar VMM03S0 +desnuquemos desnucar VMM01P0 +desnuquen desnucar VMM03P0 +desnutra desnutrir VMM03S0 +desnutramos desnutrir VMM01P0 +desnutran desnutrir VMM03P0 +desnutre desnutrir VMM02S0 +desnutrid desnutrir VMM02P0 +desnutriendo desnutrir VMG0000 +desnutrir desnutrir VMN0000 +desobedece desobedecer VMM02S0 +desobedeced desobedecer VMM02P0 +desobedecer desobedecer VMN0000 +desobedeciendo desobedecer VMG0000 +desobedezca desobedecer VMM03S0 +desobedezcamos desobedecer VMM01P0 +desobedezcan desobedecer VMM03P0 +desobliga desobligar VMM02S0 +desobligad desobligar VMM02P0 +desobligando desobligar VMG0000 +desobligar desobligar VMN0000 +desobligue desobligar VMM03S0 +desobliguemos desobligar VMM01P0 +desobliguen desobligar VMM03P0 +desobstruid desobstruir VMM02P0 +desobstruir desobstruir VMN0000 +desobstruya desobstruir VMM03S0 +desobstruyamos desobstruir VMM01P0 +desobstruyan desobstruir VMM03P0 +desobstruye desobstruir VMM02S0 +desobstruyendo desobstruir VMG0000 +desocupa desocupar VMM02S0 +desocupad desocupar VMM02P0 +desocupando desocupar VMG0000 +desocupar desocupar VMN0000 +desocupe desocupar VMM03S0 +desocupemos desocupar VMM01P0 +desocupen desocupar VMM03P0 +desodorice desodorizar VMM03S0 +desodoricemos desodorizar VMM01P0 +desodoricen desodorizar VMM03P0 +desodoriza desodorizar VMM02S0 +desodorizad desodorizar VMM02P0 +desodorizando desodorizar VMG0000 +desodorizar desodorizar VMN0000 +desoiga desoír VMM03S0 +desoigamos desoír VMM01P0 +desoigan desoír VMM03P0 +desoja desojar VMM02S0 +desojad desojar VMM02P0 +desojando desojar VMG0000 +desojar desojar VMN0000 +desoje desojar VMM03S0 +desojemos desojar VMM01P0 +desojen desojar VMM03P0 +desola desolar VMM02S0 +desolad desolar VMM02P0 +desolando desolar VMG0000 +desolar desolar VMN0000 +desoldad desoldar VMM02P0 +desoldando desoldar VMG0000 +desoldar desoldar VMN0000 +desoldemos desoldar VMM01P0 +desole desolar VMM03S0 +desolemos desolar VMM01P0 +desolen desolar VMM03P0 +desolidarice desolidarizar VMM03S0 +desolidaricemos desolidarizar VMM01P0 +desolidaricen desolidarizar VMM03P0 +desolidariza desolidarizar VMM02S0 +desolidarizad desolidarizar VMM02P0 +desolidarizando desolidarizar VMG0000 +desolidarizar desolidarizar VMN0000 +desollad desollar VMM02P0 +desollando desollar VMG0000 +desollar desollar VMN0000 +desollemos desollar VMM01P0 +desopila desopilar VMM02S0 +desopilad desopilar VMM02P0 +desopilando desopilar VMG0000 +desopilar desopilar VMN0000 +desopile desopilar VMM03S0 +desopilemos desopilar VMM01P0 +desopilen desopilar VMM03P0 +desoprima desoprimir VMM03S0 +desoprimamos desoprimir VMM01P0 +desopriman desoprimir VMM03P0 +desoprime desoprimir VMM02S0 +desoprimid desoprimir VMM02P0 +desoprimiendo desoprimir VMG0000 +desoprimir desoprimir VMN0000 +desorbita desorbitar VMM02S0 +desorbitad desorbitar VMM02P0 +desorbitando desorbitar VMG0000 +desorbitar desorbitar VMN0000 +desorbite desorbitar VMM03S0 +desorbitemos desorbitar VMM01P0 +desorbiten desorbitar VMM03P0 +desordena desordenar VMM02S0 +desordenad desordenar VMM02P0 +desordenando desordenar VMG0000 +desordenar desordenar VMN0000 +desordene desordenar VMM03S0 +desordenemos desordenar VMM01P0 +desordenen desordenar VMM03P0 +desoreja desorejar VMM02S0 +desorejad desorejar VMM02P0 +desorejando desorejar VMG0000 +desorejar desorejar VMN0000 +desoreje desorejar VMM03S0 +desorejemos desorejar VMM01P0 +desorejen desorejar VMM03P0 +desorganice desorganizar VMM03S0 +desorganicemos desorganizar VMM01P0 +desorganicen desorganizar VMM03P0 +desorganiza desorganizar VMM02S0 +desorganizad desorganizar VMM02P0 +desorganizando desorganizar VMG0000 +desorganizar desorganizar VMN0000 +desorienta desorientar VMM02S0 +desorientad desorientar VMM02P0 +desorientando desorientar VMG0000 +desorientar desorientar VMN0000 +desoriente desorientar VMM03S0 +desorientemos desorientar VMM01P0 +desorienten desorientar VMM03P0 +desorilla desorillar VMM02S0 +desorillad desorillar VMM02P0 +desorillando desorillar VMG0000 +desorillar desorillar VMN0000 +desorille desorillar VMM03S0 +desorillemos desorillar VMM01P0 +desorillen desorillar VMM03P0 +desortija desortijar VMM02S0 +desortijad desortijar VMM02P0 +desortijando desortijar VMG0000 +desortijar desortijar VMN0000 +desortije desortijar VMM03S0 +desortijemos desortijar VMM01P0 +desortijen desortijar VMM03P0 +desosad desosar VMM02P0 +desosando desosar VMG0000 +desosar desosar VMN0000 +desosemos desosar VMM01P0 +desova desovar VMM02S0 +desovad desovar VMM02P0 +desovando desovar VMG0000 +desovar desovar VMN0000 +desove desovar VMM03S0 +desovemos desovar VMM01P0 +desoven desovar VMM03P0 +desovilla desovillar VMM02S0 +desovillad desovillar VMM02P0 +desovillando desovillar VMG0000 +desovillar desovillar VMN0000 +desoville desovillar VMM03S0 +desovillemos desovillar VMM01P0 +desovillen desovillar VMM03P0 +desoxida desoxidar VMM02S0 +desoxidad desoxidar VMM02P0 +desoxidando desoxidar VMG0000 +desoxidar desoxidar VMN0000 +desoxide desoxidar VMM03S0 +desoxidemos desoxidar VMM01P0 +desoxiden desoxidar VMM03P0 +desoxigena desoxigenar VMM02S0 +desoxigenad desoxigenar VMM02P0 +desoxigenando desoxigenar VMG0000 +desoxigenar desoxigenar VMN0000 +desoxigene desoxigenar VMM03S0 +desoxigenemos desoxigenar VMM01P0 +desoxigenen desoxigenar VMM03P0 +desoye desoír VMM02S0 +desoyendo desoír VMG0000 +desoíd desoír VMM02P0 +desoír desoír VMN0000 +despabila despabilar VMM02S0 +despabilad despabilar VMM02P0 +despabilando despabilar VMG0000 +despabilar despabilar VMN0000 +despabile despabilar VMM03S0 +despabilemos despabilar VMM01P0 +despabilen despabilar VMM03P0 +despacha despachar VMM02S0 +despachad despachar VMM02P0 +despachando despachar VMG0000 +despachar despachar VMN0000 +despache despachar VMM03S0 +despachemos despachar VMM01P0 +despachen despachar VMM03P0 +despachurra despachurrar VMM02S0 +despachurrad despachurrar VMM02P0 +despachurrando despachurrar VMG0000 +despachurrar despachurrar VMN0000 +despachurre despachurrar VMM03S0 +despachurremos despachurrar VMM01P0 +despachurren despachurrar VMM03P0 +despaja despajar VMM02S0 +despajad despajar VMM02P0 +despajando despajar VMG0000 +despajar despajar VMN0000 +despaje despajar VMM03S0 +despajemos despajar VMM01P0 +despajen despajar VMM03P0 +despalda despaldar VMM02S0 +despaldad despaldar VMM02P0 +despaldando despaldar VMG0000 +despaldar despaldar VMN0000 +despalde despaldar VMM03S0 +despaldemos despaldar VMM01P0 +despalden despaldar VMM03P0 +despaldilla despaldillar VMM02S0 +despaldillad despaldillar VMM02P0 +despaldillando despaldillar VMG0000 +despaldillar despaldillar VMN0000 +despaldille despaldillar VMM03S0 +despaldillemos despaldillar VMM01P0 +despaldillen despaldillar VMM03P0 +despaletilla despaletillar VMM02S0 +despaletillad despaletillar VMM02P0 +despaletillando despaletillar VMG0000 +despaletillar despaletillar VMN0000 +despaletille despaletillar VMM03S0 +despaletillemos despaletillar VMM01P0 +despaletillen despaletillar VMM03P0 +despalma despalmar VMM02S0 +despalmad despalmar VMM02P0 +despalmando despalmar VMG0000 +despalmar despalmar VMN0000 +despalme despalmar VMM03S0 +despalmemos despalmar VMM01P0 +despalmen despalmar VMM03P0 +despampana despampanar VMM02S0 +despampanad despampanar VMM02P0 +despampanando despampanar VMG0000 +despampanar despampanar VMN0000 +despampane despampanar VMM03S0 +despampanemos despampanar VMM01P0 +despampanen despampanar VMM03P0 +despampanilla despampanillar VMM02S0 +despampanillad despampanillar VMM02P0 +despampanillando despampanillar VMG0000 +despampanillar despampanillar VMN0000 +despampanille despampanillar VMM03S0 +despampanillemos despampanillar VMM01P0 +despampanillen despampanillar VMM03P0 +despanchurra despanchurrar VMM02S0 +despanchurrad despanchurrar VMM02P0 +despanchurrando despanchurrar VMG0000 +despanchurrar despanchurrar VMN0000 +despanchurre despanchurrar VMM03S0 +despanchurremos despanchurrar VMM01P0 +despanchurren despanchurrar VMM03P0 +despanzurra despanzurrar VMM02S0 +despanzurrad despanzurrar VMM02P0 +despanzurrando despanzurrar VMG0000 +despanzurrar despanzurrar VMN0000 +despanzurre despanzurrar VMM03S0 +despanzurremos despanzurrar VMM01P0 +despanzurren despanzurrar VMM03P0 +despapa despapar VMM02S0 +despapad despapar VMM02P0 +despapando despapar VMG0000 +despapar despapar VMN0000 +despape despapar VMM03S0 +despapemos despapar VMM01P0 +despapen despapar VMM03P0 +desparea desparear VMM02S0 +desparead desparear VMM02P0 +despareando desparear VMG0000 +desparear desparear VMN0000 +despareda desparedar VMM02S0 +desparedad desparedar VMM02P0 +desparedando desparedar VMG0000 +desparedar desparedar VMN0000 +desparede desparedar VMM03S0 +desparedemos desparedar VMM01P0 +despareden desparedar VMM03P0 +despareja desparejar VMM02S0 +desparejad desparejar VMM02P0 +desparejando desparejar VMG0000 +desparejar desparejar VMN0000 +despareje desparejar VMM03S0 +desparejemos desparejar VMM01P0 +desparejen desparejar VMM03P0 +desparpaja desparpajar VMM02S0 +desparpajad desparpajar VMM02P0 +desparpajando desparpajar VMG0000 +desparpajar desparpajar VMN0000 +desparpaje desparpajar VMM03S0 +desparpajemos desparpajar VMM01P0 +desparpajen desparpajar VMM03P0 +desparrama desparramar VMM02S0 +desparramad desparramar VMM02P0 +desparramando desparramar VMG0000 +desparramar desparramar VMN0000 +desparrame desparramar VMM03S0 +desparramemos desparramar VMM01P0 +desparramen desparramar VMM03P0 +desparva desparvar VMM02S0 +desparvad desparvar VMM02P0 +desparvando desparvar VMG0000 +desparvar desparvar VMN0000 +desparve desparvar VMM03S0 +desparvemos desparvar VMM01P0 +desparven desparvar VMM03P0 +despatarra despatarrar VMM02S0 +despatarrad despatarrar VMM02P0 +despatarrando despatarrar VMG0000 +despatarrar despatarrar VMN0000 +despatarre despatarrar VMM03S0 +despatarremos despatarrar VMM01P0 +despatarren despatarrar VMM03P0 +despatilla despatillar VMM02S0 +despatillad despatillar VMM02P0 +despatillando despatillar VMG0000 +despatillar despatillar VMN0000 +despatille despatillar VMM03S0 +despatillemos despatillar VMM01P0 +despatillen despatillar VMM03P0 +despavesa despavesar VMM02S0 +despavesad despavesar VMM02P0 +despavesando despavesar VMG0000 +despavesar despavesar VMN0000 +despavese despavesar VMM03S0 +despavesemos despavesar VMM01P0 +despavesen despavesar VMM03P0 +despavona despavonar VMM02S0 +despavonad despavonar VMM02P0 +despavonando despavonar VMG0000 +despavonar despavonar VMN0000 +despavone despavonar VMM03S0 +despavonemos despavonar VMM01P0 +despavonen despavonar VMM03P0 +despavora despavorir VMM03S0 +despavoramos despavorir VMM01P0 +despavoran despavorir VMM03P0 +despavore despavorir VMM02S0 +despavorid despavorir VMM02P0 +despavoriendo despavorir VMG0000 +despavorir despavorir VMN0000 +despea despear VMM02S0 +despead despear VMM02P0 +despeando despear VMG0000 +despear despear VMN0000 +despecha despechar VMM02S0 +despechad despechar VMM02P0 +despechando despechar VMG0000 +despechar despechar VMN0000 +despeche despechar VMM03S0 +despechemos despechar VMM01P0 +despechen despechar VMM03P0 +despechuga despechugar VMM02S0 +despechugad despechugar VMM02P0 +despechugando despechugar VMG0000 +despechugar despechugar VMN0000 +despechugue despechugar VMM03S0 +despechuguemos despechugar VMM01P0 +despechuguen despechugar VMM03P0 +despedace despedazar VMM03S0 +despedacemos despedazar VMM01P0 +despedacen despedazar VMM03P0 +despedaza despedazar VMM02S0 +despedazad despedazar VMM02P0 +despedazando despedazar VMG0000 +despedazar despedazar VMN0000 +despedid despedir VMM02P0 +despedir despedir VMN0000 +despedrad despedrar VMM02P0 +despedrando despedrar VMG0000 +despedrar despedrar VMN0000 +despedrega despedregar VMM02S0 +despedregad despedregar VMM02P0 +despedregando despedregar VMG0000 +despedregar despedregar VMN0000 +despedregue despedregar VMM03S0 +despedreguemos despedregar VMM01P0 +despedreguen despedregar VMM03P0 +despedremos despedrar VMM01P0 +despee despear VMM03S0 +despeemos despear VMM01P0 +despeen despear VMM03P0 +despega despegar VMM02S0 +despegad despegar VMM02P0 +despegando despegar VMG0000 +despegar despegar VMN0000 +despegue despegar VMM03S0 +despeguemos despegar VMM01P0 +despeguen despegar VMM03P0 +despeina despeinar VMM02S0 +despeinad despeinar VMM02P0 +despeinando despeinar VMG0000 +despeinar despeinar VMN0000 +despeine despeinar VMM03S0 +despeinemos despeinar VMM01P0 +despeinen despeinar VMM03P0 +despeja despejar VMM02S0 +despejad despejar VMM02P0 +despejando despejar VMG0000 +despejar despejar VMN0000 +despeje despejar VMM03S0 +despejemos despejar VMM01P0 +despejen despejar VMM03P0 +despelleja despellejar VMM02S0 +despellejad despellejar VMM02P0 +despellejando despellejar VMG0000 +despellejar despellejar VMN0000 +despelleje despellejar VMM03S0 +despellejemos despellejar VMM01P0 +despellejen despellejar VMM03P0 +despelota despelotar VMM02S0 +despelotad despelotar VMM02P0 +despelotando despelotar VMG0000 +despelotar despelotar VMN0000 +despelote despelotar VMM03S0 +despelotemos despelotar VMM01P0 +despeloten despelotar VMM03P0 +despeluce despeluzar VMM03S0 +despelucemos despeluzar VMM01P0 +despelucen despeluzar VMM03P0 +despeluza despeluzar VMM02S0 +despeluzad despeluzar VMM02P0 +despeluzando despeluzar VMG0000 +despeluzar despeluzar VMN0000 +despeluzna despeluznar VMM02S0 +despeluznad despeluznar VMM02P0 +despeluznando despeluznar VMG0000 +despeluznar despeluznar VMN0000 +despeluzne despeluznar VMM03S0 +despeluznemos despeluznar VMM01P0 +despeluznen despeluznar VMM03P0 +despena despenar VMM02S0 +despenad despenar VMM02P0 +despenando despenar VMG0000 +despenar despenar VMN0000 +despene despenar VMM03S0 +despenemos despenar VMM01P0 +despenen despenar VMM03P0 +despepita despepitar VMM02S0 +despepitad despepitar VMM02P0 +despepitando despepitar VMG0000 +despepitar despepitar VMN0000 +despepite despepitar VMM03S0 +despepitemos despepitar VMM01P0 +despepiten despepitar VMM03P0 +desperdicia desperdiciar VMM02S0 +desperdiciad desperdiciar VMM02P0 +desperdiciando desperdiciar VMG0000 +desperdiciar desperdiciar VMN0000 +desperdicie desperdiciar VMM03S0 +desperdiciemos desperdiciar VMM01P0 +desperdicien desperdiciar VMM03P0 +desperdiga desperdigar VMM02S0 +desperdigad desperdigar VMM02P0 +desperdigando desperdigar VMG0000 +desperdigar desperdigar VMN0000 +desperdigue desperdigar VMM03S0 +desperdiguemos desperdigar VMM01P0 +desperdiguen desperdigar VMM03P0 +desperece desperecer VMM02S0 +desperece desperezar VMM03S0 +despereced desperecer VMM02P0 +desperecemos desperezar VMM01P0 +desperecen desperezar VMM03P0 +desperecer desperecer VMN0000 +despereciendo desperecer VMG0000 +despereza desperezar VMM02S0 +desperezad desperezar VMM02P0 +desperezando desperezar VMG0000 +desperezar desperezar VMN0000 +desperezca desperecer VMM03S0 +desperezcamos desperecer VMM01P0 +desperezcan desperecer VMM03P0 +desperfila desperfilar VMM02S0 +desperfilad desperfilar VMM02P0 +desperfilando desperfilar VMG0000 +desperfilar desperfilar VMN0000 +desperfile desperfilar VMM03S0 +desperfilemos desperfilar VMM01P0 +desperfilen desperfilar VMM03P0 +despernad despernar VMM02P0 +despernanca despernancar VMM02S0 +despernancad despernancar VMM02P0 +despernancando despernancar VMG0000 +despernancar despernancar VMN0000 +despernando despernar VMG0000 +despernanque despernancar VMM03S0 +despernanquemos despernancar VMM01P0 +despernanquen despernancar VMM03P0 +despernar despernar VMN0000 +despernemos despernar VMM01P0 +despersonalice despersonalizar VMM03S0 +despersonalicemos despersonalizar VMM01P0 +despersonalicen despersonalizar VMM03P0 +despersonaliza despersonalizar VMM02S0 +despersonalizad despersonalizar VMM02P0 +despersonalizando despersonalizar VMG0000 +despersonalizar despersonalizar VMN0000 +despertad despertar VMM02P0 +despertando despertar VMG0000 +despertar despertar VMN0000 +despertemos despertar VMM01P0 +despestaña despestañar VMM02S0 +despestañad despestañar VMM02P0 +despestañando despestañar VMG0000 +despestañar despestañar VMN0000 +despestañe despestañar VMM03S0 +despestañemos despestañar VMM01P0 +despestañen despestañar VMM03P0 +despezona despezonar VMM02S0 +despezonad despezonar VMM02P0 +despezonando despezonar VMG0000 +despezonar despezonar VMN0000 +despezone despezonar VMM03S0 +despezonemos despezonar VMM01P0 +despezonen despezonar VMM03P0 +despezuña despezuñar VMM02S0 +despezuñad despezuñar VMM02P0 +despezuñando despezuñar VMG0000 +despezuñar despezuñar VMN0000 +despezuñe despezuñar VMM03S0 +despezuñemos despezuñar VMM01P0 +despezuñen despezuñar VMM03P0 +despeña despeñar VMM02S0 +despeñad despeñar VMM02P0 +despeñando despeñar VMG0000 +despeñar despeñar VMN0000 +despeñe despeñar VMM03S0 +despeñemos despeñar VMM01P0 +despeñen despeñar VMM03P0 +despica despicar VMM02S0 +despicad despicar VMM02P0 +despicando despicar VMG0000 +despicar despicar VMN0000 +despicha despichar VMM02S0 +despichad despichar VMM02P0 +despichando despichar VMG0000 +despichar despichar VMN0000 +despiche despichar VMM03S0 +despichemos despichar VMM01P0 +despichen despichar VMM03P0 +despida despedir VMM03S0 +despidamos despedir VMM01P0 +despidan despedir VMM03P0 +despide despedir VMM02S0 +despidiendo despedir VMG0000 +despiedra despedrar VMM02S0 +despiedre despedrar VMM03S0 +despiedren despedrar VMM03P0 +despierna despernar VMM02S0 +despierne despernar VMM03S0 +despiernen despernar VMM03P0 +despierta despertar VMM02S0 +despierte despertar VMM03S0 +despierten despertar VMM03P0 +despilara despilarar VMM02S0 +despilarad despilarar VMM02P0 +despilarando despilarar VMG0000 +despilarar despilarar VMN0000 +despilare despilarar VMM03S0 +despilaremos despilarar VMM01P0 +despilaren despilarar VMM03P0 +despilfarra despilfarrar VMM02S0 +despilfarrad despilfarrar VMM02P0 +despilfarrando despilfarrar VMG0000 +despilfarrar despilfarrar VMN0000 +despilfarre despilfarrar VMM03S0 +despilfarremos despilfarrar VMM01P0 +despilfarren despilfarrar VMM03P0 +despimpolla despimpollar VMM02S0 +despimpollad despimpollar VMM02P0 +despimpollando despimpollar VMG0000 +despimpollar despimpollar VMN0000 +despimpolle despimpollar VMM03S0 +despimpollemos despimpollar VMM01P0 +despimpollen despimpollar VMM03P0 +despince despinzar VMM03S0 +despincemos despinzar VMM01P0 +despincen despinzar VMM03P0 +despinocha despinochar VMM02S0 +despinochad despinochar VMM02P0 +despinochando despinochar VMG0000 +despinochar despinochar VMN0000 +despinoche despinochar VMM03S0 +despinochemos despinochar VMM01P0 +despinochen despinochar VMM03P0 +despinta despintar VMM02S0 +despintad despintar VMM02P0 +despintando despintar VMG0000 +despintar despintar VMN0000 +despinte despintar VMM03S0 +despintemos despintar VMM01P0 +despinten despintar VMM03P0 +despinza despinzar VMM02S0 +despinzad despinzar VMM02P0 +despinzando despinzar VMG0000 +despinzar despinzar VMN0000 +despioja despiojar VMM02S0 +despiojad despiojar VMM02P0 +despiojando despiojar VMG0000 +despiojar despiojar VMN0000 +despioje despiojar VMM03S0 +despiojemos despiojar VMM01P0 +despiojen despiojar VMM03P0 +despique despicar VMM03S0 +despiquemos despicar VMM01P0 +despiquen despicar VMM03P0 +despista despistar VMM02S0 +despistad despistar VMM02P0 +despistando despistar VMG0000 +despistar despistar VMN0000 +despiste despistar VMM03S0 +despistemos despistar VMM01P0 +despisten despistar VMM03P0 +desplace desplacer VMM02S0 +desplace desplazar VMM03S0 +desplaced desplacer VMM02P0 +desplacemos desplazar VMM01P0 +desplacen desplazar VMM03P0 +desplacer desplacer VMN0000 +desplaciendo desplacer VMG0000 +desplanta desplantar VMM02S0 +desplantad desplantar VMM02P0 +desplantando desplantar VMG0000 +desplantar desplantar VMN0000 +desplante desplantar VMM03S0 +desplantemos desplantar VMM01P0 +desplanten desplantar VMM03P0 +desplata desplatar VMM02S0 +desplatad desplatar VMM02P0 +desplatando desplatar VMG0000 +desplatar desplatar VMN0000 +desplate desplatar VMM03S0 +desplatemos desplatar VMM01P0 +desplaten desplatar VMM03P0 +desplaza desplazar VMM02S0 +desplazad desplazar VMM02P0 +desplazando desplazar VMG0000 +desplazar desplazar VMN0000 +desplazca desplacer VMM03S0 +desplazcamos desplacer VMM01P0 +desplazcan desplacer VMM03P0 +desplegad desplegar VMM02P0 +desplegando desplegar VMG0000 +desplegar desplegar VMN0000 +despleguemos desplegar VMM01P0 +despleguetea despleguetear VMM02S0 +despleguetead despleguetear VMM02P0 +desplegueteando despleguetear VMG0000 +despleguetear despleguetear VMN0000 +despleguetee despleguetear VMM03S0 +desplegueteemos despleguetear VMM01P0 +desplegueteen despleguetear VMM03P0 +despliega desplegar VMM02S0 +despliegue desplegar VMM03S0 +desplieguen desplegar VMM03P0 +desploma desplomar VMM02S0 +desplomad desplomar VMM02P0 +desplomando desplomar VMG0000 +desplomar desplomar VMN0000 +desplome desplomar VMM03S0 +desplomemos desplomar VMM01P0 +desplomen desplomar VMM03P0 +despluma desplumar VMM02S0 +desplumad desplumar VMM02P0 +desplumando desplumar VMG0000 +desplumar desplumar VMN0000 +desplume desplumar VMM03S0 +desplumemos desplumar VMM01P0 +desplumen desplumar VMM03P0 +despoblad despoblar VMM02P0 +despoblando despoblar VMG0000 +despoblar despoblar VMN0000 +despoblemos despoblar VMM01P0 +despoja despojar VMM02S0 +despojad despojar VMM02P0 +despojando despojar VMG0000 +despojar despojar VMN0000 +despoje despojar VMM03S0 +despojemos despojar VMM01P0 +despojen despojar VMM03P0 +despolarice despolarizar VMM03S0 +despolaricemos despolarizar VMM01P0 +despolaricen despolarizar VMM03P0 +despolariza despolarizar VMM02S0 +despolarizad despolarizar VMM02P0 +despolarizando despolarizar VMG0000 +despolarizar despolarizar VMN0000 +despolva despolvar VMM02S0 +despolvad despolvar VMM02P0 +despolvando despolvar VMG0000 +despolvar despolvar VMN0000 +despolve despolvar VMM03S0 +despolvemos despolvar VMM01P0 +despolven despolvar VMM03P0 +despolvorea despolvorear VMM02S0 +despolvoread despolvorear VMM02P0 +despolvoreando despolvorear VMG0000 +despolvorear despolvorear VMN0000 +despolvoree despolvorear VMM03S0 +despolvoreemos despolvorear VMM01P0 +despolvoreen despolvorear VMM03P0 +desportilla desportillar VMM02S0 +desportillad desportillar VMM02P0 +desportillando desportillar VMG0000 +desportillar desportillar VMN0000 +desportille desportillar VMM03S0 +desportillemos desportillar VMM01P0 +desportillen desportillar VMM03P0 +desposa desposar VMM02S0 +desposad desposar VMM02P0 +desposando desposar VMG0000 +desposar desposar VMN0000 +despose desposar VMM03S0 +desposea desposeer VMM03S0 +desposeamos desposeer VMM01P0 +desposean desposeer VMM03P0 +desposee desposeer VMM02S0 +desposeed desposeer VMM02P0 +desposeer desposeer VMN0000 +desposemos desposar VMM01P0 +desposen desposar VMM03P0 +desposeyendo desposeer VMG0000 +desposta despostar VMM02S0 +despostad despostar VMM02P0 +despostando despostar VMG0000 +despostar despostar VMN0000 +desposte despostar VMM03S0 +despostemos despostar VMM01P0 +desposten despostar VMM03P0 +despostilla despostillar VMM02S0 +despostillad despostillar VMM02P0 +despostillando despostillar VMG0000 +despostillar despostillar VMN0000 +despostille despostillar VMM03S0 +despostillemos despostillar VMM01P0 +despostillen despostillar VMM03P0 +despotice despotizar VMM03S0 +despoticemos despotizar VMM01P0 +despoticen despotizar VMM03P0 +despotiza despotizar VMM02S0 +despotizad despotizar VMM02P0 +despotizando despotizar VMG0000 +despotizar despotizar VMN0000 +despotrica despotricar VMM02S0 +despotricad despotricar VMM02P0 +despotricando despotricar VMG0000 +despotricar despotricar VMN0000 +despotrique despotricar VMM03S0 +despotriquemos despotricar VMM01P0 +despotriquen despotricar VMM03P0 +desprecia despreciar VMM02S0 +despreciad despreciar VMM02P0 +despreciando despreciar VMG0000 +despreciar despreciar VMN0000 +desprecie despreciar VMM03S0 +despreciemos despreciar VMM01P0 +desprecien despreciar VMM03P0 +desprecinta desprecintar VMM02S0 +desprecintad desprecintar VMM02P0 +desprecintando desprecintar VMG0000 +desprecintar desprecintar VMN0000 +desprecinte desprecintar VMM03S0 +desprecintemos desprecintar VMM01P0 +desprecinten desprecintar VMM03P0 +desprenda desprender VMM03S0 +desprendamos desprender VMM01P0 +desprendan desprender VMM03P0 +desprende desprender VMM02S0 +desprended desprender VMM02P0 +desprender desprender VMN0000 +desprendiendo desprender VMG0000 +despreocupa despreocupar VMM02S0 +despreocupad despreocupar VMM02P0 +despreocupando despreocupar VMG0000 +despreocupar despreocupar VMN0000 +despreocupe despreocupar VMM03S0 +despreocupemos despreocupar VMM01P0 +despreocupen despreocupar VMM03P0 +desprestigia desprestigiar VMM02S0 +desprestigiad desprestigiar VMM02P0 +desprestigiando desprestigiar VMG0000 +desprestigiar desprestigiar VMN0000 +desprestigie desprestigiar VMM03S0 +desprestigiemos desprestigiar VMM01P0 +desprestigien desprestigiar VMM03P0 +despresurice despresurizar VMM03S0 +despresuricemos despresurizar VMM01P0 +despresuricen despresurizar VMM03P0 +despresuriza despresurizar VMM02S0 +despresurizad despresurizar VMM02P0 +despresurizando despresurizar VMG0000 +despresurizar despresurizar VMN0000 +desprograma desprogramar VMM02S0 +desprogramad desprogramar VMM02P0 +desprogramando desprogramar VMG0000 +desprogramar desprogramar VMN0000 +desprograme desprogramar VMM03S0 +desprogramemos desprogramar VMM01P0 +desprogramen desprogramar VMM03P0 +desproporciona desproporcionar VMM02S0 +desproporcionad desproporcionar VMM02P0 +desproporcionando desproporcionar VMG0000 +desproporcionar desproporcionar VMN0000 +desproporcione desproporcionar VMM03S0 +desproporcionemos desproporcionar VMM01P0 +desproporcionen desproporcionar VMM03P0 +desprotege desproteger VMM02S0 +desproteged desproteger VMM02P0 +desproteger desproteger VMN0000 +desprotegiendo desproteger VMG0000 +desproteja desproteger VMM03S0 +desprotejamos desproteger VMM01P0 +desprotejan desproteger VMM03P0 +desprovea desproveer VMM03S0 +desproveamos desproveer VMM01P0 +desprovean desproveer VMM03P0 +desprovee desproveer VMM02S0 +desproveed desproveer VMM02P0 +desproveer desproveer VMN0000 +desproveyendo desproveer VMG0000 +despuebla despoblar VMM02S0 +despueble despoblar VMM03S0 +despueblen despoblar VMM03P0 +despulpa despulpar VMM02S0 +despulpad despulpar VMM02P0 +despulpando despulpar VMG0000 +despulpar despulpar VMN0000 +despulpe despulpar VMM03S0 +despulpemos despulpar VMM01P0 +despulpen despulpar VMM03P0 +despuma despumar VMM02S0 +despumad despumar VMM02P0 +despumando despumar VMG0000 +despumar despumar VMN0000 +despume despumar VMM03S0 +despumemos despumar VMM01P0 +despumen despumar VMM03P0 +despunta despuntar VMM02S0 +despuntad despuntar VMM02P0 +despuntando despuntar VMG0000 +despuntar despuntar VMN0000 +despunte despuntar VMM03S0 +despuntemos despuntar VMM01P0 +despunten despuntar VMM03P0 +desquebraja desquebrajar VMM02S0 +desquebrajad desquebrajar VMM02P0 +desquebrajando desquebrajar VMG0000 +desquebrajar desquebrajar VMN0000 +desquebraje desquebrajar VMM03S0 +desquebrajemos desquebrajar VMM01P0 +desquebrajen desquebrajar VMM03P0 +desqueja desquejar VMM02S0 +desquejad desquejar VMM02P0 +desquejando desquejar VMG0000 +desquejar desquejar VMN0000 +desqueje desquejar VMM03S0 +desquejemos desquejar VMM01P0 +desquejen desquejar VMM03P0 +desqueramos desquerer VMM01P0 +desquered desquerer VMM02P0 +desquerer desquerer VMN0000 +desqueriendo desquerer VMG0000 +desquicia desquiciar VMM02S0 +desquiciad desquiciar VMM02P0 +desquiciando desquiciar VMG0000 +desquiciar desquiciar VMN0000 +desquicie desquiciar VMM03S0 +desquiciemos desquiciar VMM01P0 +desquicien desquiciar VMM03P0 +desquiera desquerer VMM03S0 +desquieran desquerer VMM03P0 +desquiere desquerer VMM02S0 +desquijara desquijarar VMM02S0 +desquijarad desquijarar VMM02P0 +desquijarando desquijarar VMG0000 +desquijarar desquijarar VMN0000 +desquijare desquijarar VMM03S0 +desquijaremos desquijarar VMM01P0 +desquijaren desquijarar VMM03P0 +desquijera desquijerar VMM02S0 +desquijerad desquijerar VMM02P0 +desquijerando desquijerar VMG0000 +desquijerar desquijerar VMN0000 +desquijere desquijerar VMM03S0 +desquijeremos desquijerar VMM01P0 +desquijeren desquijerar VMM03P0 +desquilata desquilatar VMM02S0 +desquilatad desquilatar VMM02P0 +desquilatando desquilatar VMG0000 +desquilatar desquilatar VMN0000 +desquilate desquilatar VMM03S0 +desquilatemos desquilatar VMM01P0 +desquilaten desquilatar VMM03P0 +desquita desquitar VMM02S0 +desquitad desquitar VMM02P0 +desquitando desquitar VMG0000 +desquitar desquitar VMN0000 +desquite desquitar VMM03S0 +desquitemos desquitar VMM01P0 +desquiten desquitar VMM03P0 +desrama desramar VMM02S0 +desramad desramar VMM02P0 +desramando desramar VMG0000 +desramar desramar VMN0000 +desrame desramar VMM03S0 +desramemos desramar VMM01P0 +desramen desramar VMM03P0 +desratice desratizar VMM03S0 +desraticemos desratizar VMM01P0 +desraticen desratizar VMM03P0 +desratiza desratizar VMM02S0 +desratizad desratizar VMM02P0 +desratizando desratizar VMG0000 +desratizar desratizar VMN0000 +desregula desregular VMM02S0 +desregulad desregular VMM02P0 +desregulando desregular VMG0000 +desregular desregular VMN0000 +desrice desrizar VMM03S0 +desricemos desrizar VMM01P0 +desricen desrizar VMM03P0 +desriela desrielar VMM02S0 +desrielad desrielar VMM02P0 +desrielando desrielar VMG0000 +desrielar desrielar VMN0000 +desriele desrielar VMM03S0 +desrielemos desrielar VMM01P0 +desrielen desrielar VMM03P0 +desrisca desriscar VMM02S0 +desriscad desriscar VMM02P0 +desriscando desriscar VMG0000 +desriscar desriscar VMN0000 +desrisque desriscar VMM03S0 +desrisquemos desriscar VMM01P0 +desrisquen desriscar VMM03P0 +desriza desrizar VMM02S0 +desrizad desrizar VMM02P0 +desrizando desrizar VMG0000 +desrizar desrizar VMN0000 +desriñona desriñonar VMM02S0 +desriñonad desriñonar VMM02P0 +desriñonando desriñonar VMG0000 +desriñonar desriñonar VMN0000 +desriñone desriñonar VMM03S0 +desriñonemos desriñonar VMM01P0 +desriñonen desriñonar VMM03P0 +desrobla desroblar VMM02S0 +desroblad desroblar VMM02P0 +desroblando desroblar VMG0000 +desroblar desroblar VMN0000 +desroble desroblar VMM03S0 +desroblemos desroblar VMM01P0 +desroblen desroblar VMM03P0 +destaca destacar VMM02S0 +destacad destacar VMM02P0 +destacando destacar VMG0000 +destacar destacar VMN0000 +destace destazar VMM03S0 +destacemos destazar VMM01P0 +destacen destazar VMM03P0 +destaja destajar VMM02S0 +destajad destajar VMM02P0 +destajando destajar VMG0000 +destajar destajar VMN0000 +destaje destajar VMM03S0 +destajemos destajar VMM01P0 +destajen destajar VMM03P0 +destalla destallar VMM02S0 +destallad destallar VMM02P0 +destallando destallar VMG0000 +destallar destallar VMN0000 +destalle destallar VMM03S0 +destallemos destallar VMM01P0 +destallen destallar VMM03P0 +destalona destalonar VMM02S0 +destalonad destalonar VMM02P0 +destalonando destalonar VMG0000 +destalonar destalonar VMN0000 +destalone destalonar VMM03S0 +destalonemos destalonar VMM01P0 +destalonen destalonar VMM03P0 +destapa destapar VMM02S0 +destapad destapar VMM02P0 +destapando destapar VMG0000 +destapar destapar VMN0000 +destape destapar VMM03S0 +destapemos destapar VMM01P0 +destapen destapar VMM03P0 +destapia destapiar VMM02S0 +destapiad destapiar VMM02P0 +destapiando destapiar VMG0000 +destapiar destapiar VMN0000 +destapie destapiar VMM03S0 +destapiemos destapiar VMM01P0 +destapien destapiar VMM03P0 +destapona destaponar VMM02S0 +destaponad destaponar VMM02P0 +destaponando destaponar VMG0000 +destaponar destaponar VMN0000 +destapone destaponar VMM03S0 +destaponemos destaponar VMM01P0 +destaponen destaponar VMM03P0 +destaque destacar VMM03S0 +destaquemos destacar VMM01P0 +destaquen destacar VMM03P0 +destara destarar VMM02S0 +destarad destarar VMM02P0 +destarando destarar VMG0000 +destarar destarar VMN0000 +destare destarar VMM03S0 +destaremos destarar VMM01P0 +destaren destarar VMM03P0 +destaza destazar VMM02S0 +destazad destazar VMM02P0 +destazando destazar VMG0000 +destazar destazar VMN0000 +destecha destechar VMM02S0 +destechad destechar VMM02P0 +destechando destechar VMG0000 +destechar destechar VMN0000 +desteche destechar VMM03S0 +destechemos destechar VMM01P0 +destechen destechar VMM03P0 +desteja destejar VMM02S0 +desteja destejer VMM03S0 +destejad destejar VMM02P0 +destejamos destejer VMM01P0 +destejan destejer VMM03P0 +destejando destejar VMG0000 +destejar destejar VMN0000 +desteje destejar VMM03S0 +desteje destejer VMM02S0 +destejed destejer VMM02P0 +destejemos destejar VMM01P0 +destejen destejar VMM03P0 +destejer destejer VMN0000 +destejiendo destejer VMG0000 +destella destellar VMM02S0 +destellad destellar VMM02P0 +destellando destellar VMG0000 +destellar destellar VMN0000 +destelle destellar VMM03S0 +destellemos destellar VMM01P0 +destellen destellar VMM03P0 +destempla destemplar VMM02S0 +destemplad destemplar VMM02P0 +destemplando destemplar VMG0000 +destemplar destemplar VMN0000 +destemple destemplar VMM03S0 +destemplemos destemplar VMM01P0 +destemplen destemplar VMM03P0 +destensa destensar VMM02S0 +destensad destensar VMM02P0 +destensando destensar VMG0000 +destensar destensar VMN0000 +destense destensar VMM03S0 +destensemos destensar VMM01P0 +destensen destensar VMM03P0 +destentad destentar VMM02P0 +destentando destentar VMG0000 +destentar destentar VMN0000 +destentemos destentar VMM01P0 +desternera desternerar VMM02S0 +desternerad desternerar VMM02P0 +desternerando desternerar VMG0000 +desternerar desternerar VMN0000 +desternere desternerar VMM03S0 +desterneremos desternerar VMM01P0 +desterneren desternerar VMM03P0 +desternilla desternillar VMM02S0 +desternillad desternillar VMM02P0 +desternillando desternillar VMG0000 +desternillar desternillar VMN0000 +desternille desternillar VMM03S0 +desternillemos desternillar VMM01P0 +desternillen desternillar VMM03P0 +desterrad desterrar VMM02P0 +desterrando desterrar VMG0000 +desterrar desterrar VMN0000 +desterremos desterrar VMM01P0 +desterrona desterronar VMM02S0 +desterronad desterronar VMM02P0 +desterronando desterronar VMG0000 +desterronar desterronar VMN0000 +desterrone desterronar VMM03S0 +desterronemos desterronar VMM01P0 +desterronen desterronar VMM03P0 +desteta destetar VMM02S0 +destetad destetar VMM02P0 +destetando destetar VMG0000 +destetar destetar VMN0000 +destete destetar VMM03S0 +destetemos destetar VMM01P0 +desteten destetar VMM03P0 +destetilla destetillar VMM02S0 +destetillad destetillar VMM02P0 +destetillando destetillar VMG0000 +destetillar destetillar VMN0000 +destetille destetillar VMM03S0 +destetillemos destetillar VMM01P0 +destetillen destetillar VMM03P0 +desteñid desteñir VMM02P0 +desteñir desteñir VMN0000 +destienta destentar VMM02S0 +destiente destentar VMM03S0 +destienten destentar VMM03P0 +destierra desterrar VMM02S0 +destierre desterrar VMM03S0 +destierren desterrar VMM03P0 +destila destilar VMM02S0 +destilad destilar VMM02P0 +destilando destilar VMG0000 +destilar destilar VMN0000 +destile destilar VMM03S0 +destilemos destilar VMM01P0 +destilen destilar VMM03P0 +destina destinar VMM02S0 +destinad destinar VMM02P0 +destinando destinar VMG0000 +destinar destinar VMN0000 +destine destinar VMM03S0 +destinemos destinar VMM01P0 +destinen destinar VMM03P0 +destituid destituir VMM02P0 +destituir destituir VMN0000 +destituya destituir VMM03S0 +destituyamos destituir VMM01P0 +destituyan destituir VMM03P0 +destituye destituir VMM02S0 +destituyendo destituir VMG0000 +destiña desteñir VMM03S0 +destiñamos desteñir VMM01P0 +destiñan desteñir VMM03P0 +destiñe desteñir VMM02S0 +destiñendo desteñir VMG0000 +destoca destocar VMM02S0 +destocad destocar VMM02P0 +destocando destocar VMG0000 +destocar destocar VMN0000 +destoque destocar VMM03S0 +destoquemos destocar VMM01P0 +destoquen destocar VMM03P0 +destorced destorcer VMM02P0 +destorcer destorcer VMN0000 +destorciendo destorcer VMG0000 +destornilla destornillar VMM02S0 +destornillad destornillar VMM02P0 +destornillando destornillar VMG0000 +destornillar destornillar VMN0000 +destornille destornillar VMM03S0 +destornillemos destornillar VMM01P0 +destornillen destornillar VMM03P0 +destorzamos destorcer VMM01P0 +destraba destrabar VMM02S0 +destrabad destrabar VMM02P0 +destrabando destrabar VMG0000 +destrabar destrabar VMN0000 +destrabe destrabar VMM03S0 +destrabemos destrabar VMM01P0 +destraben destrabar VMM03P0 +destrama destramar VMM02S0 +destramad destramar VMM02P0 +destramando destramar VMG0000 +destramar destramar VMN0000 +destrame destramar VMM03S0 +destramemos destramar VMM01P0 +destramen destramar VMM03P0 +destrence destrenzar VMM03S0 +destrencemos destrenzar VMM01P0 +destrencen destrenzar VMM03P0 +destrenza destrenzar VMM02S0 +destrenzad destrenzar VMM02P0 +destrenzando destrenzar VMG0000 +destrenzar destrenzar VMN0000 +destrice destrizar VMM03S0 +destricemos destrizar VMM01P0 +destricen destrizar VMM03P0 +destripa destripar VMM02S0 +destripad destripar VMM02P0 +destripando destripar VMG0000 +destripar destripar VMN0000 +destripe destripar VMM03S0 +destripemos destripar VMM01P0 +destripen destripar VMM03P0 +destriunfa destriunfar VMM02S0 +destriunfad destriunfar VMM02P0 +destriunfando destriunfar VMG0000 +destriunfar destriunfar VMN0000 +destriunfe destriunfar VMM03S0 +destriunfemos destriunfar VMM01P0 +destriunfen destriunfar VMM03P0 +destriza destrizar VMM02S0 +destrizad destrizar VMM02P0 +destrizando destrizar VMG0000 +destrizar destrizar VMN0000 +destrocad destrocar VMM02P0 +destrocando destrocar VMG0000 +destrocar destrocar VMN0000 +destroce destrozar VMM03S0 +destrocemos destrozar VMM01P0 +destrocen destrozar VMM03P0 +destrona destronar VMM02S0 +destronad destronar VMM02P0 +destronando destronar VMG0000 +destronar destronar VMN0000 +destronca destroncar VMM02S0 +destroncad destroncar VMM02P0 +destroncando destroncar VMG0000 +destroncar destroncar VMN0000 +destrone destronar VMM03S0 +destronemos destronar VMM01P0 +destronen destronar VMM03P0 +destronque destroncar VMM03S0 +destronquemos destroncar VMM01P0 +destronquen destroncar VMM03P0 +destroza destrozar VMM02S0 +destrozad destrozar VMM02P0 +destrozando destrozar VMG0000 +destrozar destrozar VMN0000 +destrueca destrocar VMM02S0 +destrueque destrocar VMM03S0 +destruequen destrocar VMM03P0 +destruid destruir VMM02P0 +destruir destruir VMN0000 +destruya destruir VMM03S0 +destruyamos destruir VMM01P0 +destruyan destruir VMM03P0 +destruye destruir VMM02S0 +destruyendo destruir VMG0000 +destuerce destorcer VMM02S0 +destuerza destorcer VMM03S0 +destuerzan destorcer VMM03P0 +destusa destusar VMM02S0 +destusad destusar VMM02P0 +destusando destusar VMG0000 +destusar destusar VMN0000 +destuse destusar VMM03S0 +destusemos destusar VMM01P0 +destusen destusar VMM03P0 +desubstancia desubstanciar VMM02S0 +desubstanciad desubstanciar VMM02P0 +desubstanciando desubstanciar VMG0000 +desubstanciar desubstanciar VMN0000 +desubstancie desubstanciar VMM03S0 +desubstanciemos desubstanciar VMM01P0 +desubstancien desubstanciar VMM03P0 +desuda desudar VMM02S0 +desudad desudar VMM02P0 +desudando desudar VMG0000 +desudar desudar VMN0000 +desude desudar VMM03S0 +desudemos desudar VMM01P0 +desuden desudar VMM03P0 +desuelda desoldar VMM02S0 +desuelde desoldar VMM03S0 +desuelden desoldar VMM03P0 +desuella desollar VMM02S0 +desuelle desollar VMM03S0 +desuellen desollar VMM03P0 +desulfura desulfurar VMM02S0 +desulfurad desulfurar VMM02P0 +desulfurando desulfurar VMG0000 +desulfurar desulfurar VMN0000 +desulfure desulfurar VMM03S0 +desulfuremos desulfurar VMM01P0 +desulfuren desulfurar VMM03P0 +desuna desunir VMM03S0 +desunamos desunir VMM01P0 +desunan desunir VMM03P0 +desunce desuncir VMM02S0 +desuncid desuncir VMM02P0 +desunciendo desuncir VMG0000 +desuncir desuncir VMN0000 +desune desunir VMM02S0 +desunid desunir VMM02P0 +desuniendo desunir VMG0000 +desunir desunir VMN0000 +desunza desuncir VMM03S0 +desunzamos desuncir VMM01P0 +desunzan desuncir VMM03P0 +desurda desurdir VMM03S0 +desurdamos desurdir VMM01P0 +desurdan desurdir VMM03P0 +desurde desurdir VMM02S0 +desurdid desurdir VMM02P0 +desurdiendo desurdir VMG0000 +desurdir desurdir VMN0000 +desusa desusar VMM02S0 +desusad desusar VMM02P0 +desusando desusar VMG0000 +desusar desusar VMN0000 +desuse desusar VMM03S0 +desusemos desusar VMM01P0 +desusen desusar VMM03P0 +desustancia desustanciar VMM02S0 +desustanciad desustanciar VMM02P0 +desustanciando desustanciar VMG0000 +desustanciar desustanciar VMN0000 +desustancie desustanciar VMM03S0 +desustanciemos desustanciar VMM01P0 +desustancien desustanciar VMM03P0 +desuña desuñar VMM02S0 +desuñad desuñar VMM02P0 +desuñando desuñar VMG0000 +desuñar desuñar VMN0000 +desuñe desuñar VMM03S0 +desuñemos desuñar VMM01P0 +desuñen desuñar VMM03P0 +desvaha desvahar VMM02S0 +desvahad desvahar VMM02P0 +desvahando desvahar VMG0000 +desvahar desvahar VMN0000 +desvahe desvahar VMM03S0 +desvahemos desvahar VMM01P0 +desvahen desvahar VMM03P0 +desvaina desvainar VMM02S0 +desvainad desvainar VMM02P0 +desvainando desvainar VMG0000 +desvainar desvainar VMN0000 +desvaine desvainar VMM03S0 +desvainemos desvainar VMM01P0 +desvainen desvainar VMM03P0 +desvalija desvalijar VMM02S0 +desvalijad desvalijar VMM02P0 +desvalijando desvalijar VMG0000 +desvalijar desvalijar VMN0000 +desvalije desvalijar VMM03S0 +desvalijemos desvalijar VMM01P0 +desvalijen desvalijar VMM03P0 +desvalora desvalorar VMM02S0 +desvalorad desvalorar VMM02P0 +desvalorando desvalorar VMG0000 +desvalorar desvalorar VMN0000 +desvalore desvalorar VMM03S0 +desvaloremos desvalorar VMM01P0 +desvaloren desvalorar VMM03P0 +desvalorice desvalorizar VMM03S0 +desvaloricemos desvalorizar VMM01P0 +desvaloricen desvalorizar VMM03P0 +desvaloriza desvalorizar VMM02S0 +desvalorizad desvalorizar VMM02P0 +desvalorizando desvalorizar VMG0000 +desvalorizar desvalorizar VMN0000 +desvanece desvanecer VMM02S0 +desvaneced desvanecer VMM02P0 +desvanecer desvanecer VMN0000 +desvaneciendo desvanecer VMG0000 +desvanezca desvanecer VMM03S0 +desvanezcamos desvanecer VMM01P0 +desvanezcan desvanecer VMM03P0 +desvara desvarar VMM02S0 +desvarad desvarar VMM02P0 +desvarando desvarar VMG0000 +desvarar desvarar VMN0000 +desvare desvarar VMM03S0 +desvaremos desvarar VMM01P0 +desvaren desvarar VMM03P0 +desvariad desvariar VMM02P0 +desvariando desvariar VMG0000 +desvariar desvariar VMN0000 +desvariemos desvariar VMM01P0 +desvaría desvariar VMM02S0 +desvaríe desvariar VMM03S0 +desvaríen desvariar VMM03P0 +desvastiga desvastigar VMM02S0 +desvastigad desvastigar VMM02P0 +desvastigando desvastigar VMG0000 +desvastigar desvastigar VMN0000 +desvastigue desvastigar VMM03S0 +desvastiguemos desvastigar VMM01P0 +desvastiguen desvastigar VMM03P0 +desveda desvedar VMM02S0 +desvedad desvedar VMM02P0 +desvedando desvedar VMG0000 +desvedar desvedar VMN0000 +desvede desvedar VMM03S0 +desvedemos desvedar VMM01P0 +desveden desvedar VMM03P0 +desvela desvelar VMM02S0 +desvelad desvelar VMM02P0 +desvelando desvelar VMG0000 +desvelar desvelar VMN0000 +desvele desvelar VMM03S0 +desvelemos desvelar VMM01P0 +desvelen desvelar VMM03P0 +desvena desvenar VMM02S0 +desvenad desvenar VMM02P0 +desvenando desvenar VMG0000 +desvenar desvenar VMN0000 +desvencija desvencijar VMM02S0 +desvencijad desvencijar VMM02P0 +desvencijando desvencijar VMG0000 +desvencijar desvencijar VMN0000 +desvencije desvencijar VMM03S0 +desvencijemos desvencijar VMM01P0 +desvencijen desvencijar VMM03P0 +desvenda desvendar VMM02S0 +desvendad desvendar VMM02P0 +desvendando desvendar VMG0000 +desvendar desvendar VMN0000 +desvende desvendar VMM03S0 +desvendemos desvendar VMM01P0 +desvenden desvendar VMM03P0 +desvene desvenar VMM03S0 +desvenemos desvenar VMM01P0 +desvenen desvenar VMM03P0 +desvergoncemos desvergonzar VMM01P0 +desvergonzad desvergonzar VMM02P0 +desvergonzando desvergonzar VMG0000 +desvergonzar desvergonzar VMN0000 +desvergüence desvergonzar VMM03S0 +desvergüencen desvergonzar VMM03P0 +desvergüenza desvergonzar VMM02S0 +desvestid desvestir VMM02P0 +desvestir desvestir VMN0000 +desviad desviar VMM02P0 +desviando desviar VMG0000 +desviar desviar VMN0000 +desviemos desviar VMM01P0 +desvincula desvincular VMM02S0 +desvinculad desvincular VMM02P0 +desvinculando desvincular VMG0000 +desvincular desvincular VMN0000 +desvincule desvincular VMM03S0 +desvinculemos desvincular VMM01P0 +desvinculen desvincular VMM03P0 +desvira desvirar VMM02S0 +desvirad desvirar VMM02P0 +desvirando desvirar VMG0000 +desvirar desvirar VMN0000 +desvire desvirar VMM03S0 +desviremos desvirar VMM01P0 +desviren desvirar VMM03P0 +desvirga desvirgar VMM02S0 +desvirgad desvirgar VMM02P0 +desvirgando desvirgar VMG0000 +desvirgar desvirgar VMN0000 +desvirgue desvirgar VMM03S0 +desvirguemos desvirgar VMM01P0 +desvirguen desvirgar VMM03P0 +desvirtuad desvirtuar VMM02P0 +desvirtuando desvirtuar VMG0000 +desvirtuar desvirtuar VMN0000 +desvirtuemos desvirtuar VMM01P0 +desvirtúa desvirtuar VMM02S0 +desvirtúe desvirtuar VMM03S0 +desvirtúen desvirtuar VMM03P0 +desvista desvestir VMM03S0 +desvistamos desvestir VMM01P0 +desvistan desvestir VMM03P0 +desviste desvestir VMM02S0 +desvistiendo desvestir VMG0000 +desvitalice desvitalizar VMM03S0 +desvitalicemos desvitalizar VMM01P0 +desvitalicen desvitalizar VMM03P0 +desvitaliza desvitalizar VMM02S0 +desvitalizad desvitalizar VMM02P0 +desvitalizando desvitalizar VMG0000 +desvitalizar desvitalizar VMN0000 +desvitrifica desvitrificar VMM02S0 +desvitrificad desvitrificar VMM02P0 +desvitrificando desvitrificar VMG0000 +desvitrificar desvitrificar VMN0000 +desvitrifique desvitrificar VMM03S0 +desvitrifiquemos desvitrificar VMM01P0 +desvitrifiquen desvitrificar VMM03P0 +desviva desvivir VMM03S0 +desvivamos desvivir VMM01P0 +desvivan desvivir VMM03P0 +desvive desvivir VMM02S0 +desvivid desvivir VMM02P0 +desviviendo desvivir VMG0000 +desvivir desvivir VMN0000 +desvolcana desvolcanar VMM02S0 +desvolcanad desvolcanar VMM02P0 +desvolcanando desvolcanar VMG0000 +desvolcanar desvolcanar VMN0000 +desvolcane desvolcanar VMM03S0 +desvolcanemos desvolcanar VMM01P0 +desvolcanen desvolcanar VMM03P0 +desvía desviar VMM02S0 +desvíe desviar VMM03S0 +desvíen desviar VMM03P0 +desyema desyemar VMM02S0 +desyemad desyemar VMM02P0 +desyemando desyemar VMG0000 +desyemar desyemar VMN0000 +desyeme desyemar VMM03S0 +desyememos desyemar VMM01P0 +desyemen desyemar VMM03P0 +desyerba desyerbar VMM02S0 +desyerbad desyerbar VMM02P0 +desyerbando desyerbar VMG0000 +desyerbar desyerbar VMN0000 +desyerbe desyerbar VMM03S0 +desyerbemos desyerbar VMM01P0 +desyerben desyerbar VMM03P0 +desyuga desyugar VMM02S0 +desyugad desyugar VMM02P0 +desyugando desyugar VMG0000 +desyugar desyugar VMN0000 +desyugue desyugar VMM03S0 +desyuguemos desyugar VMM01P0 +desyuguen desyugar VMM03P0 +deszulaca deszulacar VMM02S0 +deszulacad deszulacar VMM02P0 +deszulacando deszulacar VMG0000 +deszulacar deszulacar VMN0000 +deszulaque deszulacar VMM03S0 +deszulaquemos deszulacar VMM01P0 +deszulaquen deszulacar VMM03P0 +deszuma deszumar VMM02S0 +deszumad deszumar VMM02P0 +deszumando deszumar VMG0000 +deszumar deszumar VMN0000 +deszume deszumar VMM03S0 +deszumemos deszumar VMM01P0 +deszumen deszumar VMM03P0 +detalla detallar VMM02S0 +detallad detallar VMM02P0 +detallando detallar VMG0000 +detallar detallar VMN0000 +detalle detallar VMM03S0 +detallemos detallar VMM01P0 +detallen detallar VMM03P0 +detecta detectar VMM02S0 +detectad detectar VMM02P0 +detectando detectar VMG0000 +detectar detectar VMN0000 +detecte detectar VMM03S0 +detectemos detectar VMM01P0 +detecten detectar VMM03P0 +detened detener VMM02P0 +detener detener VMN0000 +detenga detener VMM03S0 +detengamos detener VMM01P0 +detengan detener VMM03P0 +deteniendo detener VMG0000 +detenta detentar VMM02S0 +detentad detentar VMM02P0 +detentando detentar VMG0000 +detentar detentar VMN0000 +detente detentar VMM03S0 +detentemos detentar VMM01P0 +detenten detentar VMM03P0 +deterge deterger VMM02S0 +deterged deterger VMM02P0 +deterger deterger VMN0000 +detergiendo deterger VMG0000 +deteriora deteriorar VMM02S0 +deteriorad deteriorar VMM02P0 +deteriorando deteriorar VMG0000 +deteriorar deteriorar VMN0000 +deteriore deteriorar VMM03S0 +deterioremos deteriorar VMM01P0 +deterioren deteriorar VMM03P0 +deterja deterger VMM03S0 +deterjamos deterger VMM01P0 +deterjan deterger VMM03P0 +determina determinar VMM02S0 +determinad determinar VMM02P0 +determinando determinar VMG0000 +determinar determinar VMN0000 +determine determinar VMM03S0 +determinemos determinar VMM01P0 +determinen determinar VMM03P0 +detesta detestar VMM02S0 +detestad detestar VMM02P0 +detestando detestar VMG0000 +detestar detestar VMN0000 +deteste detestar VMM03S0 +detestemos detestar VMM01P0 +detesten detestar VMM03P0 +detona detonar VMM02S0 +detonad detonar VMM02P0 +detonando detonar VMG0000 +detonar detonar VMN0000 +detone detonar VMM03S0 +detonemos detonar VMM01P0 +detonen detonar VMM03P0 +detracta detractar VMM02S0 +detractad detractar VMM02P0 +detractando detractar VMG0000 +detractar detractar VMN0000 +detracte detractar VMM03S0 +detractemos detractar VMM01P0 +detracten detractar VMM03P0 +detrae detraer VMM02S0 +detraed detraer VMM02P0 +detraer detraer VMN0000 +detraiga detraer VMM03S0 +detraigamos detraer VMM01P0 +detraigan detraer VMM03P0 +detrayendo detraer VMG0000 +detroquemos destrocar VMM01P0 +detén detener VMM02S0 +devala devalar VMM02S0 +devalad devalar VMM02P0 +devalando devalar VMG0000 +devalar devalar VMN0000 +devale devalar VMM03S0 +devalemos devalar VMM01P0 +devalen devalar VMM03P0 +devaluad devaluar VMM02P0 +devaluando devaluar VMG0000 +devaluar devaluar VMN0000 +devaluemos devaluar VMM01P0 +devalúa devaluar VMM02S0 +devalúe devaluar VMM03S0 +devalúen devaluar VMM03P0 +devana devanar VMM02S0 +devanad devanar VMM02P0 +devanando devanar VMG0000 +devanar devanar VMN0000 +devane devanar VMM03S0 +devanea devanear VMM02S0 +devanead devanear VMM02P0 +devaneando devanear VMG0000 +devanear devanear VMN0000 +devanee devanear VMM03S0 +devaneemos devanear VMM01P0 +devaneen devanear VMM03P0 +devanemos devanar VMM01P0 +devanen devanar VMM03P0 +devasta devastar VMM02S0 +devastad devastar VMM02P0 +devastando devastar VMG0000 +devastar devastar VMN0000 +devaste devastar VMM03S0 +devastemos devastar VMM01P0 +devasten devastar VMM03P0 +deven devenir VMM02S0 +devenga devengar VMM02S0 +devenga devenir VMM03S0 +devengad devengar VMM02P0 +devengamos devenir VMM01P0 +devengan devenir VMM03P0 +devengando devengar VMG0000 +devengar devengar VMN0000 +devengue devengar VMM03S0 +devenguemos devengar VMM01P0 +devenguen devengar VMM03P0 +devenid devenir VMM02P0 +devenir devenir VMN0000 +deviniendo devenir VMG0000 +devolvamos devolver VMM01P0 +devolved devolver VMM02P0 +devolver devolver VMN0000 +devolviendo devolver VMG0000 +devora devorar VMM02S0 +devorad devorar VMM02P0 +devorando devorar VMG0000 +devorar devorar VMN0000 +devore devorar VMM03S0 +devoremos devorar VMM01P0 +devoren devorar VMM03P0 +devuelva devolver VMM03S0 +devuelvan devolver VMM03P0 +devuelve devolver VMM02S0 +dezmad dezmar VMM02P0 +dezmando dezmar VMG0000 +dezmar dezmar VMN0000 +dezmemos dezmar VMM01P0 +di decir VMM02S0 +diablea diablear VMM02S0 +diablead diablear VMM02P0 +diableando diablear VMG0000 +diablear diablear VMN0000 +diablee diablear VMM03S0 +diableemos diablear VMM01P0 +diableen diablear VMM03P0 +diacona diaconar VMM02S0 +diaconad diaconar VMM02P0 +diaconando diaconar VMG0000 +diaconar diaconar VMN0000 +diacone diaconar VMM03S0 +diaconemos diaconar VMM01P0 +diaconen diaconar VMM03P0 +diafragma diafragmar VMM02S0 +diafragmad diafragmar VMM02P0 +diafragmando diafragmar VMG0000 +diafragmar diafragmar VMN0000 +diafragme diafragmar VMM03S0 +diafragmemos diafragmar VMM01P0 +diafragmen diafragmar VMM03P0 +diagnostica diagnosticar VMM02S0 +diagnosticad diagnosticar VMM02P0 +diagnosticando diagnosticar VMG0000 +diagnosticar diagnosticar VMN0000 +diagnostique diagnosticar VMM03S0 +diagnostiquemos diagnosticar VMM01P0 +diagnostiquen diagnosticar VMM03P0 +dialice dializar VMM03S0 +dialicemos dializar VMM01P0 +dialicen dializar VMM03P0 +dializa dializar VMM02S0 +dializad dializar VMM02P0 +dializando dializar VMG0000 +dializar dializar VMN0000 +dialoga dialogar VMM02S0 +dialogad dialogar VMM02P0 +dialogando dialogar VMG0000 +dialogar dialogar VMN0000 +dialogue dialogar VMM03S0 +dialoguemos dialogar VMM01P0 +dialoguen dialogar VMM03P0 +diamanta diamantar VMM02S0 +diamantad diamantar VMM02P0 +diamantando diamantar VMG0000 +diamantar diamantar VMN0000 +diamante diamantar VMM03S0 +diamantemos diamantar VMM01P0 +diamanten diamantar VMM03P0 +dibuja dibujar VMM02S0 +dibujad dibujar VMM02P0 +dibujando dibujar VMG0000 +dibujar dibujar VMN0000 +dibuje dibujar VMM03S0 +dibujemos dibujar VMM01P0 +dibujen dibujar VMM03P0 +diciendo decir VMG0000 +dicta dictar VMM02S0 +dictad dictar VMM02P0 +dictamina dictaminar VMM02S0 +dictaminad dictaminar VMM02P0 +dictaminando dictaminar VMG0000 +dictaminar dictaminar VMN0000 +dictamine dictaminar VMM03S0 +dictaminemos dictaminar VMM01P0 +dictaminen dictaminar VMM03P0 +dictando dictar VMG0000 +dictar dictar VMN0000 +dicte dictar VMM03S0 +dictemos dictar VMM01P0 +dicten dictar VMM03P0 +dienta dentar VMM02S0 +diente dentar VMM03S0 +dienten dentar VMM03P0 +diezma dezmar VMM02S0 +diezma diezmar VMM02S0 +diezmad diezmar VMM02P0 +diezmando diezmar VMG0000 +diezmar diezmar VMN0000 +diezme dezmar VMM03S0 +diezme diezmar VMM03S0 +diezmemos diezmar VMM01P0 +diezmen dezmar VMM03P0 +diezmen diezmar VMM03P0 +difama difamar VMM02S0 +difamad difamar VMM02P0 +difamando difamar VMG0000 +difamar difamar VMN0000 +difame difamar VMM03S0 +difamemos difamar VMM01P0 +difamen difamar VMM03P0 +diferencia diferenciar VMM02S0 +diferenciad diferenciar VMM02P0 +diferenciando diferenciar VMG0000 +diferenciar diferenciar VMN0000 +diferencie diferenciar VMM03S0 +diferenciemos diferenciar VMM01P0 +diferencien diferenciar VMM03P0 +diferid diferir VMM02P0 +diferir diferir VMN0000 +dificulta dificultar VMM02S0 +dificultad dificultar VMM02P0 +dificultando dificultar VMG0000 +dificultar dificultar VMN0000 +dificulte dificultar VMM03S0 +dificultemos dificultar VMM01P0 +dificulten dificultar VMM03P0 +difiera diferir VMM03S0 +difieran diferir VMM03P0 +difiere diferir VMM02S0 +difiramos diferir VMM01P0 +difiriendo diferir VMG0000 +difluid difluir VMM02P0 +difluir difluir VMN0000 +difluya difluir VMM03S0 +difluyamos difluir VMM01P0 +difluyan difluir VMM03P0 +difluye difluir VMM02S0 +difluyendo difluir VMG0000 +difracta difractar VMM02S0 +difractad difractar VMM02P0 +difractando difractar VMG0000 +difractar difractar VMN0000 +difracte difractar VMM03S0 +difractemos difractar VMM01P0 +difracten difractar VMM03P0 +difuma difumar VMM02S0 +difumad difumar VMM02P0 +difumando difumar VMG0000 +difumar difumar VMN0000 +difume difumar VMM03S0 +difumemos difumar VMM01P0 +difumen difumar VMM03P0 +difumina difuminar VMM02S0 +difuminad difuminar VMM02P0 +difuminando difuminar VMG0000 +difuminar difuminar VMN0000 +difumine difuminar VMM03S0 +difuminemos difuminar VMM01P0 +difuminen difuminar VMM03P0 +difunda difundir VMM03S0 +difundamos difundir VMM01P0 +difundan difundir VMM03P0 +difunde difundir VMM02S0 +difundid difundir VMM02P0 +difundiendo difundir VMG0000 +difundir difundir VMN0000 +diga decir VMM03S0 +digamos decir VMM01P0 +digan decir VMM03P0 +digerid digerir VMM02P0 +digerir digerir VMN0000 +digiera digerir VMM03S0 +digieran digerir VMM03P0 +digiere digerir VMM02S0 +digiramos digerir VMM01P0 +digiriendo digerir VMG0000 +digitalice digitalizar VMM03S0 +digitalicemos digitalizar VMM01P0 +digitalicen digitalizar VMM03P0 +digitaliza digitalizar VMM02S0 +digitalizad digitalizar VMM02P0 +digitalizando digitalizar VMG0000 +digitalizar digitalizar VMN0000 +digna dignar VMM02S0 +dignad dignar VMM02P0 +dignando dignar VMG0000 +dignar dignar VMN0000 +digne dignar VMM03S0 +dignemos dignar VMM01P0 +dignen dignar VMM03P0 +dignifica dignificar VMM02S0 +dignificad dignificar VMM02P0 +dignificando dignificar VMG0000 +dignificar dignificar VMN0000 +dignifique dignificar VMM03S0 +dignifiquemos dignificar VMM01P0 +dignifiquen dignificar VMM03P0 +dilacera dilacerar VMM02S0 +dilacerad dilacerar VMM02P0 +dilacerando dilacerar VMG0000 +dilacerar dilacerar VMN0000 +dilacere dilacerar VMM03S0 +dilaceremos dilacerar VMM01P0 +dilaceren dilacerar VMM03P0 +dilapida dilapidar VMM02S0 +dilapidad dilapidar VMM02P0 +dilapidando dilapidar VMG0000 +dilapidar dilapidar VMN0000 +dilapide dilapidar VMM03S0 +dilapidemos dilapidar VMM01P0 +dilapiden dilapidar VMM03P0 +dilata dilatar VMM02S0 +dilatad dilatar VMM02P0 +dilatando dilatar VMG0000 +dilatar dilatar VMN0000 +dilate dilatar VMM03S0 +dilatemos dilatar VMM01P0 +dilaten dilatar VMM03P0 +diligencia diligenciar VMM02S0 +diligenciad diligenciar VMM02P0 +diligenciando diligenciar VMG0000 +diligenciar diligenciar VMN0000 +diligencie diligenciar VMM03S0 +diligenciemos diligenciar VMM01P0 +diligencien diligenciar VMM03P0 +dilucida dilucidar VMM02S0 +dilucidad dilucidar VMM02P0 +dilucidando dilucidar VMG0000 +dilucidar dilucidar VMN0000 +dilucide dilucidar VMM03S0 +dilucidemos dilucidar VMM01P0 +diluciden dilucidar VMM03P0 +diluid diluir VMM02P0 +diluir diluir VMN0000 +diluvia diluviar VMM02S0 +diluviad diluviar VMM02P0 +diluviando diluviar VMG0000 +diluviar diluviar VMN0000 +diluvie diluviar VMM03S0 +diluviemos diluviar VMM01P0 +diluvien diluviar VMM03P0 +diluya diluir VMM03S0 +diluyamos diluir VMM01P0 +diluyan diluir VMM03P0 +diluye diluir VMM02S0 +diluyendo diluir VMG0000 +dimana dimanar VMM02S0 +dimanad dimanar VMM02P0 +dimanando dimanar VMG0000 +dimanar dimanar VMN0000 +dimane dimanar VMM03S0 +dimanemos dimanar VMM01P0 +dimanen dimanar VMM03P0 +dimensiona dimensionar VMM02S0 +dimensionad dimensionar VMM02P0 +dimensionando dimensionar VMG0000 +dimensionar dimensionar VMN0000 +dimensione dimensionar VMM03S0 +dimensionemos dimensionar VMM01P0 +dimensionen dimensionar VMM03P0 +diminuid diminuir VMM02P0 +diminuir diminuir VMN0000 +diminuya diminuir VMM03S0 +diminuyamos diminuir VMM01P0 +diminuyan diminuir VMM03P0 +diminuye diminuir VMM02S0 +diminuyendo diminuir VMG0000 +dimita dimitir VMM03S0 +dimitamos dimitir VMM01P0 +dimitan dimitir VMM03P0 +dimite dimitir VMM02S0 +dimitid dimitir VMM02P0 +dimitiendo dimitir VMG0000 +dimitir dimitir VMN0000 +dinamice dinamizar VMM03S0 +dinamicemos dinamizar VMM01P0 +dinamicen dinamizar VMM03P0 +dinamita dinamitar VMM02S0 +dinamitad dinamitar VMM02P0 +dinamitando dinamitar VMG0000 +dinamitar dinamitar VMN0000 +dinamite dinamitar VMM03S0 +dinamitemos dinamitar VMM01P0 +dinamiten dinamitar VMM03P0 +dinamiza dinamizar VMM02S0 +dinamizad dinamizar VMM02P0 +dinamizando dinamizar VMG0000 +dinamizar dinamizar VMN0000 +diptonga diptongar VMM02S0 +diptongad diptongar VMM02P0 +diptongando diptongar VMG0000 +diptongar diptongar VMN0000 +diptongue diptongar VMM03S0 +diptonguemos diptongar VMM01P0 +diptonguen diptongar VMM03P0 +diputa diputar VMM02S0 +diputad diputar VMM02P0 +diputando diputar VMG0000 +diputar diputar VMN0000 +dipute diputar VMM03S0 +diputemos diputar VMM01P0 +diputen diputar VMM03P0 +diquela diquelar VMM02S0 +diquelad diquelar VMM02P0 +diquelando diquelar VMG0000 +diquelar diquelar VMN0000 +diquele diquelar VMM03S0 +diquelemos diquelar VMM01P0 +diquelen diquelar VMM03P0 +direcciona direccionar VMM02S0 +direccionad direccionar VMM02P0 +direccionando direccionar VMG0000 +direccionar direccionar VMN0000 +direccione direccionar VMM03S0 +direccionemos direccionar VMM01P0 +direccionen direccionar VMM03P0 +dirige dirigir VMM02S0 +dirigid dirigir VMM02P0 +dirigiendo dirigir VMG0000 +dirigir dirigir VMN0000 +dirija dirigir VMM03S0 +dirijamos dirigir VMM01P0 +dirijan dirigir VMM03P0 +dirima dirimir VMM03S0 +dirimamos dirimir VMM01P0 +diriman dirimir VMM03P0 +dirime dirimir VMM02S0 +dirimid dirimir VMM02P0 +dirimiendo dirimir VMG0000 +dirimir dirimir VMN0000 +discernamos discernir VMM01P0 +discernid discernir VMM02P0 +discerniendo discernir VMG0000 +discernir discernir VMN0000 +discierna discernir VMM03S0 +disciernan discernir VMM03P0 +discierne discernir VMM02S0 +disciplina disciplinar VMM02S0 +disciplinad disciplinar VMM02P0 +disciplinando disciplinar VMG0000 +disciplinar disciplinar VMN0000 +discipline disciplinar VMM03S0 +disciplinemos disciplinar VMM01P0 +disciplinen disciplinar VMM03P0 +discontinuad discontinuar VMM02P0 +discontinuando discontinuar VMG0000 +discontinuar discontinuar VMN0000 +discontinuemos discontinuar VMM01P0 +discontinúa discontinuar VMM02S0 +discontinúe discontinuar VMM03S0 +discontinúen discontinuar VMM03P0 +disconven disconvenir VMM02S0 +disconvenga disconvenir VMM03S0 +disconvengamos disconvenir VMM01P0 +disconvengan disconvenir VMM03P0 +disconvenid disconvenir VMM02P0 +disconvenir disconvenir VMN0000 +disconviniendo disconvenir VMG0000 +discordad discordar VMM02P0 +discordando discordar VMG0000 +discordar discordar VMN0000 +discordemos discordar VMM01P0 +discrepa discrepar VMM02S0 +discrepad discrepar VMM02P0 +discrepando discrepar VMG0000 +discrepar discrepar VMN0000 +discrepe discrepar VMM03S0 +discrepemos discrepar VMM01P0 +discrepen discrepar VMM03P0 +discretea discretear VMM02S0 +discretead discretear VMM02P0 +discreteando discretear VMG0000 +discretear discretear VMN0000 +discretee discretear VMM03S0 +discreteemos discretear VMM01P0 +discreteen discretear VMM03P0 +discrimina discriminar VMM02S0 +discriminad discriminar VMM02P0 +discriminando discriminar VMG0000 +discriminar discriminar VMN0000 +discrimine discriminar VMM03S0 +discriminemos discriminar VMM01P0 +discriminen discriminar VMM03P0 +discuerda discordar VMM02S0 +discuerde discordar VMM03S0 +discuerden discordar VMM03P0 +disculpa disculpar VMM02S0 +disculpad disculpar VMM02P0 +disculpando disculpar VMG0000 +disculpar disculpar VMN0000 +disculpe disculpar VMM03S0 +disculpemos disculpar VMM01P0 +disculpen disculpar VMM03P0 +discurra discurrir VMM03S0 +discurramos discurrir VMM01P0 +discurran discurrir VMM03P0 +discurre discurrir VMM02S0 +discurrid discurrir VMM02P0 +discurriendo discurrir VMG0000 +discurrir discurrir VMN0000 +discursa discursar VMM02S0 +discursad discursar VMM02P0 +discursando discursar VMG0000 +discursar discursar VMN0000 +discurse discursar VMM03S0 +discursea discursear VMM02S0 +discursead discursear VMM02P0 +discurseando discursear VMG0000 +discursear discursear VMN0000 +discursee discursear VMM03S0 +discurseemos discursear VMM01P0 +discurseen discursear VMM03P0 +discursemos discursar VMM01P0 +discursen discursar VMM03P0 +discuta discutir VMM03S0 +discutamos discutir VMM01P0 +discutan discutir VMM03P0 +discute discutir VMM02S0 +discutid discutir VMM02P0 +discutiendo discutir VMG0000 +discutir discutir VMN0000 +diseca disecar VMM02S0 +disecad disecar VMM02P0 +disecando disecar VMG0000 +disecar disecar VMN0000 +disecciona diseccionar VMM02S0 +diseccionad diseccionar VMM02P0 +diseccionando diseccionar VMG0000 +diseccionar diseccionar VMN0000 +diseccione diseccionar VMM03S0 +diseccionemos diseccionar VMM01P0 +diseccionen diseccionar VMM03P0 +disemina diseminar VMM02S0 +diseminad diseminar VMM02P0 +diseminando diseminar VMG0000 +diseminar diseminar VMN0000 +disemine diseminar VMM03S0 +diseminemos diseminar VMM01P0 +diseminen diseminar VMM03P0 +disentid disentir VMM02P0 +disentir disentir VMN0000 +diseque disecar VMM03S0 +disequemos disecar VMM01P0 +disequen disecar VMM03P0 +diserta disertar VMM02S0 +disertad disertar VMM02P0 +disertando disertar VMG0000 +disertar disertar VMN0000 +diserte disertar VMM03S0 +disertemos disertar VMM01P0 +diserten disertar VMM03P0 +diseña diseñar VMM02S0 +diseñad diseñar VMM02P0 +diseñando diseñar VMG0000 +diseñar diseñar VMN0000 +diseñe diseñar VMM03S0 +diseñemos diseñar VMM01P0 +diseñen diseñar VMM03P0 +disforma disformar VMM02S0 +disformad disformar VMM02P0 +disformando disformar VMG0000 +disformar disformar VMN0000 +disforme disformar VMM03S0 +disformemos disformar VMM01P0 +disformen disformar VMM03P0 +disfrace disfrazar VMM03S0 +disfracemos disfrazar VMM01P0 +disfracen disfrazar VMM03P0 +disfraza disfrazar VMM02S0 +disfrazad disfrazar VMM02P0 +disfrazando disfrazar VMG0000 +disfrazar disfrazar VMN0000 +disfruta disfrutar VMM02S0 +disfrutad disfrutar VMM02P0 +disfrutando disfrutar VMG0000 +disfrutar disfrutar VMN0000 +disfrute disfrutar VMM03S0 +disfrutemos disfrutar VMM01P0 +disfruten disfrutar VMM03P0 +disfuma disfumar VMM02S0 +disfumad disfumar VMM02P0 +disfumando disfumar VMG0000 +disfumar disfumar VMN0000 +disfume disfumar VMM03S0 +disfumemos disfumar VMM01P0 +disfumen disfumar VMM03P0 +disgrega disgregar VMM02S0 +disgregad disgregar VMM02P0 +disgregando disgregar VMG0000 +disgregar disgregar VMN0000 +disgregue disgregar VMM03S0 +disgreguemos disgregar VMM01P0 +disgreguen disgregar VMM03P0 +disgusta disgustar VMM02S0 +disgustad disgustar VMM02P0 +disgustando disgustar VMG0000 +disgustar disgustar VMN0000 +disguste disgustar VMM03S0 +disgustemos disgustar VMM01P0 +disgusten disgustar VMM03P0 +disida disidir VMM03S0 +disidamos disidir VMM01P0 +disidan disidir VMM03P0 +diside disidir VMM02S0 +disidid disidir VMM02P0 +disidiendo disidir VMG0000 +disidir disidir VMN0000 +disienta disentir VMM03S0 +disientan disentir VMM03P0 +disiente disentir VMM02S0 +disimila disimilar VMM02S0 +disimilad disimilar VMM02P0 +disimilando disimilar VMG0000 +disimilar disimilar VMN0000 +disimile disimilar VMM03S0 +disimilemos disimilar VMM01P0 +disimilen disimilar VMM03P0 +disimula disimular VMM02S0 +disimulad disimular VMM02P0 +disimulando disimular VMG0000 +disimular disimular VMN0000 +disimule disimular VMM03S0 +disimulemos disimular VMM01P0 +disimulen disimular VMM03P0 +disintamos disentir VMM01P0 +disintiendo disentir VMG0000 +disipa disipar VMM02S0 +disipad disipar VMM02P0 +disipando disipar VMG0000 +disipar disipar VMN0000 +disipe disipar VMM03S0 +disipemos disipar VMM01P0 +disipen disipar VMM03P0 +disloca dislocar VMM02S0 +dislocad dislocar VMM02P0 +dislocando dislocar VMG0000 +dislocar dislocar VMN0000 +disloque dislocar VMM03S0 +disloquemos dislocar VMM01P0 +disloquen dislocar VMM03P0 +disminuid disminuir VMM02P0 +disminuir disminuir VMN0000 +disminuya disminuir VMM03S0 +disminuyamos disminuir VMM01P0 +disminuyan disminuir VMM03P0 +disminuye disminuir VMM02S0 +disminuyendo disminuir VMG0000 +disocia disociar VMM02S0 +disociad disociar VMM02P0 +disociando disociar VMG0000 +disociar disociar VMN0000 +disocie disociar VMM03S0 +disociemos disociar VMM01P0 +disocien disociar VMM03P0 +disolvamos disolver VMM01P0 +disolved disolver VMM02P0 +disolver disolver VMN0000 +disolviendo disolver VMG0000 +disonad disonar VMM02P0 +disonando disonar VMG0000 +disonar disonar VMN0000 +disonemos disonar VMM01P0 +dispara disparar VMM02S0 +disparad disparar VMM02P0 +disparando disparar VMG0000 +disparar disparar VMN0000 +disparata disparatar VMM02S0 +disparatad disparatar VMM02P0 +disparatando disparatar VMG0000 +disparatar disparatar VMN0000 +disparate disparatar VMM03S0 +disparatemos disparatar VMM01P0 +disparaten disparatar VMM03P0 +dispare disparar VMM03S0 +disparemos disparar VMM01P0 +disparen disparar VMM03P0 +dispensa dispensar VMM02S0 +dispensad dispensar VMM02P0 +dispensando dispensar VMG0000 +dispensar dispensar VMN0000 +dispense dispensar VMM03S0 +dispensemos dispensar VMM01P0 +dispensen dispensar VMM03P0 +dispersa dispersar VMM02S0 +dispersad dispersar VMM02P0 +dispersando dispersar VMG0000 +dispersar dispersar VMN0000 +disperse dispersar VMM03S0 +dispersemos dispersar VMM01P0 +dispersen dispersar VMM03P0 +displace displacer VMM02S0 +displaced displacer VMM02P0 +displacer displacer VMN0000 +displaciendo displacer VMG0000 +displazca displacer VMM03S0 +displazcamos displacer VMM01P0 +displazcan displacer VMM03P0 +disponed disponer VMM02P0 +disponer disponer VMN0000 +disponga disponer VMM03S0 +dispongamos disponer VMM01P0 +dispongan disponer VMM03P0 +disponiendo disponer VMG0000 +disputa disputar VMM02S0 +disputad disputar VMM02P0 +disputando disputar VMG0000 +disputar disputar VMN0000 +dispute disputar VMM03S0 +disputemos disputar VMM01P0 +disputen disputar VMM03P0 +dispón disponer VMM02S0 +dista distar VMM02S0 +distad distar VMM02P0 +distancia distanciar VMM02S0 +distanciad distanciar VMM02P0 +distanciando distanciar VMG0000 +distanciar distanciar VMN0000 +distancie distanciar VMM03S0 +distanciemos distanciar VMM01P0 +distancien distanciar VMM03P0 +distando distar VMG0000 +distar distar VMN0000 +diste distar VMM03S0 +distemos distar VMM01P0 +disten distar VMM03P0 +distendamos distender VMM01P0 +distended distender VMM02P0 +distender distender VMN0000 +distendiendo distender VMG0000 +distienda distender VMM03S0 +distiendan distender VMM03P0 +distiende distender VMM02S0 +distinga distinguir VMM03S0 +distingamos distinguir VMM01P0 +distingan distinguir VMM03P0 +distingue distinguir VMM02S0 +distinguid distinguir VMM02P0 +distinguiendo distinguir VMG0000 +distinguir distinguir VMN0000 +distorsiona distorsionar VMM02S0 +distorsionad distorsionar VMM02P0 +distorsionando distorsionar VMG0000 +distorsionar distorsionar VMN0000 +distorsione distorsionar VMM03S0 +distorsionemos distorsionar VMM01P0 +distorsionen distorsionar VMM03P0 +distrae distraer VMM02S0 +distraed distraer VMM02P0 +distraer distraer VMN0000 +distraiga distraer VMM03S0 +distraigamos distraer VMM01P0 +distraigan distraer VMM03P0 +distrayendo distraer VMG0000 +distribuid distribuir VMM02P0 +distribuir distribuir VMN0000 +distribuya distribuir VMM03S0 +distribuyamos distribuir VMM01P0 +distribuyan distribuir VMM03P0 +distribuye distribuir VMM02S0 +distribuyendo distribuir VMG0000 +disturba disturbar VMM02S0 +disturbad disturbar VMM02P0 +disturbando disturbar VMG0000 +disturbar disturbar VMN0000 +disturbe disturbar VMM03S0 +disturbemos disturbar VMM01P0 +disturben disturbar VMM03P0 +disuada disuadir VMM03S0 +disuadamos disuadir VMM01P0 +disuadan disuadir VMM03P0 +disuade disuadir VMM02S0 +disuadid disuadir VMM02P0 +disuadiendo disuadir VMG0000 +disuadir disuadir VMN0000 +disuelva disolver VMM03S0 +disuelvan disolver VMM03P0 +disuelve disolver VMM02S0 +disuena disonar VMM02S0 +disuene disonar VMM03S0 +disuenen disonar VMM03P0 +divaga divagar VMM02S0 +divagad divagar VMM02P0 +divagando divagar VMG0000 +divagar divagar VMN0000 +divague divagar VMM03S0 +divaguemos divagar VMM01P0 +divaguen divagar VMM03P0 +diverge divergir VMM02S0 +divergid divergir VMM02P0 +divergiendo divergir VMG0000 +divergir divergir VMN0000 +diverja divergir VMM03S0 +diverjamos divergir VMM01P0 +diverjan divergir VMM03P0 +diversifica diversificar VMM02S0 +diversificad diversificar VMM02P0 +diversificando diversificar VMG0000 +diversificar diversificar VMN0000 +diversifique diversificar VMM03S0 +diversifiquemos diversificar VMM01P0 +diversifiquen diversificar VMM03P0 +divertid divertir VMM02P0 +divertir divertir VMN0000 +divida dividir VMM03S0 +dividamos dividir VMM01P0 +dividan dividir VMM03P0 +divide dividir VMM02S0 +dividid dividir VMM02P0 +dividiendo dividir VMG0000 +dividir dividir VMN0000 +divierta divertir VMM03S0 +diviertan divertir VMM03P0 +divierte divertir VMM02S0 +divinice divinizar VMM03S0 +divinicemos divinizar VMM01P0 +divinicen divinizar VMM03P0 +diviniza divinizar VMM02S0 +divinizad divinizar VMM02P0 +divinizando divinizar VMG0000 +divinizar divinizar VMN0000 +divirtamos divertir VMM01P0 +divirtiendo divertir VMG0000 +divisa divisar VMM02S0 +divisad divisar VMM02P0 +divisando divisar VMG0000 +divisar divisar VMN0000 +divise divisar VMM03S0 +divisemos divisar VMM01P0 +divisen divisar VMM03P0 +divorcia divorciar VMM02S0 +divorciad divorciar VMM02P0 +divorciando divorciar VMG0000 +divorciar divorciar VMN0000 +divorcie divorciar VMM03S0 +divorciemos divorciar VMM01P0 +divorcien divorciar VMM03P0 +divulga divulgar VMM02S0 +divulgad divulgar VMM02P0 +divulgando divulgar VMG0000 +divulgar divulgar VMN0000 +divulgue divulgar VMM03S0 +divulguemos divulgar VMM01P0 +divulguen divulgar VMM03P0 +diña diñar VMM02S0 +diñad diñar VMM02P0 +diñando diñar VMG0000 +diñar diñar VMN0000 +diñe diñar VMM03S0 +diñemos diñar VMM01P0 +diñen diñar VMM03P0 +dobla doblar VMM02S0 +doblad doblar VMM02P0 +dobladilla dobladillar VMM02S0 +dobladillad dobladillar VMM02P0 +dobladillando dobladillar VMG0000 +dobladillar dobladillar VMN0000 +dobladille dobladillar VMM03S0 +dobladillemos dobladillar VMM01P0 +dobladillen dobladillar VMM03P0 +doblando doblar VMG0000 +doblar doblar VMN0000 +doble doblar VMM03S0 +doblega doblegar VMM02S0 +doblegad doblegar VMM02P0 +doblegando doblegar VMG0000 +doblegar doblegar VMN0000 +doblegue doblegar VMM03S0 +dobleguemos doblegar VMM01P0 +dobleguen doblegar VMM03P0 +doblemos doblar VMM01P0 +doblen doblar VMM03P0 +docilita docilitar VMM02S0 +docilitad docilitar VMM02P0 +docilitando docilitar VMG0000 +docilitar docilitar VMN0000 +docilite docilitar VMM03S0 +docilitemos docilitar VMM01P0 +dociliten docilitar VMM03P0 +doctora doctorar VMM02S0 +doctorad doctorar VMM02P0 +doctorando doctorar VMG0000 +doctorar doctorar VMN0000 +doctore doctorar VMM03S0 +doctorea doctorear VMM02S0 +doctoread doctorear VMM02P0 +doctoreando doctorear VMG0000 +doctorear doctorear VMN0000 +doctoremos doctorar VMM01P0 +doctoren doctorar VMM03P0 +doctrina doctrinar VMM02S0 +doctrinad doctrinar VMM02P0 +doctrinando doctrinar VMG0000 +doctrinar doctrinar VMN0000 +doctrine doctrinar VMM03S0 +doctrinemos doctrinar VMM01P0 +doctrinen doctrinar VMM03P0 +documenta documentar VMM02S0 +documentad documentar VMM02P0 +documentando documentar VMG0000 +documentar documentar VMN0000 +documente documentar VMM03S0 +documentemos documentar VMM01P0 +documenten documentar VMM03P0 +dogmatice dogmatizar VMM03S0 +dogmaticemos dogmatizar VMM01P0 +dogmaticen dogmatizar VMM03P0 +dogmatiza dogmatizar VMM02S0 +dogmatizad dogmatizar VMM02P0 +dogmatizando dogmatizar VMG0000 +dogmatizar dogmatizar VMN0000 +dolad dolar VMM02P0 +dolamos doler VMM01P0 +dolando dolar VMG0000 +dolar dolar VMN0000 +doled doler VMM02P0 +dolemos dolar VMM01P0 +doler doler VMN0000 +doliendo doler VMG0000 +doma domar VMM02S0 +domad domar VMM02P0 +domando domar VMG0000 +domar domar VMN0000 +dome domar VMM03S0 +domemos domar VMM01P0 +domen domar VMM03P0 +domestica domesticar VMM02S0 +domesticad domesticar VMM02P0 +domesticando domesticar VMG0000 +domesticar domesticar VMN0000 +domestique domesticar VMM03S0 +domestiquemos domesticar VMM01P0 +domestiquen domesticar VMM03P0 +domeña domeñar VMM02S0 +domeñad domeñar VMM02P0 +domeñando domeñar VMG0000 +domeñar domeñar VMN0000 +domeñe domeñar VMM03S0 +domeñemos domeñar VMM01P0 +domeñen domeñar VMM03P0 +domicilia domiciliar VMM02S0 +domiciliad domiciliar VMM02P0 +domiciliando domiciliar VMG0000 +domiciliar domiciliar VMN0000 +domicilie domiciliar VMM03S0 +domiciliemos domiciliar VMM01P0 +domicilien domiciliar VMM03P0 +domina dominar VMM02S0 +dominad dominar VMM02P0 +dominando dominar VMG0000 +dominar dominar VMN0000 +domine dominar VMM03S0 +dominemos dominar VMM01P0 +dominen dominar VMM03P0 +dona donar VMM02S0 +donad donar VMM02P0 +donando donar VMG0000 +donar donar VMN0000 +done donar VMM03S0 +donemos donar VMM01P0 +donen donar VMM03P0 +dopa dopar VMM02S0 +dopad dopar VMM02P0 +dopando dopar VMG0000 +dopar dopar VMN0000 +dope dopar VMM03S0 +dopemos dopar VMM01P0 +dopen dopar VMM03P0 +dora dorar VMM02S0 +dorad dorar VMM02P0 +dorando dorar VMG0000 +dorar dorar VMN0000 +dore dorar VMM03S0 +doremos dorar VMM01P0 +doren dorar VMM03P0 +dormid dormir VMM02P0 +dormir dormir VMN0000 +dormita dormitar VMM02S0 +dormitad dormitar VMM02P0 +dormitando dormitar VMG0000 +dormitar dormitar VMN0000 +dormite dormitar VMM03S0 +dormitemos dormitar VMM01P0 +dormiten dormitar VMM03P0 +dosifica dosificar VMM02S0 +dosificad dosificar VMM02P0 +dosificando dosificar VMG0000 +dosificar dosificar VMN0000 +dosifique dosificar VMM03S0 +dosifiquemos dosificar VMM01P0 +dosifiquen dosificar VMM03P0 +dota dotar VMM02S0 +dotad dotar VMM02P0 +dotando dotar VMG0000 +dotar dotar VMN0000 +dote dotar VMM03S0 +dotemos dotar VMM01P0 +doten dotar VMM03P0 +dovela dovelar VMM02S0 +dovelad dovelar VMM02P0 +dovelando dovelar VMG0000 +dovelar dovelar VMN0000 +dovele dovelar VMM03S0 +dovelemos dovelar VMM01P0 +dovelen dovelar VMM03P0 +draga dragar VMM02S0 +dragad dragar VMM02P0 +dragando dragar VMG0000 +dragar dragar VMN0000 +dragonea dragonear VMM02S0 +dragonead dragonear VMM02P0 +dragoneando dragonear VMG0000 +dragonear dragonear VMN0000 +dragonee dragonear VMM03S0 +dragoneemos dragonear VMM01P0 +dragoneen dragonear VMM03P0 +drague dragar VMM03S0 +draguemos dragar VMM01P0 +draguen dragar VMM03P0 +dramatice dramatizar VMM03S0 +dramaticemos dramatizar VMM01P0 +dramaticen dramatizar VMM03P0 +dramatiza dramatizar VMM02S0 +dramatizad dramatizar VMM02P0 +dramatizando dramatizar VMG0000 +dramatizar dramatizar VMN0000 +drapea drapear VMM02S0 +drapead drapear VMM02P0 +drapeando drapear VMG0000 +drapear drapear VMN0000 +drapee drapear VMM03S0 +drapeemos drapear VMM01P0 +drapeen drapear VMM03P0 +drena drenar VMM02S0 +drenad drenar VMM02P0 +drenando drenar VMG0000 +drenar drenar VMN0000 +drene drenar VMM03S0 +drenemos drenar VMM01P0 +drenen drenar VMM03P0 +dribla driblar VMM02S0 +driblad driblar VMM02P0 +driblando driblar VMG0000 +driblar driblar VMN0000 +drible driblar VMM03S0 +driblemos driblar VMM01P0 +driblen driblar VMM03P0 +drice drizar VMM03S0 +dricemos drizar VMM01P0 +dricen drizar VMM03P0 +driza drizar VMM02S0 +drizad drizar VMM02P0 +drizando drizar VMG0000 +drizar drizar VMN0000 +droga drogar VMM02S0 +drogad drogar VMM02P0 +drogando drogar VMG0000 +drogar drogar VMN0000 +drogue drogar VMM03S0 +droguemos drogar VMM01P0 +droguen drogar VMM03P0 +ducha duchar VMM02S0 +duchad duchar VMM02P0 +duchando duchar VMG0000 +duchar duchar VMN0000 +duche duchar VMM03S0 +duchemos duchar VMM01P0 +duchen duchar VMM03P0 +duda dudar VMM02S0 +dudad dudar VMM02P0 +dudando dudar VMG0000 +dudar dudar VMN0000 +dude dudar VMM03S0 +dudemos dudar VMM01P0 +duden dudar VMM03P0 +duela dolar VMM02S0 +duela doler VMM03S0 +duelan doler VMM03P0 +duele dolar VMM03S0 +duele doler VMM02S0 +duelen dolar VMM03P0 +duerma dormir VMM03S0 +duerman dormir VMM03P0 +duerme dormir VMM02S0 +dulcifica dulcificar VMM02S0 +dulcificad dulcificar VMM02P0 +dulcificando dulcificar VMG0000 +dulcificar dulcificar VMN0000 +dulcifique dulcificar VMM03S0 +dulcifiquemos dulcificar VMM01P0 +dulcifiquen dulcificar VMM03P0 +duplica duplicar VMM02S0 +duplicad duplicar VMM02P0 +duplicando duplicar VMG0000 +duplicar duplicar VMN0000 +duplique duplicar VMM03S0 +dupliquemos duplicar VMM01P0 +dupliquen duplicar VMM03P0 +dura durar VMM02S0 +durad durar VMM02P0 +durando durar VMG0000 +durar durar VMN0000 +dure durar VMM03S0 +duremos durar VMM01P0 +duren durar VMM03P0 +durmamos dormir VMM01P0 +durmiendo dormir VMG0000 +dé dar VMM03S0 +echa echar VMM02S0 +echad echar VMM02P0 +echando echar VMG0000 +echar echar VMN0000 +eche echar VMM03S0 +echemos echar VMM01P0 +echen echar VMM03P0 +eclipsa eclipsar VMM02S0 +eclipsad eclipsar VMM02P0 +eclipsando eclipsar VMG0000 +eclipsar eclipsar VMN0000 +eclipse eclipsar VMM03S0 +eclipsemos eclipsar VMM01P0 +eclipsen eclipsar VMM03P0 +economice economizar VMM03S0 +economicemos economizar VMM01P0 +economicen economizar VMM03P0 +economiza economizar VMM02S0 +economizad economizar VMM02P0 +economizando economizar VMG0000 +economizar economizar VMN0000 +ecualice ecualizar VMM03S0 +ecualicemos ecualizar VMM01P0 +ecualicen ecualizar VMM03P0 +ecualiza ecualizar VMM02S0 +ecualizad ecualizar VMM02P0 +ecualizando ecualizar VMG0000 +ecualizar ecualizar VMN0000 +edifica edificar VMM02S0 +edificad edificar VMM02P0 +edificando edificar VMG0000 +edificar edificar VMN0000 +edifique edificar VMM03S0 +edifiquemos edificar VMM01P0 +edifiquen edificar VMM03P0 +edita editar VMM02S0 +editad editar VMM02P0 +editando editar VMG0000 +editar editar VMN0000 +edite editar VMM03S0 +editemos editar VMM01P0 +editen editar VMM03P0 +editorialice editorializar VMM03S0 +editorialicemos editorializar VMM01P0 +editorialicen editorializar VMM03P0 +editorializa editorializar VMM02S0 +editorializad editorializar VMM02P0 +editorializando editorializar VMG0000 +editorializar editorializar VMN0000 +educa educar VMM02S0 +educad educar VMM02P0 +educando educar VMG0000 +educar educar VMN0000 +edulcora edulcorar VMM02S0 +edulcorad edulcorar VMM02P0 +edulcorando edulcorar VMG0000 +edulcorar edulcorar VMN0000 +edulcore edulcorar VMM03S0 +edulcoremos edulcorar VMM01P0 +edulcoren edulcorar VMM03P0 +eduque educar VMM03S0 +eduquemos educar VMM01P0 +eduquen educar VMM03P0 +efectuad efectuar VMM02P0 +efectuando efectuar VMG0000 +efectuar efectuar VMN0000 +efectuemos efectuar VMM01P0 +efectúa efectuar VMM02S0 +efectúe efectuar VMM03S0 +efectúen efectuar VMM03P0 +eflorece eflorecer VMM02S0 +efloreced eflorecer VMM02P0 +eflorecer eflorecer VMN0000 +efloreciendo eflorecer VMG0000 +eflorezca eflorecer VMM03S0 +eflorezcamos eflorecer VMM01P0 +eflorezcan eflorecer VMM03P0 +egresa egresar VMM02S0 +egresad egresar VMM02P0 +egresando egresar VMG0000 +egresar egresar VMN0000 +egrese egresar VMM03S0 +egresemos egresar VMM01P0 +egresen egresar VMM03P0 +ejecuta ejecutar VMM02S0 +ejecutad ejecutar VMM02P0 +ejecutando ejecutar VMG0000 +ejecutar ejecutar VMN0000 +ejecute ejecutar VMM03S0 +ejecutemos ejecutar VMM01P0 +ejecuten ejecutar VMM03P0 +ejecutoriad ejecutoriar VMM02P0 +ejecutoriando ejecutoriar VMG0000 +ejecutoriar ejecutoriar VMN0000 +ejecutoriemos ejecutoriar VMM01P0 +ejecutoría ejecutoriar VMM02S0 +ejecutoríe ejecutoriar VMM03S0 +ejecutoríen ejecutoriar VMM03P0 +ejemplarice ejemplarizar VMM03S0 +ejemplaricemos ejemplarizar VMM01P0 +ejemplaricen ejemplarizar VMM03P0 +ejemplariza ejemplarizar VMM02S0 +ejemplarizad ejemplarizar VMM02P0 +ejemplarizando ejemplarizar VMG0000 +ejemplarizar ejemplarizar VMN0000 +ejemplifica ejemplificar VMM02S0 +ejemplificad ejemplificar VMM02P0 +ejemplificando ejemplificar VMG0000 +ejemplificar ejemplificar VMN0000 +ejemplifique ejemplificar VMM03S0 +ejemplifiquemos ejemplificar VMM01P0 +ejemplifiquen ejemplificar VMM03P0 +ejerce ejercer VMM02S0 +ejerced ejercer VMM02P0 +ejercer ejercer VMN0000 +ejerciendo ejercer VMG0000 +ejercita ejercitar VMM02S0 +ejercitad ejercitar VMM02P0 +ejercitando ejercitar VMG0000 +ejercitar ejercitar VMN0000 +ejercite ejercitar VMM03S0 +ejercitemos ejercitar VMM01P0 +ejerciten ejercitar VMM03P0 +ejerza ejercer VMM03S0 +ejerzamos ejercer VMM01P0 +ejerzan ejercer VMM03P0 +elabora elaborar VMM02S0 +elaborad elaborar VMM02P0 +elaborando elaborar VMG0000 +elaborar elaborar VMN0000 +elabore elaborar VMM03S0 +elaboremos elaborar VMM01P0 +elaboren elaborar VMM03P0 +electrice electrizar VMM03S0 +electricemos electrizar VMM01P0 +electricen electrizar VMM03P0 +electrifica electrificar VMM02S0 +electrificad electrificar VMM02P0 +electrificando electrificar VMG0000 +electrificar electrificar VMN0000 +electrifique electrificar VMM03S0 +electrifiquemos electrificar VMM01P0 +electrifiquen electrificar VMM03P0 +electriza electrizar VMM02S0 +electrizad electrizar VMM02P0 +electrizando electrizar VMG0000 +electrizar electrizar VMN0000 +electrocuta electrocutar VMM02S0 +electrocutad electrocutar VMM02P0 +electrocutando electrocutar VMG0000 +electrocutar electrocutar VMN0000 +electrocute electrocutar VMM03S0 +electrocutemos electrocutar VMM01P0 +electrocuten electrocutar VMM03P0 +electrolice electrolizar VMM03S0 +electrolicemos electrolizar VMM01P0 +electrolicen electrolizar VMM03P0 +electroliza electrolizar VMM02S0 +electrolizad electrolizar VMM02P0 +electrolizando electrolizar VMG0000 +electrolizar electrolizar VMN0000 +elegantice elegantizar VMM03S0 +eleganticemos elegantizar VMM01P0 +eleganticen elegantizar VMM03P0 +elegantiza elegantizar VMM02S0 +elegantizad elegantizar VMM02P0 +elegantizando elegantizar VMG0000 +elegantizar elegantizar VMN0000 +elegid elegir VMM02P0 +elegir elegir VMN0000 +elementa elementar VMM02S0 +elementad elementar VMM02P0 +elementando elementar VMG0000 +elementar elementar VMN0000 +elemente elementar VMM03S0 +elementemos elementar VMM01P0 +elementen elementar VMM03P0 +eleva elevar VMM02S0 +elevad elevar VMM02P0 +elevando elevar VMG0000 +elevar elevar VMN0000 +eleve elevar VMM03S0 +elevemos elevar VMM01P0 +eleven elevar VMM03P0 +elida elidir VMM03S0 +elidamos elidir VMM01P0 +elidan elidir VMM03P0 +elide elidir VMM02S0 +elidid elidir VMM02P0 +elidiendo elidir VMG0000 +elidir elidir VMN0000 +elige elegir VMM02S0 +eligiendo elegir VMG0000 +elija elegir VMM03S0 +elijamos elegir VMM01P0 +elijan elegir VMM03P0 +elimina eliminar VMM02S0 +eliminad eliminar VMM02P0 +eliminando eliminar VMG0000 +eliminar eliminar VMN0000 +elimine eliminar VMM03S0 +eliminemos eliminar VMM01P0 +eliminen eliminar VMM03P0 +elogia elogiar VMM02S0 +elogiad elogiar VMM02P0 +elogiando elogiar VMG0000 +elogiar elogiar VMN0000 +elogie elogiar VMM03S0 +elogiemos elogiar VMM01P0 +elogien elogiar VMM03P0 +elucida elucidar VMM02S0 +elucidad elucidar VMM02P0 +elucidando elucidar VMG0000 +elucidar elucidar VMN0000 +elucide elucidar VMM03S0 +elucidemos elucidar VMM01P0 +eluciden elucidar VMM03P0 +elucubra elucubrar VMM02S0 +elucubrad elucubrar VMM02P0 +elucubrando elucubrar VMG0000 +elucubrar elucubrar VMN0000 +elucubre elucubrar VMM03S0 +elucubremos elucubrar VMM01P0 +elucubren elucubrar VMM03P0 +eluda eludir VMM03S0 +eludamos eludir VMM01P0 +eludan eludir VMM03P0 +elude eludir VMM02S0 +eludid eludir VMM02P0 +eludiendo eludir VMG0000 +eludir eludir VMN0000 +emana emanar VMM02S0 +emanad emanar VMM02P0 +emanando emanar VMG0000 +emanar emanar VMN0000 +emancipa emancipar VMM02S0 +emancipad emancipar VMM02P0 +emancipando emancipar VMG0000 +emancipar emancipar VMN0000 +emancipe emancipar VMM03S0 +emancipemos emancipar VMM01P0 +emancipen emancipar VMM03P0 +emane emanar VMM03S0 +emanemos emanar VMM01P0 +emanen emanar VMM03P0 +emascula emascular VMM02S0 +emasculad emascular VMM02P0 +emasculando emascular VMG0000 +emascular emascular VMN0000 +emascule emascular VMM03S0 +emasculemos emascular VMM01P0 +emasculen emascular VMM03P0 +embabuca embabucar VMM02S0 +embabucad embabucar VMM02P0 +embabucando embabucar VMG0000 +embabucar embabucar VMN0000 +embabuque embabucar VMM03S0 +embabuquemos embabucar VMM01P0 +embabuquen embabucar VMM03P0 +embace embazar VMM03S0 +embacemos embazar VMM01P0 +embacen embazar VMM03P0 +embadurna embadurnar VMM02S0 +embadurnad embadurnar VMM02P0 +embadurnando embadurnar VMG0000 +embadurnar embadurnar VMN0000 +embadurne embadurnar VMM03S0 +embadurnemos embadurnar VMM01P0 +embadurnen embadurnar VMM03P0 +embala embalar VMM02S0 +embalad embalar VMM02P0 +embalando embalar VMG0000 +embalar embalar VMN0000 +embaldosa embaldosar VMM02S0 +embaldosad embaldosar VMM02P0 +embaldosando embaldosar VMG0000 +embaldosar embaldosar VMN0000 +embaldose embaldosar VMM03S0 +embaldosemos embaldosar VMM01P0 +embaldosen embaldosar VMM03P0 +embale embalar VMM03S0 +embalemos embalar VMM01P0 +embalen embalar VMM03P0 +emballena emballenar VMM02S0 +emballenad emballenar VMM02P0 +emballenando emballenar VMG0000 +emballenar emballenar VMN0000 +emballene emballenar VMM03S0 +emballenemos emballenar VMM01P0 +emballenen emballenar VMM03P0 +embalsa embalsar VMM02S0 +embalsad embalsar VMM02P0 +embalsama embalsamar VMM02S0 +embalsamad embalsamar VMM02P0 +embalsamando embalsamar VMG0000 +embalsamar embalsamar VMN0000 +embalsame embalsamar VMM03S0 +embalsamemos embalsamar VMM01P0 +embalsamen embalsamar VMM03P0 +embalsando embalsar VMG0000 +embalsar embalsar VMN0000 +embalse embalsar VMM03S0 +embalsemos embalsar VMM01P0 +embalsen embalsar VMM03P0 +embanasta embanastar VMM02S0 +embanastad embanastar VMM02P0 +embanastando embanastar VMG0000 +embanastar embanastar VMN0000 +embanaste embanastar VMM03S0 +embanastemos embanastar VMM01P0 +embanasten embanastar VMM03P0 +embanca embancar VMM02S0 +embancad embancar VMM02P0 +embancando embancar VMG0000 +embancar embancar VMN0000 +embandera embanderar VMM02S0 +embanderad embanderar VMM02P0 +embanderando embanderar VMG0000 +embanderar embanderar VMN0000 +embandere embanderar VMM03S0 +embanderemos embanderar VMM01P0 +embanderen embanderar VMM03P0 +embanque embancar VMM03S0 +embanquemos embancar VMM01P0 +embanquen embancar VMM03P0 +embarace embarazar VMM03S0 +embaracemos embarazar VMM01P0 +embaracen embarazar VMM03P0 +embaraza embarazar VMM02S0 +embarazad embarazar VMM02P0 +embarazando embarazar VMG0000 +embarazar embarazar VMN0000 +embarbasca embarbascar VMM02S0 +embarbascad embarbascar VMM02P0 +embarbascando embarbascar VMG0000 +embarbascar embarbascar VMN0000 +embarbasque embarbascar VMM03S0 +embarbasquemos embarbascar VMM01P0 +embarbasquen embarbascar VMM03P0 +embarbece embarbecer VMM02S0 +embarbeced embarbecer VMM02P0 +embarbecer embarbecer VMN0000 +embarbeciendo embarbecer VMG0000 +embarbezca embarbecer VMM03S0 +embarbezcamos embarbecer VMM01P0 +embarbezcan embarbecer VMM03P0 +embarbilla embarbillar VMM02S0 +embarbillad embarbillar VMM02P0 +embarbillando embarbillar VMG0000 +embarbillar embarbillar VMN0000 +embarbille embarbillar VMM03S0 +embarbillemos embarbillar VMM01P0 +embarbillen embarbillar VMM03P0 +embarca embarcar VMM02S0 +embarcad embarcar VMM02P0 +embarcando embarcar VMG0000 +embarcar embarcar VMN0000 +embarga embargar VMM02S0 +embargad embargar VMM02P0 +embargando embargar VMG0000 +embargar embargar VMN0000 +embargue embargar VMM03S0 +embarguemos embargar VMM01P0 +embarguen embargar VMM03P0 +embarnice embarnizar VMM03S0 +embarnicemos embarnizar VMM01P0 +embarnicen embarnizar VMM03P0 +embarniza embarnizar VMM02S0 +embarnizad embarnizar VMM02P0 +embarnizando embarnizar VMG0000 +embarnizar embarnizar VMN0000 +embarque embarcar VMM03S0 +embarquemos embarcar VMM01P0 +embarquen embarcar VMM03P0 +embarra embarrar VMM02S0 +embarrad embarrar VMM02P0 +embarranca embarrancar VMM02S0 +embarrancad embarrancar VMM02P0 +embarrancando embarrancar VMG0000 +embarrancar embarrancar VMN0000 +embarrando embarrar VMG0000 +embarranque embarrancar VMM03S0 +embarranquemos embarrancar VMM01P0 +embarranquen embarrancar VMM03P0 +embarrar embarrar VMN0000 +embarre embarrar VMM03S0 +embarremos embarrar VMM01P0 +embarren embarrar VMM03P0 +embarrila embarrilar VMM02S0 +embarrilad embarrilar VMM02P0 +embarrilando embarrilar VMG0000 +embarrilar embarrilar VMN0000 +embarrile embarrilar VMM03S0 +embarrilemos embarrilar VMM01P0 +embarrilen embarrilar VMM03P0 +embarulla embarullar VMM02S0 +embarullad embarullar VMM02P0 +embarullando embarullar VMG0000 +embarullar embarullar VMN0000 +embarulle embarullar VMM03S0 +embarullemos embarullar VMM01P0 +embarullen embarullar VMM03P0 +embasta embastar VMM02S0 +embastad embastar VMM02P0 +embastando embastar VMG0000 +embastar embastar VMN0000 +embaste embastar VMM03S0 +embastece embastecer VMM02S0 +embasteced embastecer VMM02P0 +embastecer embastecer VMN0000 +embasteciendo embastecer VMG0000 +embastemos embastar VMM01P0 +embasten embastar VMM03P0 +embastezca embastecer VMM03S0 +embastezcamos embastecer VMM01P0 +embastezcan embastecer VMM03P0 +embauca embaucar VMM02S0 +embaucad embaucar VMM02P0 +embaucando embaucar VMG0000 +embaucar embaucar VMN0000 +embaula embaular VMM02S0 +embaulad embaular VMM02P0 +embaulando embaular VMG0000 +embaular embaular VMN0000 +embaule embaular VMM03S0 +embaulemos embaular VMM01P0 +embaulen embaular VMM03P0 +embauque embaucar VMM03S0 +embauquemos embaucar VMM01P0 +embauquen embaucar VMM03P0 +embayendo embair VMG0000 +embaza embazar VMM02S0 +embazad embazar VMM02P0 +embazando embazar VMG0000 +embazar embazar VMN0000 +embaíd embair VMM02P0 +embaír embair VMN0000 +embeba embeber VMM03S0 +embebamos embeber VMM01P0 +embeban embeber VMM03P0 +embebe embeber VMM02S0 +embebece embebecer VMM02S0 +embebeced embebecer VMM02P0 +embebecer embebecer VMN0000 +embebeciendo embebecer VMG0000 +embebed embeber VMM02P0 +embeber embeber VMN0000 +embebezca embebecer VMM03S0 +embebezcamos embebecer VMM01P0 +embebezcan embebecer VMM03P0 +embebiendo embeber VMG0000 +embeleca embelecar VMM02S0 +embelecad embelecar VMM02P0 +embelecando embelecar VMG0000 +embelecar embelecar VMN0000 +embeleque embelecar VMM03S0 +embelequemos embelecar VMM01P0 +embelequen embelecar VMM03P0 +embelesa embelesar VMM02S0 +embelesad embelesar VMM02P0 +embelesando embelesar VMG0000 +embelesar embelesar VMN0000 +embelese embelesar VMM03S0 +embelesemos embelesar VMM01P0 +embelesen embelesar VMM03P0 +embellaquece embellaquecer VMM02S0 +embellaqueced embellaquecer VMM02P0 +embellaquecer embellaquecer VMN0000 +embellaqueciendo embellaquecer VMG0000 +embellaquezca embellaquecer VMM03S0 +embellaquezcamos embellaquecer VMM01P0 +embellaquezcan embellaquecer VMM03P0 +embellece embellecer VMM02S0 +embelleced embellecer VMM02P0 +embellecer embellecer VMN0000 +embelleciendo embellecer VMG0000 +embellezca embellecer VMM03S0 +embellezcamos embellecer VMM01P0 +embellezcan embellecer VMM03P0 +embermeja embermejar VMM02S0 +embermejad embermejar VMM02P0 +embermejando embermejar VMG0000 +embermejar embermejar VMN0000 +embermeje embermejar VMM03S0 +embermejece embermejecer VMM02S0 +embermejeced embermejecer VMM02P0 +embermejecer embermejecer VMN0000 +embermejeciendo embermejecer VMG0000 +embermejemos embermejar VMM01P0 +embermejen embermejar VMM03P0 +embermejezca embermejecer VMM03S0 +embermejezcamos embermejecer VMM01P0 +embermejezcan embermejecer VMM03P0 +emberrenchina emberrenchinar VMM02S0 +emberrenchinad emberrenchinar VMM02P0 +emberrenchinando emberrenchinar VMG0000 +emberrenchinar emberrenchinar VMN0000 +emberrenchine emberrenchinar VMM03S0 +emberrenchinemos emberrenchinar VMM01P0 +emberrenchinen emberrenchinar VMM03P0 +emberrincha emberrinchar VMM02S0 +emberrinchad emberrinchar VMM02P0 +emberrinchando emberrinchar VMG0000 +emberrinchar emberrinchar VMN0000 +emberrinche emberrinchar VMM03S0 +emberrinchemos emberrinchar VMM01P0 +emberrinchen emberrinchar VMM03P0 +embestid embestir VMM02P0 +embestir embestir VMN0000 +embetuna embetunar VMM02S0 +embetunad embetunar VMM02P0 +embetunando embetunar VMG0000 +embetunar embetunar VMN0000 +embetune embetunar VMM03S0 +embetunemos embetunar VMM01P0 +embetunen embetunar VMM03P0 +embica embicar VMM02S0 +embicad embicar VMM02P0 +embicando embicar VMG0000 +embicar embicar VMN0000 +embija embijar VMM02S0 +embijad embijar VMM02P0 +embijando embijar VMG0000 +embijar embijar VMN0000 +embije embijar VMM03S0 +embijemos embijar VMM01P0 +embijen embijar VMM03P0 +embique embicar VMM03S0 +embiquemos embicar VMM01P0 +embiquen embicar VMM03P0 +embista embestir VMM03S0 +embistamos embestir VMM01P0 +embistan embestir VMM03P0 +embiste embestir VMM02S0 +embistiendo embestir VMG0000 +embizca embizcar VMM02S0 +embizcad embizcar VMM02P0 +embizcando embizcar VMG0000 +embizcar embizcar VMN0000 +embizque embizcar VMM03S0 +embizquemos embizcar VMM01P0 +embizquen embizcar VMM03P0 +emblandece emblandecer VMM02S0 +emblandeced emblandecer VMM02P0 +emblandecer emblandecer VMN0000 +emblandeciendo emblandecer VMG0000 +emblandezca emblandecer VMM03S0 +emblandezcamos emblandecer VMM01P0 +emblandezcan emblandecer VMM03P0 +emblanquece emblanquecer VMM02S0 +emblanqueced emblanquecer VMM02P0 +emblanquecer emblanquecer VMN0000 +emblanqueciendo emblanquecer VMG0000 +emblanquezca emblanquecer VMM03S0 +emblanquezcamos emblanquecer VMM01P0 +emblanquezcan emblanquecer VMM03P0 +emboba embobar VMM02S0 +embobad embobar VMM02P0 +embobando embobar VMG0000 +embobar embobar VMN0000 +embobe embobar VMM03S0 +embobece embobecer VMM02S0 +embobeced embobecer VMM02P0 +embobecer embobecer VMN0000 +embobeciendo embobecer VMG0000 +embobemos embobar VMM01P0 +emboben embobar VMM03P0 +embobezca embobecer VMM03S0 +embobezcamos embobecer VMM01P0 +embobezcan embobecer VMM03P0 +emboca embocar VMM02S0 +embocad embocar VMM02P0 +embocando embocar VMG0000 +embocar embocar VMN0000 +emboce embozar VMM03S0 +embocemos embozar VMM01P0 +embocen embozar VMM03P0 +embodega embodegar VMM02S0 +embodegad embodegar VMM02P0 +embodegando embodegar VMG0000 +embodegar embodegar VMN0000 +embodegue embodegar VMM03S0 +embodeguemos embodegar VMM01P0 +embodeguen embodegar VMM03P0 +emboja embojar VMM02S0 +embojad embojar VMM02P0 +embojando embojar VMG0000 +embojar embojar VMN0000 +emboje embojar VMM03S0 +embojemos embojar VMM01P0 +embojen embojar VMM03P0 +embola embolar VMM02S0 +embolad embolar VMM02P0 +embolando embolar VMG0000 +embolar embolar VMN0000 +embole embolar VMM03S0 +embolemos embolar VMM01P0 +embolen embolar VMM03P0 +embolisma embolismar VMM02S0 +embolismad embolismar VMM02P0 +embolismando embolismar VMG0000 +embolismar embolismar VMN0000 +embolisme embolismar VMM03S0 +embolismemos embolismar VMM01P0 +embolismen embolismar VMM03P0 +embolsa embolsar VMM02S0 +embolsad embolsar VMM02P0 +embolsando embolsar VMG0000 +embolsar embolsar VMN0000 +embolse embolsar VMM03S0 +embolsemos embolsar VMM01P0 +embolsen embolsar VMM03P0 +embona embonar VMM02S0 +embonad embonar VMM02P0 +embonando embonar VMG0000 +embonar embonar VMN0000 +embone embonar VMM03S0 +embonemos embonar VMM01P0 +embonen embonar VMM03P0 +emboque embocar VMM03S0 +emboquemos embocar VMM01P0 +emboquen embocar VMM03P0 +emboquilla emboquillar VMM02S0 +emboquillad emboquillar VMM02P0 +emboquillando emboquillar VMG0000 +emboquillar emboquillar VMN0000 +emboquille emboquillar VMM03S0 +emboquillemos emboquillar VMM01P0 +emboquillen emboquillar VMM03P0 +emborra emborrar VMM02S0 +emborrace emborrazar VMM03S0 +emborracemos emborrazar VMM01P0 +emborracen emborrazar VMM03P0 +emborracha emborrachar VMM02S0 +emborrachad emborrachar VMM02P0 +emborrachando emborrachar VMG0000 +emborrachar emborrachar VMN0000 +emborrache emborrachar VMM03S0 +emborrachemos emborrachar VMM01P0 +emborrachen emborrachar VMM03P0 +emborrad emborrar VMM02P0 +emborrando emborrar VMG0000 +emborrar emborrar VMN0000 +emborrasca emborrascar VMM02S0 +emborrascad emborrascar VMM02P0 +emborrascando emborrascar VMG0000 +emborrascar emborrascar VMN0000 +emborrasque emborrascar VMM03S0 +emborrasquemos emborrascar VMM01P0 +emborrasquen emborrascar VMM03P0 +emborraza emborrazar VMM02S0 +emborrazad emborrazar VMM02P0 +emborrazando emborrazar VMG0000 +emborrazar emborrazar VMN0000 +emborre emborrar VMM03S0 +emborremos emborrar VMM01P0 +emborren emborrar VMM03P0 +emborrice emborrizar VMM03S0 +emborricemos emborrizar VMM01P0 +emborricen emborrizar VMM03P0 +emborriza emborrizar VMM02S0 +emborrizad emborrizar VMM02P0 +emborrizando emborrizar VMG0000 +emborrizar emborrizar VMN0000 +emborrona emborronar VMM02S0 +emborronad emborronar VMM02P0 +emborronando emborronar VMG0000 +emborronar emborronar VMN0000 +emborrone emborronar VMM03S0 +emborronemos emborronar VMM01P0 +emborronen emborronar VMM03P0 +embosca emboscar VMM02S0 +emboscad emboscar VMM02P0 +emboscando emboscar VMG0000 +emboscar emboscar VMN0000 +embosque emboscar VMM03S0 +embosquece embosquecer VMM02S0 +embosqueced embosquecer VMM02P0 +embosquecer embosquecer VMN0000 +embosqueciendo embosquecer VMG0000 +embosquemos emboscar VMM01P0 +embosquen emboscar VMM03P0 +embosquezca embosquecer VMM03S0 +embosquezcamos embosquecer VMM01P0 +embosquezcan embosquecer VMM03P0 +embosta embostar VMM02S0 +embostad embostar VMM02P0 +embostando embostar VMG0000 +embostar embostar VMN0000 +emboste embostar VMM03S0 +embostemos embostar VMM01P0 +embosten embostar VMM03P0 +embota embotar VMM02S0 +embotad embotar VMM02P0 +embotando embotar VMG0000 +embotar embotar VMN0000 +embote embotar VMM03S0 +embotella embotellar VMM02S0 +embotellad embotellar VMM02P0 +embotellando embotellar VMG0000 +embotellar embotellar VMN0000 +embotelle embotellar VMM03S0 +embotellemos embotellar VMM01P0 +embotellen embotellar VMM03P0 +embotemos embotar VMM01P0 +emboten embotar VMM03P0 +embotija embotijar VMM02S0 +embotijad embotijar VMM02P0 +embotijando embotijar VMG0000 +embotijar embotijar VMN0000 +embotije embotijar VMM03S0 +embotijemos embotijar VMM01P0 +embotijen embotijar VMM03P0 +emboveda embovedar VMM02S0 +embovedad embovedar VMM02P0 +embovedando embovedar VMG0000 +embovedar embovedar VMN0000 +embovede embovedar VMM03S0 +embovedemos embovedar VMM01P0 +emboveden embovedar VMM03P0 +emboza embozar VMM02S0 +embozad embozar VMM02P0 +embozala embozalar VMM02S0 +embozalad embozalar VMM02P0 +embozalando embozalar VMG0000 +embozalar embozalar VMN0000 +embozale embozalar VMM03S0 +embozalemos embozalar VMM01P0 +embozalen embozalar VMM03P0 +embozando embozar VMG0000 +embozar embozar VMN0000 +emboñiga emboñigar VMM02S0 +emboñigad emboñigar VMM02P0 +emboñigando emboñigar VMG0000 +emboñigar emboñigar VMN0000 +emboñigue emboñigar VMM03S0 +emboñiguemos emboñigar VMM01P0 +emboñiguen emboñigar VMM03P0 +embrace embrazar VMM03S0 +embracemos embrazar VMM01P0 +embracen embrazar VMM03P0 +embraga embragar VMM02S0 +embragad embragar VMM02P0 +embragando embragar VMG0000 +embragar embragar VMN0000 +embrague embragar VMM03S0 +embraguemos embragar VMM01P0 +embraguen embragar VMM03P0 +embravece embravecer VMM02S0 +embraveced embravecer VMM02P0 +embravecer embravecer VMN0000 +embraveciendo embravecer VMG0000 +embravezca embravecer VMM03S0 +embravezcamos embravecer VMM01P0 +embravezcan embravecer VMM03P0 +embraza embrazar VMM02S0 +embrazad embrazar VMM02P0 +embrazando embrazar VMG0000 +embrazar embrazar VMN0000 +embrea embrear VMM02S0 +embread embrear VMM02P0 +embreando embrear VMG0000 +embrear embrear VMN0000 +embree embrear VMM03S0 +embreemos embrear VMM01P0 +embreen embrear VMM03P0 +embriaga embriagar VMM02S0 +embriagad embriagar VMM02P0 +embriagando embriagar VMG0000 +embriagar embriagar VMN0000 +embriague embriagar VMM03S0 +embriaguemos embriagar VMM01P0 +embriaguen embriagar VMM03P0 +embrida embridar VMM02S0 +embridad embridar VMM02P0 +embridando embridar VMG0000 +embridar embridar VMN0000 +embride embridar VMM03S0 +embridemos embridar VMM01P0 +embriden embridar VMM03P0 +embroca embrocar VMM02S0 +embrocad embrocar VMM02P0 +embrocando embrocar VMG0000 +embrocar embrocar VMN0000 +embrochala embrochalar VMM02S0 +embrochalad embrochalar VMM02P0 +embrochalando embrochalar VMG0000 +embrochalar embrochalar VMN0000 +embrochale embrochalar VMM03S0 +embrochalemos embrochalar VMM01P0 +embrochalen embrochalar VMM03P0 +embrolla embrollar VMM02S0 +embrollad embrollar VMM02P0 +embrollando embrollar VMG0000 +embrollar embrollar VMN0000 +embrolle embrollar VMM03S0 +embrollemos embrollar VMM01P0 +embrollen embrollar VMM03P0 +embroma embromar VMM02S0 +embromad embromar VMM02P0 +embromando embromar VMG0000 +embromar embromar VMN0000 +embrome embromar VMM03S0 +embromemos embromar VMM01P0 +embromen embromar VMM03P0 +embroque embrocar VMM03S0 +embroquela embroquelar VMM02S0 +embroquelad embroquelar VMM02P0 +embroquelando embroquelar VMG0000 +embroquelar embroquelar VMN0000 +embroquele embroquelar VMM03S0 +embroquelemos embroquelar VMM01P0 +embroquelen embroquelar VMM03P0 +embroquemos embrocar VMM01P0 +embroquen embrocar VMM03P0 +embroqueta embroquetar VMM02S0 +embroquetad embroquetar VMM02P0 +embroquetando embroquetar VMG0000 +embroquetar embroquetar VMN0000 +embroquete embroquetar VMM03S0 +embroquetemos embroquetar VMM01P0 +embroqueten embroquetar VMM03P0 +embruja embrujar VMM02S0 +embrujad embrujar VMM02P0 +embrujando embrujar VMG0000 +embrujar embrujar VMN0000 +embruje embrujar VMM03S0 +embrujemos embrujar VMM01P0 +embrujen embrujar VMM03P0 +embrutece embrutecer VMM02S0 +embruteced embrutecer VMM02P0 +embrutecer embrutecer VMN0000 +embruteciendo embrutecer VMG0000 +embrutezca embrutecer VMM03S0 +embrutezcamos embrutecer VMM01P0 +embrutezcan embrutecer VMM03P0 +embucha embuchar VMM02S0 +embuchad embuchar VMM02P0 +embuchando embuchar VMG0000 +embuchar embuchar VMN0000 +embuche embuchar VMM03S0 +embuchemos embuchar VMM01P0 +embuchen embuchar VMM03P0 +embuda embudar VMM02S0 +embudad embudar VMM02P0 +embudando embudar VMG0000 +embudar embudar VMN0000 +embude embudar VMM03S0 +embudemos embudar VMM01P0 +embuden embudar VMM03P0 +embulla embullar VMM02S0 +embullad embullar VMM02P0 +embullando embullar VMG0000 +embullar embullar VMN0000 +embulle embullar VMM03S0 +embullemos embullar VMM01P0 +embullen embullar VMM03P0 +emburuja emburujar VMM02S0 +emburujad emburujar VMM02P0 +emburujando emburujar VMG0000 +emburujar emburujar VMN0000 +emburuje emburujar VMM03S0 +emburujemos emburujar VMM01P0 +emburujen emburujar VMM03P0 +embustea embustear VMM02S0 +embustead embustear VMM02P0 +embusteando embustear VMG0000 +embustear embustear VMN0000 +embustee embustear VMM03S0 +embusteemos embustear VMM01P0 +embusteen embustear VMM03P0 +embuta embutir VMM03S0 +embutamos embutir VMM01P0 +embutan embutir VMM03P0 +embute embutir VMM02S0 +embutid embutir VMM02P0 +embutiendo embutir VMG0000 +embutir embutir VMN0000 +emerge emerger VMM02S0 +emerged emerger VMM02P0 +emerger emerger VMN0000 +emergiendo emerger VMG0000 +emerja emerger VMM03S0 +emerjamos emerger VMM01P0 +emerjan emerger VMM03P0 +emigra emigrar VMM02S0 +emigrad emigrar VMM02P0 +emigrando emigrar VMG0000 +emigrar emigrar VMN0000 +emigre emigrar VMM03S0 +emigremos emigrar VMM01P0 +emigren emigrar VMM03P0 +emita emitir VMM03S0 +emitamos emitir VMM01P0 +emitan emitir VMM03P0 +emite emitir VMM02S0 +emitid emitir VMM02P0 +emitiendo emitir VMG0000 +emitir emitir VMN0000 +emociona emocionar VMM02S0 +emocionad emocionar VMM02P0 +emocionando emocionar VMG0000 +emocionar emocionar VMN0000 +emocione emocionar VMM03S0 +emocionemos emocionar VMM01P0 +emocionen emocionar VMM03P0 +empaca empacar VMM02S0 +empacad empacar VMM02P0 +empacando empacar VMG0000 +empacar empacar VMN0000 +empacha empachar VMM02S0 +empachad empachar VMM02P0 +empachando empachar VMG0000 +empachar empachar VMN0000 +empache empachar VMM03S0 +empachemos empachar VMM01P0 +empachen empachar VMM03P0 +empadra empadrar VMM02S0 +empadrad empadrar VMM02P0 +empadrando empadrar VMG0000 +empadrar empadrar VMN0000 +empadre empadrar VMM03S0 +empadremos empadrar VMM01P0 +empadren empadrar VMM03P0 +empadrona empadronar VMM02S0 +empadronad empadronar VMM02P0 +empadronando empadronar VMG0000 +empadronar empadronar VMN0000 +empadrone empadronar VMM03S0 +empadronemos empadronar VMM01P0 +empadronen empadronar VMM03P0 +empaja empajar VMM02S0 +empajad empajar VMM02P0 +empajando empajar VMG0000 +empajar empajar VMN0000 +empaje empajar VMM03S0 +empajemos empajar VMM01P0 +empajen empajar VMM03P0 +empala empalar VMM02S0 +empalad empalar VMM02P0 +empalaga empalagar VMM02S0 +empalagad empalagar VMM02P0 +empalagando empalagar VMG0000 +empalagar empalagar VMN0000 +empalague empalagar VMM03S0 +empalaguemos empalagar VMM01P0 +empalaguen empalagar VMM03P0 +empalando empalar VMG0000 +empalar empalar VMN0000 +empale empalar VMM03S0 +empalemos empalar VMM01P0 +empalen empalar VMM03P0 +empalia empaliar VMM02S0 +empaliad empaliar VMM02P0 +empaliando empaliar VMG0000 +empaliar empaliar VMN0000 +empalice empalizar VMM03S0 +empalicemos empalizar VMM01P0 +empalicen empalizar VMM03P0 +empalie empaliar VMM03S0 +empaliemos empaliar VMM01P0 +empalien empaliar VMM03P0 +empaliza empalizar VMM02S0 +empalizad empalizar VMM02P0 +empalizando empalizar VMG0000 +empalizar empalizar VMN0000 +empalma empalmar VMM02S0 +empalmad empalmar VMM02P0 +empalmando empalmar VMG0000 +empalmar empalmar VMN0000 +empalme empalmar VMM03S0 +empalmemos empalmar VMM01P0 +empalmen empalmar VMM03P0 +empaloma empalomar VMM02S0 +empalomad empalomar VMM02P0 +empalomando empalomar VMG0000 +empalomar empalomar VMN0000 +empalome empalomar VMM03S0 +empalomemos empalomar VMM01P0 +empalomen empalomar VMM03P0 +empampa empampar VMM02S0 +empampad empampar VMM02P0 +empampando empampar VMG0000 +empampar empampar VMN0000 +empampe empampar VMM03S0 +empampemos empampar VMM01P0 +empampen empampar VMM03P0 +empana empanar VMM02S0 +empanad empanar VMM02P0 +empanando empanar VMG0000 +empanar empanar VMN0000 +empance empanzar VMM03S0 +empancemos empanzar VMM01P0 +empancen empanzar VMM03P0 +empane empanar VMM03S0 +empanemos empanar VMM01P0 +empanen empanar VMM03P0 +empantana empantanar VMM02S0 +empantanad empantanar VMM02P0 +empantanando empantanar VMG0000 +empantanar empantanar VMN0000 +empantane empantanar VMM03S0 +empantanemos empantanar VMM01P0 +empantanen empantanar VMM03P0 +empanza empanzar VMM02S0 +empanzad empanzar VMM02P0 +empanzando empanzar VMG0000 +empanzar empanzar VMN0000 +empapa empapar VMM02S0 +empapad empapar VMM02P0 +empapando empapar VMG0000 +empapar empapar VMN0000 +empape empapar VMM03S0 +empapela empapelar VMM02S0 +empapelad empapelar VMM02P0 +empapelando empapelar VMG0000 +empapelar empapelar VMN0000 +empapele empapelar VMM03S0 +empapelemos empapelar VMM01P0 +empapelen empapelar VMM03P0 +empapemos empapar VMM01P0 +empapen empapar VMM03P0 +empapirota empapirotar VMM02S0 +empapirotad empapirotar VMM02P0 +empapirotando empapirotar VMG0000 +empapirotar empapirotar VMN0000 +empapirote empapirotar VMM03S0 +empapirotemos empapirotar VMM01P0 +empapiroten empapirotar VMM03P0 +empaque empacar VMM03S0 +empaquemos empacar VMM01P0 +empaquen empacar VMM03P0 +empaqueta empaquetar VMM02S0 +empaquetad empaquetar VMM02P0 +empaquetando empaquetar VMG0000 +empaquetar empaquetar VMN0000 +empaquete empaquetar VMM03S0 +empaquetemos empaquetar VMM01P0 +empaqueten empaquetar VMM03P0 +emparama emparamar VMM02S0 +emparamad emparamar VMM02P0 +emparamando emparamar VMG0000 +emparamar emparamar VMN0000 +emparame emparamar VMM03S0 +emparamemos emparamar VMM01P0 +emparamen emparamar VMM03P0 +emparamenta emparamentar VMM02S0 +emparamentad emparamentar VMM02P0 +emparamentando emparamentar VMG0000 +emparamentar emparamentar VMN0000 +emparamente emparamentar VMM03S0 +emparamentemos emparamentar VMM01P0 +emparamenten emparamentar VMM03P0 +emparcha emparchar VMM02S0 +emparchad emparchar VMM02P0 +emparchando emparchar VMG0000 +emparchar emparchar VMN0000 +emparche emparchar VMM03S0 +emparchemos emparchar VMM01P0 +emparchen emparchar VMM03P0 +empareda emparedar VMM02S0 +emparedad emparedar VMM02P0 +emparedando emparedar VMG0000 +emparedar emparedar VMN0000 +emparede emparedar VMM03S0 +emparedemos emparedar VMM01P0 +empareden emparedar VMM03P0 +empareja emparejar VMM02S0 +emparejad emparejar VMM02P0 +emparejando emparejar VMG0000 +emparejar emparejar VMN0000 +empareje emparejar VMM03S0 +emparejemos emparejar VMM01P0 +emparejen emparejar VMM03P0 +emparenta emparentar VMM02S0 +emparentad emparentar VMM02P0 +emparentando emparentar VMG0000 +emparentar emparentar VMN0000 +emparente emparentar VMM03S0 +emparentemos emparentar VMM01P0 +emparenten emparentar VMM03P0 +emparienta emparentar VMM02S0 +empariente emparentar VMM03S0 +emparienten emparentar VMM03P0 +emparra emparrar VMM02S0 +emparrad emparrar VMM02P0 +emparrando emparrar VMG0000 +emparrar emparrar VMN0000 +emparre emparrar VMM03S0 +emparremos emparrar VMM01P0 +emparren emparrar VMM03P0 +emparrilla emparrillar VMM02S0 +emparrillad emparrillar VMM02P0 +emparrillando emparrillar VMG0000 +emparrillar emparrillar VMN0000 +emparrille emparrillar VMM03S0 +emparrillemos emparrillar VMM01P0 +emparrillen emparrillar VMM03P0 +emparva emparvar VMM02S0 +emparvad emparvar VMM02P0 +emparvando emparvar VMG0000 +emparvar emparvar VMN0000 +emparve emparvar VMM03S0 +emparvemos emparvar VMM01P0 +emparven emparvar VMM03P0 +empasta empastar VMM02S0 +empastad empastar VMM02P0 +empastando empastar VMG0000 +empastar empastar VMN0000 +empaste empastar VMM03S0 +empastela empastelar VMM02S0 +empastelad empastelar VMM02P0 +empastelando empastelar VMG0000 +empastelar empastelar VMN0000 +empastele empastelar VMM03S0 +empastelemos empastelar VMM01P0 +empastelen empastelar VMM03P0 +empastemos empastar VMM01P0 +empasten empastar VMM03P0 +empata empatar VMM02S0 +empatad empatar VMM02P0 +empatando empatar VMG0000 +empatar empatar VMN0000 +empate empatar VMM03S0 +empatemos empatar VMM01P0 +empaten empatar VMM03P0 +empavesa empavesar VMM02S0 +empavesad empavesar VMM02P0 +empavesando empavesar VMG0000 +empavesar empavesar VMN0000 +empavese empavesar VMM03S0 +empavesemos empavesar VMM01P0 +empavesen empavesar VMM03P0 +empavona empavonar VMM02S0 +empavonad empavonar VMM02P0 +empavonando empavonar VMG0000 +empavonar empavonar VMN0000 +empavone empavonar VMM03S0 +empavonemos empavonar VMM01P0 +empavonen empavonar VMM03P0 +empaña empañar VMM02S0 +empañad empañar VMM02P0 +empañando empañar VMG0000 +empañar empañar VMN0000 +empañe empañar VMM03S0 +empañemos empañar VMM01P0 +empañen empañar VMM03P0 +empañeta empañetar VMM02S0 +empañetad empañetar VMM02P0 +empañetando empañetar VMG0000 +empañetar empañetar VMN0000 +empañete empañetar VMM03S0 +empañetemos empañetar VMM01P0 +empañeten empañetar VMM03P0 +empece empecer VMM02S0 +empeced empecer VMM02P0 +empecemos empezar VMM01P0 +empecer empecer VMN0000 +empeciendo empecer VMG0000 +empecina empecinar VMM02S0 +empecinad empecinar VMM02P0 +empecinando empecinar VMG0000 +empecinar empecinar VMN0000 +empecine empecinar VMM03S0 +empecinemos empecinar VMM01P0 +empecinen empecinar VMM03P0 +empederna empedernir VMM03S0 +empedernamos empedernir VMM01P0 +empedernan empedernir VMM03P0 +empederne empedernir VMM02S0 +empedernid empedernir VMM02P0 +empederniendo empedernir VMG0000 +empedernir empedernir VMN0000 +empedrad empedrar VMM02P0 +empedrando empedrar VMG0000 +empedrar empedrar VMN0000 +empedremos empedrar VMM01P0 +empega empegar VMM02S0 +empegad empegar VMM02P0 +empegando empegar VMG0000 +empegar empegar VMN0000 +empegue empegar VMM03S0 +empeguemos empegar VMM01P0 +empeguen empegar VMM03P0 +empelecha empelechar VMM02S0 +empelechad empelechar VMM02P0 +empelechando empelechar VMG0000 +empelechar empelechar VMN0000 +empeleche empelechar VMM03S0 +empelechemos empelechar VMM01P0 +empelechen empelechar VMM03P0 +empella empellar VMM02S0 +empella empeller VMM03S0 +empellad empellar VMM02P0 +empellamos empeller VMM01P0 +empellan empeller VMM03P0 +empellando empellar VMG0000 +empellar empellar VMN0000 +empelle empellar VMM03S0 +empelle empeller VMM02S0 +empelled empeller VMM02P0 +empelleja empellejar VMM02S0 +empellejad empellejar VMM02P0 +empellejando empellejar VMG0000 +empellejar empellejar VMN0000 +empelleje empellejar VMM03S0 +empellejemos empellejar VMM01P0 +empellejen empellejar VMM03P0 +empellemos empellar VMM01P0 +empellen empellar VMM03P0 +empellendo empeller VMG0000 +empeller empeller VMN0000 +empelota empelotar VMM02S0 +empelotad empelotar VMM02P0 +empelotando empelotar VMG0000 +empelotar empelotar VMN0000 +empelote empelotar VMM03S0 +empelotemos empelotar VMM01P0 +empeloten empelotar VMM03P0 +empenacha empenachar VMM02S0 +empenachad empenachar VMM02P0 +empenachando empenachar VMG0000 +empenachar empenachar VMN0000 +empenache empenachar VMM03S0 +empenachemos empenachar VMM01P0 +empenachen empenachar VMM03P0 +empenta empentar VMM02S0 +empentad empentar VMM02P0 +empentando empentar VMG0000 +empentar empentar VMN0000 +empente empentar VMM03S0 +empentemos empentar VMM01P0 +empenten empentar VMM03P0 +empeora empeorar VMM02S0 +empeorad empeorar VMM02P0 +empeorando empeorar VMG0000 +empeorar empeorar VMN0000 +empeore empeorar VMM03S0 +empeoremos empeorar VMM01P0 +empeoren empeorar VMM03P0 +empequeñece empequeñecer VMM02S0 +empequeñeced empequeñecer VMM02P0 +empequeñecer empequeñecer VMN0000 +empequeñeciendo empequeñecer VMG0000 +empequeñezca empequeñecer VMM03S0 +empequeñezcamos empequeñecer VMM01P0 +empequeñezcan empequeñecer VMM03P0 +empercha emperchar VMM02S0 +emperchad emperchar VMM02P0 +emperchando emperchar VMG0000 +emperchar emperchar VMN0000 +emperche emperchar VMM03S0 +emperchemos emperchar VMM01P0 +emperchen emperchar VMM03P0 +emperdiga emperdigar VMM02S0 +emperdigad emperdigar VMM02P0 +emperdigando emperdigar VMG0000 +emperdigar emperdigar VMN0000 +emperdigue emperdigar VMM03S0 +emperdiguemos emperdigar VMM01P0 +emperdiguen emperdigar VMM03P0 +emperece emperezar VMM03S0 +emperecemos emperezar VMM01P0 +emperecen emperezar VMM03P0 +emperejila emperejilar VMM02S0 +emperejilad emperejilar VMM02P0 +emperejilando emperejilar VMG0000 +emperejilar emperejilar VMN0000 +emperejile emperejilar VMM03S0 +emperejilemos emperejilar VMM01P0 +emperejilen emperejilar VMM03P0 +empereza emperezar VMM02S0 +emperezad emperezar VMM02P0 +emperezando emperezar VMG0000 +emperezar emperezar VMN0000 +empergamina empergaminar VMM02S0 +empergaminad empergaminar VMM02P0 +empergaminando empergaminar VMG0000 +empergaminar empergaminar VMN0000 +empergamine empergaminar VMM03S0 +empergaminemos empergaminar VMM01P0 +empergaminen empergaminar VMM03P0 +emperifolla emperifollar VMM02S0 +emperifollad emperifollar VMM02P0 +emperifollando emperifollar VMG0000 +emperifollar emperifollar VMN0000 +emperifolle emperifollar VMM03S0 +emperifollemos emperifollar VMM01P0 +emperifollen emperifollar VMM03P0 +emperna empernar VMM02S0 +empernad empernar VMM02P0 +empernando empernar VMG0000 +empernar empernar VMN0000 +emperne empernar VMM03S0 +empernemos empernar VMM01P0 +empernen empernar VMM03P0 +emperra emperrar VMM02S0 +emperrad emperrar VMM02P0 +emperrando emperrar VMG0000 +emperrar emperrar VMN0000 +emperre emperrar VMM03S0 +emperremos emperrar VMM01P0 +emperren emperrar VMM03P0 +empezad empezar VMM02P0 +empezando empezar VMG0000 +empezar empezar VMN0000 +empezca empecer VMM03S0 +empezcamos empecer VMM01P0 +empezcan empecer VMM03P0 +empeña empeñar VMM02S0 +empeñad empeñar VMM02P0 +empeñando empeñar VMG0000 +empeñar empeñar VMN0000 +empeñe empeñar VMM03S0 +empeñemos empeñar VMM01P0 +empeñen empeñar VMM03P0 +empica empicar VMM02S0 +empicad empicar VMM02P0 +empicando empicar VMG0000 +empicar empicar VMN0000 +empicota empicotar VMM02S0 +empicotad empicotar VMM02P0 +empicotando empicotar VMG0000 +empicotar empicotar VMN0000 +empicote empicotar VMM03S0 +empicotemos empicotar VMM01P0 +empicoten empicotar VMM03P0 +empiece empezar VMM03S0 +empiecen empezar VMM03P0 +empiedra empedrar VMM02S0 +empiedre empedrar VMM03S0 +empiedren empedrar VMM03P0 +empieza empezar VMM02S0 +empila empilar VMM02S0 +empilad empilar VMM02P0 +empilando empilar VMG0000 +empilar empilar VMN0000 +empile empilar VMM03S0 +empilemos empilar VMM01P0 +empilen empilar VMM03P0 +empina empinar VMM02S0 +empinad empinar VMM02P0 +empinando empinar VMG0000 +empinar empinar VMN0000 +empine empinar VMM03S0 +empinemos empinar VMM01P0 +empinen empinar VMM03P0 +empingorota empingorotar VMM02S0 +empingorotad empingorotar VMM02P0 +empingorotando empingorotar VMG0000 +empingorotar empingorotar VMN0000 +empingorote empingorotar VMM03S0 +empingorotemos empingorotar VMM01P0 +empingoroten empingorotar VMM03P0 +empipa empipar VMM02S0 +empipad empipar VMM02P0 +empipando empipar VMG0000 +empipar empipar VMN0000 +empipe empipar VMM03S0 +empipemos empipar VMM01P0 +empipen empipar VMM03P0 +empique empicar VMM03S0 +empiquemos empicar VMM01P0 +empiquen empicar VMM03P0 +empitona empitonar VMM02S0 +empitonad empitonar VMM02P0 +empitonando empitonar VMG0000 +empitonar empitonar VMN0000 +empitone empitonar VMM03S0 +empitonemos empitonar VMM01P0 +empitonen empitonar VMM03P0 +empizarra empizarrar VMM02S0 +empizarrad empizarrar VMM02P0 +empizarrando empizarrar VMG0000 +empizarrar empizarrar VMN0000 +empizarre empizarrar VMM03S0 +empizarremos empizarrar VMM01P0 +empizarren empizarrar VMM03P0 +emplace emplazar VMM03S0 +emplacemos emplazar VMM01P0 +emplacen emplazar VMM03P0 +emplasta emplastar VMM02S0 +emplastad emplastar VMM02P0 +emplastando emplastar VMG0000 +emplastar emplastar VMN0000 +emplaste emplastar VMM03S0 +emplastece emplastecer VMM02S0 +emplasteced emplastecer VMM02P0 +emplastecer emplastecer VMN0000 +emplasteciendo emplastecer VMG0000 +emplastemos emplastar VMM01P0 +emplasten emplastar VMM03P0 +emplastezca emplastecer VMM03S0 +emplastezcamos emplastecer VMM01P0 +emplastezcan emplastecer VMM03P0 +emplaza emplazar VMM02S0 +emplazad emplazar VMM02P0 +emplazando emplazar VMG0000 +emplazar emplazar VMN0000 +emplea emplear VMM02S0 +emplead emplear VMM02P0 +empleando emplear VMG0000 +emplear emplear VMN0000 +emplee emplear VMM03S0 +empleemos emplear VMM01P0 +empleen emplear VMM03P0 +emploma emplomar VMM02S0 +emplomad emplomar VMM02P0 +emplomando emplomar VMG0000 +emplomar emplomar VMN0000 +emplome emplomar VMM03S0 +emplomemos emplomar VMM01P0 +emplomen emplomar VMM03P0 +empluma emplumar VMM02S0 +emplumad emplumar VMM02P0 +emplumando emplumar VMG0000 +emplumar emplumar VMN0000 +emplume emplumar VMM03S0 +emplumece emplumecer VMM02S0 +emplumeced emplumecer VMM02P0 +emplumecer emplumecer VMN0000 +emplumeciendo emplumecer VMG0000 +emplumemos emplumar VMM01P0 +emplumen emplumar VMM03P0 +emplumezca emplumecer VMM03S0 +emplumezcamos emplumecer VMM01P0 +emplumezcan emplumecer VMM03P0 +empobrece empobrecer VMM02S0 +empobreced empobrecer VMM02P0 +empobrecer empobrecer VMN0000 +empobreciendo empobrecer VMG0000 +empobrezca empobrecer VMM03S0 +empobrezcamos empobrecer VMM01P0 +empobrezcan empobrecer VMM03P0 +empoce empozar VMM03S0 +empocemos empozar VMM01P0 +empocen empozar VMM03P0 +empolla empollar VMM02S0 +empollad empollar VMM02P0 +empollando empollar VMG0000 +empollar empollar VMN0000 +empolle empollar VMM03S0 +empollemos empollar VMM01P0 +empollen empollar VMM03P0 +empolva empolvar VMM02S0 +empolvad empolvar VMM02P0 +empolvando empolvar VMG0000 +empolvar empolvar VMN0000 +empolve empolvar VMM03S0 +empolvemos empolvar VMM01P0 +empolven empolvar VMM03P0 +empolvora empolvorar VMM02S0 +empolvorad empolvorar VMM02P0 +empolvorando empolvorar VMG0000 +empolvorar empolvorar VMN0000 +empolvore empolvorar VMM03S0 +empolvoremos empolvorar VMM01P0 +empolvoren empolvorar VMM03P0 +empolvorice empolvorizar VMM03S0 +empolvoricemos empolvorizar VMM01P0 +empolvoricen empolvorizar VMM03P0 +empolvoriza empolvorizar VMM02S0 +empolvorizad empolvorizar VMM02P0 +empolvorizando empolvorizar VMG0000 +empolvorizar empolvorizar VMN0000 +emponcha emponchar VMM02S0 +emponchad emponchar VMM02P0 +emponchando emponchar VMG0000 +emponchar emponchar VMN0000 +emponche emponchar VMM03S0 +emponchemos emponchar VMM01P0 +emponchen emponchar VMM03P0 +emponzoña emponzoñar VMM02S0 +emponzoñad emponzoñar VMM02P0 +emponzoñando emponzoñar VMG0000 +emponzoñar emponzoñar VMN0000 +emponzoñe emponzoñar VMM03S0 +emponzoñemos emponzoñar VMM01P0 +emponzoñen emponzoñar VMM03P0 +empopa empopar VMM02S0 +empopad empopar VMM02P0 +empopando empopar VMG0000 +empopar empopar VMN0000 +empope empopar VMM03S0 +empopemos empopar VMM01P0 +empopen empopar VMM03P0 +emporcad emporcar VMM02P0 +emporcando emporcar VMG0000 +emporcar emporcar VMN0000 +emporquemos emporcar VMM01P0 +empotra empotrar VMM02S0 +empotrad empotrar VMM02P0 +empotrando empotrar VMG0000 +empotrar empotrar VMN0000 +empotre empotrar VMM03S0 +empotremos empotrar VMM01P0 +empotren empotrar VMM03P0 +empotrera empotrerar VMM02S0 +empotrerad empotrerar VMM02P0 +empotrerando empotrerar VMG0000 +empotrerar empotrerar VMN0000 +empotrere empotrerar VMM03S0 +empotreremos empotrerar VMM01P0 +empotreren empotrerar VMM03P0 +empoza empozar VMM02S0 +empozad empozar VMM02P0 +empozando empozar VMG0000 +empozar empozar VMN0000 +empradice empradizar VMM03S0 +empradicemos empradizar VMM01P0 +empradicen empradizar VMM03P0 +empradiza empradizar VMM02S0 +empradizad empradizar VMM02P0 +empradizando empradizar VMG0000 +empradizar empradizar VMN0000 +emprenda emprender VMM03S0 +emprendamos emprender VMM01P0 +emprendan emprender VMM03P0 +emprende emprender VMM02S0 +emprended emprender VMM02P0 +emprender emprender VMN0000 +emprendiendo emprender VMG0000 +empreña empreñar VMM02S0 +empreñad empreñar VMM02P0 +empreñando empreñar VMG0000 +empreñar empreñar VMN0000 +empreñe empreñar VMM03S0 +empreñemos empreñar VMM01P0 +empreñen empreñar VMM03P0 +emprima emprimar VMM02S0 +emprimad emprimar VMM02P0 +emprimando emprimar VMG0000 +emprimar emprimar VMN0000 +emprime emprimar VMM03S0 +emprimemos emprimar VMM01P0 +emprimen emprimar VMM03P0 +empringa empringar VMM02S0 +empringad empringar VMM02P0 +empringando empringar VMG0000 +empringar empringar VMN0000 +empringue empringar VMM03S0 +empringuemos empringar VMM01P0 +empringuen empringar VMM03P0 +empuerca emporcar VMM02S0 +empuerque emporcar VMM03S0 +empuerquen emporcar VMM03P0 +empuja empujar VMM02S0 +empujad empujar VMM02P0 +empujando empujar VMG0000 +empujar empujar VMN0000 +empuje empujar VMM03S0 +empujemos empujar VMM01P0 +empujen empujar VMM03P0 +empulga empulgar VMM02S0 +empulgad empulgar VMM02P0 +empulgando empulgar VMG0000 +empulgar empulgar VMN0000 +empulgue empulgar VMM03S0 +empulguemos empulgar VMM01P0 +empulguen empulgar VMM03P0 +empuña empuñar VMM02S0 +empuñad empuñar VMM02P0 +empuñando empuñar VMG0000 +empuñar empuñar VMN0000 +empuñe empuñar VMM03S0 +empuñemos empuñar VMM01P0 +empuñen empuñar VMM03P0 +emula emular VMM02S0 +emulad emular VMM02P0 +emulando emular VMG0000 +emular emular VMN0000 +emule emular VMM03S0 +emulemos emular VMM01P0 +emulen emular VMM03P0 +emulsiona emulsionar VMM02S0 +emulsionad emulsionar VMM02P0 +emulsionando emulsionar VMG0000 +emulsionar emulsionar VMN0000 +emulsione emulsionar VMM03S0 +emulsionemos emulsionar VMM01P0 +emulsionen emulsionar VMM03P0 +enaceita enaceitar VMM02S0 +enaceitad enaceitar VMM02P0 +enaceitando enaceitar VMG0000 +enaceitar enaceitar VMN0000 +enaceite enaceitar VMM03S0 +enaceitemos enaceitar VMM01P0 +enaceiten enaceitar VMM03P0 +enagua enaguar VMM02S0 +enaguace enaguazar VMM03S0 +enaguacemos enaguazar VMM01P0 +enaguacen enaguazar VMM03P0 +enaguacha enaguachar VMM02S0 +enaguachad enaguachar VMM02P0 +enaguachando enaguachar VMG0000 +enaguachar enaguachar VMN0000 +enaguache enaguachar VMM03S0 +enaguachemos enaguachar VMM01P0 +enaguachen enaguachar VMM03P0 +enaguad enaguar VMM02P0 +enaguando enaguar VMG0000 +enaguar enaguar VMN0000 +enaguaza enaguazar VMM02S0 +enaguazad enaguazar VMM02P0 +enaguazando enaguazar VMG0000 +enaguazar enaguazar VMN0000 +enagüe enaguar VMM03S0 +enagüemos enaguar VMM01P0 +enagüen enaguar VMM03P0 +enajena enajenar VMM02S0 +enajenad enajenar VMM02P0 +enajenando enajenar VMG0000 +enajenar enajenar VMN0000 +enajene enajenar VMM03S0 +enajenemos enajenar VMM01P0 +enajenen enajenar VMM03P0 +enalba enalbar VMM02S0 +enalbad enalbar VMM02P0 +enalbando enalbar VMG0000 +enalbar enalbar VMN0000 +enalbarda enalbardar VMM02S0 +enalbardad enalbardar VMM02P0 +enalbardando enalbardar VMG0000 +enalbardar enalbardar VMN0000 +enalbarde enalbardar VMM03S0 +enalbardemos enalbardar VMM01P0 +enalbarden enalbardar VMM03P0 +enalbe enalbar VMM03S0 +enalbemos enalbar VMM01P0 +enalben enalbar VMM03P0 +enaltece enaltecer VMM02S0 +enalteced enaltecer VMM02P0 +enaltecer enaltecer VMN0000 +enalteciendo enaltecer VMG0000 +enaltezca enaltecer VMM03S0 +enaltezcamos enaltecer VMM01P0 +enaltezcan enaltecer VMM03P0 +enamora enamorar VMM02S0 +enamorad enamorar VMM02P0 +enamorando enamorar VMG0000 +enamorar enamorar VMN0000 +enamore enamorar VMM03S0 +enamoremos enamorar VMM01P0 +enamoren enamorar VMM03P0 +enamorica enamoricar VMM02S0 +enamoricad enamoricar VMM02P0 +enamoricando enamoricar VMG0000 +enamoricar enamoricar VMN0000 +enamorique enamoricar VMM03S0 +enamoriquemos enamoricar VMM01P0 +enamoriquen enamoricar VMM03P0 +enamorisca enamoriscar VMM02S0 +enamoriscad enamoriscar VMM02P0 +enamoriscando enamoriscar VMG0000 +enamoriscar enamoriscar VMN0000 +enamorisque enamoriscar VMM03S0 +enamorisquemos enamoriscar VMM01P0 +enamorisquen enamoriscar VMM03P0 +enancha enanchar VMM02S0 +enanchad enanchar VMM02P0 +enanchando enanchar VMG0000 +enanchar enanchar VMN0000 +enanche enanchar VMM03S0 +enanchemos enanchar VMM01P0 +enanchen enanchar VMM03P0 +enangosta enangostar VMM02S0 +enangostad enangostar VMM02P0 +enangostando enangostar VMG0000 +enangostar enangostar VMN0000 +enangoste enangostar VMM03S0 +enangostemos enangostar VMM01P0 +enangosten enangostar VMM03P0 +enarbola enarbolar VMM02S0 +enarbolad enarbolar VMM02P0 +enarbolando enarbolar VMG0000 +enarbolar enarbolar VMN0000 +enarbole enarbolar VMM03S0 +enarbolemos enarbolar VMM01P0 +enarbolen enarbolar VMM03P0 +enarca enarcar VMM02S0 +enarcad enarcar VMM02P0 +enarcando enarcar VMG0000 +enarcar enarcar VMN0000 +enardece enardecer VMM02S0 +enardeced enardecer VMM02P0 +enardecer enardecer VMN0000 +enardeciendo enardecer VMG0000 +enardezca enardecer VMM03S0 +enardezcamos enardecer VMM01P0 +enardezcan enardecer VMM03P0 +enarena enarenar VMM02S0 +enarenad enarenar VMM02P0 +enarenando enarenar VMG0000 +enarenar enarenar VMN0000 +enarene enarenar VMM03S0 +enarenemos enarenar VMM01P0 +enarenen enarenar VMM03P0 +enarque enarcar VMM03S0 +enarquemos enarcar VMM01P0 +enarquen enarcar VMM03P0 +enasta enastar VMM02S0 +enastad enastar VMM02P0 +enastando enastar VMG0000 +enastar enastar VMN0000 +enaste enastar VMM03S0 +enastemos enastar VMM01P0 +enasten enastar VMM03P0 +encaba encabar VMM02S0 +encabad encabar VMM02P0 +encabalga encabalgar VMM02S0 +encabalgad encabalgar VMM02P0 +encabalgando encabalgar VMG0000 +encabalgar encabalgar VMN0000 +encabalgue encabalgar VMM03S0 +encabalguemos encabalgar VMM01P0 +encabalguen encabalgar VMM03P0 +encaballa encaballar VMM02S0 +encaballad encaballar VMM02P0 +encaballando encaballar VMG0000 +encaballar encaballar VMN0000 +encaballe encaballar VMM03S0 +encaballemos encaballar VMM01P0 +encaballen encaballar VMM03P0 +encabando encabar VMG0000 +encabar encabar VMN0000 +encabe encabar VMM03S0 +encabece encabezar VMM03S0 +encabecemos encabezar VMM01P0 +encabecen encabezar VMM03P0 +encabemos encabar VMM01P0 +encaben encabar VMM03P0 +encabestra encabestrar VMM02S0 +encabestrad encabestrar VMM02P0 +encabestrando encabestrar VMG0000 +encabestrar encabestrar VMN0000 +encabestre encabestrar VMM03S0 +encabestremos encabestrar VMM01P0 +encabestren encabestrar VMM03P0 +encabeza encabezar VMM02S0 +encabezad encabezar VMM02P0 +encabezando encabezar VMG0000 +encabezar encabezar VMN0000 +encabrita encabritar VMM02S0 +encabritad encabritar VMM02P0 +encabritando encabritar VMG0000 +encabritar encabritar VMN0000 +encabrite encabritar VMM03S0 +encabritemos encabritar VMM01P0 +encabriten encabritar VMM03P0 +encacha encachar VMM02S0 +encachad encachar VMM02P0 +encachando encachar VMG0000 +encachar encachar VMN0000 +encache encachar VMM03S0 +encachemos encachar VMM01P0 +encachen encachar VMM03P0 +encada encadar VMM02S0 +encadad encadar VMM02P0 +encadando encadar VMG0000 +encadar encadar VMN0000 +encade encadar VMM03S0 +encademos encadar VMM01P0 +encaden encadar VMM03P0 +encadena encadenar VMM02S0 +encadenad encadenar VMM02P0 +encadenando encadenar VMG0000 +encadenar encadenar VMN0000 +encadene encadenar VMM03S0 +encadenemos encadenar VMM01P0 +encadenen encadenar VMM03P0 +encaja encajar VMM02S0 +encajad encajar VMM02P0 +encajando encajar VMG0000 +encajar encajar VMN0000 +encaje encajar VMM03S0 +encajemos encajar VMM01P0 +encajen encajar VMM03P0 +encajona encajonar VMM02S0 +encajonad encajonar VMM02P0 +encajonando encajonar VMG0000 +encajonar encajonar VMN0000 +encajone encajonar VMM03S0 +encajonemos encajonar VMM01P0 +encajonen encajonar VMM03P0 +encala encalar VMM02S0 +encalaboce encalabozar VMM03S0 +encalabocemos encalabozar VMM01P0 +encalabocen encalabozar VMM03P0 +encalaboza encalabozar VMM02S0 +encalabozad encalabozar VMM02P0 +encalabozando encalabozar VMG0000 +encalabozar encalabozar VMN0000 +encalabrina encalabrinar VMM02S0 +encalabrinad encalabrinar VMM02P0 +encalabrinando encalabrinar VMG0000 +encalabrinar encalabrinar VMN0000 +encalabrine encalabrinar VMM03S0 +encalabrinemos encalabrinar VMM01P0 +encalabrinen encalabrinar VMM03P0 +encalad encalar VMM02P0 +encalamoca encalamocar VMM02S0 +encalamocad encalamocar VMM02P0 +encalamocando encalamocar VMG0000 +encalamocar encalamocar VMN0000 +encalamoque encalamocar VMM03S0 +encalamoquemos encalamocar VMM01P0 +encalamoquen encalamocar VMM03P0 +encalando encalar VMG0000 +encalar encalar VMN0000 +encale encalar VMM03S0 +encalemos encalar VMM01P0 +encalen encalar VMM03P0 +encalla encallar VMM02S0 +encallad encallar VMM02P0 +encallando encallar VMG0000 +encallar encallar VMN0000 +encalle encallar VMM03S0 +encallece encallecer VMM02S0 +encalleced encallecer VMM02P0 +encallecer encallecer VMN0000 +encalleciendo encallecer VMG0000 +encallemos encallar VMM01P0 +encallen encallar VMM03P0 +encallezca encallecer VMM03S0 +encallezcamos encallecer VMM01P0 +encallezcan encallecer VMM03P0 +encalma encalmar VMM02S0 +encalmad encalmar VMM02P0 +encalmando encalmar VMG0000 +encalmar encalmar VMN0000 +encalme encalmar VMM03S0 +encalmemos encalmar VMM01P0 +encalmen encalmar VMM03P0 +encalvece encalvecer VMM02S0 +encalveced encalvecer VMM02P0 +encalvecer encalvecer VMN0000 +encalveciendo encalvecer VMG0000 +encalvezca encalvecer VMM03S0 +encalvezcamos encalvecer VMM01P0 +encalvezcan encalvecer VMM03P0 +encama encamar VMM02S0 +encamad encamar VMM02P0 +encamando encamar VMG0000 +encamar encamar VMN0000 +encambija encambijar VMM02S0 +encambijad encambijar VMM02P0 +encambijando encambijar VMG0000 +encambijar encambijar VMN0000 +encambije encambijar VMM03S0 +encambijemos encambijar VMM01P0 +encambijen encambijar VMM03P0 +encame encamar VMM03S0 +encamemos encamar VMM01P0 +encamen encamar VMM03P0 +encamina encaminar VMM02S0 +encaminad encaminar VMM02P0 +encaminando encaminar VMG0000 +encaminar encaminar VMN0000 +encamine encaminar VMM03S0 +encaminemos encaminar VMM01P0 +encaminen encaminar VMM03P0 +encamisa encamisar VMM02S0 +encamisad encamisar VMM02P0 +encamisando encamisar VMG0000 +encamisar encamisar VMN0000 +encamise encamisar VMM03S0 +encamisemos encamisar VMM01P0 +encamisen encamisar VMM03P0 +encamota encamotar VMM02S0 +encamotad encamotar VMM02P0 +encamotando encamotar VMG0000 +encamotar encamotar VMN0000 +encamote encamotar VMM03S0 +encamotemos encamotar VMM01P0 +encamoten encamotar VMM03P0 +encampana encampanar VMM02S0 +encampanad encampanar VMM02P0 +encampanando encampanar VMG0000 +encampanar encampanar VMN0000 +encampane encampanar VMM03S0 +encampanemos encampanar VMM01P0 +encampanen encampanar VMM03P0 +encanalla encanallar VMM02S0 +encanallad encanallar VMM02P0 +encanallando encanallar VMG0000 +encanallar encanallar VMN0000 +encanalle encanallar VMM03S0 +encanallemos encanallar VMM01P0 +encanallen encanallar VMM03P0 +encanasta encanastar VMM02S0 +encanastad encanastar VMM02P0 +encanastando encanastar VMG0000 +encanastar encanastar VMN0000 +encanaste encanastar VMM03S0 +encanastemos encanastar VMM01P0 +encanasten encanastar VMM03P0 +encancera encancerar VMM02S0 +encancerad encancerar VMM02P0 +encancerando encancerar VMG0000 +encancerar encancerar VMN0000 +encancere encancerar VMM03S0 +encanceremos encancerar VMM01P0 +encanceren encancerar VMM03P0 +encandece encandecer VMM02S0 +encandeced encandecer VMM02P0 +encandecer encandecer VMN0000 +encandeciendo encandecer VMG0000 +encandela encandelar VMM02S0 +encandelad encandelar VMM02P0 +encandelando encandelar VMG0000 +encandelar encandelar VMN0000 +encandele encandelar VMM03S0 +encandelemos encandelar VMM01P0 +encandelen encandelar VMM03P0 +encandezca encandecer VMM03S0 +encandezcamos encandecer VMM01P0 +encandezcan encandecer VMM03P0 +encandila encandilar VMM02S0 +encandilad encandilar VMM02P0 +encandilando encandilar VMG0000 +encandilar encandilar VMN0000 +encandile encandilar VMM03S0 +encandilemos encandilar VMM01P0 +encandilen encandilar VMM03P0 +encanece encanecer VMM02S0 +encaneced encanecer VMM02P0 +encanecer encanecer VMN0000 +encaneciendo encanecer VMG0000 +encanezca encanecer VMM03S0 +encanezcamos encanecer VMM01P0 +encanezcan encanecer VMM03P0 +encanija encanijar VMM02S0 +encanijad encanijar VMM02P0 +encanijando encanijar VMG0000 +encanijar encanijar VMN0000 +encanije encanijar VMM03S0 +encanijemos encanijar VMM01P0 +encanijen encanijar VMM03P0 +encanilla encanillar VMM02S0 +encanillad encanillar VMM02P0 +encanillando encanillar VMG0000 +encanillar encanillar VMN0000 +encanille encanillar VMM03S0 +encanillemos encanillar VMM01P0 +encanillen encanillar VMM03P0 +encanta encantar VMM02S0 +encantad encantar VMM02P0 +encantando encantar VMG0000 +encantar encantar VMN0000 +encantara encantarar VMM02S0 +encantarad encantarar VMM02P0 +encantarando encantarar VMG0000 +encantarar encantarar VMN0000 +encantare encantarar VMM03S0 +encantaremos encantarar VMM01P0 +encantaren encantarar VMM03P0 +encante encantar VMM03S0 +encantemos encantar VMM01P0 +encanten encantar VMM03P0 +encanuta encanutar VMM02S0 +encanutad encanutar VMM02P0 +encanutando encanutar VMG0000 +encanutar encanutar VMN0000 +encanute encanutar VMM03S0 +encanutemos encanutar VMM01P0 +encanuten encanutar VMM03P0 +encapacha encapachar VMM02S0 +encapachad encapachar VMM02P0 +encapachando encapachar VMG0000 +encapachar encapachar VMN0000 +encapache encapachar VMM03S0 +encapachemos encapachar VMM01P0 +encapachen encapachar VMM03P0 +encaparazona encaparazonar VMM02S0 +encaparazonad encaparazonar VMM02P0 +encaparazonando encaparazonar VMG0000 +encaparazonar encaparazonar VMN0000 +encaparazone encaparazonar VMM03S0 +encaparazonemos encaparazonar VMM01P0 +encaparazonen encaparazonar VMM03P0 +encapilla encapillar VMM02S0 +encapillad encapillar VMM02P0 +encapillando encapillar VMG0000 +encapillar encapillar VMN0000 +encapille encapillar VMM03S0 +encapillemos encapillar VMM01P0 +encapillen encapillar VMM03P0 +encapirota encapirotar VMM02S0 +encapirotad encapirotar VMM02P0 +encapirotando encapirotar VMG0000 +encapirotar encapirotar VMN0000 +encapirote encapirotar VMM03S0 +encapirotemos encapirotar VMM01P0 +encapiroten encapirotar VMM03P0 +encapota encapotar VMM02S0 +encapotad encapotar VMM02P0 +encapotando encapotar VMG0000 +encapotar encapotar VMN0000 +encapote encapotar VMM03S0 +encapotemos encapotar VMM01P0 +encapoten encapotar VMM03P0 +encapricha encaprichar VMM02S0 +encaprichad encaprichar VMM02P0 +encaprichando encaprichar VMG0000 +encaprichar encaprichar VMN0000 +encapriche encaprichar VMM03S0 +encaprichemos encaprichar VMM01P0 +encaprichen encaprichar VMM03P0 +encapsula encapsular VMM02S0 +encapsulad encapsular VMM02P0 +encapsulando encapsular VMG0000 +encapsular encapsular VMN0000 +encapsule encapsular VMM03S0 +encapsulemos encapsular VMM01P0 +encapsulen encapsular VMM03P0 +encapuce encapuzar VMM03S0 +encapucemos encapuzar VMM01P0 +encapucen encapuzar VMM03P0 +encapucha encapuchar VMM02S0 +encapuchad encapuchar VMM02P0 +encapuchando encapuchar VMG0000 +encapuchar encapuchar VMN0000 +encapuche encapuchar VMM03S0 +encapuchemos encapuchar VMM01P0 +encapuchen encapuchar VMM03P0 +encapuza encapuzar VMM02S0 +encapuzad encapuzar VMM02P0 +encapuzando encapuzar VMG0000 +encapuzar encapuzar VMN0000 +encara encarar VMM02S0 +encarad encarar VMM02P0 +encarama encaramar VMM02S0 +encaramad encaramar VMM02P0 +encaramando encaramar VMG0000 +encaramar encaramar VMN0000 +encarame encaramar VMM03S0 +encaramemos encaramar VMM01P0 +encaramen encaramar VMM03P0 +encarando encarar VMG0000 +encarar encarar VMN0000 +encarcela encarcelar VMM02S0 +encarcelad encarcelar VMM02P0 +encarcelando encarcelar VMG0000 +encarcelar encarcelar VMN0000 +encarcele encarcelar VMM03S0 +encarcelemos encarcelar VMM01P0 +encarcelen encarcelar VMM03P0 +encare encarar VMM03S0 +encarece encarecer VMM02S0 +encareced encarecer VMM02P0 +encarecer encarecer VMN0000 +encareciendo encarecer VMG0000 +encaremos encarar VMM01P0 +encaren encarar VMM03P0 +encarezca encarecer VMM03S0 +encarezcamos encarecer VMM01P0 +encarezcan encarecer VMM03P0 +encarga encargar VMM02S0 +encargad encargar VMM02P0 +encargando encargar VMG0000 +encargar encargar VMN0000 +encargue encargar VMM03S0 +encarguemos encargar VMM01P0 +encarguen encargar VMM03P0 +encariña encariñar VMM02S0 +encariñad encariñar VMM02P0 +encariñando encariñar VMG0000 +encariñar encariñar VMN0000 +encariñe encariñar VMM03S0 +encariñemos encariñar VMM01P0 +encariñen encariñar VMM03P0 +encarna encarnar VMM02S0 +encarnad encarnar VMM02P0 +encarnando encarnar VMG0000 +encarnar encarnar VMN0000 +encarne encarnar VMM03S0 +encarnece encarnecer VMM02S0 +encarneced encarnecer VMM02P0 +encarnecer encarnecer VMN0000 +encarneciendo encarnecer VMG0000 +encarnemos encarnar VMM01P0 +encarnen encarnar VMM03P0 +encarnezca encarnecer VMM03S0 +encarnezcamos encarnecer VMM01P0 +encarnezcan encarnecer VMM03P0 +encarnice encarnizar VMM03S0 +encarnicemos encarnizar VMM01P0 +encarnicen encarnizar VMM03P0 +encarniza encarnizar VMM02S0 +encarnizad encarnizar VMM02P0 +encarnizando encarnizar VMG0000 +encarnizar encarnizar VMN0000 +encarpeta encarpetar VMM02S0 +encarpetad encarpetar VMM02P0 +encarpetando encarpetar VMG0000 +encarpetar encarpetar VMN0000 +encarpete encarpetar VMM03S0 +encarpetemos encarpetar VMM01P0 +encarpeten encarpetar VMM03P0 +encarrila encarrilar VMM02S0 +encarrilad encarrilar VMM02P0 +encarrilando encarrilar VMG0000 +encarrilar encarrilar VMN0000 +encarrile encarrilar VMM03S0 +encarrilemos encarrilar VMM01P0 +encarrilen encarrilar VMM03P0 +encarrilla encarrillar VMM02S0 +encarrillad encarrillar VMM02P0 +encarrillando encarrillar VMG0000 +encarrillar encarrillar VMN0000 +encarrille encarrillar VMM03S0 +encarrillemos encarrillar VMM01P0 +encarrillen encarrillar VMM03P0 +encarroña encarroñar VMM02S0 +encarroñad encarroñar VMM02P0 +encarroñando encarroñar VMG0000 +encarroñar encarroñar VMN0000 +encarroñe encarroñar VMM03S0 +encarroñemos encarroñar VMM01P0 +encarroñen encarroñar VMM03P0 +encarruja encarrujar VMM02S0 +encarrujad encarrujar VMM02P0 +encarrujando encarrujar VMG0000 +encarrujar encarrujar VMN0000 +encarruje encarrujar VMM03S0 +encarrujemos encarrujar VMM01P0 +encarrujen encarrujar VMM03P0 +encarta encartar VMM02S0 +encartad encartar VMM02P0 +encartando encartar VMG0000 +encartar encartar VMN0000 +encarte encartar VMM03S0 +encartemos encartar VMM01P0 +encarten encartar VMM03P0 +encartona encartonar VMM02S0 +encartonad encartonar VMM02P0 +encartonando encartonar VMG0000 +encartonar encartonar VMN0000 +encartone encartonar VMM03S0 +encartonemos encartonar VMM01P0 +encartonen encartonar VMM03P0 +encascabela encascabelar VMM02S0 +encascabelad encascabelar VMM02P0 +encascabelando encascabelar VMG0000 +encascabelar encascabelar VMN0000 +encascabele encascabelar VMM03S0 +encascabelemos encascabelar VMM01P0 +encascabelen encascabelar VMM03P0 +encascota encascotar VMM02S0 +encascotad encascotar VMM02P0 +encascotando encascotar VMG0000 +encascotar encascotar VMN0000 +encascote encascotar VMM03S0 +encascotemos encascotar VMM01P0 +encascoten encascotar VMM03P0 +encasilla encasillar VMM02S0 +encasillad encasillar VMM02P0 +encasillando encasillar VMG0000 +encasillar encasillar VMN0000 +encasille encasillar VMM03S0 +encasillemos encasillar VMM01P0 +encasillen encasillar VMM03P0 +encasqueta encasquetar VMM02S0 +encasquetad encasquetar VMM02P0 +encasquetando encasquetar VMG0000 +encasquetar encasquetar VMN0000 +encasquete encasquetar VMM03S0 +encasquetemos encasquetar VMM01P0 +encasqueten encasquetar VMM03P0 +encasquilla encasquillar VMM02S0 +encasquillad encasquillar VMM02P0 +encasquillando encasquillar VMG0000 +encasquillar encasquillar VMN0000 +encasquille encasquillar VMM03S0 +encasquillemos encasquillar VMM01P0 +encasquillen encasquillar VMM03P0 +encastilla encastillar VMM02S0 +encastillad encastillar VMM02P0 +encastillando encastillar VMG0000 +encastillar encastillar VMN0000 +encastille encastillar VMM03S0 +encastillemos encastillar VMM01P0 +encastillen encastillar VMM03P0 +encastra encastrar VMM02S0 +encastrad encastrar VMM02P0 +encastrando encastrar VMG0000 +encastrar encastrar VMN0000 +encastre encastrar VMM03S0 +encastremos encastrar VMM01P0 +encastren encastrar VMM03P0 +encatusa encatusar VMM02S0 +encatusad encatusar VMM02P0 +encatusando encatusar VMG0000 +encatusar encatusar VMN0000 +encatuse encatusar VMM03S0 +encatusemos encatusar VMM01P0 +encatusen encatusar VMM03P0 +encauce encauzar VMM03S0 +encaucemos encauzar VMM01P0 +encaucen encauzar VMM03P0 +encaucha encauchar VMM02S0 +encauchad encauchar VMM02P0 +encauchando encauchar VMG0000 +encauchar encauchar VMN0000 +encauche encauchar VMM03S0 +encauchemos encauchar VMM01P0 +encauchen encauchar VMM03P0 +encausa encausar VMM02S0 +encausad encausar VMM02P0 +encausando encausar VMG0000 +encausar encausar VMN0000 +encause encausar VMM03S0 +encausemos encausar VMM01P0 +encausen encausar VMM03P0 +encauza encauzar VMM02S0 +encauzad encauzar VMM02P0 +encauzando encauzar VMG0000 +encauzar encauzar VMN0000 +encaña encañar VMM02S0 +encañad encañar VMM02P0 +encañando encañar VMG0000 +encañar encañar VMN0000 +encañe encañar VMM03S0 +encañemos encañar VMM01P0 +encañen encañar VMM03P0 +encañona encañonar VMM02S0 +encañonad encañonar VMM02P0 +encañonando encañonar VMG0000 +encañonar encañonar VMN0000 +encañone encañonar VMM03S0 +encañonemos encañonar VMM01P0 +encañonen encañonar VMM03P0 +encañuta encañutar VMM02S0 +encañutad encañutar VMM02P0 +encañutando encañutar VMG0000 +encañutar encañutar VMN0000 +encebada encebadar VMM02S0 +encebadad encebadar VMM02P0 +encebadando encebadar VMG0000 +encebadar encebadar VMN0000 +encebade encebadar VMM03S0 +encebademos encebadar VMM01P0 +encebaden encebadar VMM03P0 +encela encelar VMM02S0 +encelad encelar VMM02P0 +encelando encelar VMG0000 +encelar encelar VMN0000 +encele encelar VMM03S0 +encelemos encelar VMM01P0 +encelen encelar VMM03P0 +encenaga encenagar VMM02S0 +encenagad encenagar VMM02P0 +encenagando encenagar VMG0000 +encenagar encenagar VMN0000 +encenague encenagar VMM03S0 +encenaguemos encenagar VMM01P0 +encenaguen encenagar VMM03P0 +encendamos encender VMM01P0 +encended encender VMM02P0 +encender encender VMN0000 +encendiendo encender VMG0000 +encenice encenizar VMM03S0 +encenicemos encenizar VMM01P0 +encenicen encenizar VMM03P0 +enceniza encenizar VMM02S0 +encenizad encenizar VMM02P0 +encenizando encenizar VMG0000 +encenizar encenizar VMN0000 +encenta encentar VMM02S0 +encentad encentar VMM02P0 +encentando encentar VMG0000 +encentar encentar VMN0000 +encente encentar VMM03S0 +encentemos encentar VMM01P0 +encenten encentar VMM03P0 +encepa encepar VMM02S0 +encepad encepar VMM02P0 +encepando encepar VMG0000 +encepar encepar VMN0000 +encepe encepar VMM03S0 +encepemos encepar VMM01P0 +encepen encepar VMM03P0 +encera encerar VMM02S0 +encerad encerar VMM02P0 +encerando encerar VMG0000 +encerar encerar VMN0000 +encere encerar VMM03S0 +enceremos encerar VMM01P0 +enceren encerar VMM03P0 +encerota encerotar VMM02S0 +encerotad encerotar VMM02P0 +encerotando encerotar VMG0000 +encerotar encerotar VMN0000 +encerote encerotar VMM03S0 +encerotemos encerotar VMM01P0 +enceroten encerotar VMM03P0 +encerrad encerrar VMM02P0 +encerrando encerrar VMG0000 +encerrar encerrar VMN0000 +encerremos encerrar VMM01P0 +encespeda encespedar VMM02S0 +encespedad encespedar VMM02P0 +encespedando encespedar VMG0000 +encespedar encespedar VMN0000 +encespede encespedar VMM03S0 +encespedemos encespedar VMM01P0 +encespeden encespedar VMM03P0 +encesta encestar VMM02S0 +encestad encestar VMM02P0 +encestando encestar VMG0000 +encestar encestar VMN0000 +enceste encestar VMM03S0 +encestemos encestar VMM01P0 +encesten encestar VMM03P0 +enchaleca enchalecar VMM02S0 +enchalecad enchalecar VMM02P0 +enchalecando enchalecar VMG0000 +enchalecar enchalecar VMN0000 +enchaleque enchalecar VMM03S0 +enchalequemos enchalecar VMM01P0 +enchalequen enchalecar VMM03P0 +enchancleta enchancletar VMM02S0 +enchancletad enchancletar VMM02P0 +enchancletando enchancletar VMG0000 +enchancletar enchancletar VMN0000 +enchanclete enchancletar VMM03S0 +enchancletemos enchancletar VMM01P0 +enchancleten enchancletar VMM03P0 +enchapa enchapar VMM02S0 +enchapad enchapar VMM02P0 +enchapando enchapar VMG0000 +enchapar enchapar VMN0000 +enchape enchapar VMM03S0 +enchapemos enchapar VMM01P0 +enchapen enchapar VMM03P0 +encharca encharcar VMM02S0 +encharcad encharcar VMM02P0 +encharcando encharcar VMG0000 +encharcar encharcar VMN0000 +encharque encharcar VMM03S0 +encharquemos encharcar VMM01P0 +encharquen encharcar VMM03P0 +enchaveta enchavetar VMM02S0 +enchavetad enchavetar VMM02P0 +enchavetando enchavetar VMG0000 +enchavetar enchavetar VMN0000 +enchavete enchavetar VMM03S0 +enchavetemos enchavetar VMM01P0 +enchaveten enchavetar VMM03P0 +enchila enchilar VMM02S0 +enchilad enchilar VMM02P0 +enchilando enchilar VMG0000 +enchilar enchilar VMN0000 +enchile enchilar VMM03S0 +enchilemos enchilar VMM01P0 +enchilen enchilar VMM03P0 +enchina enchinar VMM02S0 +enchinad enchinar VMM02P0 +enchinando enchinar VMG0000 +enchinar enchinar VMN0000 +enchine enchinar VMM03S0 +enchinemos enchinar VMM01P0 +enchinen enchinar VMM03P0 +enchirona enchironar VMM02S0 +enchironad enchironar VMM02P0 +enchironando enchironar VMG0000 +enchironar enchironar VMN0000 +enchirone enchironar VMM03S0 +enchironemos enchironar VMM01P0 +enchironen enchironar VMM03P0 +enchueca enchuecar VMM02S0 +enchuecad enchuecar VMM02P0 +enchuecando enchuecar VMG0000 +enchuecar enchuecar VMN0000 +enchueque enchuecar VMM03S0 +enchuequemos enchuecar VMM01P0 +enchuequen enchuecar VMM03P0 +enchufa enchufar VMM02S0 +enchufad enchufar VMM02P0 +enchufando enchufar VMG0000 +enchufar enchufar VMN0000 +enchufe enchufar VMM03S0 +enchufemos enchufar VMM01P0 +enchufen enchufar VMM03P0 +encienda encender VMM03S0 +enciendan encender VMM03P0 +enciende encender VMM02S0 +encierra encerrar VMM02S0 +encierre encerrar VMM03S0 +encierren encerrar VMM03P0 +encima encimar VMM02S0 +encimad encimar VMM02P0 +encimando encimar VMG0000 +encimar encimar VMN0000 +encime encimar VMM03S0 +encimemos encimar VMM01P0 +encimen encimar VMM03P0 +encinta encintar VMM02S0 +encintad encintar VMM02P0 +encintando encintar VMG0000 +encintar encintar VMN0000 +encinte encintar VMM03S0 +encintemos encintar VMM01P0 +encinten encintar VMM03P0 +encisma encismar VMM02S0 +encismad encismar VMM02P0 +encismando encismar VMG0000 +encismar encismar VMN0000 +encisme encismar VMM03S0 +encismemos encismar VMM01P0 +encismen encismar VMM03P0 +encizaña encizañar VMM02S0 +encizañad encizañar VMM02P0 +encizañando encizañar VMG0000 +encizañar encizañar VMN0000 +encizañe encizañar VMM03S0 +encizañemos encizañar VMM01P0 +encizañen encizañar VMM03P0 +enclaustra enclaustrar VMM02S0 +enclaustrad enclaustrar VMM02P0 +enclaustrando enclaustrar VMG0000 +enclaustrar enclaustrar VMN0000 +enclaustre enclaustrar VMM03S0 +enclaustremos enclaustrar VMM01P0 +enclaustren enclaustrar VMM03P0 +enclava enclavar VMM02S0 +enclavad enclavar VMM02P0 +enclavando enclavar VMG0000 +enclavar enclavar VMN0000 +enclave enclavar VMM03S0 +enclavemos enclavar VMM01P0 +enclaven enclavar VMM03P0 +enclavija enclavijar VMM02S0 +enclavijad enclavijar VMM02P0 +enclavijando enclavijar VMG0000 +enclavijar enclavijar VMN0000 +enclavije enclavijar VMM03S0 +enclavijemos enclavijar VMM01P0 +enclavijen enclavijar VMM03P0 +enclocad enclocar VMM02P0 +enclocando enclocar VMG0000 +enclocar enclocar VMN0000 +encloquece encloquecer VMM02S0 +encloqueced encloquecer VMM02P0 +encloquecer encloquecer VMN0000 +encloqueciendo encloquecer VMG0000 +encloquemos enclocar VMM01P0 +encloquezca encloquecer VMM03S0 +encloquezcamos encloquecer VMM01P0 +encloquezcan encloquecer VMM03P0 +enclueca enclocar VMM02S0 +enclueque enclocar VMM03S0 +encluequen enclocar VMM03P0 +encoba encobar VMM02S0 +encobad encobar VMM02P0 +encobando encobar VMG0000 +encobar encobar VMN0000 +encobe encobar VMM03S0 +encobemos encobar VMM01P0 +encoben encobar VMM03P0 +encobra encobrar VMM02S0 +encobrad encobrar VMM02P0 +encobrando encobrar VMG0000 +encobrar encobrar VMN0000 +encobre encobrar VMM03S0 +encobremos encobrar VMM01P0 +encobren encobrar VMM03P0 +encocora encocorar VMM02S0 +encocorad encocorar VMM02P0 +encocorando encocorar VMG0000 +encocorar encocorar VMN0000 +encocore encocorar VMM03S0 +encocoremos encocorar VMM01P0 +encocoren encocorar VMM03P0 +encofra encofrar VMM02S0 +encofrad encofrar VMM02P0 +encofrando encofrar VMG0000 +encofrar encofrar VMN0000 +encofre encofrar VMM03S0 +encofremos encofrar VMM01P0 +encofren encofrar VMM03P0 +encoge encoger VMM02S0 +encoged encoger VMM02P0 +encoger encoger VMN0000 +encogiendo encoger VMG0000 +encoja encoger VMM03S0 +encojamos encoger VMM01P0 +encojan encoger VMM03P0 +encola encolar VMM02S0 +encolad encolar VMM02P0 +encolando encolar VMG0000 +encolar encolar VMN0000 +encole encolar VMM03S0 +encolemos encolar VMM01P0 +encolen encolar VMM03P0 +encolerice encolerizar VMM03S0 +encolericemos encolerizar VMM01P0 +encolericen encolerizar VMM03P0 +encoleriza encolerizar VMM02S0 +encolerizad encolerizar VMM02P0 +encolerizando encolerizar VMG0000 +encolerizar encolerizar VMN0000 +encomendad encomendar VMM02P0 +encomendando encomendar VMG0000 +encomendar encomendar VMN0000 +encomendemos encomendar VMM01P0 +encomia encomiar VMM02S0 +encomiad encomiar VMM02P0 +encomiando encomiar VMG0000 +encomiar encomiar VMN0000 +encomie encomiar VMM03S0 +encomiemos encomiar VMM01P0 +encomien encomiar VMM03P0 +encomienda encomendar VMM02S0 +encomiende encomendar VMM03S0 +encomienden encomendar VMM03P0 +encompadra encompadrar VMM02S0 +encompadrad encompadrar VMM02P0 +encompadrando encompadrar VMG0000 +encompadrar encompadrar VMN0000 +encompadre encompadrar VMM03S0 +encompadremos encompadrar VMM01P0 +encompadren encompadrar VMM03P0 +encona enconar VMM02S0 +enconad enconar VMM02P0 +enconando enconar VMG0000 +enconar enconar VMN0000 +encone enconar VMM03S0 +enconemos enconar VMM01P0 +enconen enconar VMM03P0 +encontrad encontrar VMM02P0 +encontrando encontrar VMG0000 +encontrar encontrar VMN0000 +encontremos encontrar VMM01P0 +encopeta encopetar VMM02S0 +encopetad encopetar VMM02P0 +encopetando encopetar VMG0000 +encopetar encopetar VMN0000 +encopete encopetar VMM03S0 +encopetemos encopetar VMM01P0 +encopeten encopetar VMM03P0 +encorad encorar VMM02P0 +encoraja encorajar VMM02S0 +encorajad encorajar VMM02P0 +encorajando encorajar VMG0000 +encorajar encorajar VMN0000 +encoraje encorajar VMM03S0 +encorajemos encorajar VMM01P0 +encorajen encorajar VMM03P0 +encorajina encorajinar VMM02S0 +encorajinad encorajinar VMM02P0 +encorajinando encorajinar VMG0000 +encorajinar encorajinar VMN0000 +encorajine encorajinar VMM03S0 +encorajinemos encorajinar VMM01P0 +encorajinen encorajinar VMM03P0 +encorando encorar VMG0000 +encorar encorar VMN0000 +encorcha encorchar VMM02S0 +encorchad encorchar VMM02P0 +encorchando encorchar VMG0000 +encorchar encorchar VMN0000 +encorche encorchar VMM03S0 +encorchemos encorchar VMM01P0 +encorchen encorchar VMM03P0 +encorcheta encorchetar VMM02S0 +encorchetad encorchetar VMM02P0 +encorchetando encorchetar VMG0000 +encorchetar encorchetar VMN0000 +encorchete encorchetar VMM03S0 +encorchetemos encorchetar VMM01P0 +encorcheten encorchetar VMM03P0 +encordad encordar VMM02P0 +encordando encordar VMG0000 +encordar encordar VMN0000 +encordela encordelar VMM02S0 +encordelad encordelar VMM02P0 +encordelando encordelar VMG0000 +encordelar encordelar VMN0000 +encordele encordelar VMM03S0 +encordelemos encordelar VMM01P0 +encordelen encordelar VMM03P0 +encordemos encordar VMM01P0 +encordona encordonar VMM02S0 +encordonad encordonar VMM02P0 +encordonando encordonar VMG0000 +encordonar encordonar VMN0000 +encordone encordonar VMM03S0 +encordonemos encordonar VMM01P0 +encordonen encordonar VMM03P0 +encoremos encorar VMM01P0 +encoroce encorozar VMM03S0 +encorocemos encorozar VMM01P0 +encorocen encorozar VMM03P0 +encoroza encorozar VMM02S0 +encorozad encorozar VMM02P0 +encorozando encorozar VMG0000 +encorozar encorozar VMN0000 +encorrala encorralar VMM02S0 +encorralad encorralar VMM02P0 +encorralando encorralar VMG0000 +encorralar encorralar VMN0000 +encorrale encorralar VMM03S0 +encorralemos encorralar VMM01P0 +encorralen encorralar VMM03P0 +encorseta encorsetar VMM02S0 +encorsetad encorsetar VMM02P0 +encorsetando encorsetar VMG0000 +encorsetar encorsetar VMN0000 +encorsete encorsetar VMM03S0 +encorsetemos encorsetar VMM01P0 +encorseten encorsetar VMM03P0 +encorva encorvar VMM02S0 +encorvad encorvar VMM02P0 +encorvando encorvar VMG0000 +encorvar encorvar VMN0000 +encorve encorvar VMM03S0 +encorvemos encorvar VMM01P0 +encorven encorvar VMM03P0 +encostala encostalar VMM02S0 +encostalad encostalar VMM02P0 +encostalando encostalar VMG0000 +encostalar encostalar VMN0000 +encostale encostalar VMM03S0 +encostalemos encostalar VMM01P0 +encostalen encostalar VMM03P0 +encostra encostrar VMM02S0 +encostrad encostrar VMM02P0 +encostrando encostrar VMG0000 +encostrar encostrar VMN0000 +encostre encostrar VMM03S0 +encostremos encostrar VMM01P0 +encostren encostrar VMM03P0 +encovad encovar VMM02P0 +encovando encovar VMG0000 +encovar encovar VMN0000 +encovemos encovar VMM01P0 +encrasa encrasar VMM02S0 +encrasad encrasar VMM02P0 +encrasando encrasar VMG0000 +encrasar encrasar VMN0000 +encrase encrasar VMM03S0 +encrasemos encrasar VMM01P0 +encrasen encrasar VMM03P0 +encrespa encrespar VMM02S0 +encrespad encrespar VMM02P0 +encrespando encrespar VMG0000 +encrespar encrespar VMN0000 +encrespe encrespar VMM03S0 +encrespemos encrespar VMM01P0 +encrespen encrespar VMM03P0 +encripta encriptar VMM02S0 +encriptad encriptar VMM02P0 +encriptando encriptar VMG0000 +encriptar encriptar VMN0000 +encripte encriptar VMM03S0 +encriptemos encriptar VMM01P0 +encripten encriptar VMM03P0 +encristala encristalar VMM02S0 +encristalad encristalar VMM02P0 +encristalando encristalar VMG0000 +encristalar encristalar VMN0000 +encristale encristalar VMM03S0 +encristalemos encristalar VMM01P0 +encristalen encristalar VMM03P0 +encrudece encrudecer VMM02S0 +encrudeced encrudecer VMM02P0 +encrudecer encrudecer VMN0000 +encrudeciendo encrudecer VMG0000 +encrudezca encrudecer VMM03S0 +encrudezcamos encrudecer VMM01P0 +encrudezcan encrudecer VMM03P0 +encruelece encruelecer VMM02S0 +encrueleced encruelecer VMM02P0 +encruelecer encruelecer VMN0000 +encrueleciendo encruelecer VMG0000 +encruelezca encruelecer VMM03S0 +encruelezcamos encruelecer VMM01P0 +encruelezcan encruelecer VMM03P0 +encuaderna encuadernar VMM02S0 +encuadernad encuadernar VMM02P0 +encuadernando encuadernar VMG0000 +encuadernar encuadernar VMN0000 +encuaderne encuadernar VMM03S0 +encuadernemos encuadernar VMM01P0 +encuadernen encuadernar VMM03P0 +encuadra encuadrar VMM02S0 +encuadrad encuadrar VMM02P0 +encuadrando encuadrar VMG0000 +encuadrar encuadrar VMN0000 +encuadre encuadrar VMM03S0 +encuadremos encuadrar VMM01P0 +encuadren encuadrar VMM03P0 +encuba encubar VMM02S0 +encubad encubar VMM02P0 +encubando encubar VMG0000 +encubar encubar VMN0000 +encube encubar VMM03S0 +encubemos encubar VMM01P0 +encuben encubar VMM03P0 +encubra encubrir VMM03S0 +encubramos encubrir VMM01P0 +encubran encubrir VMM03P0 +encubre encubrir VMM02S0 +encubrid encubrir VMM02P0 +encubriendo encubrir VMG0000 +encubrir encubrir VMN0000 +encuentra encontrar VMM02S0 +encuentre encontrar VMM03S0 +encuentren encontrar VMM03P0 +encuera encorar VMM02S0 +encuera encuerar VMM02S0 +encuerad encuerar VMM02P0 +encuerando encuerar VMG0000 +encuerar encuerar VMN0000 +encuerda encordar VMM02S0 +encuerde encordar VMM03S0 +encuerden encordar VMM03P0 +encuere encorar VMM03S0 +encuere encuerar VMM03S0 +encueremos encuerar VMM01P0 +encueren encorar VMM03P0 +encueren encuerar VMM03P0 +encuesta encuestar VMM02S0 +encuestad encuestar VMM02P0 +encuestando encuestar VMG0000 +encuestar encuestar VMN0000 +encueste encuestar VMM03S0 +encuestemos encuestar VMM01P0 +encuesten encuestar VMM03P0 +encueva encovar VMM02S0 +encueve encovar VMM03S0 +encueven encovar VMM03P0 +encuita encuitar VMM02S0 +encuitad encuitar VMM02P0 +encuitando encuitar VMG0000 +encuitar encuitar VMN0000 +encuite encuitar VMM03S0 +encuitemos encuitar VMM01P0 +encuiten encuitar VMM03P0 +encumbra encumbrar VMM02S0 +encumbrad encumbrar VMM02P0 +encumbrando encumbrar VMG0000 +encumbrar encumbrar VMN0000 +encumbre encumbrar VMM03S0 +encumbremos encumbrar VMM01P0 +encumbren encumbrar VMM03P0 +encuna encunar VMM02S0 +encunad encunar VMM02P0 +encunando encunar VMG0000 +encunar encunar VMN0000 +encune encunar VMM03S0 +encunemos encunar VMM01P0 +encunen encunar VMM03P0 +encureña encureñar VMM02S0 +encureñad encureñar VMM02P0 +encureñando encureñar VMG0000 +encureñar encureñar VMN0000 +encureñe encureñar VMM03S0 +encureñemos encureñar VMM01P0 +encureñen encureñar VMM03P0 +encurta encurtir VMM03S0 +encurtamos encurtir VMM01P0 +encurtan encurtir VMM03P0 +encurte encurtir VMM02S0 +encurtid encurtir VMM02P0 +encurtiendo encurtir VMG0000 +encurtir encurtir VMN0000 +endecha endechar VMM02S0 +endechad endechar VMM02P0 +endechando endechar VMG0000 +endechar endechar VMN0000 +endeche endechar VMM03S0 +endechemos endechar VMM01P0 +endechen endechar VMM03P0 +endemonia endemoniar VMM02S0 +endemoniad endemoniar VMM02P0 +endemoniando endemoniar VMG0000 +endemoniar endemoniar VMN0000 +endemonie endemoniar VMM03S0 +endemoniemos endemoniar VMM01P0 +endemonien endemoniar VMM03P0 +endentad endentar VMM02P0 +endentando endentar VMG0000 +endentar endentar VMN0000 +endentece endentecer VMM02S0 +endenteced endentecer VMM02P0 +endentecer endentecer VMN0000 +endenteciendo endentecer VMG0000 +endentemos endentar VMM01P0 +endentezca endentecer VMM03S0 +endentezcamos endentecer VMM01P0 +endentezcan endentecer VMM03P0 +enderece enderezar VMM03S0 +enderecemos enderezar VMM01P0 +enderecen enderezar VMM03P0 +endereza enderezar VMM02S0 +enderezad enderezar VMM02P0 +enderezando enderezar VMG0000 +enderezar enderezar VMN0000 +endeuda endeudar VMM02S0 +endeudad endeudar VMM02P0 +endeudando endeudar VMG0000 +endeudar endeudar VMN0000 +endeude endeudar VMM03S0 +endeudemos endeudar VMM01P0 +endeuden endeudar VMM03P0 +endiabla endiablar VMM02S0 +endiablad endiablar VMM02P0 +endiablando endiablar VMG0000 +endiablar endiablar VMN0000 +endiable endiablar VMM03S0 +endiablemos endiablar VMM01P0 +endiablen endiablar VMM03P0 +endienta endentar VMM02S0 +endiente endentar VMM03S0 +endienten endentar VMM03P0 +endilga endilgar VMM02S0 +endilgad endilgar VMM02P0 +endilgando endilgar VMG0000 +endilgar endilgar VMN0000 +endilgue endilgar VMM03S0 +endilguemos endilgar VMM01P0 +endilguen endilgar VMM03P0 +endiosa endiosar VMM02S0 +endiosad endiosar VMM02P0 +endiosando endiosar VMG0000 +endiosar endiosar VMN0000 +endiose endiosar VMM03S0 +endiosemos endiosar VMM01P0 +endiosen endiosar VMM03P0 +endita enditar VMM02S0 +enditad enditar VMM02P0 +enditando enditar VMG0000 +enditar enditar VMN0000 +endite enditar VMM03S0 +enditemos enditar VMM01P0 +enditen enditar VMM03P0 +endiña endiñar VMM02S0 +endiñad endiñar VMM02P0 +endiñando endiñar VMG0000 +endiñar endiñar VMN0000 +endiñe endiñar VMM03S0 +endiñemos endiñar VMM01P0 +endiñen endiñar VMM03P0 +endominga endomingar VMM02S0 +endomingad endomingar VMM02P0 +endomingando endomingar VMG0000 +endomingar endomingar VMN0000 +endomingue endomingar VMM03S0 +endominguemos endomingar VMM01P0 +endominguen endomingar VMM03P0 +endosa endosar VMM02S0 +endosad endosar VMM02P0 +endosando endosar VMG0000 +endosar endosar VMN0000 +endose endosar VMM03S0 +endosela endoselar VMM02S0 +endoselad endoselar VMM02P0 +endoselando endoselar VMG0000 +endoselar endoselar VMN0000 +endosele endoselar VMM03S0 +endoselemos endoselar VMM01P0 +endoselen endoselar VMM03P0 +endosemos endosar VMM01P0 +endosen endosar VMM03P0 +endroga endrogar VMM02S0 +endrogad endrogar VMM02P0 +endrogando endrogar VMG0000 +endrogar endrogar VMN0000 +endrogue endrogar VMM03S0 +endroguemos endrogar VMM01P0 +endroguen endrogar VMM03P0 +endulce endulzar VMM03S0 +endulcemos endulzar VMM01P0 +endulcen endulzar VMM03P0 +endulza endulzar VMM02S0 +endulzad endulzar VMM02P0 +endulzando endulzar VMG0000 +endulzar endulzar VMN0000 +endura endurar VMM02S0 +endurad endurar VMM02P0 +endurando endurar VMG0000 +endurar endurar VMN0000 +endure endurar VMM03S0 +endurece endurecer VMM02S0 +endureced endurecer VMM02P0 +endurecer endurecer VMN0000 +endureciendo endurecer VMG0000 +enduremos endurar VMM01P0 +enduren endurar VMM03P0 +endurezca endurecer VMM03S0 +endurezcamos endurecer VMM01P0 +endurezcan endurecer VMM03P0 +enemista enemistar VMM02S0 +enemistad enemistar VMM02P0 +enemistando enemistar VMG0000 +enemistar enemistar VMN0000 +enemiste enemistar VMM03S0 +enemistemos enemistar VMM01P0 +enemisten enemistar VMM03P0 +enerva enervar VMM02S0 +enervad enervar VMM02P0 +enervando enervar VMG0000 +enervar enervar VMN0000 +enerve enervar VMM03S0 +enervemos enervar VMM01P0 +enerven enervar VMM03P0 +enfada enfadar VMM02S0 +enfadad enfadar VMM02P0 +enfadando enfadar VMG0000 +enfadar enfadar VMN0000 +enfade enfadar VMM03S0 +enfademos enfadar VMM01P0 +enfaden enfadar VMM03P0 +enfalda enfaldar VMM02S0 +enfaldad enfaldar VMM02P0 +enfaldando enfaldar VMG0000 +enfaldar enfaldar VMN0000 +enfalde enfaldar VMM03S0 +enfaldemos enfaldar VMM01P0 +enfalden enfaldar VMM03P0 +enfanga enfangar VMM02S0 +enfangad enfangar VMM02P0 +enfangando enfangar VMG0000 +enfangar enfangar VMN0000 +enfangue enfangar VMM03S0 +enfanguemos enfangar VMM01P0 +enfanguen enfangar VMM03P0 +enfarda enfardar VMM02S0 +enfardad enfardar VMM02P0 +enfardando enfardar VMG0000 +enfardar enfardar VMN0000 +enfarde enfardar VMM03S0 +enfardela enfardelar VMM02S0 +enfardelad enfardelar VMM02P0 +enfardelando enfardelar VMG0000 +enfardelar enfardelar VMN0000 +enfardele enfardelar VMM03S0 +enfardelemos enfardelar VMM01P0 +enfardelen enfardelar VMM03P0 +enfardemos enfardar VMM01P0 +enfarden enfardar VMM03P0 +enfatice enfatizar VMM03S0 +enfaticemos enfatizar VMM01P0 +enfaticen enfatizar VMM03P0 +enfatiza enfatizar VMM02S0 +enfatizad enfatizar VMM02P0 +enfatizando enfatizar VMG0000 +enfatizar enfatizar VMN0000 +enfatuad enfatuar VMM02P0 +enfatuando enfatuar VMG0000 +enfatúa enfatuar VMM02S0 +enferma enfermar VMM02S0 +enfermad enfermar VMM02P0 +enfermando enfermar VMG0000 +enfermar enfermar VMN0000 +enferme enfermar VMM03S0 +enfermemos enfermar VMM01P0 +enfermen enfermar VMM03P0 +enfervorice enfervorizar VMM03S0 +enfervoricemos enfervorizar VMM01P0 +enfervoricen enfervorizar VMM03P0 +enfervoriza enfervorizar VMM02S0 +enfervorizad enfervorizar VMM02P0 +enfervorizando enfervorizar VMG0000 +enfervorizar enfervorizar VMN0000 +enfeuda enfeudar VMM02S0 +enfeudad enfeudar VMM02P0 +enfeudando enfeudar VMG0000 +enfeudar enfeudar VMN0000 +enfeude enfeudar VMM03S0 +enfeudemos enfeudar VMM01P0 +enfeuden enfeudar VMM03P0 +enfila enfilar VMM02S0 +enfilad enfilar VMM02P0 +enfilando enfilar VMG0000 +enfilar enfilar VMN0000 +enfile enfilar VMM03S0 +enfilemos enfilar VMM01P0 +enfilen enfilar VMM03P0 +enfistola enfistolar VMM02S0 +enfistolad enfistolar VMM02P0 +enfistolando enfistolar VMG0000 +enfistolar enfistolar VMN0000 +enfistole enfistolar VMM03S0 +enfistolemos enfistolar VMM01P0 +enfistolen enfistolar VMM03P0 +enflaquece enflaquecer VMM02S0 +enflaqueced enflaquecer VMM02P0 +enflaquecer enflaquecer VMN0000 +enflaqueciendo enflaquecer VMG0000 +enflaquezca enflaquecer VMM03S0 +enflaquezcamos enflaquecer VMM01P0 +enflaquezcan enflaquecer VMM03P0 +enflauta enflautar VMM02S0 +enflautad enflautar VMM02P0 +enflautando enflautar VMG0000 +enflautar enflautar VMN0000 +enflaute enflautar VMM03S0 +enflautemos enflautar VMM01P0 +enflauten enflautar VMM03P0 +enfoca enfocar VMM02S0 +enfocad enfocar VMM02P0 +enfocando enfocar VMG0000 +enfocar enfocar VMN0000 +enfoque enfocar VMM03S0 +enfoquemos enfocar VMM01P0 +enfoquen enfocar VMM03P0 +enfosca enfoscar VMM02S0 +enfoscad enfoscar VMM02P0 +enfoscando enfoscar VMG0000 +enfoscar enfoscar VMN0000 +enfosque enfoscar VMM03S0 +enfosquemos enfoscar VMM01P0 +enfosquen enfoscar VMM03P0 +enfraila enfrailar VMM02S0 +enfrailad enfrailar VMM02P0 +enfrailando enfrailar VMG0000 +enfrailar enfrailar VMN0000 +enfraile enfrailar VMM03S0 +enfrailemos enfrailar VMM01P0 +enfrailen enfrailar VMM03P0 +enfrasca enfrascar VMM02S0 +enfrascad enfrascar VMM02P0 +enfrascando enfrascar VMG0000 +enfrascar enfrascar VMN0000 +enfrasque enfrascar VMM03S0 +enfrasquemos enfrascar VMM01P0 +enfrasquen enfrascar VMM03P0 +enfrena enfrenar VMM02S0 +enfrenad enfrenar VMM02P0 +enfrenando enfrenar VMG0000 +enfrenar enfrenar VMN0000 +enfrene enfrenar VMM03S0 +enfrenemos enfrenar VMM01P0 +enfrenen enfrenar VMM03P0 +enfrenta enfrentar VMM02S0 +enfrentad enfrentar VMM02P0 +enfrentando enfrentar VMG0000 +enfrentar enfrentar VMN0000 +enfrente enfrentar VMM03S0 +enfrentemos enfrentar VMM01P0 +enfrenten enfrentar VMM03P0 +enfriad enfriar VMM02P0 +enfriando enfriar VMG0000 +enfriar enfriar VMN0000 +enfriemos enfriar VMM01P0 +enfronta enfrontar VMM02S0 +enfrontad enfrontar VMM02P0 +enfrontando enfrontar VMG0000 +enfrontar enfrontar VMN0000 +enfronte enfrontar VMM03S0 +enfrontemos enfrontar VMM01P0 +enfronten enfrontar VMM03P0 +enfría enfriar VMM02S0 +enfríe enfriar VMM03S0 +enfríen enfriar VMM03P0 +enfulla enfullar VMM02S0 +enfullad enfullar VMM02P0 +enfullando enfullar VMG0000 +enfullar enfullar VMN0000 +enfulle enfullar VMM03S0 +enfullemos enfullar VMM01P0 +enfullen enfullar VMM03P0 +enfunda enfundar VMM02S0 +enfundad enfundar VMM02P0 +enfundando enfundar VMG0000 +enfundar enfundar VMN0000 +enfunde enfundar VMM03S0 +enfundemos enfundar VMM01P0 +enfunden enfundar VMM03P0 +enfurece enfurecer VMM02S0 +enfureced enfurecer VMM02P0 +enfurecer enfurecer VMN0000 +enfureciendo enfurecer VMG0000 +enfurezca enfurecer VMM03S0 +enfurezcamos enfurecer VMM01P0 +enfurezcan enfurecer VMM03P0 +enfurruña enfurruñar VMM02S0 +enfurruñad enfurruñar VMM02P0 +enfurruñando enfurruñar VMG0000 +enfurruñar enfurruñar VMN0000 +enfurruñe enfurruñar VMM03S0 +enfurruñemos enfurruñar VMM01P0 +enfurruñen enfurruñar VMM03P0 +enfurta enfurtir VMM03S0 +enfurtamos enfurtir VMM01P0 +enfurtan enfurtir VMM03P0 +enfurte enfurtir VMM02S0 +enfurtid enfurtir VMM02P0 +enfurtiendo enfurtir VMG0000 +enfurtir enfurtir VMN0000 +engace engazar VMM03S0 +engacemos engazar VMM01P0 +engacen engazar VMM03P0 +engafa engafar VMM02S0 +engafad engafar VMM02P0 +engafando engafar VMG0000 +engafar engafar VMN0000 +engafe engafar VMM03S0 +engafemos engafar VMM01P0 +engafen engafar VMM03P0 +engaita engaitar VMM02S0 +engaitad engaitar VMM02P0 +engaitando engaitar VMG0000 +engaitar engaitar VMN0000 +engaite engaitar VMM03S0 +engaitemos engaitar VMM01P0 +engaiten engaitar VMM03P0 +engalana engalanar VMM02S0 +engalanad engalanar VMM02P0 +engalanando engalanar VMG0000 +engalanar engalanar VMN0000 +engalane engalanar VMM03S0 +engalanemos engalanar VMM01P0 +engalanen engalanar VMM03P0 +engalga engalgar VMM02S0 +engalgad engalgar VMM02P0 +engalgando engalgar VMG0000 +engalgar engalgar VMN0000 +engalgue engalgar VMM03S0 +engalguemos engalgar VMM01P0 +engalguen engalgar VMM03P0 +engalla engallar VMM02S0 +engallad engallar VMM02P0 +engallando engallar VMG0000 +engallar engallar VMN0000 +engalle engallar VMM03S0 +engallemos engallar VMM01P0 +engallen engallar VMM03P0 +engancha enganchar VMM02S0 +enganchad enganchar VMM02P0 +enganchando enganchar VMG0000 +enganchar enganchar VMN0000 +enganche enganchar VMM03S0 +enganchemos enganchar VMM01P0 +enganchen enganchar VMM03P0 +engarabata engarabatar VMM02S0 +engarabatad engarabatar VMM02P0 +engarabatando engarabatar VMG0000 +engarabatar engarabatar VMN0000 +engarabate engarabatar VMM03S0 +engarabatemos engarabatar VMM01P0 +engarabaten engarabatar VMM03P0 +engarabita engarabitar VMM02S0 +engarabitad engarabitar VMM02P0 +engarabitando engarabitar VMG0000 +engarabitar engarabitar VMN0000 +engarabite engarabitar VMM03S0 +engarabitemos engarabitar VMM01P0 +engarabiten engarabitar VMM03P0 +engarba engarbar VMM02S0 +engarbad engarbar VMM02P0 +engarbando engarbar VMG0000 +engarbar engarbar VMN0000 +engarbe engarbar VMM03S0 +engarbemos engarbar VMM01P0 +engarben engarbar VMM03P0 +engarce engarzar VMM03S0 +engarcemos engarzar VMM01P0 +engarcen engarzar VMM03P0 +engarganta engargantar VMM02S0 +engargantad engargantar VMM02P0 +engargantando engargantar VMG0000 +engargantar engargantar VMN0000 +engargante engargantar VMM03S0 +engargantemos engargantar VMM01P0 +engarganten engargantar VMM03P0 +engargola engargolar VMM02S0 +engargolad engargolar VMM02P0 +engargolando engargolar VMG0000 +engargolar engargolar VMN0000 +engargole engargolar VMM03S0 +engargolemos engargolar VMM01P0 +engargolen engargolar VMM03P0 +engarrafa engarrafar VMM02S0 +engarrafad engarrafar VMM02P0 +engarrafando engarrafar VMG0000 +engarrafar engarrafar VMN0000 +engarrafe engarrafar VMM03S0 +engarrafemos engarrafar VMM01P0 +engarrafen engarrafar VMM03P0 +engarrota engarrotar VMM02S0 +engarrotad engarrotar VMM02P0 +engarrotando engarrotar VMG0000 +engarrotar engarrotar VMN0000 +engarrote engarrotar VMM03S0 +engarrotemos engarrotar VMM01P0 +engarroten engarrotar VMM03P0 +engarza engarzar VMM02S0 +engarzad engarzar VMM02P0 +engarzando engarzar VMG0000 +engarzar engarzar VMN0000 +engasta engastar VMM02S0 +engastad engastar VMM02P0 +engastando engastar VMG0000 +engastar engastar VMN0000 +engaste engastar VMM03S0 +engastemos engastar VMM01P0 +engasten engastar VMM03P0 +engatilla engatillar VMM02S0 +engatillad engatillar VMM02P0 +engatillando engatillar VMG0000 +engatillar engatillar VMN0000 +engatille engatillar VMM03S0 +engatillemos engatillar VMM01P0 +engatillen engatillar VMM03P0 +engatusa engatusar VMM02S0 +engatusad engatusar VMM02P0 +engatusando engatusar VMG0000 +engatusar engatusar VMN0000 +engatuse engatusar VMM03S0 +engatusemos engatusar VMM01P0 +engatusen engatusar VMM03P0 +engavilla engavillar VMM02S0 +engavillad engavillar VMM02P0 +engavillando engavillar VMG0000 +engavillar engavillar VMN0000 +engaville engavillar VMM03S0 +engavillemos engavillar VMM01P0 +engavillen engavillar VMM03P0 +engaza engazar VMM02S0 +engazad engazar VMM02P0 +engazando engazar VMG0000 +engazar engazar VMN0000 +engaña engañar VMM02S0 +engañad engañar VMM02P0 +engañando engañar VMG0000 +engañar engañar VMN0000 +engañe engañar VMM03S0 +engañemos engañar VMM01P0 +engañen engañar VMM03P0 +engendra engendrar VMM02S0 +engendrad engendrar VMM02P0 +engendrando engendrar VMG0000 +engendrar engendrar VMN0000 +engendre engendrar VMM03S0 +engendremos engendrar VMM01P0 +engendren engendrar VMM03P0 +engerid engerir VMM02P0 +engerir engerir VMN0000 +engiba engibar VMM02S0 +engibad engibar VMM02P0 +engibando engibar VMG0000 +engibar engibar VMN0000 +engibe engibar VMM03S0 +engibemos engibar VMM01P0 +engiben engibar VMM03P0 +engiera engerir VMM03S0 +engieran engerir VMM03P0 +engiere engerir VMM02S0 +engiramos engerir VMM01P0 +engiriendo engerir VMG0000 +engloba englobar VMM02S0 +englobad englobar VMM02P0 +englobando englobar VMG0000 +englobar englobar VMN0000 +englobe englobar VMM03S0 +englobemos englobar VMM01P0 +engloben englobar VMM03P0 +engolfa engolfar VMM02S0 +engolfad engolfar VMM02P0 +engolfando engolfar VMG0000 +engolfar engolfar VMN0000 +engolfe engolfar VMM03S0 +engolfemos engolfar VMM01P0 +engolfen engolfar VMM03P0 +engolosina engolosinar VMM02S0 +engolosinad engolosinar VMM02P0 +engolosinando engolosinar VMG0000 +engolosinar engolosinar VMN0000 +engolosine engolosinar VMM03S0 +engolosinemos engolosinar VMM01P0 +engolosinen engolosinar VMM03P0 +engoma engomar VMM02S0 +engomad engomar VMM02P0 +engomando engomar VMG0000 +engomar engomar VMN0000 +engome engomar VMM03S0 +engomemos engomar VMM01P0 +engomen engomar VMM03P0 +engorda engordar VMM02S0 +engordad engordar VMM02P0 +engordando engordar VMG0000 +engordar engordar VMN0000 +engorde engordar VMM03S0 +engordemos engordar VMM01P0 +engorden engordar VMM03P0 +engozna engoznar VMM02S0 +engoznad engoznar VMM02P0 +engoznando engoznar VMG0000 +engoznar engoznar VMN0000 +engozne engoznar VMM03S0 +engoznemos engoznar VMM01P0 +engoznen engoznar VMM03P0 +engrana engranar VMM02S0 +engranad engranar VMM02P0 +engranando engranar VMG0000 +engranar engranar VMN0000 +engrandece engrandecer VMM02S0 +engrandeced engrandecer VMM02P0 +engrandecer engrandecer VMN0000 +engrandeciendo engrandecer VMG0000 +engrandezca engrandecer VMM03S0 +engrandezcamos engrandecer VMM01P0 +engrandezcan engrandecer VMM03P0 +engrane engranar VMM03S0 +engranemos engranar VMM01P0 +engranen engranar VMM03P0 +engranera engranerar VMM02S0 +engranerad engranerar VMM02P0 +engranerando engranerar VMG0000 +engranerar engranerar VMN0000 +engranere engranerar VMM03S0 +engraneremos engranerar VMM01P0 +engraneren engranerar VMM03P0 +engranuja engranujar VMM02S0 +engranujad engranujar VMM02P0 +engranujando engranujar VMG0000 +engranujar engranujar VMN0000 +engranuje engranujar VMM03S0 +engranujemos engranujar VMM01P0 +engranujen engranujar VMM03P0 +engrapa engrapar VMM02S0 +engrapad engrapar VMM02P0 +engrapando engrapar VMG0000 +engrapar engrapar VMN0000 +engrape engrapar VMM03S0 +engrapemos engrapar VMM01P0 +engrapen engrapar VMM03P0 +engrasa engrasar VMM02S0 +engrasad engrasar VMM02P0 +engrasando engrasar VMG0000 +engrasar engrasar VMN0000 +engrase engrasar VMM03S0 +engrasemos engrasar VMM01P0 +engrasen engrasar VMM03P0 +engresca engrescar VMM02S0 +engrescad engrescar VMM02P0 +engrescando engrescar VMG0000 +engrescar engrescar VMN0000 +engresque engrescar VMM03S0 +engresquemos engrescar VMM01P0 +engresquen engrescar VMM03P0 +engreíd engreír VMM02P0 +engreír engreír VMN0000 +engriamos engreír VMM01P0 +engriendo engreír VMG0000 +engrifa engrifar VMM02S0 +engrifad engrifar VMM02P0 +engrifando engrifar VMG0000 +engrifar engrifar VMN0000 +engrife engrifar VMM03S0 +engrifemos engrifar VMM01P0 +engrifen engrifar VMM03P0 +engrilla engrillar VMM02S0 +engrillad engrillar VMM02P0 +engrillando engrillar VMG0000 +engrillar engrillar VMN0000 +engrille engrillar VMM03S0 +engrillemos engrillar VMM01P0 +engrillen engrillar VMM03P0 +engringa engringar VMM02S0 +engringad engringar VMM02P0 +engringando engringar VMG0000 +engringar engringar VMN0000 +engringue engringar VMM03S0 +engringuemos engringar VMM01P0 +engringuen engringar VMM03P0 +engrosa engrosar VMM02S0 +engrosad engrosar VMM02P0 +engrosando engrosar VMG0000 +engrosar engrosar VMN0000 +engrose engrosar VMM03S0 +engrosemos engrosar VMM01P0 +engrosen engrosar VMM03P0 +engruda engrudar VMM02S0 +engrudad engrudar VMM02P0 +engrudando engrudar VMG0000 +engrudar engrudar VMN0000 +engrude engrudar VMM03S0 +engrudemos engrudar VMM01P0 +engruden engrudar VMM03P0 +engruesa engrosar VMM02S0 +engruesa engruesar VMM02S0 +engruesad engruesar VMM02P0 +engruesando engruesar VMG0000 +engruesar engruesar VMN0000 +engruese engrosar VMM03S0 +engruese engruesar VMM03S0 +engruesemos engruesar VMM01P0 +engruesen engrosar VMM03P0 +engruesen engruesar VMM03P0 +engrumece engrumecer VMM02S0 +engrumeced engrumecer VMM02P0 +engrumecer engrumecer VMN0000 +engrumeciendo engrumecer VMG0000 +engrumezca engrumecer VMM03S0 +engrumezcamos engrumecer VMM01P0 +engrumezcan engrumecer VMM03P0 +engría engreír VMM03S0 +engrían engreír VMM03P0 +engríe engreír VMM02S0 +enguachina enguachinar VMM02S0 +enguachinad enguachinar VMM02P0 +enguachinando enguachinar VMG0000 +enguachinar enguachinar VMN0000 +enguachine enguachinar VMM03S0 +enguachinemos enguachinar VMM01P0 +enguachinen enguachinar VMM03P0 +engualdrapa engualdrapar VMM02S0 +engualdrapad engualdrapar VMM02P0 +engualdrapando engualdrapar VMG0000 +engualdrapar engualdrapar VMN0000 +engualdrape engualdrapar VMM03S0 +engualdrapemos engualdrapar VMM01P0 +engualdrapen engualdrapar VMM03P0 +enguanta enguantar VMM02S0 +enguantad enguantar VMM02P0 +enguantando enguantar VMG0000 +enguantar enguantar VMN0000 +enguante enguantar VMM03S0 +enguantemos enguantar VMM01P0 +enguanten enguantar VMM03P0 +enguata enguatar VMM02S0 +enguatad enguatar VMM02P0 +enguatando enguatar VMG0000 +enguatar enguatar VMN0000 +enguate enguatar VMM03S0 +enguatemos enguatar VMM01P0 +enguaten enguatar VMM03P0 +enguijarra enguijarrar VMM02S0 +enguijarrad enguijarrar VMM02P0 +enguijarrando enguijarrar VMG0000 +enguijarrar enguijarrar VMN0000 +enguijarre enguijarrar VMM03S0 +enguijarremos enguijarrar VMM01P0 +enguijarren enguijarrar VMM03P0 +enguillota enguillotar VMM02S0 +enguillotad enguillotar VMM02P0 +enguillotando enguillotar VMG0000 +enguillotar enguillotar VMN0000 +enguillote enguillotar VMM03S0 +enguillotemos enguillotar VMM01P0 +enguilloten enguillotar VMM03P0 +enguirnalda enguirnaldar VMM02S0 +enguirnaldad enguirnaldar VMM02P0 +enguirnaldando enguirnaldar VMG0000 +enguirnaldar enguirnaldar VMN0000 +enguirnalde enguirnaldar VMM03S0 +enguirnaldemos enguirnaldar VMM01P0 +enguirnalden enguirnaldar VMM03P0 +enguizga enguizgar VMM02S0 +enguizgad enguizgar VMM02P0 +enguizgando enguizgar VMG0000 +enguizgar enguizgar VMN0000 +enguizgue enguizgar VMM03S0 +enguizguemos enguizgar VMM01P0 +enguizguen enguizgar VMM03P0 +engulla engullir VMM03S0 +engullamos engullir VMM01P0 +engullan engullir VMM03P0 +engulle engullir VMM02S0 +engullendo engullir VMG0000 +engullid engullir VMM02P0 +engullir engullir VMN0000 +engurruña engurruñar VMM02S0 +engurruñad engurruñar VMM02P0 +engurruñando engurruñar VMG0000 +engurruñar engurruñar VMN0000 +engurruñe engurruñar VMM03S0 +engurruñemos engurruñar VMM01P0 +engurruñen engurruñar VMM03P0 +enhacina enhacinar VMM02S0 +enhacinad enhacinar VMM02P0 +enhacinando enhacinar VMG0000 +enhacinar enhacinar VMN0000 +enhacine enhacinar VMM03S0 +enhacinemos enhacinar VMM01P0 +enhacinen enhacinar VMM03P0 +enharina enharinar VMM02S0 +enharinad enharinar VMM02P0 +enharinando enharinar VMG0000 +enharinar enharinar VMN0000 +enharine enharinar VMM03S0 +enharinemos enharinar VMM01P0 +enharinen enharinar VMM03P0 +enhastiad enhastiar VMM02P0 +enhastiando enhastiar VMG0000 +enhastiar enhastiar VMN0000 +enhastiemos enhastiar VMM01P0 +enhastía enhastiar VMM02S0 +enhastíe enhastiar VMM03S0 +enhastíen enhastiar VMM03P0 +enhebilla enhebillar VMM02S0 +enhebillad enhebillar VMM02P0 +enhebillando enhebillar VMG0000 +enhebillar enhebillar VMN0000 +enhebille enhebillar VMM03S0 +enhebillemos enhebillar VMM01P0 +enhebillen enhebillar VMM03P0 +enhebra enhebrar VMM02S0 +enhebrad enhebrar VMM02P0 +enhebrando enhebrar VMG0000 +enhebrar enhebrar VMN0000 +enhebre enhebrar VMM03S0 +enhebremos enhebrar VMM01P0 +enhebren enhebrar VMM03P0 +enhena enhenar VMM02S0 +enhenad enhenar VMM02P0 +enhenando enhenar VMG0000 +enhenar enhenar VMN0000 +enhene enhenar VMM03S0 +enhenemos enhenar VMM01P0 +enhenen enhenar VMM03P0 +enherbola enherbolar VMM02S0 +enherbolad enherbolar VMM02P0 +enherbolando enherbolar VMG0000 +enherbolar enherbolar VMN0000 +enherbole enherbolar VMM03S0 +enherbolemos enherbolar VMM01P0 +enherbolen enherbolar VMM03P0 +enhila enhilar VMM02S0 +enhilad enhilar VMM02P0 +enhilando enhilar VMG0000 +enhilar enhilar VMN0000 +enhile enhilar VMM03S0 +enhilemos enhilar VMM01P0 +enhilen enhilar VMM03P0 +enhorna enhornar VMM02S0 +enhornad enhornar VMM02P0 +enhornando enhornar VMG0000 +enhornar enhornar VMN0000 +enhorne enhornar VMM03S0 +enhornemos enhornar VMM01P0 +enhornen enhornar VMM03P0 +enhueca enhuecar VMM02S0 +enhuecad enhuecar VMM02P0 +enhuecando enhuecar VMG0000 +enhuecar enhuecar VMN0000 +enhueque enhuecar VMM03S0 +enhuequemos enhuecar VMM01P0 +enhuequen enhuecar VMM03P0 +enjabona enjabonar VMM02S0 +enjabonad enjabonar VMM02P0 +enjabonando enjabonar VMG0000 +enjabonar enjabonar VMN0000 +enjabone enjabonar VMM03S0 +enjabonemos enjabonar VMM01P0 +enjabonen enjabonar VMM03P0 +enjaece enjaezar VMM03S0 +enjaecemos enjaezar VMM01P0 +enjaecen enjaezar VMM03P0 +enjaeza enjaezar VMM02S0 +enjaezad enjaezar VMM02P0 +enjaezando enjaezar VMG0000 +enjaezar enjaezar VMN0000 +enjalbega enjalbegar VMM02S0 +enjalbegad enjalbegar VMM02P0 +enjalbegando enjalbegar VMG0000 +enjalbegar enjalbegar VMN0000 +enjalbegue enjalbegar VMM03S0 +enjalbeguemos enjalbegar VMM01P0 +enjalbeguen enjalbegar VMM03P0 +enjalma enjalmar VMM02S0 +enjalmad enjalmar VMM02P0 +enjalmando enjalmar VMG0000 +enjalmar enjalmar VMN0000 +enjalme enjalmar VMM03S0 +enjalmemos enjalmar VMM01P0 +enjalmen enjalmar VMM03P0 +enjambra enjambrar VMM02S0 +enjambrad enjambrar VMM02P0 +enjambrando enjambrar VMG0000 +enjambrar enjambrar VMN0000 +enjambre enjambrar VMM03S0 +enjambremos enjambrar VMM01P0 +enjambren enjambrar VMM03P0 +enjaquima enjaquimar VMM02S0 +enjaquimad enjaquimar VMM02P0 +enjaquimando enjaquimar VMG0000 +enjaquimar enjaquimar VMN0000 +enjaquime enjaquimar VMM03S0 +enjaquimemos enjaquimar VMM01P0 +enjaquimen enjaquimar VMM03P0 +enjarcia enjarciar VMM02S0 +enjarciad enjarciar VMM02P0 +enjarciando enjarciar VMG0000 +enjarciar enjarciar VMN0000 +enjarcie enjarciar VMM03S0 +enjarciemos enjarciar VMM01P0 +enjarcien enjarciar VMM03P0 +enjareta enjaretar VMM02S0 +enjaretad enjaretar VMM02P0 +enjaretando enjaretar VMG0000 +enjaretar enjaretar VMN0000 +enjarete enjaretar VMM03S0 +enjaretemos enjaretar VMM01P0 +enjareten enjaretar VMM03P0 +enjaula enjaular VMM02S0 +enjaulad enjaular VMM02P0 +enjaulando enjaular VMG0000 +enjaular enjaular VMN0000 +enjaule enjaular VMM03S0 +enjaulemos enjaular VMM01P0 +enjaulen enjaular VMM03P0 +enjeba enjebar VMM02S0 +enjebad enjebar VMM02P0 +enjebando enjebar VMG0000 +enjebar enjebar VMN0000 +enjebe enjebar VMM03S0 +enjebemos enjebar VMM01P0 +enjeben enjebar VMM03P0 +enjerta enjertar VMM02S0 +enjertad enjertar VMM02P0 +enjertando enjertar VMG0000 +enjertar enjertar VMN0000 +enjerte enjertar VMM03S0 +enjertemos enjertar VMM01P0 +enjerten enjertar VMM03P0 +enjoya enjoyar VMM02S0 +enjoyad enjoyar VMM02P0 +enjoyando enjoyar VMG0000 +enjoyar enjoyar VMN0000 +enjoye enjoyar VMM03S0 +enjoyemos enjoyar VMM01P0 +enjoyen enjoyar VMM03P0 +enjuaga enjuagar VMM02S0 +enjuagad enjuagar VMM02P0 +enjuagando enjuagar VMG0000 +enjuagar enjuagar VMN0000 +enjuague enjuagar VMM03S0 +enjuaguemos enjuagar VMM01P0 +enjuaguen enjuagar VMM03P0 +enjuga enjugar VMM02S0 +enjugad enjugar VMM02P0 +enjugando enjugar VMG0000 +enjugar enjugar VMN0000 +enjugue enjugar VMM03S0 +enjuguemos enjugar VMM01P0 +enjuguen enjugar VMM03P0 +enjuicia enjuiciar VMM02S0 +enjuiciad enjuiciar VMM02P0 +enjuiciando enjuiciar VMG0000 +enjuiciar enjuiciar VMN0000 +enjuicie enjuiciar VMM03S0 +enjuiciemos enjuiciar VMM01P0 +enjuicien enjuiciar VMM03P0 +enjuta enjutar VMM02S0 +enjutad enjutar VMM02P0 +enjutando enjutar VMG0000 +enjutar enjutar VMN0000 +enjute enjutar VMM03S0 +enjutemos enjutar VMM01P0 +enjuten enjutar VMM03P0 +enlabia enlabiar VMM02S0 +enlabiad enlabiar VMM02P0 +enlabiando enlabiar VMG0000 +enlabiar enlabiar VMN0000 +enlabie enlabiar VMM03S0 +enlabiemos enlabiar VMM01P0 +enlabien enlabiar VMM03P0 +enlace enlazar VMM03S0 +enlacemos enlazar VMM01P0 +enlacen enlazar VMM03P0 +enladrilla enladrillar VMM02S0 +enladrillad enladrillar VMM02P0 +enladrillando enladrillar VMG0000 +enladrillar enladrillar VMN0000 +enladrille enladrillar VMM03S0 +enladrillemos enladrillar VMM01P0 +enladrillen enladrillar VMM03P0 +enlaguna enlagunar VMM02S0 +enlagunad enlagunar VMM02P0 +enlagunando enlagunar VMG0000 +enlagunar enlagunar VMN0000 +enlagune enlagunar VMM03S0 +enlagunemos enlagunar VMM01P0 +enlagunen enlagunar VMM03P0 +enlama enlamar VMM02S0 +enlamad enlamar VMM02P0 +enlamando enlamar VMG0000 +enlamar enlamar VMN0000 +enlame enlamar VMM03S0 +enlamemos enlamar VMM01P0 +enlamen enlamar VMM03P0 +enlata enlatar VMM02S0 +enlatad enlatar VMM02P0 +enlatando enlatar VMG0000 +enlatar enlatar VMN0000 +enlate enlatar VMM03S0 +enlatemos enlatar VMM01P0 +enlaten enlatar VMM03P0 +enlaza enlazar VMM02S0 +enlazad enlazar VMM02P0 +enlazando enlazar VMG0000 +enlazar enlazar VMN0000 +enlecha enlechar VMM02S0 +enlechad enlechar VMM02P0 +enlechando enlechar VMG0000 +enlechar enlechar VMN0000 +enleche enlechar VMM03S0 +enlechemos enlechar VMM01P0 +enlechen enlechar VMM03P0 +enlegaja enlegajar VMM02S0 +enlegajad enlegajar VMM02P0 +enlegajando enlegajar VMG0000 +enlegajar enlegajar VMN0000 +enlegaje enlegajar VMM03S0 +enlegajemos enlegajar VMM01P0 +enlegajen enlegajar VMM03P0 +enlegama enlegamar VMM02S0 +enlegamad enlegamar VMM02P0 +enlegamando enlegamar VMG0000 +enlegamar enlegamar VMN0000 +enlegame enlegamar VMM03S0 +enlegamemos enlegamar VMM01P0 +enlegamen enlegamar VMM03P0 +enlejiad enlejiar VMM02P0 +enlejiando enlejiar VMG0000 +enlejiar enlejiar VMN0000 +enlejiemos enlejiar VMM01P0 +enlejía enlejiar VMM02S0 +enlejíe enlejiar VMM03S0 +enlejíen enlejiar VMM03P0 +enliga enligar VMM02S0 +enligad enligar VMM02P0 +enligando enligar VMG0000 +enligar enligar VMN0000 +enligue enligar VMM03S0 +enliguemos enligar VMM01P0 +enliguen enligar VMM03P0 +enlistona enlistonar VMM02S0 +enlistonad enlistonar VMM02P0 +enlistonando enlistonar VMG0000 +enlistonar enlistonar VMN0000 +enlistone enlistonar VMM03S0 +enlistonemos enlistonar VMM01P0 +enlistonen enlistonar VMM03P0 +enllanta enllantar VMM02S0 +enllantad enllantar VMM02P0 +enllantando enllantar VMG0000 +enllantar enllantar VMN0000 +enllante enllantar VMM03S0 +enllantemos enllantar VMM01P0 +enllanten enllantar VMM03P0 +enlobreguece enlobreguecer VMM02S0 +enlobregueced enlobreguecer VMM02P0 +enlobreguecer enlobreguecer VMN0000 +enlobregueciendo enlobreguecer VMG0000 +enlobreguezca enlobreguecer VMM03S0 +enlobreguezcamos enlobreguecer VMM01P0 +enlobreguezcan enlobreguecer VMM03P0 +enloda enlodar VMM02S0 +enlodace enlodazar VMM03S0 +enlodacemos enlodazar VMM01P0 +enlodacen enlodazar VMM03P0 +enlodad enlodar VMM02P0 +enlodando enlodar VMG0000 +enlodar enlodar VMN0000 +enlodaza enlodazar VMM02S0 +enlodazad enlodazar VMM02P0 +enlodazando enlodazar VMG0000 +enlodazar enlodazar VMN0000 +enlode enlodar VMM03S0 +enlodemos enlodar VMM01P0 +enloden enlodar VMM03P0 +enloma enlomar VMM02S0 +enlomad enlomar VMM02P0 +enlomando enlomar VMG0000 +enlomar enlomar VMN0000 +enlome enlomar VMM03S0 +enlomemos enlomar VMM01P0 +enlomen enlomar VMM03P0 +enloquece enloquecer VMM02S0 +enloqueced enloquecer VMM02P0 +enloquecer enloquecer VMN0000 +enloqueciendo enloquecer VMG0000 +enloquezca enloquecer VMM03S0 +enloquezcamos enloquecer VMM01P0 +enloquezcan enloquecer VMM03P0 +enlosa enlosar VMM02S0 +enlosad enlosar VMM02P0 +enlosando enlosar VMG0000 +enlosar enlosar VMN0000 +enlose enlosar VMM03S0 +enlosemos enlosar VMM01P0 +enlosen enlosar VMM03P0 +enluce enlucir VMM02S0 +enlucid enlucir VMM02P0 +enluciendo enlucir VMG0000 +enlucir enlucir VMN0000 +enlustrece enlustrecer VMM02S0 +enlustreced enlustrecer VMM02P0 +enlustrecer enlustrecer VMN0000 +enlustreciendo enlustrecer VMG0000 +enlustrezca enlustrecer VMM03S0 +enlustrezcamos enlustrecer VMM01P0 +enlustrezcan enlustrecer VMM03P0 +enluta enlutar VMM02S0 +enlutad enlutar VMM02P0 +enlutando enlutar VMG0000 +enlutar enlutar VMN0000 +enlute enlutar VMM03S0 +enlutemos enlutar VMM01P0 +enluten enlutar VMM03P0 +enluzca enlucir VMM03S0 +enluzcamos enlucir VMM01P0 +enluzcan enlucir VMM03P0 +enmadera enmaderar VMM02S0 +enmaderad enmaderar VMM02P0 +enmaderando enmaderar VMG0000 +enmaderar enmaderar VMN0000 +enmadere enmaderar VMM03S0 +enmaderemos enmaderar VMM01P0 +enmaderen enmaderar VMM03P0 +enmadra enmadrar VMM02S0 +enmadrad enmadrar VMM02P0 +enmadrando enmadrar VMG0000 +enmadrar enmadrar VMN0000 +enmadre enmadrar VMM03S0 +enmadremos enmadrar VMM01P0 +enmadren enmadrar VMM03P0 +enmagrece enmagrecer VMM02S0 +enmagreced enmagrecer VMM02P0 +enmagrecer enmagrecer VMN0000 +enmagreciendo enmagrecer VMG0000 +enmagrezca enmagrecer VMM03S0 +enmagrezcamos enmagrecer VMM01P0 +enmagrezcan enmagrecer VMM03P0 +enmalece enmalecer VMM02S0 +enmaleced enmalecer VMM02P0 +enmalecer enmalecer VMN0000 +enmaleciendo enmalecer VMG0000 +enmalezca enmalecer VMM03S0 +enmalezcamos enmalecer VMM01P0 +enmalezcan enmalecer VMM03P0 +enmalla enmallar VMM02S0 +enmallad enmallar VMM02P0 +enmallando enmallar VMG0000 +enmallar enmallar VMN0000 +enmalle enmallar VMM03S0 +enmallemos enmallar VMM01P0 +enmallen enmallar VMM03P0 +enmanga enmangar VMM02S0 +enmangad enmangar VMM02P0 +enmangando enmangar VMG0000 +enmangar enmangar VMN0000 +enmangue enmangar VMM03S0 +enmanguemos enmangar VMM01P0 +enmanguen enmangar VMM03P0 +enmanta enmantar VMM02S0 +enmantad enmantar VMM02P0 +enmantando enmantar VMG0000 +enmantar enmantar VMN0000 +enmante enmantar VMM03S0 +enmantemos enmantar VMM01P0 +enmanten enmantar VMM03P0 +enmara enmarar VMM02S0 +enmarad enmarar VMM02P0 +enmarando enmarar VMG0000 +enmarar enmarar VMN0000 +enmaraña enmarañar VMM02S0 +enmarañad enmarañar VMM02P0 +enmarañando enmarañar VMG0000 +enmarañar enmarañar VMN0000 +enmarañe enmarañar VMM03S0 +enmarañemos enmarañar VMM01P0 +enmarañen enmarañar VMM03P0 +enmarca enmarcar VMM02S0 +enmarcad enmarcar VMM02P0 +enmarcando enmarcar VMG0000 +enmarcar enmarcar VMN0000 +enmare enmarar VMM03S0 +enmaremos enmarar VMM01P0 +enmaren enmarar VMM03P0 +enmarida enmaridar VMM02S0 +enmaridad enmaridar VMM02P0 +enmaridando enmaridar VMG0000 +enmaridar enmaridar VMN0000 +enmaride enmaridar VMM03S0 +enmaridemos enmaridar VMM01P0 +enmariden enmaridar VMM03P0 +enmarillece enmarillecer VMM02S0 +enmarilleced enmarillecer VMM02P0 +enmarillecer enmarillecer VMN0000 +enmarilleciendo enmarillecer VMG0000 +enmarillezca enmarillecer VMM03S0 +enmarillezcamos enmarillecer VMM01P0 +enmarillezcan enmarillecer VMM03P0 +enmarque enmarcar VMM03S0 +enmarquemos enmarcar VMM01P0 +enmarquen enmarcar VMM03P0 +enmascara enmascarar VMM02S0 +enmascarad enmascarar VMM02P0 +enmascarando enmascarar VMG0000 +enmascarar enmascarar VMN0000 +enmascare enmascarar VMM03S0 +enmascaremos enmascarar VMM01P0 +enmascaren enmascarar VMM03P0 +enmasilla enmasillar VMM02S0 +enmasillad enmasillar VMM02P0 +enmasillando enmasillar VMG0000 +enmasillar enmasillar VMN0000 +enmasille enmasillar VMM03S0 +enmasillemos enmasillar VMM01P0 +enmasillen enmasillar VMM03P0 +enmelad enmelar VMM02P0 +enmelando enmelar VMG0000 +enmelar enmelar VMN0000 +enmelemos enmelar VMM01P0 +enmendad enmendar VMM02P0 +enmendando enmendar VMG0000 +enmendar enmendar VMN0000 +enmendemos enmendar VMM01P0 +enmiela enmelar VMM02S0 +enmiele enmelar VMM03S0 +enmielen enmelar VMM03P0 +enmienda enmendar VMM02S0 +enmiende enmendar VMM03S0 +enmienden enmendar VMM03P0 +enmohece enmohecer VMM02S0 +enmoheced enmohecer VMM02P0 +enmohecer enmohecer VMN0000 +enmoheciendo enmohecer VMG0000 +enmohezca enmohecer VMM03S0 +enmohezcamos enmohecer VMM01P0 +enmohezcan enmohecer VMM03P0 +enmollece enmollecer VMM02S0 +enmolleced enmollecer VMM02P0 +enmollecer enmollecer VMN0000 +enmolleciendo enmollecer VMG0000 +enmollezca enmollecer VMM03S0 +enmollezcamos enmollecer VMM01P0 +enmollezcan enmollecer VMM03P0 +enmonda enmondar VMM02S0 +enmondad enmondar VMM02P0 +enmondando enmondar VMG0000 +enmondar enmondar VMN0000 +enmonde enmondar VMM03S0 +enmondemos enmondar VMM01P0 +enmonden enmondar VMM03P0 +enmudece enmudecer VMM02S0 +enmudeced enmudecer VMM02P0 +enmudecer enmudecer VMN0000 +enmudeciendo enmudecer VMG0000 +enmudezca enmudecer VMM03S0 +enmudezcamos enmudecer VMM01P0 +enmudezcan enmudecer VMM03P0 +enmugrece enmugrecer VMM02S0 +enmugreced enmugrecer VMM02P0 +enmugrecer enmugrecer VMN0000 +enmugreciendo enmugrecer VMG0000 +enmugrezca enmugrecer VMM03S0 +enmugrezcamos enmugrecer VMM01P0 +enmugrezcan enmugrecer VMM03P0 +ennegrece ennegrecer VMM02S0 +ennegreced ennegrecer VMM02P0 +ennegrecer ennegrecer VMN0000 +ennegreciendo ennegrecer VMG0000 +ennegrezca ennegrecer VMM03S0 +ennegrezcamos ennegrecer VMM01P0 +ennegrezcan ennegrecer VMM03P0 +ennoblece ennoblecer VMM02S0 +ennobleced ennoblecer VMM02P0 +ennoblecer ennoblecer VMN0000 +ennobleciendo ennoblecer VMG0000 +ennoblezca ennoblecer VMM03S0 +ennoblezcamos ennoblecer VMM01P0 +ennoblezcan ennoblecer VMM03P0 +enoja enojar VMM02S0 +enojad enojar VMM02P0 +enojando enojar VMG0000 +enojar enojar VMN0000 +enoje enojar VMM03S0 +enojemos enojar VMM01P0 +enojen enojar VMM03P0 +enorgullece enorgullecer VMM02S0 +enorgulleced enorgullecer VMM02P0 +enorgullecer enorgullecer VMN0000 +enorgulleciendo enorgullecer VMG0000 +enorgullezca enorgullecer VMM03S0 +enorgullezcamos enorgullecer VMM01P0 +enorgullezcan enorgullecer VMM03P0 +enquicia enquiciar VMM02S0 +enquiciad enquiciar VMM02P0 +enquiciando enquiciar VMG0000 +enquiciar enquiciar VMN0000 +enquicie enquiciar VMM03S0 +enquiciemos enquiciar VMM01P0 +enquicien enquiciar VMM03P0 +enquillotra enquillotrar VMM02S0 +enquillotrad enquillotrar VMM02P0 +enquillotrando enquillotrar VMG0000 +enquillotrar enquillotrar VMN0000 +enquillotre enquillotrar VMM03S0 +enquillotremos enquillotrar VMM01P0 +enquillotren enquillotrar VMM03P0 +enquista enquistar VMM02S0 +enquistad enquistar VMM02P0 +enquistando enquistar VMG0000 +enquistar enquistar VMN0000 +enquiste enquistar VMM03S0 +enquistemos enquistar VMM01P0 +enquisten enquistar VMM03P0 +enrabia enrabiar VMM02S0 +enrabiad enrabiar VMM02P0 +enrabiando enrabiar VMG0000 +enrabiar enrabiar VMN0000 +enrabie enrabiar VMM03S0 +enrabiemos enrabiar VMM01P0 +enrabien enrabiar VMM03P0 +enrabieta enrabietar VMM02S0 +enrabietad enrabietar VMM02P0 +enrabietando enrabietar VMG0000 +enrabietar enrabietar VMN0000 +enrabiete enrabietar VMM03S0 +enrabietemos enrabietar VMM01P0 +enrabieten enrabietar VMM03P0 +enraicemos enraizar VMM01P0 +enraizad enraizar VMM02P0 +enraizando enraizar VMG0000 +enraizar enraizar VMN0000 +enrama enramar VMM02S0 +enramad enramar VMM02P0 +enramando enramar VMG0000 +enramar enramar VMN0000 +enrame enramar VMM03S0 +enramemos enramar VMM01P0 +enramen enramar VMM03P0 +enrancia enranciar VMM02S0 +enranciad enranciar VMM02P0 +enranciando enranciar VMG0000 +enranciar enranciar VMN0000 +enrancie enranciar VMM03S0 +enranciemos enranciar VMM01P0 +enrancien enranciar VMM03P0 +enrarece enrarecer VMM02S0 +enrareced enrarecer VMM02P0 +enrarecer enrarecer VMN0000 +enrareciendo enrarecer VMG0000 +enrarezca enrarecer VMM03S0 +enrarezcamos enrarecer VMM01P0 +enrarezcan enrarecer VMM03P0 +enrasa enrasar VMM02S0 +enrasad enrasar VMM02P0 +enrasando enrasar VMG0000 +enrasar enrasar VMN0000 +enrase enrasar VMM03S0 +enrasemos enrasar VMM01P0 +enrasen enrasar VMM03P0 +enraya enrayar VMM02S0 +enrayad enrayar VMM02P0 +enrayando enrayar VMG0000 +enrayar enrayar VMN0000 +enraye enrayar VMM03S0 +enrayemos enrayar VMM01P0 +enrayen enrayar VMM03P0 +enraíce enraizar VMM03S0 +enraícen enraizar VMM03P0 +enraíza enraizar VMM02S0 +enreda enredar VMM02S0 +enredad enredar VMM02P0 +enredando enredar VMG0000 +enredar enredar VMN0000 +enrede enredar VMM03S0 +enredemos enredar VMM01P0 +enreden enredar VMM03P0 +enreja enrejar VMM02S0 +enrejad enrejar VMM02P0 +enrejando enrejar VMG0000 +enrejar enrejar VMN0000 +enreje enrejar VMM03S0 +enrejemos enrejar VMM01P0 +enrejen enrejar VMM03P0 +enriad enriar VMM02P0 +enriando enriar VMG0000 +enriar enriar VMN0000 +enriela enrielar VMM02S0 +enrielad enrielar VMM02P0 +enrielando enrielar VMG0000 +enrielar enrielar VMN0000 +enriele enrielar VMM03S0 +enrielemos enrielar VMM01P0 +enrielen enrielar VMM03P0 +enriemos enriar VMM01P0 +enripia enripiar VMM02S0 +enripiad enripiar VMM02P0 +enripiando enripiar VMG0000 +enripiar enripiar VMN0000 +enripie enripiar VMM03S0 +enripiemos enripiar VMM01P0 +enripien enripiar VMM03P0 +enriquece enriquecer VMM02S0 +enriqueced enriquecer VMM02P0 +enriquecer enriquecer VMN0000 +enriqueciendo enriquecer VMG0000 +enriquezca enriquecer VMM03S0 +enriquezcamos enriquecer VMM01P0 +enriquezcan enriquecer VMM03P0 +enrisca enriscar VMM02S0 +enriscad enriscar VMM02P0 +enriscando enriscar VMG0000 +enriscar enriscar VMN0000 +enrisque enriscar VMM03S0 +enrisquemos enriscar VMM01P0 +enrisquen enriscar VMM03P0 +enristra enristrar VMM02S0 +enristrad enristrar VMM02P0 +enristrando enristrar VMG0000 +enristrar enristrar VMN0000 +enristre enristrar VMM03S0 +enristremos enristrar VMM01P0 +enristren enristrar VMM03P0 +enroca enrocar VMM02S0 +enrocad enrocar VMM02P0 +enrocando enrocar VMG0000 +enrocar enrocar VMN0000 +enrodad enrodar VMM02P0 +enrodando enrodar VMG0000 +enrodar enrodar VMN0000 +enrodemos enrodar VMM01P0 +enrodriga enrodrigar VMM02S0 +enrodrigad enrodrigar VMM02P0 +enrodrigando enrodrigar VMG0000 +enrodrigar enrodrigar VMN0000 +enrodrigona enrodrigonar VMM02S0 +enrodrigonad enrodrigonar VMM02P0 +enrodrigonando enrodrigonar VMG0000 +enrodrigonar enrodrigonar VMN0000 +enrodrigone enrodrigonar VMM03S0 +enrodrigonemos enrodrigonar VMM01P0 +enrodrigonen enrodrigonar VMM03P0 +enrodrigue enrodrigar VMM03S0 +enrodriguemos enrodrigar VMM01P0 +enrodriguen enrodrigar VMM03P0 +enrojece enrojecer VMM02S0 +enrojeced enrojecer VMM02P0 +enrojecer enrojecer VMN0000 +enrojeciendo enrojecer VMG0000 +enrojezca enrojecer VMM03S0 +enrojezcamos enrojecer VMM01P0 +enrojezcan enrojecer VMM03P0 +enrola enrolar VMM02S0 +enrolad enrolar VMM02P0 +enrolando enrolar VMG0000 +enrolar enrolar VMN0000 +enrole enrolar VMM03S0 +enrolemos enrolar VMM01P0 +enrolen enrolar VMM03P0 +enrolla enrollar VMM02S0 +enrollad enrollar VMM02P0 +enrollando enrollar VMG0000 +enrollar enrollar VMN0000 +enrolle enrollar VMM03S0 +enrollemos enrollar VMM01P0 +enrollen enrollar VMM03P0 +enroma enromar VMM02S0 +enromad enromar VMM02P0 +enromando enromar VMG0000 +enromar enromar VMN0000 +enrome enromar VMM03S0 +enromemos enromar VMM01P0 +enromen enromar VMM03P0 +enronquece enronquecer VMM02S0 +enronqueced enronquecer VMM02P0 +enronquecer enronquecer VMN0000 +enronqueciendo enronquecer VMG0000 +enronquezca enronquecer VMM03S0 +enronquezcamos enronquecer VMM01P0 +enronquezcan enronquecer VMM03P0 +enroque enrocar VMM03S0 +enroquemos enrocar VMM01P0 +enroquen enrocar VMM03P0 +enrosca enroscar VMM02S0 +enroscad enroscar VMM02P0 +enroscando enroscar VMG0000 +enroscar enroscar VMN0000 +enrosque enroscar VMM03S0 +enrosquemos enroscar VMM01P0 +enrosquen enroscar VMM03P0 +enrostra enrostrar VMM02S0 +enrostrad enrostrar VMM02P0 +enrostrando enrostrar VMG0000 +enrostrar enrostrar VMN0000 +enrostre enrostrar VMM03S0 +enrostremos enrostrar VMM01P0 +enrostren enrostrar VMM03P0 +enrubia enrubiar VMM02S0 +enrubiad enrubiar VMM02P0 +enrubiando enrubiar VMG0000 +enrubiar enrubiar VMN0000 +enrubie enrubiar VMM03S0 +enrubiemos enrubiar VMM01P0 +enrubien enrubiar VMM03P0 +enrueca enrocar VMM02S0 +enrueda enrodar VMM02S0 +enruede enrodar VMM03S0 +enrueden enrodar VMM03P0 +enrueque enrocar VMM03S0 +enruequen enrocar VMM03P0 +enría enriar VMM02S0 +enríe enriar VMM03S0 +enríen enriar VMM03P0 +ensabana ensabanar VMM02S0 +ensabanad ensabanar VMM02P0 +ensabanando ensabanar VMG0000 +ensabanar ensabanar VMN0000 +ensabane ensabanar VMM03S0 +ensabanemos ensabanar VMM01P0 +ensabanen ensabanar VMM03P0 +ensaca ensacar VMM02S0 +ensacad ensacar VMM02P0 +ensacando ensacar VMG0000 +ensacar ensacar VMN0000 +ensalce ensalzar VMM03S0 +ensalcemos ensalzar VMM01P0 +ensalcen ensalzar VMM03P0 +ensaliva ensalivar VMM02S0 +ensalivad ensalivar VMM02P0 +ensalivando ensalivar VMG0000 +ensalivar ensalivar VMN0000 +ensalive ensalivar VMM03S0 +ensalivemos ensalivar VMM01P0 +ensaliven ensalivar VMM03P0 +ensalma ensalmar VMM02S0 +ensalmad ensalmar VMM02P0 +ensalmando ensalmar VMG0000 +ensalmar ensalmar VMN0000 +ensalme ensalmar VMM03S0 +ensalmemos ensalmar VMM01P0 +ensalmen ensalmar VMM03P0 +ensalza ensalzar VMM02S0 +ensalzad ensalzar VMM02P0 +ensalzando ensalzar VMG0000 +ensalzar ensalzar VMN0000 +ensambenita ensambenitar VMM02S0 +ensambenitad ensambenitar VMM02P0 +ensambenitando ensambenitar VMG0000 +ensambenitar ensambenitar VMN0000 +ensambenite ensambenitar VMM03S0 +ensambenitemos ensambenitar VMM01P0 +ensambeniten ensambenitar VMM03P0 +ensambla ensamblar VMM02S0 +ensamblad ensamblar VMM02P0 +ensamblando ensamblar VMG0000 +ensamblar ensamblar VMN0000 +ensamble ensamblar VMM03S0 +ensamblemos ensamblar VMM01P0 +ensamblen ensamblar VMM03P0 +ensancha ensanchar VMM02S0 +ensanchad ensanchar VMM02P0 +ensanchando ensanchar VMG0000 +ensanchar ensanchar VMN0000 +ensanche ensanchar VMM03S0 +ensanchemos ensanchar VMM01P0 +ensanchen ensanchar VMM03P0 +ensandece ensandecer VMM02S0 +ensandeced ensandecer VMM02P0 +ensandecer ensandecer VMN0000 +ensandeciendo ensandecer VMG0000 +ensandezca ensandecer VMM03S0 +ensandezcamos ensandecer VMM01P0 +ensandezcan ensandecer VMM03P0 +ensangrentad ensangrentar VMM02P0 +ensangrentando ensangrentar VMG0000 +ensangrentar ensangrentar VMN0000 +ensangrentemos ensangrentar VMM01P0 +ensangrienta ensangrentar VMM02S0 +ensangriente ensangrentar VMM03S0 +ensangrienten ensangrentar VMM03P0 +ensaque ensacar VMM03S0 +ensaquemos ensacar VMM01P0 +ensaquen ensacar VMM03P0 +ensarmentad ensarmentar VMM02P0 +ensarmentando ensarmentar VMG0000 +ensarmentar ensarmentar VMN0000 +ensarmentemos ensarmentar VMM01P0 +ensarmienta ensarmentar VMM02S0 +ensarmiente ensarmentar VMM03S0 +ensarmienten ensarmentar VMM03P0 +ensarta ensartar VMM02S0 +ensartad ensartar VMM02P0 +ensartando ensartar VMG0000 +ensartar ensartar VMN0000 +ensarte ensartar VMM03S0 +ensartemos ensartar VMM01P0 +ensarten ensartar VMM03P0 +ensaya ensayar VMM02S0 +ensayad ensayar VMM02P0 +ensayando ensayar VMG0000 +ensayar ensayar VMN0000 +ensaye ensayar VMM03S0 +ensayemos ensayar VMM01P0 +ensayen ensayar VMM03P0 +ensaña ensañar VMM02S0 +ensañad ensañar VMM02P0 +ensañando ensañar VMG0000 +ensañar ensañar VMN0000 +ensañe ensañar VMM03S0 +ensañemos ensañar VMM01P0 +ensañen ensañar VMM03P0 +enseba ensebar VMM02S0 +ensebad ensebar VMM02P0 +ensebando ensebar VMG0000 +ensebar ensebar VMN0000 +ensebe ensebar VMM03S0 +ensebemos ensebar VMM01P0 +enseben ensebar VMM03P0 +enselva enselvar VMM02S0 +enselvad enselvar VMM02P0 +enselvando enselvar VMG0000 +enselvar enselvar VMN0000 +enselve enselvar VMM03S0 +enselvemos enselvar VMM01P0 +enselven enselvar VMM03P0 +ensena ensenar VMM02S0 +ensenad ensenar VMM02P0 +ensenando ensenar VMG0000 +ensenar ensenar VMN0000 +ensene ensenar VMM03S0 +ensenemos ensenar VMM01P0 +ensenen ensenar VMM03P0 +ensera enserar VMM02S0 +enserad enserar VMM02P0 +enserando enserar VMG0000 +enserar enserar VMN0000 +ensere enserar VMM03S0 +enseremos enserar VMM01P0 +enseren enserar VMM03P0 +enseria enseriar VMM02S0 +enseriad enseriar VMM02P0 +enseriando enseriar VMG0000 +enseriar enseriar VMN0000 +enserie enseriar VMM03S0 +enseriemos enseriar VMM01P0 +enserien enseriar VMM03P0 +enseña enseñar VMM02S0 +enseñad enseñar VMM02P0 +enseñando enseñar VMG0000 +enseñar enseñar VMN0000 +enseñe enseñar VMM03S0 +enseñemos enseñar VMM01P0 +enseñen enseñar VMM03P0 +enseñorea enseñorear VMM02S0 +enseñoread enseñorear VMM02P0 +enseñoreando enseñorear VMG0000 +enseñorear enseñorear VMN0000 +enseñoree enseñorear VMM03S0 +enseñoreemos enseñorear VMM01P0 +enseñoreen enseñorear VMM03P0 +ensila ensilar VMM02S0 +ensilad ensilar VMM02P0 +ensilando ensilar VMG0000 +ensilar ensilar VMN0000 +ensile ensilar VMM03S0 +ensilemos ensilar VMM01P0 +ensilen ensilar VMM03P0 +ensilla ensillar VMM02S0 +ensillad ensillar VMM02P0 +ensillando ensillar VMG0000 +ensillar ensillar VMN0000 +ensille ensillar VMM03S0 +ensillemos ensillar VMM01P0 +ensillen ensillar VMM03P0 +ensilvece ensilvecer VMM02S0 +ensilveced ensilvecer VMM02P0 +ensilvecer ensilvecer VMN0000 +ensilveciendo ensilvecer VMG0000 +ensilvezca ensilvecer VMM03S0 +ensilvezcamos ensilvecer VMM01P0 +ensilvezcan ensilvecer VMM03P0 +ensimisma ensimismar VMM02S0 +ensimismad ensimismar VMM02P0 +ensimismando ensimismar VMG0000 +ensimismar ensimismar VMN0000 +ensimisme ensimismar VMM03S0 +ensimismemos ensimismar VMM01P0 +ensimismen ensimismar VMM03P0 +ensoberbece ensoberbecer VMM02S0 +ensoberbeced ensoberbecer VMM02P0 +ensoberbecer ensoberbecer VMN0000 +ensoberbeciendo ensoberbecer VMG0000 +ensoberbezca ensoberbecer VMM03S0 +ensoberbezcamos ensoberbecer VMM01P0 +ensoberbezcan ensoberbecer VMM03P0 +ensoga ensogar VMM02S0 +ensogad ensogar VMM02P0 +ensogando ensogar VMG0000 +ensogar ensogar VMN0000 +ensogue ensogar VMM03S0 +ensoguemos ensogar VMM01P0 +ensoguen ensogar VMM03P0 +ensombrece ensombrecer VMM02S0 +ensombreced ensombrecer VMM02P0 +ensombrecer ensombrecer VMN0000 +ensombreciendo ensombrecer VMG0000 +ensombrezca ensombrecer VMM03S0 +ensombrezcamos ensombrecer VMM01P0 +ensombrezcan ensombrecer VMM03P0 +ensopa ensopar VMM02S0 +ensopad ensopar VMM02P0 +ensopando ensopar VMG0000 +ensopar ensopar VMN0000 +ensope ensopar VMM03S0 +ensopemos ensopar VMM01P0 +ensopen ensopar VMM03P0 +ensordece ensordecer VMM02S0 +ensordeced ensordecer VMM02P0 +ensordecer ensordecer VMN0000 +ensordeciendo ensordecer VMG0000 +ensordezca ensordecer VMM03S0 +ensordezcamos ensordecer VMM01P0 +ensordezcan ensordecer VMM03P0 +ensortija ensortijar VMM02S0 +ensortijad ensortijar VMM02P0 +ensortijando ensortijar VMG0000 +ensortijar ensortijar VMN0000 +ensortije ensortijar VMM03S0 +ensortijemos ensortijar VMM01P0 +ensortijen ensortijar VMM03P0 +ensoñad ensoñar VMM02P0 +ensoñando ensoñar VMG0000 +ensoñar ensoñar VMN0000 +ensoñemos ensoñar VMM01P0 +ensucia ensuciar VMM02S0 +ensuciad ensuciar VMM02P0 +ensuciando ensuciar VMG0000 +ensuciar ensuciar VMN0000 +ensucie ensuciar VMM03S0 +ensuciemos ensuciar VMM01P0 +ensucien ensuciar VMM03P0 +ensueña ensoñar VMM02S0 +ensueñe ensoñar VMM03S0 +ensueñen ensoñar VMM03P0 +entabla entablar VMM02S0 +entablad entablar VMM02P0 +entablando entablar VMG0000 +entablar entablar VMN0000 +entable entablar VMM03S0 +entablemos entablar VMM01P0 +entablen entablar VMM03P0 +entablera entablerar VMM02S0 +entablerad entablerar VMM02P0 +entablerando entablerar VMG0000 +entablerar entablerar VMN0000 +entablere entablerar VMM03S0 +entableremos entablerar VMM01P0 +entableren entablerar VMM03P0 +entablilla entablillar VMM02S0 +entablillad entablillar VMM02P0 +entablillando entablillar VMG0000 +entablillar entablillar VMN0000 +entablille entablillar VMM03S0 +entablillemos entablillar VMM01P0 +entablillen entablillar VMM03P0 +entalama entalamar VMM02S0 +entalamad entalamar VMM02P0 +entalamando entalamar VMG0000 +entalamar entalamar VMN0000 +entalame entalamar VMM03S0 +entalamemos entalamar VMM01P0 +entalamen entalamar VMM03P0 +entalega entalegar VMM02S0 +entalegad entalegar VMM02P0 +entalegando entalegar VMG0000 +entalegar entalegar VMN0000 +entalegue entalegar VMM03S0 +entaleguemos entalegar VMM01P0 +entaleguen entalegar VMM03P0 +entalinga entalingar VMM02S0 +entalingad entalingar VMM02P0 +entalingando entalingar VMG0000 +entalingar entalingar VMN0000 +entalingue entalingar VMM03S0 +entalinguemos entalingar VMM01P0 +entalinguen entalingar VMM03P0 +entalla entallar VMM02S0 +entallad entallar VMM02P0 +entallando entallar VMG0000 +entallar entallar VMN0000 +entalle entallar VMM03S0 +entallece entallecer VMM02S0 +entalleced entallecer VMM02P0 +entallecer entallecer VMN0000 +entalleciendo entallecer VMG0000 +entallemos entallar VMM01P0 +entallen entallar VMM03P0 +entallezca entallecer VMM03S0 +entallezcamos entallecer VMM01P0 +entallezcan entallecer VMM03P0 +entapice entapizar VMM03S0 +entapicemos entapizar VMM01P0 +entapicen entapizar VMM03P0 +entapiza entapizar VMM02S0 +entapizad entapizar VMM02P0 +entapizando entapizar VMG0000 +entapizar entapizar VMN0000 +entapuja entapujar VMM02S0 +entapujad entapujar VMM02P0 +entapujando entapujar VMG0000 +entapujar entapujar VMN0000 +entapuje entapujar VMM03S0 +entapujemos entapujar VMM01P0 +entapujen entapujar VMM03P0 +entarima entarimar VMM02S0 +entarimad entarimar VMM02P0 +entarimando entarimar VMG0000 +entarimar entarimar VMN0000 +entarime entarimar VMM03S0 +entarimemos entarimar VMM01P0 +entarimen entarimar VMM03P0 +entarquina entarquinar VMM02S0 +entarquinad entarquinar VMM02P0 +entarquinando entarquinar VMG0000 +entarquinar entarquinar VMN0000 +entarquine entarquinar VMM03S0 +entarquinemos entarquinar VMM01P0 +entarquinen entarquinar VMM03P0 +entaruga entarugar VMM02S0 +entarugad entarugar VMM02P0 +entarugando entarugar VMG0000 +entarugar entarugar VMN0000 +entarugue entarugar VMM03S0 +entaruguemos entarugar VMM01P0 +entaruguen entarugar VMM03P0 +enteca entecar VMM02S0 +entecad entecar VMM02P0 +entecando entecar VMG0000 +entecar entecar VMN0000 +entecha entechar VMM02S0 +entechad entechar VMM02P0 +entechando entechar VMG0000 +entechar entechar VMN0000 +enteche entechar VMM03S0 +entechemos entechar VMM01P0 +entechen entechar VMM03P0 +enteja entejar VMM02S0 +entejad entejar VMM02P0 +entejando entejar VMG0000 +entejar entejar VMN0000 +enteje entejar VMM03S0 +entejemos entejar VMM01P0 +entejen entejar VMM03P0 +entendamos entender VMM01P0 +entended entender VMM02P0 +entender entender VMN0000 +entendiendo entender VMG0000 +entenebrece entenebrecer VMM02S0 +entenebreced entenebrecer VMM02P0 +entenebrecer entenebrecer VMN0000 +entenebreciendo entenebrecer VMG0000 +entenebrezca entenebrecer VMM03S0 +entenebrezcamos entenebrecer VMM01P0 +entenebrezcan entenebrecer VMM03P0 +enteque entecar VMM03S0 +entequemos entecar VMM01P0 +entequen entecar VMM03P0 +entera enterar VMM02S0 +enterad enterar VMM02P0 +enterando enterar VMG0000 +enterar enterar VMN0000 +enterca entercar VMM02S0 +entercad entercar VMM02P0 +entercando entercar VMG0000 +entercar entercar VMN0000 +entere enterar VMM03S0 +enteremos enterar VMM01P0 +enteren enterar VMM03P0 +enternece enternecer VMM02S0 +enterneced enternecer VMM02P0 +enternecer enternecer VMN0000 +enterneciendo enternecer VMG0000 +enternezca enternecer VMM03S0 +enternezcamos enternecer VMM01P0 +enternezcan enternecer VMM03P0 +enterque entercar VMM03S0 +enterquemos entercar VMM01P0 +enterquen entercar VMM03P0 +enterrad enterrar VMM02P0 +enterrando enterrar VMG0000 +enterrar enterrar VMN0000 +enterremos enterrar VMM01P0 +entesa entesar VMM02S0 +entesad entesar VMM02P0 +entesando entesar VMG0000 +entesar entesar VMN0000 +entese entesar VMM03S0 +entesemos entesar VMM01P0 +entesen entesar VMM03P0 +entiba entibar VMM02S0 +entibad entibar VMM02P0 +entibando entibar VMG0000 +entibar entibar VMN0000 +entibe entibar VMM03S0 +entibemos entibar VMM01P0 +entiben entibar VMM03P0 +entibia entibiar VMM02S0 +entibiad entibiar VMM02P0 +entibiando entibiar VMG0000 +entibiar entibiar VMN0000 +entibie entibiar VMM03S0 +entibiemos entibiar VMM01P0 +entibien entibiar VMM03P0 +entice entizar VMM03S0 +enticemos entizar VMM01P0 +enticen entizar VMM03P0 +entienda entender VMM03S0 +entiendan entender VMM03P0 +entiende entender VMM02S0 +entierra enterrar VMM02S0 +entierre enterrar VMM03S0 +entierren enterrar VMM03P0 +entiesa entiesar VMM02S0 +entiesad entiesar VMM02P0 +entiesando entiesar VMG0000 +entiesar entiesar VMN0000 +entiese entiesar VMM03S0 +entiesemos entiesar VMM01P0 +entiesen entiesar VMM03P0 +entina entinar VMM02S0 +entinad entinar VMM02P0 +entinando entinar VMG0000 +entinar entinar VMN0000 +entine entinar VMM03S0 +entinemos entinar VMM01P0 +entinen entinar VMM03P0 +entinta entintar VMM02S0 +entintad entintar VMM02P0 +entintando entintar VMG0000 +entintar entintar VMN0000 +entinte entintar VMM03S0 +entintemos entintar VMM01P0 +entinten entintar VMM03P0 +entiza entizar VMM02S0 +entizad entizar VMM02P0 +entizando entizar VMG0000 +entizar entizar VMN0000 +entizna entiznar VMM02S0 +entiznad entiznar VMM02P0 +entiznando entiznar VMG0000 +entiznar entiznar VMN0000 +entizne entiznar VMM03S0 +entiznemos entiznar VMM01P0 +entiznen entiznar VMM03P0 +entolda entoldar VMM02S0 +entoldad entoldar VMM02P0 +entoldando entoldar VMG0000 +entoldar entoldar VMN0000 +entolde entoldar VMM03S0 +entoldemos entoldar VMM01P0 +entolden entoldar VMM03P0 +entona entonar VMM02S0 +entonad entonar VMM02P0 +entonando entonar VMG0000 +entonar entonar VMN0000 +entone entonar VMM03S0 +entonela entonelar VMM02S0 +entonelad entonelar VMM02P0 +entonelando entonelar VMG0000 +entonelar entonelar VMN0000 +entonele entonelar VMM03S0 +entonelemos entonelar VMM01P0 +entonelen entonelar VMM03P0 +entonemos entonar VMM01P0 +entonen entonar VMM03P0 +entonga entongar VMM02S0 +entongad entongar VMM02P0 +entongando entongar VMG0000 +entongar entongar VMN0000 +entongue entongar VMM03S0 +entonguemos entongar VMM01P0 +entonguen entongar VMM03P0 +entontece entontecer VMM02S0 +entonteced entontecer VMM02P0 +entontecer entontecer VMN0000 +entonteciendo entontecer VMG0000 +entontezca entontecer VMM03S0 +entontezcamos entontecer VMM01P0 +entontezcan entontecer VMM03P0 +entorcha entorchar VMM02S0 +entorchad entorchar VMM02P0 +entorchando entorchar VMG0000 +entorchar entorchar VMN0000 +entorche entorchar VMM03S0 +entorchemos entorchar VMM01P0 +entorchen entorchar VMM03P0 +entorila entorilar VMM02S0 +entorilad entorilar VMM02P0 +entorilando entorilar VMG0000 +entorilar entorilar VMN0000 +entorile entorilar VMM03S0 +entorilemos entorilar VMM01P0 +entorilen entorilar VMM03P0 +entorna entornar VMM02S0 +entornad entornar VMM02P0 +entornando entornar VMG0000 +entornar entornar VMN0000 +entorne entornar VMM03S0 +entornemos entornar VMM01P0 +entornen entornar VMM03P0 +entorpece entorpecer VMM02S0 +entorpeced entorpecer VMM02P0 +entorpecer entorpecer VMN0000 +entorpeciendo entorpecer VMG0000 +entorpezca entorpecer VMM03S0 +entorpezcamos entorpecer VMM01P0 +entorpezcan entorpecer VMM03P0 +entortad entortar VMM02P0 +entortando entortar VMG0000 +entortar entortar VMN0000 +entortemos entortar VMM01P0 +entosiga entosigar VMM02S0 +entosigad entosigar VMM02P0 +entosigando entosigar VMG0000 +entosigar entosigar VMN0000 +entosigue entosigar VMM03S0 +entosiguemos entosigar VMM01P0 +entosiguen entosigar VMM03P0 +entra entrar VMM02S0 +entraba entrabar VMM02S0 +entrabad entrabar VMM02P0 +entrabando entrabar VMG0000 +entrabar entrabar VMN0000 +entrabe entrabar VMM03S0 +entrabemos entrabar VMM01P0 +entraben entrabar VMM03P0 +entrad entrar VMM02P0 +entrama entramar VMM02S0 +entramad entramar VMM02P0 +entramando entramar VMG0000 +entramar entramar VMN0000 +entrame entramar VMM03S0 +entramemos entramar VMM01P0 +entramen entramar VMM03P0 +entrampa entrampar VMM02S0 +entrampad entrampar VMM02P0 +entrampando entrampar VMG0000 +entrampar entrampar VMN0000 +entrampe entrampar VMM03S0 +entrampemos entrampar VMM01P0 +entrampen entrampar VMM03P0 +entrando entrar VMG0000 +entrar entrar VMN0000 +entraña entrañar VMM02S0 +entrañad entrañar VMM02P0 +entrañando entrañar VMG0000 +entrañar entrañar VMN0000 +entrañe entrañar VMM03S0 +entrañemos entrañar VMM01P0 +entrañen entrañar VMM03P0 +entre entrar VMM03S0 +entreabra entreabrir VMM03S0 +entreabramos entreabrir VMM01P0 +entreabran entreabrir VMM03P0 +entreabre entreabrir VMM02S0 +entreabrid entreabrir VMM02P0 +entreabriendo entreabrir VMG0000 +entreabrir entreabrir VMN0000 +entreayuda entreayudar VMM02S0 +entreayudad entreayudar VMM02P0 +entreayudando entreayudar VMG0000 +entreayudar entreayudar VMN0000 +entreayude entreayudar VMM03S0 +entreayudemos entreayudar VMM01P0 +entreayuden entreayudar VMM03P0 +entrecava entrecavar VMM02S0 +entrecavad entrecavar VMM02P0 +entrecavando entrecavar VMG0000 +entrecavar entrecavar VMN0000 +entrecave entrecavar VMM03S0 +entrecavemos entrecavar VMM01P0 +entrecaven entrecavar VMM03P0 +entrecerrad entrecerrar VMM02P0 +entrecerrando entrecerrar VMG0000 +entrecerrar entrecerrar VMN0000 +entrecerremos entrecerrar VMM01P0 +entrechoca entrechocar VMM02S0 +entrechocad entrechocar VMM02P0 +entrechocando entrechocar VMG0000 +entrechocar entrechocar VMN0000 +entrechoque entrechocar VMM03S0 +entrechoquemos entrechocar VMM01P0 +entrechoquen entrechocar VMM03P0 +entrecierra entrecerrar VMM02S0 +entrecierre entrecerrar VMM03S0 +entrecierren entrecerrar VMM03P0 +entrecoma entrecomar VMM02S0 +entrecomad entrecomar VMM02P0 +entrecomando entrecomar VMG0000 +entrecomar entrecomar VMN0000 +entrecome entrecomar VMM03S0 +entrecomemos entrecomar VMM01P0 +entrecomen entrecomar VMM03P0 +entrecomilla entrecomillar VMM02S0 +entrecomillad entrecomillar VMM02P0 +entrecomillando entrecomillar VMG0000 +entrecomillar entrecomillar VMN0000 +entrecomille entrecomillar VMM03S0 +entrecomillemos entrecomillar VMM01P0 +entrecomillen entrecomillar VMM03P0 +entrecorta entrecortar VMM02S0 +entrecortad entrecortar VMM02P0 +entrecortando entrecortar VMG0000 +entrecortar entrecortar VMN0000 +entrecorte entrecortar VMM03S0 +entrecortemos entrecortar VMM01P0 +entrecorten entrecortar VMM03P0 +entrecruce entrecruzar VMM03S0 +entrecrucemos entrecruzar VMM01P0 +entrecrucen entrecruzar VMM03P0 +entrecruza entrecruzar VMM02S0 +entrecruzad entrecruzar VMM02P0 +entrecruzando entrecruzar VMG0000 +entrecruzar entrecruzar VMN0000 +entredecid entredecir VMM02P0 +entredecir entredecir VMN0000 +entredice entredecir VMM02S0 +entrediciendo entredecir VMG0000 +entrediga entredecir VMM03S0 +entredigamos entredecir VMM01P0 +entredigan entredecir VMM03P0 +entrega entregar VMM02S0 +entregad entregar VMM02P0 +entregando entregar VMG0000 +entregar entregar VMN0000 +entregue entregar VMM03S0 +entreguemos entregar VMM01P0 +entreguen entregar VMM03P0 +entrejunta entrejuntar VMM02S0 +entrejuntad entrejuntar VMM02P0 +entrejuntando entrejuntar VMG0000 +entrejuntar entrejuntar VMN0000 +entrejunte entrejuntar VMM03S0 +entrejuntemos entrejuntar VMM01P0 +entrejunten entrejuntar VMM03P0 +entrelace entrelazar VMM03S0 +entrelacemos entrelazar VMM01P0 +entrelacen entrelazar VMM03P0 +entrelaza entrelazar VMM02S0 +entrelazad entrelazar VMM02P0 +entrelazando entrelazar VMG0000 +entrelazar entrelazar VMN0000 +entrelinea entrelinear VMM02S0 +entrelinead entrelinear VMM02P0 +entrelineando entrelinear VMG0000 +entrelinear entrelinear VMN0000 +entrelinee entrelinear VMM03S0 +entrelineemos entrelinear VMM01P0 +entrelineen entrelinear VMM03P0 +entreluce entrelucir VMM02S0 +entrelucid entrelucir VMM02P0 +entreluciendo entrelucir VMG0000 +entrelucir entrelucir VMN0000 +entreluzca entrelucir VMM03S0 +entreluzcamos entrelucir VMM01P0 +entreluzcan entrelucir VMM03P0 +entremeta entremeter VMM03S0 +entremetamos entremeter VMM01P0 +entremetan entremeter VMM03P0 +entremete entremeter VMM02S0 +entremeted entremeter VMM02P0 +entremeter entremeter VMN0000 +entremetiendo entremeter VMG0000 +entremezcla entremezclar VMM02S0 +entremezclad entremezclar VMM02P0 +entremezclando entremezclar VMG0000 +entremezclar entremezclar VMN0000 +entremezcle entremezclar VMM03S0 +entremezclemos entremezclar VMM01P0 +entremezclen entremezclar VMM03P0 +entremos entrar VMM01P0 +entren entrar VMM03P0 +entrena entrenar VMM02S0 +entrenad entrenar VMM02P0 +entrenando entrenar VMG0000 +entrenar entrenar VMN0000 +entrene entrenar VMM03S0 +entrenemos entrenar VMM01P0 +entrenen entrenar VMM03P0 +entreoiga entreoír VMM03S0 +entreoigamos entreoír VMM01P0 +entreoigan entreoír VMM03P0 +entreoye entreoír VMM02S0 +entreoyendo entreoír VMG0000 +entreoíd entreoír VMM02P0 +entreoír entreoír VMN0000 +entrepela entrepelar VMM02S0 +entrepelad entrepelar VMM02P0 +entrepelando entrepelar VMG0000 +entrepelar entrepelar VMN0000 +entrepele entrepelar VMM03S0 +entrepelemos entrepelar VMM01P0 +entrepelen entrepelar VMM03P0 +entrepernad entrepernar VMM02P0 +entrepernando entrepernar VMG0000 +entrepernar entrepernar VMN0000 +entrepernemos entrepernar VMM01P0 +entrepierna entrepernar VMM02S0 +entrepierne entrepernar VMM03S0 +entrepiernen entrepernar VMM03P0 +entrerrenglona entrerrenglonar VMM02S0 +entrerrenglonad entrerrenglonar VMM02P0 +entrerrenglonando entrerrenglonar VMG0000 +entrerrenglonar entrerrenglonar VMN0000 +entrerrenglone entrerrenglonar VMM03S0 +entrerrenglonemos entrerrenglonar VMM01P0 +entrerrenglonen entrerrenglonar VMM03P0 +entresaca entresacar VMM02S0 +entresacad entresacar VMM02P0 +entresacando entresacar VMG0000 +entresacar entresacar VMN0000 +entresaque entresacar VMM03S0 +entresaquemos entresacar VMM01P0 +entresaquen entresacar VMM03P0 +entretalla entretallar VMM02S0 +entretallad entretallar VMM02P0 +entretallando entretallar VMG0000 +entretallar entretallar VMN0000 +entretalle entretallar VMM03S0 +entretallemos entretallar VMM01P0 +entretallen entretallar VMM03P0 +entreteja entretejer VMM03S0 +entretejamos entretejer VMM01P0 +entretejan entretejer VMM03P0 +entreteje entretejer VMM02S0 +entretejed entretejer VMM02P0 +entretejer entretejer VMN0000 +entretejiendo entretejer VMG0000 +entretela entretelar VMM02S0 +entretelad entretelar VMM02P0 +entretelando entretelar VMG0000 +entretelar entretelar VMN0000 +entretele entretelar VMM03S0 +entretelemos entretelar VMM01P0 +entretelen entretelar VMM03P0 +entretened entretener VMM02P0 +entretener entretener VMN0000 +entretenga entretener VMM03S0 +entretengamos entretener VMM01P0 +entretengan entretener VMM03P0 +entreteniendo entretener VMG0000 +entretén entretener VMM02S0 +entrevea entrever VMM03S0 +entreveamos entrever VMM01P0 +entrevean entrever VMM03P0 +entreved entrever VMM02P0 +entrever entrever VMN0000 +entrevera entreverar VMM02S0 +entreverad entreverar VMM02P0 +entreverando entreverar VMG0000 +entreverar entreverar VMN0000 +entrevere entreverar VMM03S0 +entreveremos entreverar VMM01P0 +entreveren entreverar VMM03P0 +entreviendo entrever VMG0000 +entreviga entrevigar VMM02S0 +entrevigad entrevigar VMM02P0 +entrevigando entrevigar VMG0000 +entrevigar entrevigar VMN0000 +entrevigue entrevigar VMM03S0 +entreviguemos entrevigar VMM01P0 +entreviguen entrevigar VMM03P0 +entrevista entrevistar VMM02S0 +entrevistad entrevistar VMM02P0 +entrevistando entrevistar VMG0000 +entrevistar entrevistar VMN0000 +entreviste entrevistar VMM03S0 +entrevistemos entrevistar VMM01P0 +entrevisten entrevistar VMM03P0 +entrevé entrever VMM02S0 +entripa entripar VMM02S0 +entripad entripar VMM02P0 +entripando entripar VMG0000 +entripar entripar VMN0000 +entripe entripar VMM03S0 +entripemos entripar VMM01P0 +entripen entripar VMM03P0 +entristece entristecer VMM02S0 +entristeced entristecer VMM02P0 +entristecer entristecer VMN0000 +entristeciendo entristecer VMG0000 +entristezca entristecer VMM03S0 +entristezcamos entristecer VMM01P0 +entristezcan entristecer VMM03P0 +entroja entrojar VMM02S0 +entrojad entrojar VMM02P0 +entrojando entrojar VMG0000 +entrojar entrojar VMN0000 +entroje entrojar VMM03S0 +entrojemos entrojar VMM01P0 +entrojen entrojar VMM03P0 +entrometa entrometer VMM03S0 +entrometamos entrometer VMM01P0 +entrometan entrometer VMM03P0 +entromete entrometer VMM02S0 +entrometed entrometer VMM02P0 +entrometer entrometer VMN0000 +entrometiendo entrometer VMG0000 +entrona entronar VMM02S0 +entronad entronar VMM02P0 +entronando entronar VMG0000 +entronar entronar VMN0000 +entronca entroncar VMM02S0 +entroncad entroncar VMM02P0 +entroncando entroncar VMG0000 +entroncar entroncar VMN0000 +entrone entronar VMM03S0 +entronemos entronar VMM01P0 +entronen entronar VMM03P0 +entronice entronizar VMM03S0 +entronicemos entronizar VMM01P0 +entronicen entronizar VMM03P0 +entroniza entronizar VMM02S0 +entronizad entronizar VMM02P0 +entronizando entronizar VMG0000 +entronizar entronizar VMN0000 +entronque entroncar VMM03S0 +entronquemos entroncar VMM01P0 +entronquen entroncar VMM03P0 +entrucha entruchar VMM02S0 +entruchad entruchar VMM02P0 +entruchando entruchar VMG0000 +entruchar entruchar VMN0000 +entruche entruchar VMM03S0 +entruchemos entruchar VMM01P0 +entruchen entruchar VMM03P0 +entruja entrujar VMM02S0 +entrujad entrujar VMM02P0 +entrujando entrujar VMG0000 +entrujar entrujar VMN0000 +entruje entrujar VMM03S0 +entrujemos entrujar VMM01P0 +entrujen entrujar VMM03P0 +entuba entubar VMM02S0 +entubad entubar VMM02P0 +entubando entubar VMG0000 +entubar entubar VMN0000 +entube entubar VMM03S0 +entubemos entubar VMM01P0 +entuben entubar VMM03P0 +entuerta entortar VMM02S0 +entuerte entortar VMM03S0 +entuerten entortar VMM03P0 +entullece entullecer VMM02S0 +entulleced entullecer VMM02P0 +entullecer entullecer VMN0000 +entulleciendo entullecer VMG0000 +entullezca entullecer VMM03S0 +entullezcamos entullecer VMM01P0 +entullezcan entullecer VMM03P0 +entuma entumir VMM03S0 +entumamos entumir VMM01P0 +entuman entumir VMM03P0 +entume entumir VMM02S0 +entumece entumecer VMM02S0 +entumeced entumecer VMM02P0 +entumecer entumecer VMN0000 +entumeciendo entumecer VMG0000 +entumezca entumecer VMM03S0 +entumezcamos entumecer VMM01P0 +entumezcan entumecer VMM03P0 +entumid entumir VMM02P0 +entumiendo entumir VMG0000 +entumir entumir VMN0000 +entunica entunicar VMM02S0 +entunicad entunicar VMM02P0 +entunicando entunicar VMG0000 +entunicar entunicar VMN0000 +entunique entunicar VMM03S0 +entuniquemos entunicar VMM01P0 +entuniquen entunicar VMM03P0 +entupa entupir VMM03S0 +entupamos entupir VMM01P0 +entupan entupir VMM03P0 +entupe entupir VMM02S0 +entupid entupir VMM02P0 +entupiendo entupir VMG0000 +entupir entupir VMN0000 +enturbia enturbiar VMM02S0 +enturbiad enturbiar VMM02P0 +enturbiando enturbiar VMG0000 +enturbiar enturbiar VMN0000 +enturbie enturbiar VMM03S0 +enturbiemos enturbiar VMM01P0 +enturbien enturbiar VMM03P0 +entusiasma entusiasmar VMM02S0 +entusiasmad entusiasmar VMM02P0 +entusiasmando entusiasmar VMG0000 +entusiasmar entusiasmar VMN0000 +entusiasme entusiasmar VMM03S0 +entusiasmemos entusiasmar VMM01P0 +entusiasmen entusiasmar VMM03P0 +enuclea enuclear VMM02S0 +enuclead enuclear VMM02P0 +enucleando enuclear VMG0000 +enuclear enuclear VMN0000 +enuclee enuclear VMM03S0 +enucleemos enuclear VMM01P0 +enucleen enuclear VMM03P0 +enumera enumerar VMM02S0 +enumerad enumerar VMM02P0 +enumerando enumerar VMG0000 +enumerar enumerar VMN0000 +enumere enumerar VMM03S0 +enumeremos enumerar VMM01P0 +enumeren enumerar VMM03P0 +enuncia enunciar VMM02S0 +enunciad enunciar VMM02P0 +enunciando enunciar VMG0000 +enunciar enunciar VMN0000 +enuncie enunciar VMM03S0 +enunciemos enunciar VMM01P0 +enuncien enunciar VMM03P0 +envaina envainar VMM02S0 +envainad envainar VMM02P0 +envainando envainar VMG0000 +envainar envainar VMN0000 +envaine envainar VMM03S0 +envainemos envainar VMM01P0 +envainen envainar VMM03P0 +envalentona envalentonar VMM02S0 +envalentonad envalentonar VMM02P0 +envalentonando envalentonar VMG0000 +envalentonar envalentonar VMN0000 +envalentone envalentonar VMM03S0 +envalentonemos envalentonar VMM01P0 +envalentonen envalentonar VMM03P0 +envalija envalijar VMM02S0 +envalijad envalijar VMM02P0 +envalijando envalijar VMG0000 +envalijar envalijar VMN0000 +envalije envalijar VMM03S0 +envalijemos envalijar VMM01P0 +envalijen envalijar VMM03P0 +envanece envanecer VMM02S0 +envaneced envanecer VMM02P0 +envanecer envanecer VMN0000 +envaneciendo envanecer VMG0000 +envanezca envanecer VMM03S0 +envanezcamos envanecer VMM01P0 +envanezcan envanecer VMM03P0 +envara envarar VMM02S0 +envarad envarar VMM02P0 +envarando envarar VMG0000 +envarar envarar VMN0000 +envare envarar VMM03S0 +envaremos envarar VMM01P0 +envaren envarar VMM03P0 +envasa envasar VMM02S0 +envasad envasar VMM02P0 +envasando envasar VMG0000 +envasar envasar VMN0000 +envase envasar VMM03S0 +envasemos envasar VMM01P0 +envasen envasar VMM03P0 +envedija envedijar VMM02S0 +envedijad envedijar VMM02P0 +envedijando envedijar VMG0000 +envedijar envedijar VMN0000 +envedije envedijar VMM03S0 +envedijemos envedijar VMM01P0 +envedijen envedijar VMM03P0 +envejece envejecer VMM02S0 +envejeced envejecer VMM02P0 +envejecer envejecer VMN0000 +envejeciendo envejecer VMG0000 +envejezca envejecer VMM03S0 +envejezcamos envejecer VMM01P0 +envejezcan envejecer VMM03P0 +envenena envenenar VMM02S0 +envenenad envenenar VMM02P0 +envenenando envenenar VMG0000 +envenenar envenenar VMN0000 +envenene envenenar VMM03S0 +envenenemos envenenar VMM01P0 +envenenen envenenar VMM03P0 +envera enverar VMM02S0 +enverad enverar VMM02P0 +enverando enverar VMG0000 +enverar enverar VMN0000 +enverdece enverdecer VMM02S0 +enverdeced enverdecer VMM02P0 +enverdecer enverdecer VMN0000 +enverdeciendo enverdecer VMG0000 +enverdezca enverdecer VMM03S0 +enverdezcamos enverdecer VMM01P0 +enverdezcan enverdecer VMM03P0 +envere enverar VMM03S0 +enveremos enverar VMM01P0 +enveren enverar VMM03P0 +enverga envergar VMM02S0 +envergad envergar VMM02P0 +envergando envergar VMG0000 +envergar envergar VMN0000 +envergue envergar VMM03S0 +enverguemos envergar VMM01P0 +enverguen envergar VMM03P0 +enviad enviar VMM02P0 +enviando enviar VMG0000 +enviar enviar VMN0000 +envicia enviciar VMM02S0 +enviciad enviciar VMM02P0 +enviciando enviciar VMG0000 +enviciar enviciar VMN0000 +envicie enviciar VMM03S0 +enviciemos enviciar VMM01P0 +envicien enviciar VMM03P0 +envida envidar VMM02S0 +envidad envidar VMM02P0 +envidando envidar VMG0000 +envidar envidar VMN0000 +envide envidar VMM03S0 +envidemos envidar VMM01P0 +enviden envidar VMM03P0 +envidia envidiar VMM02S0 +envidiad envidiar VMM02P0 +envidiando envidiar VMG0000 +envidiar envidiar VMN0000 +envidie envidiar VMM03S0 +envidiemos envidiar VMM01P0 +envidien envidiar VMM03P0 +enviemos enviar VMM01P0 +envilece envilecer VMM02S0 +envileced envilecer VMM02P0 +envilecer envilecer VMN0000 +envileciendo envilecer VMG0000 +envilezca envilecer VMM03S0 +envilezcamos envilecer VMM01P0 +envilezcan envilecer VMM03P0 +envina envinar VMM02S0 +envinad envinar VMM02P0 +envinagra envinagrar VMM02S0 +envinagrad envinagrar VMM02P0 +envinagrando envinagrar VMG0000 +envinagrar envinagrar VMN0000 +envinagre envinagrar VMM03S0 +envinagremos envinagrar VMM01P0 +envinagren envinagrar VMM03P0 +envinando envinar VMG0000 +envinar envinar VMN0000 +envine envinar VMM03S0 +envinemos envinar VMM01P0 +envinen envinar VMM03P0 +envisca enviscar VMM02S0 +enviscad enviscar VMM02P0 +enviscando enviscar VMG0000 +enviscar enviscar VMN0000 +envisque enviscar VMM03S0 +envisquemos enviscar VMM01P0 +envisquen enviscar VMM03P0 +enviuda enviudar VMM02S0 +enviudad enviudar VMM02P0 +enviudando enviudar VMG0000 +enviudar enviudar VMN0000 +enviude enviudar VMM03S0 +enviudemos enviudar VMM01P0 +enviuden enviudar VMM03P0 +envolvamos envolver VMM01P0 +envolved envolver VMM02P0 +envolver envolver VMN0000 +envolviendo envolver VMG0000 +envuelva envolver VMM03S0 +envuelvan envolver VMM03P0 +envuelve envolver VMM02S0 +envía enviar VMM02S0 +envíe enviar VMM03S0 +envíen enviar VMM03P0 +enyerba enyerbar VMM02S0 +enyerbad enyerbar VMM02P0 +enyerbando enyerbar VMG0000 +enyerbar enyerbar VMN0000 +enyerbe enyerbar VMM03S0 +enyerbemos enyerbar VMM01P0 +enyerben enyerbar VMM03P0 +enyesa enyesar VMM02S0 +enyesad enyesar VMM02P0 +enyesando enyesar VMG0000 +enyesar enyesar VMN0000 +enyese enyesar VMM03S0 +enyesemos enyesar VMM01P0 +enyesen enyesar VMM03P0 +enyuga enyugar VMM02S0 +enyugad enyugar VMM02P0 +enyugando enyugar VMG0000 +enyugar enyugar VMN0000 +enyugue enyugar VMM03S0 +enyuguemos enyugar VMM01P0 +enyuguen enyugar VMM03P0 +enzainad enzainar VMM02P0 +enzainando enzainar VMG0000 +enzainar enzainar VMN0000 +enzainemos enzainar VMM01P0 +enzarce enzarzar VMM03S0 +enzarcemos enzarzar VMM01P0 +enzarcen enzarzar VMM03P0 +enzarza enzarzar VMM02S0 +enzarzad enzarzar VMM02P0 +enzarzando enzarzar VMG0000 +enzarzar enzarzar VMN0000 +enzaína enzainar VMM02S0 +enzaíne enzainar VMM03S0 +enzaínen enzainar VMM03P0 +enzuncha enzunchar VMM02S0 +enzunchad enzunchar VMM02P0 +enzunchando enzunchar VMG0000 +enzunchar enzunchar VMN0000 +enzunche enzunchar VMM03S0 +enzunchemos enzunchar VMM01P0 +enzunchen enzunchar VMM03P0 +enzurdece enzurdecer VMM02S0 +enzurdeced enzurdecer VMM02P0 +enzurdecer enzurdecer VMN0000 +enzurdeciendo enzurdecer VMG0000 +enzurdezca enzurdecer VMM03S0 +enzurdezcamos enzurdecer VMM01P0 +enzurdezcan enzurdecer VMM03P0 +enzurice enzurizar VMM03S0 +enzuricemos enzurizar VMM01P0 +enzuricen enzurizar VMM03P0 +enzuriza enzurizar VMM02S0 +enzurizad enzurizar VMM02P0 +enzurizando enzurizar VMG0000 +enzurizar enzurizar VMN0000 +enzurrona enzurronar VMM02S0 +enzurronad enzurronar VMM02P0 +enzurronando enzurronar VMG0000 +enzurronar enzurronar VMN0000 +enzurrone enzurronar VMM03S0 +enzurronemos enzurronar VMM01P0 +enzurronen enzurronar VMM03P0 +epiloga epilogar VMM02S0 +epilogad epilogar VMM02P0 +epilogando epilogar VMG0000 +epilogar epilogar VMN0000 +epilogue epilogar VMM03S0 +epiloguemos epilogar VMM01P0 +epiloguen epilogar VMM03P0 +epitoma epitomar VMM02S0 +epitomad epitomar VMM02P0 +epitomando epitomar VMG0000 +epitomar epitomar VMN0000 +epitome epitomar VMM03S0 +epitomemos epitomar VMM01P0 +epitomen epitomar VMM03P0 +equidista equidistar VMM02S0 +equidistad equidistar VMM02P0 +equidistando equidistar VMG0000 +equidistar equidistar VMN0000 +equidiste equidistar VMM03S0 +equidistemos equidistar VMM01P0 +equidisten equidistar VMM03P0 +equilibra equilibrar VMM02S0 +equilibrad equilibrar VMM02P0 +equilibrando equilibrar VMG0000 +equilibrar equilibrar VMN0000 +equilibre equilibrar VMM03S0 +equilibremos equilibrar VMM01P0 +equilibren equilibrar VMM03P0 +equipa equipar VMM02S0 +equipad equipar VMM02P0 +equipando equipar VMG0000 +equipar equipar VMN0000 +equipara equiparar VMM02S0 +equiparad equiparar VMM02P0 +equiparando equiparar VMG0000 +equiparar equiparar VMN0000 +equipare equiparar VMM03S0 +equiparemos equiparar VMM01P0 +equiparen equiparar VMM03P0 +equipe equipar VMM03S0 +equipemos equipar VMM01P0 +equipen equipar VMM03P0 +equipondera equiponderar VMM02S0 +equiponderad equiponderar VMM02P0 +equiponderando equiponderar VMG0000 +equiponderar equiponderar VMN0000 +equipondere equiponderar VMM03S0 +equiponderemos equiponderar VMM01P0 +equiponderen equiponderar VMM03P0 +equivale equivaler VMM02S0 +equivaled equivaler VMM02P0 +equivaler equivaler VMN0000 +equivalga equivaler VMM03S0 +equivalgamos equivaler VMM01P0 +equivalgan equivaler VMM03P0 +equivaliendo equivaler VMG0000 +equivoca equivocar VMM02S0 +equivocad equivocar VMM02P0 +equivocando equivocar VMG0000 +equivocar equivocar VMN0000 +equivoque equivocar VMM03S0 +equivoquemos equivocar VMM01P0 +equivoquen equivocar VMM03P0 +era erar VMM02S0 +erad erar VMM02P0 +erando erar VMG0000 +erar erar VMN0000 +ere erar VMM03S0 +eremos erar VMM01P0 +eren erar VMM03P0 +ergotice ergotizar VMM03S0 +ergoticemos ergotizar VMM01P0 +ergoticen ergotizar VMM03P0 +ergotiza ergotizar VMM02S0 +ergotizad ergotizar VMM02P0 +ergotizando ergotizar VMG0000 +ergotizar ergotizar VMN0000 +erguid erguir VMM02P0 +erguir erguir VMN0000 +erice erizar VMM03S0 +ericemos erizar VMM01P0 +ericen erizar VMM03P0 +erige erigir VMM02S0 +erigid erigir VMM02P0 +erigiendo erigir VMG0000 +erigir erigir VMN0000 +erija erigir VMM03S0 +erijamos erigir VMM01P0 +erijan erigir VMM03P0 +eriza erizar VMM02S0 +erizad erizar VMM02P0 +erizando erizar VMG0000 +erizar erizar VMN0000 +eroga erogar VMM02S0 +erogad erogar VMM02P0 +erogando erogar VMG0000 +erogar erogar VMN0000 +erogue erogar VMM03S0 +eroguemos erogar VMM01P0 +eroguen erogar VMM03P0 +erosiona erosionar VMM02S0 +erosionad erosionar VMM02P0 +erosionando erosionar VMG0000 +erosionar erosionar VMN0000 +erosione erosionar VMM03S0 +erosionemos erosionar VMM01P0 +erosionen erosionar VMM03P0 +errad errar VMM02P0 +erradica erradicar VMM02S0 +erradicad erradicar VMM02P0 +erradicando erradicar VMG0000 +erradicar erradicar VMN0000 +erradique erradicar VMM03S0 +erradiquemos erradicar VMM01P0 +erradiquen erradicar VMM03P0 +errando errar VMG0000 +errar errar VMN0000 +erremos errar VMM01P0 +eructa eructar VMM02S0 +eructad eructar VMM02P0 +eructando eructar VMG0000 +eructar eructar VMN0000 +eructe eructar VMM03S0 +eructemos eructar VMM01P0 +eructen eructar VMM03P0 +eruta erutar VMM02S0 +erutad erutar VMM02P0 +erutando erutar VMG0000 +erutar erutar VMN0000 +erute erutar VMM03S0 +erutemos erutar VMM01P0 +eruten erutar VMM03P0 +esboce esbozar VMM03S0 +esbocemos esbozar VMM01P0 +esbocen esbozar VMM03P0 +esboza esbozar VMM02S0 +esbozad esbozar VMM02P0 +esbozando esbozar VMG0000 +esbozar esbozar VMN0000 +escabecha escabechar VMM02S0 +escabechad escabechar VMM02P0 +escabechando escabechar VMG0000 +escabechar escabechar VMN0000 +escabeche escabechar VMM03S0 +escabechemos escabechar VMM01P0 +escabechen escabechar VMM03P0 +escabulla escabullir VMM03S0 +escabullamos escabullir VMM01P0 +escabullan escabullir VMM03P0 +escabulle escabullir VMM02S0 +escabullendo escabullir VMG0000 +escabullid escabullir VMM02P0 +escabullir escabullir VMN0000 +escacha escachar VMM02S0 +escachad escachar VMM02P0 +escachando escachar VMG0000 +escachar escachar VMN0000 +escacharra escacharrar VMM02S0 +escacharrad escacharrar VMM02P0 +escacharrando escacharrar VMG0000 +escacharrar escacharrar VMN0000 +escacharre escacharrar VMM03S0 +escacharremos escacharrar VMM01P0 +escacharren escacharrar VMM03P0 +escache escachar VMM03S0 +escachemos escachar VMM01P0 +escachen escachar VMM03P0 +escachifolla escachifollar VMM02S0 +escachifollad escachifollar VMM02P0 +escachifollando escachifollar VMG0000 +escachifollar escachifollar VMN0000 +escachifolle escachifollar VMM03S0 +escachifollemos escachifollar VMM01P0 +escachifollen escachifollar VMM03P0 +escachifulla escachifullar VMM02S0 +escachifullad escachifullar VMM02P0 +escachifullando escachifullar VMG0000 +escachifullar escachifullar VMN0000 +escafila escafilar VMM02S0 +escafilad escafilar VMM02P0 +escafilando escafilar VMG0000 +escafilar escafilar VMN0000 +escafile escafilar VMM03S0 +escafilemos escafilar VMM01P0 +escafilen escafilar VMM03P0 +escala escalar VMM02S0 +escalabra escalabrar VMM02S0 +escalabrad escalabrar VMM02P0 +escalabrando escalabrar VMG0000 +escalabrar escalabrar VMN0000 +escalabre escalabrar VMM03S0 +escalabremos escalabrar VMM01P0 +escalabren escalabrar VMM03P0 +escalad escalar VMM02P0 +escalando escalar VMG0000 +escalar escalar VMN0000 +escalda escaldar VMM02S0 +escaldad escaldar VMM02P0 +escaldando escaldar VMG0000 +escaldar escaldar VMN0000 +escalde escaldar VMM03S0 +escaldemos escaldar VMM01P0 +escalden escaldar VMM03P0 +escale escalar VMM03S0 +escalemos escalar VMM01P0 +escalen escalar VMM03P0 +escalfa escalfar VMM02S0 +escalfad escalfar VMM02P0 +escalfando escalfar VMG0000 +escalfar escalfar VMN0000 +escalfe escalfar VMM03S0 +escalfemos escalfar VMM01P0 +escalfen escalfar VMM03P0 +escalona escalonar VMM02S0 +escalonad escalonar VMM02P0 +escalonando escalonar VMG0000 +escalonar escalonar VMN0000 +escalone escalonar VMM03S0 +escalonemos escalonar VMM01P0 +escalonen escalonar VMM03P0 +escama escamar VMM02S0 +escamad escamar VMM02P0 +escamando escamar VMG0000 +escamar escamar VMN0000 +escame escamar VMM03S0 +escamemos escamar VMM01P0 +escamen escamar VMM03P0 +escamonda escamondar VMM02S0 +escamondad escamondar VMM02P0 +escamondando escamondar VMG0000 +escamondar escamondar VMN0000 +escamonde escamondar VMM03S0 +escamondemos escamondar VMM01P0 +escamonden escamondar VMM03P0 +escamota escamotar VMM02S0 +escamotad escamotar VMM02P0 +escamotando escamotar VMG0000 +escamotar escamotar VMN0000 +escamote escamotar VMM03S0 +escamotea escamotear VMM02S0 +escamotead escamotear VMM02P0 +escamoteando escamotear VMG0000 +escamotear escamotear VMN0000 +escamotee escamotear VMM03S0 +escamoteemos escamotear VMM01P0 +escamoteen escamotear VMM03P0 +escamotemos escamotar VMM01P0 +escamoten escamotar VMM03P0 +escampa escampar VMM02S0 +escampad escampar VMM02P0 +escampando escampar VMG0000 +escampar escampar VMN0000 +escampe escampar VMM03S0 +escampemos escampar VMM01P0 +escampen escampar VMM03P0 +escamuja escamujar VMM02S0 +escamujad escamujar VMM02P0 +escamujando escamujar VMG0000 +escamujar escamujar VMN0000 +escamuje escamujar VMM03S0 +escamujemos escamujar VMM01P0 +escamujen escamujar VMM03P0 +escancia escanciar VMM02S0 +escanciad escanciar VMM02P0 +escanciando escanciar VMG0000 +escanciar escanciar VMN0000 +escancie escanciar VMM03S0 +escanciemos escanciar VMM01P0 +escancien escanciar VMM03P0 +escanda escandir VMM03S0 +escandalice escandalizar VMM03S0 +escandalicemos escandalizar VMM01P0 +escandalicen escandalizar VMM03P0 +escandaliza escandalizar VMM02S0 +escandalizad escandalizar VMM02P0 +escandalizando escandalizar VMG0000 +escandalizar escandalizar VMN0000 +escandalla escandallar VMM02S0 +escandallad escandallar VMM02P0 +escandallando escandallar VMG0000 +escandallar escandallar VMN0000 +escandalle escandallar VMM03S0 +escandallemos escandallar VMM01P0 +escandallen escandallar VMM03P0 +escandamos escandir VMM01P0 +escandan escandir VMM03P0 +escande escandir VMM02S0 +escandid escandir VMM02P0 +escandiendo escandir VMG0000 +escandir escandir VMN0000 +escanea escanear VMM02S0 +escanead escanear VMM02P0 +escaneando escanear VMG0000 +escanear escanear VMN0000 +escanee escanear VMM03S0 +escaneemos escanear VMM01P0 +escaneen escanear VMM03P0 +escantilla escantillar VMM02S0 +escantillad escantillar VMM02P0 +escantillando escantillar VMG0000 +escantillar escantillar VMN0000 +escantille escantillar VMM03S0 +escantillemos escantillar VMM01P0 +escantillen escantillar VMM03P0 +escapa escapar VMM02S0 +escapad escapar VMM02P0 +escapando escapar VMG0000 +escapar escapar VMN0000 +escape escapar VMM03S0 +escapemos escapar VMM01P0 +escapen escapar VMM03P0 +escarabajea escarabajear VMM02S0 +escarabajead escarabajear VMM02P0 +escarabajeando escarabajear VMG0000 +escarabajear escarabajear VMN0000 +escarabajee escarabajear VMM03S0 +escarabajeemos escarabajear VMM01P0 +escarabajeen escarabajear VMM03P0 +escaramuce escaramuzar VMM03S0 +escaramucea escaramucear VMM02S0 +escaramucead escaramucear VMM02P0 +escaramuceando escaramucear VMG0000 +escaramucear escaramucear VMN0000 +escaramucee escaramucear VMM03S0 +escaramuceemos escaramucear VMM01P0 +escaramuceen escaramucear VMM03P0 +escaramucemos escaramuzar VMM01P0 +escaramucen escaramuzar VMM03P0 +escaramuza escaramuzar VMM02S0 +escaramuzad escaramuzar VMM02P0 +escaramuzando escaramuzar VMG0000 +escaramuzar escaramuzar VMN0000 +escarba escarbar VMM02S0 +escarbad escarbar VMM02P0 +escarbando escarbar VMG0000 +escarbar escarbar VMN0000 +escarbe escarbar VMM03S0 +escarbemos escarbar VMM01P0 +escarben escarbar VMM03P0 +escarce escarzar VMM03S0 +escarcea escarcear VMM02S0 +escarcead escarcear VMM02P0 +escarceando escarcear VMG0000 +escarcear escarcear VMN0000 +escarcee escarcear VMM03S0 +escarceemos escarcear VMM01P0 +escarceen escarcear VMM03P0 +escarcemos escarzar VMM01P0 +escarcen escarzar VMM03P0 +escarcha escarchar VMM02S0 +escarchad escarchar VMM02P0 +escarchando escarchar VMG0000 +escarchar escarchar VMN0000 +escarche escarchar VMM03S0 +escarchemos escarchar VMM01P0 +escarchen escarchar VMM03P0 +escarda escardar VMM02S0 +escardad escardar VMM02P0 +escardando escardar VMG0000 +escardar escardar VMN0000 +escarde escardar VMM03S0 +escardemos escardar VMM01P0 +escarden escardar VMM03P0 +escardilla escardillar VMM02S0 +escardillad escardillar VMM02P0 +escardillando escardillar VMG0000 +escardillar escardillar VMN0000 +escardille escardillar VMM03S0 +escardillemos escardillar VMM01P0 +escardillen escardillar VMM03P0 +escaria escariar VMM02S0 +escariad escariar VMM02P0 +escariando escariar VMG0000 +escariar escariar VMN0000 +escarice escarizar VMM03S0 +escaricemos escarizar VMM01P0 +escaricen escarizar VMM03P0 +escarie escariar VMM03S0 +escariemos escariar VMM01P0 +escarien escariar VMM03P0 +escarifica escarificar VMM02S0 +escarificad escarificar VMM02P0 +escarificando escarificar VMG0000 +escarificar escarificar VMN0000 +escarique escarificar VMM03S0 +escariquemos escarificar VMM01P0 +escariquen escarificar VMM03P0 +escariza escarizar VMM02S0 +escarizad escarizar VMM02P0 +escarizando escarizar VMG0000 +escarizar escarizar VMN0000 +escarmena escarmenar VMM02S0 +escarmenad escarmenar VMM02P0 +escarmenando escarmenar VMG0000 +escarmenar escarmenar VMN0000 +escarmene escarmenar VMM03S0 +escarmenemos escarmenar VMM01P0 +escarmenen escarmenar VMM03P0 +escarmentad escarmentar VMM02P0 +escarmentando escarmentar VMG0000 +escarmentar escarmentar VMN0000 +escarmentemos escarmentar VMM01P0 +escarmienta escarmentar VMM02S0 +escarmiente escarmentar VMM03S0 +escarmienten escarmentar VMM03P0 +escarnece escarnecer VMM02S0 +escarneced escarnecer VMM02P0 +escarnecer escarnecer VMN0000 +escarneciendo escarnecer VMG0000 +escarnezca escarnecer VMM03S0 +escarnezcamos escarnecer VMM01P0 +escarnezcan escarnecer VMM03P0 +escarola escarolar VMM02S0 +escarolad escarolar VMM02P0 +escarolando escarolar VMG0000 +escarolar escarolar VMN0000 +escarole escarolar VMM03S0 +escarolemos escarolar VMM01P0 +escarolen escarolar VMM03P0 +escarpa escarpar VMM02S0 +escarpad escarpar VMM02P0 +escarpando escarpar VMG0000 +escarpar escarpar VMN0000 +escarpe escarpar VMM03S0 +escarpemos escarpar VMM01P0 +escarpen escarpar VMM03P0 +escarrancha escarranchar VMM02S0 +escarranchad escarranchar VMM02P0 +escarranchando escarranchar VMG0000 +escarranchar escarranchar VMN0000 +escarranche escarranchar VMM03S0 +escarranchemos escarranchar VMM01P0 +escarranchen escarranchar VMM03P0 +escarza escarzar VMM02S0 +escarzad escarzar VMM02P0 +escarzando escarzar VMG0000 +escarzar escarzar VMN0000 +escasea escasear VMM02S0 +escasead escasear VMM02P0 +escaseando escasear VMG0000 +escasear escasear VMN0000 +escasee escasear VMM03S0 +escaseemos escasear VMM01P0 +escaseen escasear VMM03P0 +escatima escatimar VMM02S0 +escatimad escatimar VMM02P0 +escatimando escatimar VMG0000 +escatimar escatimar VMN0000 +escatime escatimar VMM03S0 +escatimemos escatimar VMM01P0 +escatimen escatimar VMM03P0 +escayola escayolar VMM02S0 +escayolad escayolar VMM02P0 +escayolando escayolar VMG0000 +escayolar escayolar VMN0000 +escayole escayolar VMM03S0 +escayolemos escayolar VMM01P0 +escayolen escayolar VMM03P0 +escenifica escenificar VMM02S0 +escenificad escenificar VMM02P0 +escenificando escenificar VMG0000 +escenificar escenificar VMN0000 +escenifique escenificar VMM03S0 +escenifiquemos escenificar VMM01P0 +escenifiquen escenificar VMM03P0 +escinda escindir VMM03S0 +escindamos escindir VMM01P0 +escindan escindir VMM03P0 +escinde escindir VMM02S0 +escindid escindir VMM02P0 +escindiendo escindir VMG0000 +escindir escindir VMN0000 +esclarece esclarecer VMM02S0 +esclareced esclarecer VMM02P0 +esclarecer esclarecer VMN0000 +esclareciendo esclarecer VMG0000 +esclarezca esclarecer VMM03S0 +esclarezcamos esclarecer VMM01P0 +esclarezcan esclarecer VMM03P0 +esclavice esclavizar VMM03S0 +esclavicemos esclavizar VMM01P0 +esclavicen esclavizar VMM03P0 +esclaviza esclavizar VMM02S0 +esclavizad esclavizar VMM02P0 +esclavizando esclavizar VMG0000 +esclavizar esclavizar VMN0000 +escobilla escobillar VMM02S0 +escobillad escobillar VMM02P0 +escobillando escobillar VMG0000 +escobillar escobillar VMN0000 +escobille escobillar VMM03S0 +escobillemos escobillar VMM01P0 +escobillen escobillar VMM03P0 +escoced escocer VMM02P0 +escocer escocer VMN0000 +escociendo escocer VMG0000 +escoda escodar VMM02S0 +escodad escodar VMM02P0 +escodando escodar VMG0000 +escodar escodar VMN0000 +escode escodar VMM03S0 +escodemos escodar VMM01P0 +escoden escodar VMM03P0 +escofina escofinar VMM02S0 +escofinad escofinar VMM02P0 +escofinando escofinar VMG0000 +escofinar escofinar VMN0000 +escofine escofinar VMM03S0 +escofinemos escofinar VMM01P0 +escofinen escofinar VMM03P0 +escoge escoger VMM02S0 +escoged escoger VMM02P0 +escoger escoger VMN0000 +escogiendo escoger VMG0000 +escoja escoger VMM03S0 +escojamos escoger VMM01P0 +escojan escoger VMM03P0 +escolarice escolarizar VMM03S0 +escolaricemos escolarizar VMM01P0 +escolaricen escolarizar VMM03P0 +escolariza escolarizar VMM02S0 +escolarizad escolarizar VMM02P0 +escolarizando escolarizar VMG0000 +escolarizar escolarizar VMN0000 +escolia escoliar VMM02S0 +escoliad escoliar VMM02P0 +escoliando escoliar VMG0000 +escoliar escoliar VMN0000 +escolie escoliar VMM03S0 +escoliemos escoliar VMM01P0 +escolien escoliar VMM03P0 +escolla escollar VMM02S0 +escollad escollar VMM02P0 +escollando escollar VMG0000 +escollar escollar VMN0000 +escolle escollar VMM03S0 +escollemos escollar VMM01P0 +escollen escollar VMM03P0 +escolta escoltar VMM02S0 +escoltad escoltar VMM02P0 +escoltando escoltar VMG0000 +escoltar escoltar VMN0000 +escolte escoltar VMM03S0 +escoltemos escoltar VMM01P0 +escolten escoltar VMM03P0 +escombra escombrar VMM02S0 +escombrad escombrar VMM02P0 +escombrando escombrar VMG0000 +escombrar escombrar VMN0000 +escombre escombrar VMM03S0 +escombremos escombrar VMM01P0 +escombren escombrar VMM03P0 +esconda esconder VMM03S0 +escondamos esconder VMM01P0 +escondan esconder VMM03P0 +esconde esconder VMM02S0 +esconded esconder VMM02P0 +esconder esconder VMN0000 +escondiendo esconder VMG0000 +escopetea escopetear VMM02S0 +escopetead escopetear VMM02P0 +escopeteando escopetear VMG0000 +escopetear escopetear VMN0000 +escopetee escopetear VMM03S0 +escopeteemos escopetear VMM01P0 +escopeteen escopetear VMM03P0 +escoplea escoplear VMM02S0 +escoplead escoplear VMM02P0 +escopleando escoplear VMG0000 +escoplear escoplear VMN0000 +escoplee escoplear VMM03S0 +escopleemos escoplear VMM01P0 +escopleen escoplear VMM03P0 +escora escorar VMM02S0 +escorad escorar VMM02P0 +escorando escorar VMG0000 +escorar escorar VMN0000 +escorce escorzar VMM03S0 +escorcemos escorzar VMM01P0 +escorcen escorzar VMM03P0 +escore escorar VMM03S0 +escoremos escorar VMM01P0 +escoren escorar VMM03P0 +escoria escoriar VMM02S0 +escoriad escoriar VMM02P0 +escoriando escoriar VMG0000 +escoriar escoriar VMN0000 +escorie escoriar VMM03S0 +escoriemos escoriar VMM01P0 +escorien escoriar VMM03P0 +escorifica escorificar VMM02S0 +escorificad escorificar VMM02P0 +escorificando escorificar VMG0000 +escorificar escorificar VMN0000 +escorifique escorificar VMM03S0 +escorifiquemos escorificar VMM01P0 +escorifiquen escorificar VMM03P0 +escorza escorzar VMM02S0 +escorzad escorzar VMM02P0 +escorzando escorzar VMG0000 +escorzar escorzar VMN0000 +escosca escoscar VMM02S0 +escoscad escoscar VMM02P0 +escoscando escoscar VMG0000 +escoscar escoscar VMN0000 +escosque escoscar VMM03S0 +escosquemos escoscar VMM01P0 +escosquen escoscar VMM03P0 +escota escotar VMM02S0 +escotad escotar VMM02P0 +escotando escotar VMG0000 +escotar escotar VMN0000 +escote escotar VMM03S0 +escotemos escotar VMM01P0 +escoten escotar VMM03P0 +escozamos escocer VMM01P0 +escriba escribir VMM03S0 +escribamos escribir VMM01P0 +escriban escribir VMM03P0 +escribe escribir VMM02S0 +escribid escribir VMM02P0 +escribiendo escribir VMG0000 +escribir escribir VMN0000 +escritura escriturar VMM02S0 +escriturad escriturar VMM02P0 +escriturando escriturar VMG0000 +escriturar escriturar VMN0000 +escriture escriturar VMM03S0 +escrituremos escriturar VMM01P0 +escrituren escriturar VMM03P0 +escruta escrutar VMM02S0 +escrutad escrutar VMM02P0 +escrutando escrutar VMG0000 +escrutar escrutar VMN0000 +escrute escrutar VMM03S0 +escrutemos escrutar VMM01P0 +escruten escrutar VMM03P0 +escuadra escuadrar VMM02S0 +escuadrad escuadrar VMM02P0 +escuadrando escuadrar VMG0000 +escuadrar escuadrar VMN0000 +escuadre escuadrar VMM03S0 +escuadremos escuadrar VMM01P0 +escuadren escuadrar VMM03P0 +escuadrona escuadronar VMM02S0 +escuadronad escuadronar VMM02P0 +escuadronando escuadronar VMG0000 +escuadronar escuadronar VMN0000 +escuadrone escuadronar VMM03S0 +escuadronemos escuadronar VMM01P0 +escuadronen escuadronar VMM03P0 +escucha escuchar VMM02S0 +escuchad escuchar VMM02P0 +escuchando escuchar VMG0000 +escuchar escuchar VMN0000 +escuche escuchar VMM03S0 +escuchemos escuchar VMM01P0 +escuchen escuchar VMM03P0 +escuda escudar VMM02S0 +escudad escudar VMM02P0 +escudando escudar VMG0000 +escudar escudar VMN0000 +escude escudar VMM03S0 +escudemos escudar VMM01P0 +escuden escudar VMM03P0 +escuderea escuderear VMM02S0 +escuderead escuderear VMM02P0 +escudereando escuderear VMG0000 +escuderear escuderear VMN0000 +escuderee escuderear VMM03S0 +escudereemos escuderear VMM01P0 +escudereen escuderear VMM03P0 +escudilla escudillar VMM02S0 +escudillad escudillar VMM02P0 +escudillando escudillar VMG0000 +escudillar escudillar VMN0000 +escudille escudillar VMM03S0 +escudillemos escudillar VMM01P0 +escudillen escudillar VMM03P0 +escudriña escudriñar VMM02S0 +escudriñad escudriñar VMM02P0 +escudriñando escudriñar VMG0000 +escudriñar escudriñar VMN0000 +escudriñe escudriñar VMM03S0 +escudriñemos escudriñar VMM01P0 +escudriñen escudriñar VMM03P0 +escuece escocer VMM02S0 +escueza escocer VMM03S0 +escuezan escocer VMM03P0 +esculca esculcar VMM02S0 +esculcad esculcar VMM02P0 +esculcando esculcar VMG0000 +esculcar esculcar VMN0000 +esculpa esculpir VMM03S0 +esculpamos esculpir VMM01P0 +esculpan esculpir VMM03P0 +esculpe esculpir VMM02S0 +esculpid esculpir VMM02P0 +esculpiendo esculpir VMG0000 +esculpir esculpir VMN0000 +esculque esculcar VMM03S0 +esculquemos esculcar VMM01P0 +esculquen esculcar VMM03P0 +escupa escupir VMM03S0 +escupamos escupir VMM01P0 +escupan escupir VMM03P0 +escupe escupir VMM02S0 +escupid escupir VMM02P0 +escupiendo escupir VMG0000 +escupir escupir VMN0000 +escurra escurrir VMM03S0 +escurramos escurrir VMM01P0 +escurran escurrir VMM03P0 +escurre escurrir VMM02S0 +escurrid escurrir VMM02P0 +escurriendo escurrir VMG0000 +escurrir escurrir VMN0000 +esdrujulice esdrujulizar VMM03S0 +esdrujulicemos esdrujulizar VMM01P0 +esdrujulicen esdrujulizar VMM03P0 +esdrujuliza esdrujulizar VMM02S0 +esdrujulizad esdrujulizar VMM02P0 +esdrujulizando esdrujulizar VMG0000 +esdrujulizar esdrujulizar VMN0000 +esfacela esfacelar VMM02S0 +esfacelad esfacelar VMM02P0 +esfacelando esfacelar VMG0000 +esfacelar esfacelar VMN0000 +esfacele esfacelar VMM03S0 +esfacelemos esfacelar VMM01P0 +esfacelen esfacelar VMM03P0 +esforcemos esforzar VMM01P0 +esforzad esforzar VMM02P0 +esforzando esforzar VMG0000 +esforzar esforzar VMN0000 +esfuerce esforzar VMM03S0 +esfuercen esforzar VMM03P0 +esfuerza esforzar VMM02S0 +esfuma esfumar VMM02S0 +esfumad esfumar VMM02P0 +esfumando esfumar VMG0000 +esfumar esfumar VMN0000 +esfume esfumar VMM03S0 +esfumemos esfumar VMM01P0 +esfumen esfumar VMM03P0 +esfumina esfuminar VMM02S0 +esfuminad esfuminar VMM02P0 +esfuminando esfuminar VMG0000 +esfuminar esfuminar VMN0000 +esfumine esfuminar VMM03S0 +esfuminemos esfuminar VMM01P0 +esfuminen esfuminar VMM03P0 +esgrafiad esgrafiar VMM02P0 +esgrafiando esgrafiar VMG0000 +esgrafiar esgrafiar VMN0000 +esgrafiemos esgrafiar VMM01P0 +esgrafía esgrafiar VMM02S0 +esgrafíe esgrafiar VMM03S0 +esgrafíen esgrafiar VMM03P0 +esgrima esgrimir VMM03S0 +esgrimamos esgrimir VMM01P0 +esgriman esgrimir VMM03P0 +esgrime esgrimir VMM02S0 +esgrimid esgrimir VMM02P0 +esgrimiendo esgrimir VMG0000 +esgrimir esgrimir VMN0000 +esguace esguazar VMM03S0 +esguacemos esguazar VMM01P0 +esguacen esguazar VMM03P0 +esguaza esguazar VMM02S0 +esguazad esguazar VMM02P0 +esguazando esguazar VMG0000 +esguazar esguazar VMN0000 +eslabona eslabonar VMM02S0 +eslabonad eslabonar VMM02P0 +eslabonando eslabonar VMG0000 +eslabonar eslabonar VMN0000 +eslabone eslabonar VMM03S0 +eslabonemos eslabonar VMM01P0 +eslabonen eslabonar VMM03P0 +eslinga eslingar VMM02S0 +eslingad eslingar VMM02P0 +eslingando eslingar VMG0000 +eslingar eslingar VMN0000 +esmalta esmaltar VMM02S0 +esmaltad esmaltar VMM02P0 +esmaltando esmaltar VMG0000 +esmaltar esmaltar VMN0000 +esmalte esmaltar VMM03S0 +esmaltemos esmaltar VMM01P0 +esmalten esmaltar VMM03P0 +esmera esmerar VMM02S0 +esmerad esmerar VMM02P0 +esmerando esmerar VMG0000 +esmerar esmerar VMN0000 +esmere esmerar VMM03S0 +esmeremos esmerar VMM01P0 +esmeren esmerar VMM03P0 +esmerila esmerilar VMM02S0 +esmerilad esmerilar VMM02P0 +esmerilando esmerilar VMG0000 +esmerilar esmerilar VMN0000 +esmerile esmerilar VMM03S0 +esmerilemos esmerilar VMM01P0 +esmerilen esmerilar VMM03P0 +espabila espabilar VMM02S0 +espabilad espabilar VMM02P0 +espabilando espabilar VMG0000 +espabilar espabilar VMN0000 +espabile espabilar VMM03S0 +espabilemos espabilar VMM01P0 +espabilen espabilar VMM03P0 +espachurra espachurrar VMM02S0 +espachurrad espachurrar VMM02P0 +espachurrando espachurrar VMG0000 +espachurrar espachurrar VMN0000 +espachurre espachurrar VMM03S0 +espachurremos espachurrar VMM01P0 +espachurren espachurrar VMM03P0 +espacia espaciar VMM02S0 +espaciad espaciar VMM02P0 +espaciando espaciar VMG0000 +espaciar espaciar VMN0000 +espacie espaciar VMM03S0 +espaciemos espaciar VMM01P0 +espacien espaciar VMM03P0 +espada espadar VMM02S0 +espadad espadar VMM02P0 +espadando espadar VMG0000 +espadar espadar VMN0000 +espade espadar VMM03S0 +espademos espadar VMM01P0 +espaden espadar VMM03P0 +espadilla espadillar VMM02S0 +espadillad espadillar VMM02P0 +espadillando espadillar VMG0000 +espadillar espadillar VMN0000 +espadille espadillar VMM03S0 +espadillemos espadillar VMM01P0 +espadillen espadillar VMM03P0 +espala espalar VMM02S0 +espalad espalar VMM02P0 +espalando espalar VMG0000 +espalar espalar VMN0000 +espaldea espaldear VMM02S0 +espaldead espaldear VMM02P0 +espaldeando espaldear VMG0000 +espaldear espaldear VMN0000 +espaldee espaldear VMM03S0 +espaldeemos espaldear VMM01P0 +espaldeen espaldear VMM03P0 +espaldona espaldonar VMM02S0 +espaldonad espaldonar VMM02P0 +espaldonando espaldonar VMG0000 +espaldonar espaldonar VMN0000 +espaldone espaldonar VMM03S0 +espaldonemos espaldonar VMM01P0 +espaldonen espaldonar VMM03P0 +espale espalar VMM03S0 +espalemos espalar VMM01P0 +espalen espalar VMM03P0 +espanta espantar VMM02S0 +espantad espantar VMM02P0 +espantando espantar VMG0000 +espantar espantar VMN0000 +espante espantar VMM03S0 +espantemos espantar VMM01P0 +espanten espantar VMM03P0 +esparce esparcir VMM02S0 +esparcid esparcir VMM02P0 +esparciendo esparcir VMG0000 +esparcir esparcir VMN0000 +esparranca esparrancar VMM02S0 +esparrancad esparrancar VMM02P0 +esparrancando esparrancar VMG0000 +esparrancar esparrancar VMN0000 +esparranque esparrancar VMM03S0 +esparranquemos esparrancar VMM01P0 +esparranquen esparrancar VMM03P0 +esparza esparcir VMM03S0 +esparzamos esparcir VMM01P0 +esparzan esparcir VMM03P0 +espatarra espatarrar VMM02S0 +espatarrad espatarrar VMM02P0 +espatarrando espatarrar VMG0000 +espatarrar espatarrar VMN0000 +espatarre espatarrar VMM03S0 +espatarremos espatarrar VMM01P0 +espatarren espatarrar VMM03P0 +española españolar VMM02S0 +españolad españolar VMM02P0 +españolando españolar VMG0000 +españolar españolar VMN0000 +españole españolar VMM03S0 +españolemos españolar VMM01P0 +españolen españolar VMM03P0 +españolice españolizar VMM03S0 +españolicemos españolizar VMM01P0 +españolicen españolizar VMM03P0 +españoliza españolizar VMM02S0 +españolizad españolizar VMM02P0 +españolizando españolizar VMG0000 +españolizar españolizar VMN0000 +especialice especializar VMM03S0 +especialicemos especializar VMM01P0 +especialicen especializar VMM03P0 +especializa especializar VMM02S0 +especializad especializar VMM02P0 +especializando especializar VMG0000 +especializar especializar VMN0000 +especifica especificar VMM02S0 +especificad especificar VMM02P0 +especificando especificar VMG0000 +especificar especificar VMN0000 +especifique especificar VMM03S0 +especifiquemos especificar VMM01P0 +especifiquen especificar VMM03P0 +especula especular VMM02S0 +especulad especular VMM02P0 +especulando especular VMG0000 +especular especular VMN0000 +especule especular VMM03S0 +especulemos especular VMM01P0 +especulen especular VMM03P0 +espeja espejar VMM02S0 +espejad espejar VMM02P0 +espejando espejar VMG0000 +espejar espejar VMN0000 +espeje espejar VMM03S0 +espejea espejear VMM02S0 +espejead espejear VMM02P0 +espejeando espejear VMG0000 +espejear espejear VMN0000 +espejee espejear VMM03S0 +espejeemos espejear VMM01P0 +espejeen espejear VMM03P0 +espejemos espejar VMM01P0 +espejen espejar VMM03P0 +espeluce espeluzar VMM03S0 +espelucemos espeluzar VMM01P0 +espelucen espeluzar VMM03P0 +espeluza espeluzar VMM02S0 +espeluzad espeluzar VMM02P0 +espeluzando espeluzar VMG0000 +espeluzar espeluzar VMN0000 +espeluzna espeluznar VMM02S0 +espeluznad espeluznar VMM02P0 +espeluznando espeluznar VMG0000 +espeluznar espeluznar VMN0000 +espeluzne espeluznar VMM03S0 +espeluznemos espeluznar VMM01P0 +espeluznen espeluznar VMM03P0 +espera esperar VMM02S0 +esperad esperar VMM02P0 +esperance esperanzar VMM03S0 +esperancemos esperanzar VMM01P0 +esperancen esperanzar VMM03P0 +esperando esperar VMG0000 +esperanza esperanzar VMM02S0 +esperanzad esperanzar VMM02P0 +esperanzando esperanzar VMG0000 +esperanzar esperanzar VMN0000 +esperar esperar VMN0000 +espere esperar VMM03S0 +esperemos esperar VMM01P0 +esperen esperar VMM03P0 +espernanca espernancar VMM02S0 +espernancad espernancar VMM02P0 +espernancando espernancar VMG0000 +espernancar espernancar VMN0000 +espernanque espernancar VMM03S0 +espernanquemos espernancar VMM01P0 +espernanquen espernancar VMM03P0 +espesa espesar VMM02S0 +espesad espesar VMM02P0 +espesando espesar VMG0000 +espesar espesar VMN0000 +espese espesar VMM03S0 +espesemos espesar VMM01P0 +espesen espesar VMM03P0 +espeta espetar VMM02S0 +espetad espetar VMM02P0 +espetando espetar VMG0000 +espetar espetar VMN0000 +espete espetar VMM03S0 +espetemos espetar VMM01P0 +espeten espetar VMM03P0 +espiad espiar VMM02P0 +espiando espiar VMG0000 +espiar espiar VMN0000 +espicha espichar VMM02S0 +espichad espichar VMM02P0 +espichando espichar VMG0000 +espichar espichar VMN0000 +espiche espichar VMM03S0 +espichemos espichar VMM01P0 +espichen espichar VMM03P0 +espiemos espiar VMM01P0 +espiga espigar VMM02S0 +espigad espigar VMM02P0 +espigando espigar VMG0000 +espigar espigar VMN0000 +espigue espigar VMM03S0 +espiguemos espigar VMM01P0 +espiguen espigar VMM03P0 +espina espinar VMM02S0 +espinad espinar VMM02P0 +espinando espinar VMG0000 +espinar espinar VMN0000 +espine espinar VMM03S0 +espinemos espinar VMM01P0 +espinen espinar VMM03P0 +espira espirar VMM02S0 +espirad espirar VMM02P0 +espirando espirar VMG0000 +espirar espirar VMN0000 +espire espirar VMM03S0 +espiremos espirar VMM01P0 +espiren espirar VMM03P0 +espiritualice espiritualizar VMM03S0 +espiritualicemos espiritualizar VMM01P0 +espiritualicen espiritualizar VMM03P0 +espiritualiza espiritualizar VMM02S0 +espiritualizad espiritualizar VMM02P0 +espiritualizando espiritualizar VMG0000 +espiritualizar espiritualizar VMN0000 +espita espitar VMM02S0 +espitad espitar VMM02P0 +espitando espitar VMG0000 +espitar espitar VMN0000 +espite espitar VMM03S0 +espitemos espitar VMM01P0 +espiten espitar VMM03P0 +esplenda esplender VMM03S0 +esplendamos esplender VMM01P0 +esplendan esplender VMM03P0 +esplende esplender VMM02S0 +esplended esplender VMM02P0 +esplender esplender VMN0000 +esplendiendo esplender VMG0000 +espolea espolear VMM02S0 +espolead espolear VMM02P0 +espoleando espolear VMG0000 +espolear espolear VMN0000 +espolee espolear VMM03S0 +espoleemos espolear VMM01P0 +espoleen espolear VMM03P0 +espolina espolinar VMM02S0 +espolinad espolinar VMM02P0 +espolinando espolinar VMG0000 +espolinar espolinar VMN0000 +espoline espolinar VMM03S0 +espolinemos espolinar VMM01P0 +espolinen espolinar VMM03P0 +espolvorea espolvorear VMM02S0 +espolvoread espolvorear VMM02P0 +espolvoreando espolvorear VMG0000 +espolvorear espolvorear VMN0000 +espolvoree espolvorear VMM03S0 +espolvoreemos espolvorear VMM01P0 +espolvoreen espolvorear VMM03P0 +esponja esponjar VMM02S0 +esponjad esponjar VMM02P0 +esponjando esponjar VMG0000 +esponjar esponjar VMN0000 +esponje esponjar VMM03S0 +esponjemos esponjar VMM01P0 +esponjen esponjar VMM03P0 +espontanea espontanear VMM02S0 +espontanead espontanear VMM02P0 +espontaneando espontanear VMG0000 +espontanear espontanear VMN0000 +espontanee espontanear VMM03S0 +espontaneemos espontanear VMM01P0 +espontaneen espontanear VMM03P0 +esportea esportear VMM02S0 +esportead esportear VMM02P0 +esporteando esportear VMG0000 +esportear esportear VMN0000 +esportee esportear VMM03S0 +esporteemos esportear VMM01P0 +esporteen esportear VMM03P0 +esposa esposar VMM02S0 +esposad esposar VMM02P0 +esposando esposar VMG0000 +esposar esposar VMN0000 +espose esposar VMM03S0 +esposemos esposar VMM01P0 +esposen esposar VMM03P0 +esprinta esprintar VMM02S0 +esprintad esprintar VMM02P0 +esprintando esprintar VMG0000 +esprintar esprintar VMN0000 +esprinte esprintar VMM03S0 +esprintemos esprintar VMM01P0 +esprinten esprintar VMM03P0 +espulga espulgar VMM02S0 +espulgad espulgar VMM02P0 +espulgando espulgar VMG0000 +espulgar espulgar VMN0000 +espulgue espulgar VMM03S0 +espulguemos espulgar VMM01P0 +espulguen espulgar VMM03P0 +espuma espumar VMM02S0 +espumad espumar VMM02P0 +espumaja espumajar VMM02S0 +espumajad espumajar VMM02P0 +espumajando espumajar VMG0000 +espumajar espumajar VMN0000 +espumajea espumajear VMM02S0 +espumajead espumajear VMM02P0 +espumajeando espumajear VMG0000 +espumajear espumajear VMN0000 +espumajee espumajear VMM03S0 +espumajeemos espumajear VMM01P0 +espumajeen espumajear VMM03P0 +espumando espumar VMG0000 +espumar espumar VMN0000 +espume espumar VMM03S0 +espumemos espumar VMM01P0 +espumen espumar VMM03P0 +espurrea espurrear VMM02S0 +espurread espurrear VMM02P0 +espurreando espurrear VMG0000 +espurrear espurrear VMN0000 +espurree espurrear VMM03S0 +espurreemos espurrear VMM01P0 +espurreen espurrear VMM03P0 +espurriad espurriar VMM02P0 +espurriando espurriar VMG0000 +espurriar espurriar VMN0000 +espurriemos espurriar VMM01P0 +espurría espurriar VMM02S0 +espurríe espurriar VMM03S0 +espurríen espurriar VMM03P0 +esputa esputar VMM02S0 +esputad esputar VMM02P0 +esputando esputar VMG0000 +esputar esputar VMN0000 +espute esputar VMM03S0 +esputemos esputar VMM01P0 +esputen esputar VMM03P0 +espía espiar VMM02S0 +espíe espiar VMM03S0 +espíen espiar VMM03P0 +esquematice esquematizar VMM03S0 +esquematicemos esquematizar VMM01P0 +esquematicen esquematizar VMM03P0 +esquematiza esquematizar VMM02S0 +esquematizad esquematizar VMM02P0 +esquematizando esquematizar VMG0000 +esquematizar esquematizar VMN0000 +esquiad esquiar VMM02P0 +esquiando esquiar VMG0000 +esquiar esquiar VMN0000 +esquiemos esquiar VMM01P0 +esquila esquilar VMM02S0 +esquilad esquilar VMM02P0 +esquilando esquilar VMG0000 +esquilar esquilar VMN0000 +esquile esquilar VMM03S0 +esquilemos esquilar VMM01P0 +esquilen esquilar VMM03P0 +esquilma esquilmar VMM02S0 +esquilmad esquilmar VMM02P0 +esquilmando esquilmar VMG0000 +esquilmar esquilmar VMN0000 +esquilme esquilmar VMM03S0 +esquilmemos esquilmar VMM01P0 +esquilmen esquilmar VMM03P0 +esquina esquinar VMM02S0 +esquinad esquinar VMM02P0 +esquinando esquinar VMG0000 +esquinar esquinar VMN0000 +esquince esquinzar VMM03S0 +esquincemos esquinzar VMM01P0 +esquincen esquinzar VMM03P0 +esquine esquinar VMM03S0 +esquinemos esquinar VMM01P0 +esquinen esquinar VMM03P0 +esquinza esquinzar VMM02S0 +esquinzad esquinzar VMM02P0 +esquinzando esquinzar VMG0000 +esquinzar esquinzar VMN0000 +esquiva esquivar VMM02S0 +esquivad esquivar VMM02P0 +esquivando esquivar VMG0000 +esquivar esquivar VMN0000 +esquive esquivar VMM03S0 +esquivemos esquivar VMM01P0 +esquiven esquivar VMM03P0 +esquía esquiar VMM02S0 +esquíe esquiar VMM03S0 +esquíen esquiar VMM03P0 +estabilice estabilizar VMM03S0 +estabilicemos estabilizar VMM01P0 +estabilicen estabilizar VMM03P0 +estabiliza estabilizar VMM02S0 +estabilizad estabilizar VMM02P0 +estabilizando estabilizar VMG0000 +estabilizar estabilizar VMN0000 +establece establecer VMM02S0 +estableced establecer VMM02P0 +establecer establecer VMN0000 +estableciendo establecer VMG0000 +establezca establecer VMM03S0 +establezcamos establecer VMM01P0 +establezcan establecer VMM03P0 +estabula estabular VMM02S0 +estabulad estabular VMM02P0 +estabulando estabular VMG0000 +estabular estabular VMN0000 +estabule estabular VMM03S0 +estabulemos estabular VMM01P0 +estabulen estabular VMM03P0 +estaca estacar VMM02S0 +estacad estacar VMM02P0 +estacando estacar VMG0000 +estacar estacar VMN0000 +estaciona estacionar VMM02S0 +estacionad estacionar VMM02P0 +estacionando estacionar VMG0000 +estacionar estacionar VMN0000 +estacione estacionar VMM03S0 +estacionemos estacionar VMM01P0 +estacionen estacionar VMM03P0 +estafa estafar VMM02S0 +estafad estafar VMM02P0 +estafando estafar VMG0000 +estafar estafar VMN0000 +estafe estafar VMM03S0 +estafemos estafar VMM01P0 +estafen estafar VMM03P0 +estalla estallar VMM02S0 +estallad estallar VMM02P0 +estallando estallar VMG0000 +estallar estallar VMN0000 +estalle estallar VMM03S0 +estallemos estallar VMM01P0 +estallen estallar VMM03P0 +estambra estambrar VMM02S0 +estambrad estambrar VMM02P0 +estambrando estambrar VMG0000 +estambrar estambrar VMN0000 +estambre estambrar VMM03S0 +estambremos estambrar VMM01P0 +estambren estambrar VMM03P0 +estampa estampar VMM02S0 +estampad estampar VMM02P0 +estampando estampar VMG0000 +estampar estampar VMN0000 +estampe estampar VMM03S0 +estampemos estampar VMM01P0 +estampen estampar VMM03P0 +estampilla estampillar VMM02S0 +estampillad estampillar VMM02P0 +estampillando estampillar VMG0000 +estampillar estampillar VMN0000 +estampille estampillar VMM03S0 +estampillemos estampillar VMM01P0 +estampillen estampillar VMM03P0 +estanca estancar VMM02S0 +estancad estancar VMM02P0 +estancando estancar VMG0000 +estancar estancar VMN0000 +estandardice estandardizar VMM03S0 +estandardicemos estandardizar VMM01P0 +estandardicen estandardizar VMM03P0 +estandardiza estandardizar VMM02S0 +estandardizad estandardizar VMM02P0 +estandardizando estandardizar VMG0000 +estandardizar estandardizar VMN0000 +estandarice estandarizar VMM03S0 +estandaricemos estandarizar VMM01P0 +estandaricen estandarizar VMM03P0 +estandariza estandarizar VMM02S0 +estandarizad estandarizar VMM02P0 +estandarizando estandarizar VMG0000 +estandarizar estandarizar VMN0000 +estanque estancar VMM03S0 +estanquemos estancar VMM01P0 +estanquen estancar VMM03P0 +estaque estacar VMM03S0 +estaquemos estacar VMM01P0 +estaquen estacar VMM03P0 +estaquilla estaquillar VMM02S0 +estaquillad estaquillar VMM02P0 +estaquillando estaquillar VMG0000 +estaquillar estaquillar VMN0000 +estaquille estaquillar VMM03S0 +estaquillemos estaquillar VMM01P0 +estaquillen estaquillar VMM03P0 +estad estar VAM02P0 +estar estar VAN0000 +estarce estarcir VMM02S0 +estarcid estarcir VMM02P0 +estarciendo estarcir VMG0000 +estarcir estarcir VMN0000 +estarza estarcir VMM03S0 +estarzamos estarcir VMM01P0 +estarzan estarcir VMM03P0 +estatuid estatuir VMM02P0 +estatuir estatuir VMN0000 +estatuya estatuir VMM03S0 +estatuyamos estatuir VMM01P0 +estatuyan estatuir VMM03P0 +estatuye estatuir VMM02S0 +estatuyendo estatuir VMG0000 +estaña estañar VMM02S0 +estañad estañar VMM02P0 +estañando estañar VMG0000 +estañar estañar VMN0000 +estañe estañar VMM03S0 +estañemos estañar VMM01P0 +estañen estañar VMM03P0 +estece estezar VMM03S0 +estecemos estezar VMM01P0 +estecen estezar VMM03P0 +estemos estar VMM01P0 +estenografiad estenografiar VMM02P0 +estenografiando estenografiar VMG0000 +estenografiar estenografiar VMN0000 +estenografiemos estenografiar VMM01P0 +estenografía estenografiar VMM02S0 +estenografíe estenografiar VMM03S0 +estenografíen estenografiar VMM03P0 +estera esterar VMM02S0 +esterad esterar VMM02P0 +esterando esterar VMG0000 +esterar esterar VMN0000 +estercola estercolar VMM02S0 +estercolad estercolar VMM02P0 +estercolando estercolar VMG0000 +estercolar estercolar VMN0000 +estercole estercolar VMM03S0 +estercolemos estercolar VMM01P0 +estercolen estercolar VMM03P0 +estere esterar VMM03S0 +esteremos esterar VMM01P0 +esteren esterar VMM03P0 +estereotipa estereotipar VMM02S0 +estereotipad estereotipar VMM02P0 +estereotipando estereotipar VMG0000 +estereotipar estereotipar VMN0000 +estereotipe estereotipar VMM03S0 +estereotipemos estereotipar VMM01P0 +estereotipen estereotipar VMM03P0 +esterifica esterificar VMM02S0 +esterificad esterificar VMM02P0 +esterificando esterificar VMG0000 +esterificar esterificar VMN0000 +esterifique esterificar VMM03S0 +esterifiquemos esterificar VMM01P0 +esterifiquen esterificar VMM03P0 +esterilice esterilizar VMM03S0 +esterilicemos esterilizar VMM01P0 +esterilicen esterilizar VMM03P0 +esteriliza esterilizar VMM02S0 +esterilizad esterilizar VMM02P0 +esterilizando esterilizar VMG0000 +esterilizar esterilizar VMN0000 +esteza estezar VMM02S0 +estezad estezar VMM02P0 +estezando estezar VMG0000 +estezar estezar VMN0000 +estiba estibar VMM02S0 +estibad estibar VMM02P0 +estibando estibar VMG0000 +estibar estibar VMN0000 +estibe estibar VMM03S0 +estibemos estibar VMM01P0 +estiben estibar VMM03P0 +estigmatice estigmatizar VMM03S0 +estigmaticemos estigmatizar VMM01P0 +estigmaticen estigmatizar VMM03P0 +estigmatiza estigmatizar VMM02S0 +estigmatizad estigmatizar VMM02P0 +estigmatizando estigmatizar VMG0000 +estigmatizar estigmatizar VMN0000 +estila estilar VMM02S0 +estilad estilar VMM02P0 +estilando estilar VMG0000 +estilar estilar VMN0000 +estile estilar VMM03S0 +estilemos estilar VMM01P0 +estilen estilar VMM03P0 +estilice estilizar VMM03S0 +estilicemos estilizar VMM01P0 +estilicen estilizar VMM03P0 +estiliza estilizar VMM02S0 +estilizad estilizar VMM02P0 +estilizando estilizar VMG0000 +estilizar estilizar VMN0000 +estima estimar VMM02S0 +estimad estimar VMM02P0 +estimando estimar VMG0000 +estimar estimar VMN0000 +estime estimar VMM03S0 +estimemos estimar VMM01P0 +estimen estimar VMM03P0 +estimula estimular VMM02S0 +estimulad estimular VMM02P0 +estimulando estimular VMG0000 +estimular estimular VMN0000 +estimule estimular VMM03S0 +estimulemos estimular VMM01P0 +estimulen estimular VMM03P0 +estipendia estipendiar VMM02S0 +estipendiad estipendiar VMM02P0 +estipendiando estipendiar VMG0000 +estipendiar estipendiar VMN0000 +estipendie estipendiar VMM03S0 +estipendiemos estipendiar VMM01P0 +estipendien estipendiar VMM03P0 +estipula estipular VMM02S0 +estipulad estipular VMM02P0 +estipulando estipular VMG0000 +estipular estipular VMN0000 +estipule estipular VMM03S0 +estipulemos estipular VMM01P0 +estipulen estipular VMM03P0 +estira estirar VMM02S0 +estirad estirar VMM02P0 +estirando estirar VMG0000 +estirar estirar VMN0000 +estire estirar VMM03S0 +estiremos estirar VMM01P0 +estiren estirar VMM03P0 +estofa estofar VMM02S0 +estofad estofar VMM02P0 +estofando estofar VMG0000 +estofar estofar VMN0000 +estofe estofar VMM03S0 +estofemos estofar VMM01P0 +estofen estofar VMM03P0 +estomaga estomagar VMM02S0 +estomagad estomagar VMM02P0 +estomagando estomagar VMG0000 +estomagar estomagar VMN0000 +estomague estomagar VMM03S0 +estomaguemos estomagar VMM01P0 +estomaguen estomagar VMM03P0 +estoquea estoquear VMM02S0 +estoquead estoquear VMM02P0 +estoqueando estoquear VMG0000 +estoquear estoquear VMN0000 +estoquee estoquear VMM03S0 +estoqueemos estoquear VMM01P0 +estoqueen estoquear VMM03P0 +estorba estorbar VMM02S0 +estorbad estorbar VMM02P0 +estorbando estorbar VMG0000 +estorbar estorbar VMN0000 +estorbe estorbar VMM03S0 +estorbemos estorbar VMM01P0 +estorben estorbar VMM03P0 +estornuda estornudar VMM02S0 +estornudad estornudar VMM02P0 +estornudando estornudar VMG0000 +estornudar estornudar VMN0000 +estornude estornudar VMM03S0 +estornudemos estornudar VMM01P0 +estornuden estornudar VMM03P0 +estova estovar VMM02S0 +estovad estovar VMM02P0 +estovando estovar VMG0000 +estovar estovar VMN0000 +estove estovar VMM03S0 +estovemos estovar VMM01P0 +estoven estovar VMM03P0 +estraga estragar VMM02S0 +estragad estragar VMM02P0 +estragando estragar VMG0000 +estragar estragar VMN0000 +estrague estragar VMM03S0 +estraguemos estragar VMM01P0 +estraguen estragar VMM03P0 +estrangula estrangular VMM02S0 +estrangulad estrangular VMM02P0 +estrangulando estrangular VMG0000 +estrangular estrangular VMN0000 +estrangule estrangular VMM03S0 +estrangulemos estrangular VMM01P0 +estrangulen estrangular VMM03P0 +estraperlea estraperlear VMM02S0 +estraperlead estraperlear VMM02P0 +estraperleando estraperlear VMG0000 +estraperlear estraperlear VMN0000 +estraperlee estraperlear VMM03S0 +estraperleemos estraperlear VMM01P0 +estraperleen estraperlear VMM03P0 +estratifica estratificar VMM02S0 +estratificad estratificar VMM02P0 +estratificando estratificar VMG0000 +estratificar estratificar VMN0000 +estratifique estratificar VMM03S0 +estratifiquemos estratificar VMM01P0 +estratifiquen estratificar VMM03P0 +estrecha estrechar VMM02S0 +estrechad estrechar VMM02P0 +estrechando estrechar VMG0000 +estrechar estrechar VMN0000 +estreche estrechar VMM03S0 +estrechemos estrechar VMM01P0 +estrechen estrechar VMM03P0 +estregad estregar VMM02P0 +estregando estregar VMG0000 +estregar estregar VMN0000 +estreguemos estregar VMM01P0 +estrella estrellar VMM02S0 +estrellad estrellar VMM02P0 +estrellando estrellar VMG0000 +estrellar estrellar VMN0000 +estrelle estrellar VMM03S0 +estrellemos estrellar VMM01P0 +estrellen estrellar VMM03P0 +estremece estremecer VMM02S0 +estremeced estremecer VMM02P0 +estremecer estremecer VMN0000 +estremeciendo estremecer VMG0000 +estremezca estremecer VMM03S0 +estremezcamos estremecer VMM01P0 +estremezcan estremecer VMM03P0 +estrena estrenar VMM02S0 +estrenad estrenar VMM02P0 +estrenando estrenar VMG0000 +estrenar estrenar VMN0000 +estrene estrenar VMM03S0 +estrenemos estrenar VMM01P0 +estrenen estrenar VMM03P0 +estreñid estreñir VMM02P0 +estreñir estreñir VMN0000 +estriad estriar VMM02P0 +estriando estriar VMG0000 +estriar estriar VMN0000 +estriba estribar VMM02S0 +estribad estribar VMM02P0 +estribando estribar VMG0000 +estribar estribar VMN0000 +estribe estribar VMM03S0 +estribemos estribar VMM01P0 +estriben estribar VMM03P0 +estridula estridular VMM02S0 +estridulad estridular VMM02P0 +estridulando estridular VMG0000 +estridular estridular VMN0000 +estridule estridular VMM03S0 +estridulemos estridular VMM01P0 +estridulen estridular VMM03P0 +estriega estregar VMM02S0 +estriegue estregar VMM03S0 +estrieguen estregar VMM03P0 +estriemos estriar VMM01P0 +estriña estreñir VMM03S0 +estriñamos estreñir VMM01P0 +estriñan estreñir VMM03P0 +estriñe estreñir VMM02S0 +estriñendo estreñir VMG0000 +estropea estropear VMM02S0 +estropead estropear VMM02P0 +estropeando estropear VMG0000 +estropear estropear VMN0000 +estropee estropear VMM03S0 +estropeemos estropear VMM01P0 +estropeen estropear VMM03P0 +estructura estructurar VMM02S0 +estructurad estructurar VMM02P0 +estructurando estructurar VMG0000 +estructurar estructurar VMN0000 +estructure estructurar VMM03S0 +estructuremos estructurar VMM01P0 +estructuren estructurar VMM03P0 +estruja estrujar VMM02S0 +estrujad estrujar VMM02P0 +estrujando estrujar VMG0000 +estrujar estrujar VMN0000 +estruje estrujar VMM03S0 +estrujemos estrujar VMM01P0 +estrujen estrujar VMM03P0 +estría estriar VMM02S0 +estríe estriar VMM03S0 +estríen estriar VMM03P0 +estuca estucar VMM02S0 +estucad estucar VMM02P0 +estucando estucar VMG0000 +estucar estucar VMN0000 +estucha estuchar VMM02S0 +estuchad estuchar VMM02P0 +estuchando estuchar VMG0000 +estuchar estuchar VMN0000 +estuche estuchar VMM03S0 +estuchemos estuchar VMM01P0 +estuchen estuchar VMM03P0 +estudia estudiar VMM02S0 +estudiad estudiar VMM02P0 +estudiando estudiar VMG0000 +estudiar estudiar VMN0000 +estudie estudiar VMM03S0 +estudiemos estudiar VMM01P0 +estudien estudiar VMM03P0 +estufa estufar VMM02S0 +estufad estufar VMM02P0 +estufando estufar VMG0000 +estufar estufar VMN0000 +estufe estufar VMM03S0 +estufemos estufar VMM01P0 +estufen estufar VMM03P0 +estupra estuprar VMM02S0 +estuprad estuprar VMM02P0 +estuprando estuprar VMG0000 +estuprar estuprar VMN0000 +estupre estuprar VMM03S0 +estupremos estuprar VMM01P0 +estupren estuprar VMM03P0 +estuque estucar VMM03S0 +estuquemos estucar VMM01P0 +estuquen estucar VMM03P0 +está estar VMM02S0 +esté estar VMM03S0 +estén estar VMM03P0 +eterice eterizar VMM03S0 +etericemos eterizar VMM01P0 +etericen eterizar VMM03P0 +eterifica eterificar VMM02S0 +eterificad eterificar VMM02P0 +eterificando eterificar VMG0000 +eterificar eterificar VMN0000 +eterifique eterificar VMM03S0 +eterifiquemos eterificar VMM01P0 +eterifiquen eterificar VMM03P0 +eteriza eterizar VMM02S0 +eterizad eterizar VMM02P0 +eterizando eterizar VMG0000 +eterizar eterizar VMN0000 +eternice eternizar VMM03S0 +eternicemos eternizar VMM01P0 +eternicen eternizar VMM03P0 +eterniza eternizar VMM02S0 +eternizad eternizar VMM02P0 +eternizando eternizar VMG0000 +eternizar eternizar VMN0000 +etimologice etimologizar VMM03S0 +etimologicemos etimologizar VMM01P0 +etimologicen etimologizar VMM03P0 +etimologiza etimologizar VMM02S0 +etimologizad etimologizar VMM02P0 +etimologizando etimologizar VMG0000 +etimologizar etimologizar VMN0000 +etiqueta etiquetar VMM02S0 +etiquetad etiquetar VMM02P0 +etiquetando etiquetar VMG0000 +etiquetar etiquetar VMN0000 +etiquete etiquetar VMM03S0 +etiquetemos etiquetar VMM01P0 +etiqueten etiquetar VMM03P0 +europeice europeizar VMM03S0 +europeicemos europeizar VMM01P0 +europeicen europeizar VMM03P0 +europeiza europeizar VMM02S0 +europeizad europeizar VMM02P0 +europeizando europeizar VMG0000 +europeizar europeizar VMN0000 +eutrofice eutrofizar VMM03S0 +eutroficemos eutrofizar VMM01P0 +eutroficen eutrofizar VMM03P0 +eutrofiza eutrofizar VMM02S0 +eutrofizad eutrofizar VMM02P0 +eutrofizando eutrofizar VMG0000 +eutrofizar eutrofizar VMN0000 +evacuad evacuar VMM02P0 +evacuando evacuar VMG0000 +evacuar evacuar VMN0000 +evacuemos evacuar VMM01P0 +evacúa evacuar VMM02S0 +evacúe evacuar VMM03S0 +evacúen evacuar VMM03P0 +evada evadir VMM03S0 +evadamos evadir VMM01P0 +evadan evadir VMM03P0 +evade evadir VMM02S0 +evadid evadir VMM02P0 +evadiendo evadir VMG0000 +evadir evadir VMN0000 +evaluad evaluar VMM02P0 +evaluando evaluar VMG0000 +evaluar evaluar VMN0000 +evaluemos evaluar VMM01P0 +evalúa evaluar VMM02S0 +evalúe evaluar VMM03S0 +evalúen evaluar VMM03P0 +evangelice evangelizar VMM03S0 +evangelicemos evangelizar VMM01P0 +evangelicen evangelizar VMM03P0 +evangeliza evangelizar VMM02S0 +evangelizad evangelizar VMM02P0 +evangelizando evangelizar VMG0000 +evangelizar evangelizar VMN0000 +evapora evaporar VMM02S0 +evaporad evaporar VMM02P0 +evaporando evaporar VMG0000 +evaporar evaporar VMN0000 +evapore evaporar VMM03S0 +evaporemos evaporar VMM01P0 +evaporen evaporar VMM03P0 +evaporice evaporizar VMM03S0 +evaporicemos evaporizar VMM01P0 +evaporicen evaporizar VMM03P0 +evaporiza evaporizar VMM02S0 +evaporizad evaporizar VMM02P0 +evaporizando evaporizar VMG0000 +evaporizar evaporizar VMN0000 +evidencia evidenciar VMM02S0 +evidenciad evidenciar VMM02P0 +evidenciando evidenciar VMG0000 +evidenciar evidenciar VMN0000 +evidencie evidenciar VMM03S0 +evidenciemos evidenciar VMM01P0 +evidencien evidenciar VMM03P0 +evita evitar VMM02S0 +evitad evitar VMM02P0 +evitando evitar VMG0000 +evitar evitar VMN0000 +evite evitar VMM03S0 +evitemos evitar VMM01P0 +eviten evitar VMM03P0 +evoca evocar VMM02S0 +evocad evocar VMM02P0 +evocando evocar VMG0000 +evocar evocar VMN0000 +evoluciona evolucionar VMM02S0 +evolucionad evolucionar VMM02P0 +evolucionando evolucionar VMG0000 +evolucionar evolucionar VMN0000 +evolucione evolucionar VMM03S0 +evolucionemos evolucionar VMM01P0 +evolucionen evolucionar VMM03P0 +evoque evocar VMM03S0 +evoquemos evocar VMM01P0 +evoquen evocar VMM03P0 +exacerba exacerbar VMM02S0 +exacerbad exacerbar VMM02P0 +exacerbando exacerbar VMG0000 +exacerbar exacerbar VMN0000 +exacerbe exacerbar VMM03S0 +exacerbemos exacerbar VMM01P0 +exacerben exacerbar VMM03P0 +exagera exagerar VMM02S0 +exagerad exagerar VMM02P0 +exagerando exagerar VMG0000 +exagerar exagerar VMN0000 +exagere exagerar VMM03S0 +exageremos exagerar VMM01P0 +exageren exagerar VMM03P0 +exalta exaltar VMM02S0 +exaltad exaltar VMM02P0 +exaltando exaltar VMG0000 +exaltar exaltar VMN0000 +exalte exaltar VMM03S0 +exaltemos exaltar VMM01P0 +exalten exaltar VMM03P0 +examina examinar VMM02S0 +examinad examinar VMM02P0 +examinando examinar VMG0000 +examinar examinar VMN0000 +examine examinar VMM03S0 +examinemos examinar VMM01P0 +examinen examinar VMM03P0 +exaspera exasperar VMM02S0 +exasperad exasperar VMM02P0 +exasperando exasperar VMG0000 +exasperar exasperar VMN0000 +exaspere exasperar VMM03S0 +exasperemos exasperar VMM01P0 +exasperen exasperar VMM03P0 +excandece excandecer VMM02S0 +excandeced excandecer VMM02P0 +excandecer excandecer VMN0000 +excandeciendo excandecer VMG0000 +excandezca excandecer VMM03S0 +excandezcamos excandecer VMM01P0 +excandezcan excandecer VMM03P0 +excarcela excarcelar VMM02S0 +excarcelad excarcelar VMM02P0 +excarcelando excarcelar VMG0000 +excarcelar excarcelar VMN0000 +excarcele excarcelar VMM03S0 +excarcelemos excarcelar VMM01P0 +excarcelen excarcelar VMM03P0 +excava excavar VMM02S0 +excavad excavar VMM02P0 +excavando excavar VMG0000 +excavar excavar VMN0000 +excave excavar VMM03S0 +excavemos excavar VMM01P0 +excaven excavar VMM03P0 +exceda exceder VMM03S0 +excedamos exceder VMM01P0 +excedan exceder VMM03P0 +excede exceder VMM02S0 +exceded exceder VMM02P0 +exceder exceder VMN0000 +excediendo exceder VMG0000 +excepciona excepcionar VMM02S0 +excepcionad excepcionar VMM02P0 +excepcionando excepcionar VMG0000 +excepcionar excepcionar VMN0000 +excepcione excepcionar VMM03S0 +excepcionemos excepcionar VMM01P0 +excepcionen excepcionar VMM03P0 +exceptuad exceptuar VMM02P0 +exceptuando exceptuar VMG0000 +exceptuar exceptuar VMN0000 +exceptuemos exceptuar VMM01P0 +exceptúa exceptuar VMM02S0 +exceptúe exceptuar VMM03S0 +exceptúen exceptuar VMM03P0 +excita excitar VMM02S0 +excitad excitar VMM02P0 +excitando excitar VMG0000 +excitar excitar VMN0000 +excite excitar VMM03S0 +excitemos excitar VMM01P0 +exciten excitar VMM03P0 +exclama exclamar VMM02S0 +exclamad exclamar VMM02P0 +exclamando exclamar VMG0000 +exclamar exclamar VMN0000 +exclame exclamar VMM03S0 +exclamemos exclamar VMM01P0 +exclamen exclamar VMM03P0 +exclaustra exclaustrar VMM02S0 +exclaustrad exclaustrar VMM02P0 +exclaustrando exclaustrar VMG0000 +exclaustrar exclaustrar VMN0000 +exclaustre exclaustrar VMM03S0 +exclaustremos exclaustrar VMM01P0 +exclaustren exclaustrar VMM03P0 +excluid excluir VMM02P0 +excluir excluir VMN0000 +excluya excluir VMM03S0 +excluyamos excluir VMM01P0 +excluyan excluir VMM03P0 +excluye excluir VMM02S0 +excluyendo excluir VMG0000 +excomulga excomulgar VMM02S0 +excomulgad excomulgar VMM02P0 +excomulgando excomulgar VMG0000 +excomulgar excomulgar VMN0000 +excomulgue excomulgar VMM03S0 +excomulguemos excomulgar VMM01P0 +excomulguen excomulgar VMM03P0 +excoria excoriar VMM02S0 +excoriad excoriar VMM02P0 +excoriando excoriar VMG0000 +excoriar excoriar VMN0000 +excorie excoriar VMM03S0 +excoriemos excoriar VMM01P0 +excorien excoriar VMM03P0 +excrementa excrementar VMM02S0 +excrementad excrementar VMM02P0 +excrementando excrementar VMG0000 +excrementar excrementar VMN0000 +excremente excrementar VMM03S0 +excrementemos excrementar VMM01P0 +excrementen excrementar VMM03P0 +excreta excretar VMM02S0 +excretad excretar VMM02P0 +excretando excretar VMG0000 +excretar excretar VMN0000 +excrete excretar VMM03S0 +excretemos excretar VMM01P0 +excreten excretar VMM03P0 +exculpa exculpar VMM02S0 +exculpad exculpar VMM02P0 +exculpando exculpar VMG0000 +exculpar exculpar VMN0000 +exculpe exculpar VMM03S0 +exculpemos exculpar VMM01P0 +exculpen exculpar VMM03P0 +excusa excusar VMM02S0 +excusad excusar VMM02P0 +excusando excusar VMG0000 +excusar excusar VMN0000 +excuse excusar VMM03S0 +excusemos excusar VMM01P0 +excusen excusar VMM03P0 +execra execrar VMM02S0 +execrad execrar VMM02P0 +execrando execrar VMG0000 +execrar execrar VMN0000 +execre execrar VMM03S0 +execremos execrar VMM01P0 +execren execrar VMM03P0 +exenta exentar VMM02S0 +exentad exentar VMM02P0 +exentando exentar VMG0000 +exentar exentar VMN0000 +exente exentar VMM03S0 +exentemos exentar VMM01P0 +exenten exentar VMM03P0 +exfolia exfoliar VMM02S0 +exfoliad exfoliar VMM02P0 +exfoliando exfoliar VMG0000 +exfoliar exfoliar VMN0000 +exfolie exfoliar VMM03S0 +exfoliemos exfoliar VMM01P0 +exfolien exfoliar VMM03P0 +exhala exhalar VMM02S0 +exhalad exhalar VMM02P0 +exhalando exhalar VMG0000 +exhalar exhalar VMN0000 +exhale exhalar VMM03S0 +exhalemos exhalar VMM01P0 +exhalen exhalar VMM03P0 +exhereda exheredar VMM02S0 +exheredad exheredar VMM02P0 +exheredando exheredar VMG0000 +exheredar exheredar VMN0000 +exherede exheredar VMM03S0 +exheredemos exheredar VMM01P0 +exhereden exheredar VMM03P0 +exhiba exhibir VMM03S0 +exhibamos exhibir VMM01P0 +exhiban exhibir VMM03P0 +exhibe exhibir VMM02S0 +exhibid exhibir VMM02P0 +exhibiendo exhibir VMG0000 +exhibir exhibir VMN0000 +exhorta exhortar VMM02S0 +exhortad exhortar VMM02P0 +exhortando exhortar VMG0000 +exhortar exhortar VMN0000 +exhorte exhortar VMM03S0 +exhortemos exhortar VMM01P0 +exhorten exhortar VMM03P0 +exhuma exhumar VMM02S0 +exhumad exhumar VMM02P0 +exhumando exhumar VMG0000 +exhumar exhumar VMN0000 +exhume exhumar VMM03S0 +exhumemos exhumar VMM01P0 +exhumen exhumar VMM03P0 +exige exigir VMM02S0 +exigid exigir VMM02P0 +exigiendo exigir VMG0000 +exigir exigir VMN0000 +exija exigir VMM03S0 +exijamos exigir VMM01P0 +exijan exigir VMM03P0 +exila exilar VMM02S0 +exilad exilar VMM02P0 +exilando exilar VMG0000 +exilar exilar VMN0000 +exile exilar VMM03S0 +exilemos exilar VMM01P0 +exilen exilar VMM03P0 +exilia exiliar VMM02S0 +exiliad exiliar VMM02P0 +exiliando exiliar VMG0000 +exiliar exiliar VMN0000 +exilie exiliar VMM03S0 +exiliemos exiliar VMM01P0 +exilien exiliar VMM03P0 +exima eximir VMM03S0 +eximamos eximir VMM01P0 +eximan eximir VMM03P0 +exime eximir VMM02S0 +eximid eximir VMM02P0 +eximiendo eximir VMG0000 +eximir eximir VMN0000 +exista existir VMM03S0 +existamos existir VMM01P0 +existan existir VMM03P0 +existe existir VMM02S0 +existid existir VMM02P0 +existiendo existir VMG0000 +existir existir VMN0000 +exonera exonerar VMM02S0 +exonerad exonerar VMM02P0 +exonerando exonerar VMG0000 +exonerar exonerar VMN0000 +exonere exonerar VMM03S0 +exoneremos exonerar VMM01P0 +exoneren exonerar VMM03P0 +exorcice exorcizar VMM03S0 +exorcicemos exorcizar VMM01P0 +exorcicen exorcizar VMM03P0 +exorciza exorcizar VMM02S0 +exorcizad exorcizar VMM02P0 +exorcizando exorcizar VMG0000 +exorcizar exorcizar VMN0000 +exorna exornar VMM02S0 +exornad exornar VMM02P0 +exornando exornar VMG0000 +exornar exornar VMN0000 +exorne exornar VMM03S0 +exornemos exornar VMM01P0 +exornen exornar VMM03P0 +expanda expandir VMM03S0 +expandamos expandir VMM01P0 +expandan expandir VMM03P0 +expande expandir VMM02S0 +expandid expandir VMM02P0 +expandiendo expandir VMG0000 +expandir expandir VMN0000 +expansiona expansionar VMM02S0 +expansionad expansionar VMM02P0 +expansionando expansionar VMG0000 +expansionar expansionar VMN0000 +expansione expansionar VMM03S0 +expansionemos expansionar VMM01P0 +expansionen expansionar VMM03P0 +expatriad expatriar VMM02P0 +expatriando expatriar VMG0000 +expatriar expatriar VMN0000 +expatriemos expatriar VMM01P0 +expatría expatriar VMM02S0 +expatríe expatriar VMM03S0 +expatríen expatriar VMM03P0 +expectora expectorar VMM02S0 +expectorad expectorar VMM02P0 +expectorando expectorar VMG0000 +expectorar expectorar VMN0000 +expectore expectorar VMM03S0 +expectoremos expectorar VMM01P0 +expectoren expectorar VMM03P0 +expedid expedir VMM02P0 +expedienta expedientar VMM02S0 +expedientad expedientar VMM02P0 +expedientando expedientar VMG0000 +expedientar expedientar VMN0000 +expediente expedientar VMM03S0 +expedientemos expedientar VMM01P0 +expedienten expedientar VMM03P0 +expedir expedir VMN0000 +expela expeler VMM03S0 +expelamos expeler VMM01P0 +expelan expeler VMM03P0 +expele expeler VMM02S0 +expeled expeler VMM02P0 +expeler expeler VMN0000 +expeliendo expeler VMG0000 +expenda expender VMM03S0 +expendamos expender VMM01P0 +expendan expender VMM03P0 +expende expender VMM02S0 +expended expender VMM02P0 +expender expender VMN0000 +expendiendo expender VMG0000 +expensa expensar VMM02S0 +expensad expensar VMM02P0 +expensando expensar VMG0000 +expensar expensar VMN0000 +expense expensar VMM03S0 +expensemos expensar VMM01P0 +expensen expensar VMM03P0 +experimenta experimentar VMM02S0 +experimentad experimentar VMM02P0 +experimentando experimentar VMG0000 +experimentar experimentar VMN0000 +experimente experimentar VMM03S0 +experimentemos experimentar VMM01P0 +experimenten experimentar VMM03P0 +expiad expiar VMM02P0 +expiando expiar VMG0000 +expiar expiar VMN0000 +expida expedir VMM03S0 +expidamos expedir VMM01P0 +expidan expedir VMM03P0 +expide expedir VMM02S0 +expidiendo expedir VMG0000 +expiemos expiar VMM01P0 +expila expilar VMM02S0 +expilad expilar VMM02P0 +expilando expilar VMG0000 +expilar expilar VMN0000 +expile expilar VMM03S0 +expilemos expilar VMM01P0 +expilen expilar VMM03P0 +expira expirar VMM02S0 +expirad expirar VMM02P0 +expirando expirar VMG0000 +expirar expirar VMN0000 +expire expirar VMM03S0 +expiremos expirar VMM01P0 +expiren expirar VMM03P0 +explana explanar VMM02S0 +explanad explanar VMM02P0 +explanando explanar VMG0000 +explanar explanar VMN0000 +explane explanar VMM03S0 +explanemos explanar VMM01P0 +explanen explanar VMM03P0 +explaya explayar VMM02S0 +explayad explayar VMM02P0 +explayando explayar VMG0000 +explayar explayar VMN0000 +explaye explayar VMM03S0 +explayemos explayar VMM01P0 +explayen explayar VMM03P0 +explica explicar VMM02S0 +explicad explicar VMM02P0 +explicando explicar VMG0000 +explicar explicar VMN0000 +explicita explicitar VMM02S0 +explicitad explicitar VMM02P0 +explicitando explicitar VMG0000 +explicitar explicitar VMN0000 +explicite explicitar VMM03S0 +explicitemos explicitar VMM01P0 +expliciten explicitar VMM03P0 +explicotea explicotear VMM02S0 +explicotead explicotear VMM02P0 +explicoteando explicotear VMG0000 +explicotear explicotear VMN0000 +explicotee explicotear VMM03S0 +explicoteemos explicotear VMM01P0 +explicoteen explicotear VMM03P0 +explique explicar VMM03S0 +expliquemos explicar VMM01P0 +expliquen explicar VMM03P0 +explora explorar VMM02S0 +explorad explorar VMM02P0 +explorando explorar VMG0000 +explorar explorar VMN0000 +explore explorar VMM03S0 +exploremos explorar VMM01P0 +exploren explorar VMM03P0 +explosiona explosionar VMM02S0 +explosionad explosionar VMM02P0 +explosionando explosionar VMG0000 +explosionar explosionar VMN0000 +explosione explosionar VMM03S0 +explosionemos explosionar VMM01P0 +explosionen explosionar VMM03P0 +explota explotar VMM02S0 +explotad explotar VMM02P0 +explotando explotar VMG0000 +explotar explotar VMN0000 +explote explotar VMM03S0 +explotemos explotar VMM01P0 +exploten explotar VMM03P0 +expolia expoliar VMM02S0 +expoliad expoliar VMM02P0 +expoliando expoliar VMG0000 +expoliar expoliar VMN0000 +expolie expoliar VMM03S0 +expoliemos expoliar VMM01P0 +expolien expoliar VMM03P0 +exponed exponer VMM02P0 +exponer exponer VMN0000 +exponga exponer VMM03S0 +expongamos exponer VMM01P0 +expongan exponer VMM03P0 +exponiendo exponer VMG0000 +exporta exportar VMM02S0 +exportad exportar VMM02P0 +exportando exportar VMG0000 +exportar exportar VMN0000 +exporte exportar VMM03S0 +exportemos exportar VMM01P0 +exporten exportar VMM03P0 +expresa expresar VMM02S0 +expresad expresar VMM02P0 +expresando expresar VMG0000 +expresar expresar VMN0000 +exprese expresar VMM03S0 +expresemos expresar VMM01P0 +expresen expresar VMM03P0 +exprima exprimir VMM03S0 +exprimamos exprimir VMM01P0 +expriman exprimir VMM03P0 +exprime exprimir VMM02S0 +exprimid exprimir VMM02P0 +exprimiendo exprimir VMG0000 +exprimir exprimir VMN0000 +expropia expropiar VMM02S0 +expropiad expropiar VMM02P0 +expropiando expropiar VMG0000 +expropiar expropiar VMN0000 +expropie expropiar VMM03S0 +expropiemos expropiar VMM01P0 +expropien expropiar VMM03P0 +expugna expugnar VMM02S0 +expugnad expugnar VMM02P0 +expugnando expugnar VMG0000 +expugnar expugnar VMN0000 +expugne expugnar VMM03S0 +expugnemos expugnar VMM01P0 +expugnen expugnar VMM03P0 +expulsa expulsar VMM02S0 +expulsad expulsar VMM02P0 +expulsando expulsar VMG0000 +expulsar expulsar VMN0000 +expulse expulsar VMM03S0 +expulsemos expulsar VMM01P0 +expulsen expulsar VMM03P0 +expurga expurgar VMM02S0 +expurgad expurgar VMM02P0 +expurgando expurgar VMG0000 +expurgar expurgar VMN0000 +expurgue expurgar VMM03S0 +expurguemos expurgar VMM01P0 +expurguen expurgar VMM03P0 +expía expiar VMM02S0 +expíe expiar VMM03S0 +expíen expiar VMM03P0 +expón exponer VMM02S0 +extasiad extasiar VMM02P0 +extasiando extasiar VMG0000 +extasiar extasiar VMN0000 +extasiemos extasiar VMM01P0 +extasía extasiar VMM02S0 +extasíe extasiar VMM03S0 +extasíen extasiar VMM03P0 +extendamos extender VMM01P0 +extended extender VMM02P0 +extender extender VMN0000 +extendiendo extender VMG0000 +extenuad extenuar VMM02P0 +extenuando extenuar VMG0000 +extenuar extenuar VMN0000 +extenuemos extenuar VMM01P0 +extenúa extenuar VMM02S0 +extenúe extenuar VMM03S0 +extenúen extenuar VMM03P0 +exteriorice exteriorizar VMM03S0 +exterioricemos exteriorizar VMM01P0 +exterioricen exteriorizar VMM03P0 +exterioriza exteriorizar VMM02S0 +exteriorizad exteriorizar VMM02P0 +exteriorizando exteriorizar VMG0000 +exteriorizar exteriorizar VMN0000 +extermina exterminar VMM02S0 +exterminad exterminar VMM02P0 +exterminando exterminar VMG0000 +exterminar exterminar VMN0000 +extermine exterminar VMM03S0 +exterminemos exterminar VMM01P0 +exterminen exterminar VMM03P0 +externalice externalizar VMM03S0 +externalicemos externalizar VMM01P0 +externalicen externalizar VMM03P0 +externaliza externalizar VMM02S0 +externalizad externalizar VMM02P0 +externalizando externalizar VMG0000 +externalizar externalizar VMN0000 +extienda extender VMM03S0 +extiendan extender VMM03P0 +extiende extender VMM02S0 +extinga extinguir VMM03S0 +extingamos extinguir VMM01P0 +extingan extinguir VMM03P0 +extingue extinguir VMM02S0 +extinguid extinguir VMM02P0 +extinguiendo extinguir VMG0000 +extinguir extinguir VMN0000 +extirpa extirpar VMM02S0 +extirpad extirpar VMM02P0 +extirpando extirpar VMG0000 +extirpar extirpar VMN0000 +extirpe extirpar VMM03S0 +extirpemos extirpar VMM01P0 +extirpen extirpar VMM03P0 +extorsiona extorsionar VMM02S0 +extorsionad extorsionar VMM02P0 +extorsionando extorsionar VMG0000 +extorsionar extorsionar VMN0000 +extorsione extorsionar VMM03S0 +extorsionemos extorsionar VMM01P0 +extorsionen extorsionar VMM03P0 +extracta extractar VMM02S0 +extractad extractar VMM02P0 +extractando extractar VMG0000 +extractar extractar VMN0000 +extracte extractar VMM03S0 +extractemos extractar VMM01P0 +extracten extractar VMM03P0 +extradita extraditar VMM02S0 +extraditad extraditar VMM02P0 +extraditando extraditar VMG0000 +extraditar extraditar VMN0000 +extradite extraditar VMM03S0 +extraditemos extraditar VMM01P0 +extraditen extraditar VMM03P0 +extrae extraer VMM02S0 +extraed extraer VMM02P0 +extraer extraer VMN0000 +extraiga extraer VMM03S0 +extraigamos extraer VMM01P0 +extraigan extraer VMM03P0 +extralimita extralimitar VMM02S0 +extralimitad extralimitar VMM02P0 +extralimitando extralimitar VMG0000 +extralimitar extralimitar VMN0000 +extralimite extralimitar VMM03S0 +extralimitemos extralimitar VMM01P0 +extralimiten extralimitar VMM03P0 +extranjerice extranjerizar VMM03S0 +extranjericemos extranjerizar VMM01P0 +extranjericen extranjerizar VMM03P0 +extranjeriza extranjerizar VMM02S0 +extranjerizad extranjerizar VMM02P0 +extranjerizando extranjerizar VMG0000 +extranjerizar extranjerizar VMN0000 +extrapola extrapolar VMM02S0 +extrapolad extrapolar VMM02P0 +extrapolando extrapolar VMG0000 +extrapolar extrapolar VMN0000 +extrapole extrapolar VMM03S0 +extrapolemos extrapolar VMM01P0 +extrapolen extrapolar VMM03P0 +extravasa extravasar VMM02S0 +extravasad extravasar VMM02P0 +extravasando extravasar VMG0000 +extravasar extravasar VMN0000 +extravase extravasar VMM03S0 +extravasemos extravasar VMM01P0 +extravasen extravasar VMM03P0 +extravena extravenar VMM02S0 +extravenad extravenar VMM02P0 +extravenando extravenar VMG0000 +extravenar extravenar VMN0000 +extravene extravenar VMM03S0 +extravenemos extravenar VMM01P0 +extravenen extravenar VMM03P0 +extraviad extraviar VMM02P0 +extraviando extraviar VMG0000 +extraviar extraviar VMN0000 +extraviemos extraviar VMM01P0 +extravía extraviar VMM02S0 +extravíe extraviar VMM03S0 +extravíen extraviar VMM03P0 +extrayendo extraer VMG0000 +extraña extrañar VMM02S0 +extrañad extrañar VMM02P0 +extrañando extrañar VMG0000 +extrañar extrañar VMN0000 +extrañe extrañar VMM03S0 +extrañemos extrañar VMM01P0 +extrañen extrañar VMM03P0 +extrema extremar VMM02S0 +extremad extremar VMM02P0 +extremando extremar VMG0000 +extremar extremar VMN0000 +extreme extremar VMM03S0 +extrememos extremar VMM01P0 +extremen extremar VMM03P0 +extruda extrudir VMM03S0 +extrudamos extrudir VMM01P0 +extrudan extrudir VMM03P0 +extrude extrudir VMM02S0 +extrudid extrudir VMM02P0 +extrudiendo extrudir VMG0000 +extrudir extrudir VMN0000 +exuda exudar VMM02S0 +exudad exudar VMM02P0 +exudando exudar VMG0000 +exudar exudar VMN0000 +exude exudar VMM03S0 +exudemos exudar VMM01P0 +exuden exudar VMM03P0 +exulcera exulcerar VMM02S0 +exulcerad exulcerar VMM02P0 +exulcerando exulcerar VMG0000 +exulcerar exulcerar VMN0000 +exulcere exulcerar VMM03S0 +exulceremos exulcerar VMM01P0 +exulceren exulcerar VMM03P0 +exulta exultar VMM02S0 +exultad exultar VMM02P0 +exultando exultar VMG0000 +exultar exultar VMN0000 +exulte exultar VMM03S0 +exultemos exultar VMM01P0 +exulten exultar VMM03P0 +eyacula eyacular VMM02S0 +eyaculad eyacular VMM02P0 +eyaculando eyacular VMG0000 +eyacular eyacular VMN0000 +eyacule eyacular VMM03S0 +eyaculemos eyacular VMM01P0 +eyaculen eyacular VMM03P0 +fabrica fabricar VMM02S0 +fabricad fabricar VMM02P0 +fabricando fabricar VMG0000 +fabricar fabricar VMN0000 +fabrique fabricar VMM03S0 +fabriquemos fabricar VMM01P0 +fabriquen fabricar VMM03P0 +fachea fachear VMM02S0 +fachead fachear VMM02P0 +facheando fachear VMG0000 +fachear fachear VMN0000 +fachee fachear VMM03S0 +facheemos fachear VMM01P0 +facheen fachear VMM03P0 +fachendea fachendear VMM02S0 +fachendead fachendear VMM02P0 +fachendeando fachendear VMG0000 +fachendear fachendear VMN0000 +fachendee fachendear VMM03S0 +fachendeemos fachendear VMM01P0 +fachendeen fachendear VMM03P0 +facilita facilitar VMM02S0 +facilitad facilitar VMM02P0 +facilitando facilitar VMG0000 +facilitar facilitar VMN0000 +facilite facilitar VMM03S0 +facilitemos facilitar VMM01P0 +faciliten facilitar VMM03P0 +factura facturar VMM02S0 +facturad facturar VMM02P0 +facturando facturar VMG0000 +facturar facturar VMN0000 +facture facturar VMM03S0 +facturemos facturar VMM01P0 +facturen facturar VMM03P0 +faculta facultar VMM02S0 +facultad facultar VMM02P0 +facultando facultar VMG0000 +facultar facultar VMN0000 +faculte facultar VMM03S0 +facultemos facultar VMM01P0 +faculten facultar VMM03P0 +faena faenar VMM02S0 +faenad faenar VMM02P0 +faenando faenar VMG0000 +faenar faenar VMN0000 +faene faenar VMM03S0 +faenemos faenar VMM01P0 +faenen faenar VMM03P0 +faja fajar VMM02S0 +fajad fajar VMM02P0 +fajando fajar VMG0000 +fajar fajar VMN0000 +faje fajar VMM03S0 +fajemos fajar VMM01P0 +fajen fajar VMM03P0 +faldea faldear VMM02S0 +faldead faldear VMM02P0 +faldeando faldear VMG0000 +faldear faldear VMN0000 +faldee faldear VMM03S0 +faldeemos faldear VMM01P0 +faldeen faldear VMM03P0 +falla fallar VMM02S0 +falla fallir VMM03S0 +fallad fallar VMM02P0 +fallamos fallir VMM01P0 +fallan fallir VMM03P0 +fallando fallar VMG0000 +fallar fallar VMN0000 +falle fallar VMM03S0 +falle fallir VMM02S0 +fallece fallecer VMM02S0 +falleced fallecer VMM02P0 +fallecer fallecer VMN0000 +falleciendo fallecer VMG0000 +fallemos fallar VMM01P0 +fallen fallar VMM03P0 +fallendo fallir VMG0000 +fallezca fallecer VMM03S0 +fallezcamos fallecer VMM01P0 +fallezcan fallecer VMM03P0 +fallid fallir VMM02P0 +fallir fallir VMN0000 +falsea falsear VMM02S0 +falsead falsear VMM02P0 +falseando falsear VMG0000 +falsear falsear VMN0000 +falsee falsear VMM03S0 +falseemos falsear VMM01P0 +falseen falsear VMM03P0 +falsifica falsificar VMM02S0 +falsificad falsificar VMM02P0 +falsificando falsificar VMG0000 +falsificar falsificar VMN0000 +falsifique falsificar VMM03S0 +falsifiquemos falsificar VMM01P0 +falsifiquen falsificar VMM03P0 +falta faltar VMM02S0 +faltad faltar VMM02P0 +faltando faltar VMG0000 +faltar faltar VMN0000 +falte faltar VMM03S0 +faltemos faltar VMM01P0 +falten faltar VMM03P0 +familiarice familiarizar VMM03S0 +familiaricemos familiarizar VMM01P0 +familiaricen familiarizar VMM03P0 +familiariza familiarizar VMM02S0 +familiarizad familiarizar VMM02P0 +familiarizando familiarizar VMG0000 +familiarizar familiarizar VMN0000 +fanatice fanatizar VMM03S0 +fanaticemos fanatizar VMM01P0 +fanaticen fanatizar VMM03P0 +fanatiza fanatizar VMM02S0 +fanatizad fanatizar VMM02P0 +fanatizando fanatizar VMG0000 +fanatizar fanatizar VMN0000 +fanfarrea fanfarrear VMM02S0 +fanfarread fanfarrear VMM02P0 +fanfarreando fanfarrear VMG0000 +fanfarrear fanfarrear VMN0000 +fanfarree fanfarrear VMM03S0 +fanfarreemos fanfarrear VMM01P0 +fanfarreen fanfarrear VMM03P0 +fanfarronea fanfarronear VMM02S0 +fanfarronead fanfarronear VMM02P0 +fanfarroneando fanfarronear VMG0000 +fanfarronear fanfarronear VMN0000 +fanfarronee fanfarronear VMM03S0 +fanfarroneemos fanfarronear VMM01P0 +fanfarroneen fanfarronear VMM03P0 +fantasea fantasear VMM02S0 +fantasead fantasear VMM02P0 +fantaseando fantasear VMG0000 +fantasear fantasear VMN0000 +fantasee fantasear VMM03S0 +fantaseemos fantasear VMM01P0 +fantaseen fantasear VMM03P0 +faramallea faramallear VMM02S0 +faramallead faramallear VMM02P0 +faramalleando faramallear VMG0000 +faramallear faramallear VMN0000 +faramallee faramallear VMM03S0 +faramalleemos faramallear VMM01P0 +faramalleen faramallear VMM03P0 +farandulea farandulear VMM02S0 +farandulead farandulear VMM02P0 +faranduleando farandulear VMG0000 +farandulear farandulear VMN0000 +farandulee farandulear VMM03S0 +faranduleemos farandulear VMM01P0 +faranduleen farandulear VMM03P0 +farda fardar VMM02S0 +fardad fardar VMM02P0 +fardando fardar VMG0000 +fardar fardar VMN0000 +farde fardar VMM03S0 +fardemos fardar VMM01P0 +farden fardar VMM03P0 +farfulla farfullar VMM02S0 +farfullad farfullar VMM02P0 +farfullando farfullar VMG0000 +farfullar farfullar VMN0000 +farfulle farfullar VMM03S0 +farfullemos farfullar VMM01P0 +farfullen farfullar VMM03P0 +farolea farolear VMM02S0 +farolead farolear VMM02P0 +faroleando farolear VMG0000 +farolear farolear VMN0000 +farolee farolear VMM03S0 +faroleemos farolear VMM01P0 +faroleen farolear VMM03P0 +farrea farrear VMM02S0 +farread farrear VMM02P0 +farreando farrear VMG0000 +farrear farrear VMN0000 +farree farrear VMM03S0 +farreemos farrear VMM01P0 +farreen farrear VMM03P0 +fascina fascinar VMM02S0 +fascinad fascinar VMM02P0 +fascinando fascinar VMG0000 +fascinar fascinar VMN0000 +fascine fascinar VMM03S0 +fascinemos fascinar VMM01P0 +fascinen fascinar VMM03P0 +fastidia fastidiar VMM02S0 +fastidiad fastidiar VMM02P0 +fastidiando fastidiar VMG0000 +fastidiar fastidiar VMN0000 +fastidie fastidiar VMM03S0 +fastidiemos fastidiar VMM01P0 +fastidien fastidiar VMM03P0 +fatiga fatigar VMM02S0 +fatigad fatigar VMM02P0 +fatigando fatigar VMG0000 +fatigar fatigar VMN0000 +fatigue fatigar VMM03S0 +fatiguemos fatigar VMM01P0 +fatiguen fatigar VMM03P0 +favorece favorecer VMM02S0 +favoreced favorecer VMM02P0 +favorecer favorecer VMN0000 +favoreciendo favorecer VMG0000 +favorezca favorecer VMM03S0 +favorezcamos favorecer VMM01P0 +favorezcan favorecer VMM03P0 +fecha fechar VMM02S0 +fechad fechar VMM02P0 +fechando fechar VMG0000 +fechar fechar VMN0000 +feche fechar VMM03S0 +fechemos fechar VMM01P0 +fechen fechar VMM03P0 +fecunda fecundar VMM02S0 +fecundad fecundar VMM02P0 +fecundando fecundar VMG0000 +fecundar fecundar VMN0000 +fecunde fecundar VMM03S0 +fecundemos fecundar VMM01P0 +fecunden fecundar VMM03P0 +fecundice fecundizar VMM03S0 +fecundicemos fecundizar VMM01P0 +fecundicen fecundizar VMM03P0 +fecundiza fecundizar VMM02S0 +fecundizad fecundizar VMM02P0 +fecundizando fecundizar VMG0000 +fecundizar fecundizar VMN0000 +federa federar VMM02S0 +federad federar VMM02P0 +federando federar VMG0000 +federar federar VMN0000 +federe federar VMM03S0 +federemos federar VMM01P0 +federen federar VMM03P0 +felicita felicitar VMM02S0 +felicitad felicitar VMM02P0 +felicitando felicitar VMG0000 +felicitar felicitar VMN0000 +felicite felicitar VMM03S0 +felicitemos felicitar VMM01P0 +feliciten felicitar VMM03P0 +felpa felpar VMM02S0 +felpad felpar VMM02P0 +felpando felpar VMG0000 +felpar felpar VMN0000 +felpe felpar VMM03S0 +felpemos felpar VMM01P0 +felpen felpar VMM03P0 +fenece fenecer VMM02S0 +feneced fenecer VMM02P0 +fenecer fenecer VMN0000 +feneciendo fenecer VMG0000 +fenezca fenecer VMM03S0 +fenezcamos fenecer VMM01P0 +fenezcan fenecer VMM03P0 +feria feriar VMM02S0 +feriad feriar VMM02P0 +feriando feriar VMG0000 +feriar feriar VMN0000 +ferie feriar VMM03S0 +feriemos feriar VMM01P0 +ferien feriar VMM03P0 +fermenta fermentar VMM02S0 +fermentad fermentar VMM02P0 +fermentando fermentar VMG0000 +fermentar fermentar VMN0000 +fermente fermentar VMM03S0 +fermentemos fermentar VMM01P0 +fermenten fermentar VMM03P0 +ferrad ferrar VMM02P0 +ferrando ferrar VMG0000 +ferrar ferrar VMN0000 +ferremos ferrar VMM01P0 +fertilice fertilizar VMM03S0 +fertilicemos fertilizar VMM01P0 +fertilicen fertilizar VMM03P0 +fertiliza fertilizar VMM02S0 +fertilizad fertilizar VMM02P0 +fertilizando fertilizar VMG0000 +fertilizar fertilizar VMN0000 +fervorice fervorizar VMM03S0 +fervoricemos fervorizar VMM01P0 +fervoricen fervorizar VMM03P0 +fervoriza fervorizar VMM02S0 +fervorizad fervorizar VMM02P0 +fervorizando fervorizar VMG0000 +fervorizar fervorizar VMN0000 +festeja festejar VMM02S0 +festejad festejar VMM02P0 +festejando festejar VMG0000 +festejar festejar VMN0000 +festeje festejar VMM03S0 +festejemos festejar VMM01P0 +festejen festejar VMM03P0 +festonea festonear VMM02S0 +festonead festonear VMM02P0 +festoneando festonear VMG0000 +festonear festonear VMN0000 +festonee festonear VMM03S0 +festoneemos festonear VMM01P0 +festoneen festonear VMM03P0 +fiad fiar VMM02P0 +fiando fiar VMG0000 +fiar fiar VMN0000 +ficha fichar VMM02S0 +fichad fichar VMM02P0 +fichando fichar VMG0000 +fichar fichar VMN0000 +fiche fichar VMM03S0 +fichemos fichar VMM01P0 +fichen fichar VMM03P0 +fiemos fiar VMM01P0 +fierra ferrar VMM02S0 +fierre ferrar VMM03S0 +fierren ferrar VMM03P0 +figura figurar VMM02S0 +figurad figurar VMM02P0 +figurando figurar VMG0000 +figurar figurar VMN0000 +figure figurar VMM03S0 +figuremos figurar VMM01P0 +figuren figurar VMM03P0 +fija fijar VMM02S0 +fijad fijar VMM02P0 +fijando fijar VMG0000 +fijar fijar VMN0000 +fije fijar VMM03S0 +fijemos fijar VMM01P0 +fijen fijar VMM03P0 +filetea filetear VMM02S0 +filetead filetear VMM02P0 +fileteando filetear VMG0000 +filetear filetear VMN0000 +filetee filetear VMM03S0 +fileteemos filetear VMM01P0 +fileteen filetear VMM03P0 +filiad filiar VMM02P0 +filiando filiar VMG0000 +filiar filiar VMN0000 +filiemos filiar VMM01P0 +filma filmar VMM02S0 +filmad filmar VMM02P0 +filmando filmar VMG0000 +filmar filmar VMN0000 +filme filmar VMM03S0 +filmemos filmar VMM01P0 +filmen filmar VMM03P0 +filosofa filosofar VMM02S0 +filosofad filosofar VMM02P0 +filosofando filosofar VMG0000 +filosofar filosofar VMN0000 +filosofe filosofar VMM03S0 +filosofemos filosofar VMM01P0 +filosofen filosofar VMM03P0 +filtra filtrar VMM02S0 +filtrad filtrar VMM02P0 +filtrando filtrar VMG0000 +filtrar filtrar VMN0000 +filtre filtrar VMM03S0 +filtremos filtrar VMM01P0 +filtren filtrar VMM03P0 +filía filiar VMM02S0 +filíe filiar VMM03S0 +filíen filiar VMM03P0 +fina finar VMM02S0 +finad finar VMM02P0 +finalice finalizar VMM03S0 +finalicemos finalizar VMM01P0 +finalicen finalizar VMM03P0 +finaliza finalizar VMM02S0 +finalizad finalizar VMM02P0 +finalizando finalizar VMG0000 +finalizar finalizar VMN0000 +financia financiar VMM02S0 +financiad financiar VMM02P0 +financiando financiar VMG0000 +financiar financiar VMN0000 +financie financiar VMM03S0 +financiemos financiar VMM01P0 +financien financiar VMM03P0 +finando finar VMG0000 +finar finar VMN0000 +fine finar VMM03S0 +finemos finar VMM01P0 +finen finar VMM03P0 +finge fingir VMM02S0 +fingid fingir VMM02P0 +fingiendo fingir VMG0000 +fingir fingir VMN0000 +finiquita finiquitar VMM02S0 +finiquitad finiquitar VMM02P0 +finiquitando finiquitar VMG0000 +finiquitar finiquitar VMN0000 +finiquite finiquitar VMM03S0 +finiquitemos finiquitar VMM01P0 +finiquiten finiquitar VMM03P0 +finja fingir VMM03S0 +finjamos fingir VMM01P0 +finjan fingir VMM03P0 +finta fintar VMM02S0 +fintad fintar VMM02P0 +fintando fintar VMG0000 +fintar fintar VMN0000 +finte fintar VMM03S0 +fintea fintear VMM02S0 +fintead fintear VMM02P0 +finteando fintear VMG0000 +fintear fintear VMN0000 +fintee fintear VMM03S0 +finteemos fintear VMM01P0 +finteen fintear VMM03P0 +fintemos fintar VMM01P0 +finten fintar VMM03P0 +firma firmar VMM02S0 +firmad firmar VMM02P0 +firmando firmar VMG0000 +firmar firmar VMN0000 +firme firmar VMM03S0 +firmemos firmar VMM01P0 +firmen firmar VMM03P0 +fiscalice fiscalizar VMM03S0 +fiscalicemos fiscalizar VMM01P0 +fiscalicen fiscalizar VMM03P0 +fiscaliza fiscalizar VMM02S0 +fiscalizad fiscalizar VMM02P0 +fiscalizando fiscalizar VMG0000 +fiscalizar fiscalizar VMN0000 +fisga fisgar VMM02S0 +fisgad fisgar VMM02P0 +fisgando fisgar VMG0000 +fisgar fisgar VMN0000 +fisgonea fisgonear VMM02S0 +fisgonead fisgonear VMM02P0 +fisgoneando fisgonear VMG0000 +fisgonear fisgonear VMN0000 +fisgonee fisgonear VMM03S0 +fisgoneemos fisgonear VMM01P0 +fisgoneen fisgonear VMM03P0 +fisgue fisgar VMM03S0 +fisguemos fisgar VMM01P0 +fisguen fisgar VMM03P0 +fisiona fisionar VMM02S0 +fisionad fisionar VMM02P0 +fisionando fisionar VMG0000 +fisionar fisionar VMN0000 +fisione fisionar VMM03S0 +fisionemos fisionar VMM01P0 +fisionen fisionar VMM03P0 +flagela flagelar VMM02S0 +flagelad flagelar VMM02P0 +flagelando flagelar VMG0000 +flagelar flagelar VMN0000 +flagele flagelar VMM03S0 +flagelemos flagelar VMM01P0 +flagelen flagelar VMM03P0 +flamea flamear VMM02S0 +flamead flamear VMM02P0 +flameando flamear VMG0000 +flamear flamear VMN0000 +flamee flamear VMM03S0 +flameemos flamear VMM01P0 +flameen flamear VMM03P0 +flanquea flanquear VMM02S0 +flanquead flanquear VMM02P0 +flanqueando flanquear VMG0000 +flanquear flanquear VMN0000 +flanquee flanquear VMM03S0 +flanqueemos flanquear VMM01P0 +flanqueen flanquear VMM03P0 +flaquea flaquear VMM02S0 +flaquead flaquear VMM02P0 +flaqueando flaquear VMG0000 +flaquear flaquear VMN0000 +flaquee flaquear VMM03S0 +flaqueemos flaquear VMM01P0 +flaqueen flaquear VMM03P0 +flecha flechar VMM02S0 +flechad flechar VMM02P0 +flechando flechar VMG0000 +flechar flechar VMN0000 +fleche flechar VMM03S0 +flechemos flechar VMM01P0 +flechen flechar VMM03P0 +fleta fletar VMM02S0 +fletad fletar VMM02P0 +fletando fletar VMG0000 +fletar fletar VMN0000 +flete fletar VMM03S0 +fletemos fletar VMM01P0 +fleten fletar VMM03P0 +flexibilice flexibilizar VMM03S0 +flexibilicemos flexibilizar VMM01P0 +flexibilicen flexibilizar VMM03P0 +flexibiliza flexibilizar VMM02S0 +flexibilizad flexibilizar VMM02P0 +flexibilizando flexibilizar VMG0000 +flexibilizar flexibilizar VMN0000 +flexiona flexionar VMM02S0 +flexionad flexionar VMM02P0 +flexionando flexionar VMG0000 +flexionar flexionar VMN0000 +flexione flexionar VMM03S0 +flexionemos flexionar VMM01P0 +flexionen flexionar VMM03P0 +flipa flipar VMM02S0 +flipad flipar VMM02P0 +flipando flipar VMG0000 +flipar flipar VMN0000 +flipe flipar VMM03S0 +flipemos flipar VMM01P0 +flipen flipar VMM03P0 +flirtea flirtear VMM02S0 +flirtead flirtear VMM02P0 +flirteando flirtear VMG0000 +flirtear flirtear VMN0000 +flirtee flirtear VMM03S0 +flirteemos flirtear VMM01P0 +flirteen flirtear VMM03P0 +flocula flocular VMM02S0 +floculad flocular VMM02P0 +floculando flocular VMG0000 +flocular flocular VMN0000 +flocule flocular VMM03S0 +floculemos flocular VMM01P0 +floculen flocular VMM03P0 +flojea flojear VMM02S0 +flojead flojear VMM02P0 +flojeando flojear VMG0000 +flojear flojear VMN0000 +flojee flojear VMM03S0 +flojeemos flojear VMM01P0 +flojeen flojear VMM03P0 +flordelisa flordelisar VMM02S0 +flordelisad flordelisar VMM02P0 +flordelisando flordelisar VMG0000 +flordelisar flordelisar VMN0000 +flordelise flordelisar VMM03S0 +flordelisemos flordelisar VMM01P0 +flordelisen flordelisar VMM03P0 +florea florear VMM02S0 +floread florear VMM02P0 +floreando florear VMG0000 +florear florear VMN0000 +florece florecer VMM02S0 +floreced florecer VMM02P0 +florecer florecer VMN0000 +floreciendo florecer VMG0000 +floree florear VMM03S0 +floreemos florear VMM01P0 +floreen florear VMM03P0 +floretea floretear VMM02S0 +floretead floretear VMM02P0 +floreteando floretear VMG0000 +floretear floretear VMN0000 +floretee floretear VMM03S0 +floreteemos floretear VMM01P0 +floreteen floretear VMM03P0 +florezca florecer VMM03S0 +florezcamos florecer VMM01P0 +florezcan florecer VMM03P0 +flota flotar VMM02S0 +flotad flotar VMM02P0 +flotando flotar VMG0000 +flotar flotar VMN0000 +flote flotar VMM03S0 +flotemos flotar VMM01P0 +floten flotar VMM03P0 +fluctuad fluctuar VMM02P0 +fluctuando fluctuar VMG0000 +fluctuar fluctuar VMN0000 +fluctuemos fluctuar VMM01P0 +fluctúa fluctuar VMM02S0 +fluctúe fluctuar VMM03S0 +fluctúen fluctuar VMM03P0 +fluid fluir VMM02P0 +fluidifica fluidificar VMM02S0 +fluidificad fluidificar VMM02P0 +fluidificando fluidificar VMG0000 +fluidificar fluidificar VMN0000 +fluidifique fluidificar VMM03S0 +fluidifiquemos fluidificar VMM01P0 +fluidifiquen fluidificar VMM03P0 +fluir fluir VMN0000 +fluya fluir VMM03S0 +fluyamos fluir VMM01P0 +fluyan fluir VMM03P0 +fluye fluir VMM02S0 +fluyendo fluir VMG0000 +focalice focalizar VMM03S0 +focalicemos focalizar VMM01P0 +focalicen focalizar VMM03P0 +focaliza focalizar VMM02S0 +focalizad focalizar VMM02P0 +focalizando focalizar VMG0000 +focalizar focalizar VMN0000 +foguea foguear VMM02S0 +foguead foguear VMM02P0 +fogueando foguear VMG0000 +foguear foguear VMN0000 +foguee foguear VMM03S0 +fogueemos foguear VMM01P0 +fogueen foguear VMM03P0 +folia foliar VMM02S0 +foliad foliar VMM02P0 +foliando foliar VMG0000 +foliar foliar VMN0000 +folie foliar VMM03S0 +foliemos foliar VMM01P0 +folien foliar VMM03P0 +folla follar VMM02S0 +follad follar VMM02P0 +follando follar VMG0000 +follar follar VMN0000 +folle follar VMM03S0 +follemos follar VMM01P0 +follen follar VMM03P0 +fomenta fomentar VMM02S0 +fomentad fomentar VMM02P0 +fomentando fomentar VMG0000 +fomentar fomentar VMN0000 +fomente fomentar VMM03S0 +fomentemos fomentar VMM01P0 +fomenten fomentar VMM03P0 +fondea fondear VMM02S0 +fondead fondear VMM02P0 +fondeando fondear VMG0000 +fondear fondear VMN0000 +fondee fondear VMM03S0 +fondeemos fondear VMM01P0 +fondeen fondear VMM03P0 +forceja forcejar VMM02S0 +forcejad forcejar VMM02P0 +forcejando forcejar VMG0000 +forcejar forcejar VMN0000 +forceje forcejar VMM03S0 +forcejea forcejear VMM02S0 +forcejead forcejear VMM02P0 +forcejeando forcejear VMG0000 +forcejear forcejear VMN0000 +forcejee forcejear VMM03S0 +forcejeemos forcejear VMM01P0 +forcejeen forcejear VMM03P0 +forcejemos forcejar VMM01P0 +forcejen forcejar VMM03P0 +forcemos forzar VMM01P0 +foresta forestar VMM02S0 +forestad forestar VMM02P0 +forestando forestar VMG0000 +forestar forestar VMN0000 +foreste forestar VMM03S0 +forestemos forestar VMM01P0 +foresten forestar VMM03P0 +forja forjar VMM02S0 +forjad forjar VMM02P0 +forjando forjar VMG0000 +forjar forjar VMN0000 +forje forjar VMM03S0 +forjemos forjar VMM01P0 +forjen forjar VMM03P0 +forma formar VMM02S0 +formad formar VMM02P0 +formalice formalizar VMM03S0 +formalicemos formalizar VMM01P0 +formalicen formalizar VMM03P0 +formaliza formalizar VMM02S0 +formalizad formalizar VMM02P0 +formalizando formalizar VMG0000 +formalizar formalizar VMN0000 +formando formar VMG0000 +formar formar VMN0000 +formatea formatear VMM02S0 +formatead formatear VMM02P0 +formateando formatear VMG0000 +formatear formatear VMN0000 +formatee formatear VMM03S0 +formateemos formatear VMM01P0 +formateen formatear VMM03P0 +forme formar VMM03S0 +formemos formar VMM01P0 +formen formar VMM03P0 +formula formular VMM02S0 +formulad formular VMM02P0 +formulando formular VMG0000 +formular formular VMN0000 +formule formular VMM03S0 +formulemos formular VMM01P0 +formulen formular VMM03P0 +fornica fornicar VMM02S0 +fornicad fornicar VMM02P0 +fornicando fornicar VMG0000 +fornicar fornicar VMN0000 +fornique fornicar VMM03S0 +forniquemos fornicar VMM01P0 +forniquen fornicar VMM03P0 +forra forrar VMM02S0 +forrad forrar VMM02P0 +forrajea forrajear VMM02S0 +forrajead forrajear VMM02P0 +forrajeando forrajear VMG0000 +forrajear forrajear VMN0000 +forrajee forrajear VMM03S0 +forrajeemos forrajear VMM01P0 +forrajeen forrajear VMM03P0 +forrando forrar VMG0000 +forrar forrar VMN0000 +forre forrar VMM03S0 +forremos forrar VMM01P0 +forren forrar VMM03P0 +fortalece fortalecer VMM02S0 +fortaleced fortalecer VMM02P0 +fortalecer fortalecer VMN0000 +fortaleciendo fortalecer VMG0000 +fortalezca fortalecer VMM03S0 +fortalezcamos fortalecer VMM01P0 +fortalezcan fortalecer VMM03P0 +fortifica fortificar VMM02S0 +fortificad fortificar VMM02P0 +fortificando fortificar VMG0000 +fortificar fortificar VMN0000 +fortifique fortificar VMM03S0 +fortifiquemos fortificar VMM01P0 +fortifiquen fortificar VMM03P0 +forzad forzar VMM02P0 +forzando forzar VMG0000 +forzar forzar VMN0000 +fosa fosar VMM02S0 +fosad fosar VMM02P0 +fosando fosar VMG0000 +fosar fosar VMN0000 +fose fosar VMM03S0 +fosemos fosar VMM01P0 +fosen fosar VMM03P0 +fosfata fosfatar VMM02S0 +fosfatad fosfatar VMM02P0 +fosfatando fosfatar VMG0000 +fosfatar fosfatar VMN0000 +fosfate fosfatar VMM03S0 +fosfatemos fosfatar VMM01P0 +fosfaten fosfatar VMM03P0 +fosforece fosforecer VMM02S0 +fosforeced fosforecer VMM02P0 +fosforecer fosforecer VMN0000 +fosforeciendo fosforecer VMG0000 +fosforesce fosforescer VMM02S0 +fosforesced fosforescer VMM02P0 +fosforescer fosforescer VMN0000 +fosforesciendo fosforescer VMG0000 +fosforezca fosforecer VMM03S0 +fosforezca fosforescer VMM03S0 +fosforezcamos fosforecer VMM01P0 +fosforezcamos fosforescer VMM01P0 +fosforezcan fosforecer VMM03P0 +fosforezcan fosforescer VMM03P0 +fosilice fosilizar VMM03S0 +fosilicemos fosilizar VMM01P0 +fosilicen fosilizar VMM03P0 +fosiliza fosilizar VMM02S0 +fosilizad fosilizar VMM02P0 +fosilizando fosilizar VMG0000 +fosilizar fosilizar VMN0000 +fotocopia fotocopiar VMM02S0 +fotocopiad fotocopiar VMM02P0 +fotocopiando fotocopiar VMG0000 +fotocopiar fotocopiar VMN0000 +fotocopie fotocopiar VMM03S0 +fotocopiemos fotocopiar VMM01P0 +fotocopien fotocopiar VMM03P0 +fotograba fotograbar VMM02S0 +fotograbad fotograbar VMM02P0 +fotograbando fotograbar VMG0000 +fotograbar fotograbar VMN0000 +fotograbe fotograbar VMM03S0 +fotograbemos fotograbar VMM01P0 +fotograben fotograbar VMM03P0 +fotografiad fotografiar VMM02P0 +fotografiando fotografiar VMG0000 +fotografiar fotografiar VMN0000 +fotografiemos fotografiar VMM01P0 +fotografía fotografiar VMM02S0 +fotografíe fotografiar VMM03S0 +fotografíen fotografiar VMM03P0 +fotolitografiad fotolitografiar VMM02P0 +fotolitografiando fotolitografiar VMG0000 +fotolitografiar fotolitografiar VMN0000 +fotolitografiemos fotolitografiar VMM01P0 +fotolitografía fotolitografiar VMM02S0 +fotolitografíe fotolitografiar VMM03S0 +fotolitografíen fotolitografiar VMM03P0 +fracasa fracasar VMM02S0 +fracasad fracasar VMM02P0 +fracasando fracasar VMG0000 +fracasar fracasar VMN0000 +fracase fracasar VMM03S0 +fracasemos fracasar VMM01P0 +fracasen fracasar VMM03P0 +fracciona fraccionar VMM02S0 +fraccionad fraccionar VMM02P0 +fraccionando fraccionar VMG0000 +fraccionar fraccionar VMN0000 +fraccione fraccionar VMM03S0 +fraccionemos fraccionar VMM01P0 +fraccionen fraccionar VMM03P0 +fractura fracturar VMM02S0 +fracturad fracturar VMM02P0 +fracturando fracturar VMG0000 +fracturar fracturar VMN0000 +fracture fracturar VMM03S0 +fracturemos fracturar VMM01P0 +fracturen fracturar VMM03P0 +fragmenta fragmentar VMM02S0 +fragmentad fragmentar VMM02P0 +fragmentando fragmentar VMG0000 +fragmentar fragmentar VMN0000 +fragmente fragmentar VMM03S0 +fragmentemos fragmentar VMM01P0 +fragmenten fragmentar VMM03P0 +fragua fraguar VMM02S0 +fraguad fraguar VMM02P0 +fraguando fraguar VMG0000 +fraguar fraguar VMN0000 +fragüe fraguar VMM03S0 +fragüemos fraguar VMM01P0 +fragüen fraguar VMM03P0 +frangolla frangollar VMM02S0 +frangollad frangollar VMM02P0 +frangollando frangollar VMG0000 +frangollar frangollar VMN0000 +frangolle frangollar VMM03S0 +frangollemos frangollar VMM01P0 +frangollen frangollar VMM03P0 +franjea franjear VMM02S0 +franjead franjear VMM02P0 +franjeando franjear VMG0000 +franjear franjear VMN0000 +franjee franjear VMM03S0 +franjeemos franjear VMM01P0 +franjeen franjear VMM03P0 +franquea franquear VMM02S0 +franquead franquear VMM02P0 +franqueando franquear VMG0000 +franquear franquear VMN0000 +franquee franquear VMM03S0 +franqueemos franquear VMM01P0 +franqueen franquear VMM03P0 +frasea frasear VMM02S0 +frasead frasear VMM02P0 +fraseando frasear VMG0000 +frasear frasear VMN0000 +frasee frasear VMM03S0 +fraseemos frasear VMM01P0 +fraseen frasear VMM03P0 +fraternice fraternizar VMM03S0 +fraternicemos fraternizar VMM01P0 +fraternicen fraternizar VMM03P0 +fraterniza fraternizar VMM02S0 +fraternizad fraternizar VMM02P0 +fraternizando fraternizar VMG0000 +fraternizar fraternizar VMN0000 +frece frezar VMM03S0 +frecemos frezar VMM01P0 +frecen frezar VMM03P0 +frecuenta frecuentar VMM02S0 +frecuentad frecuentar VMM02P0 +frecuentando frecuentar VMG0000 +frecuentar frecuentar VMN0000 +frecuente frecuentar VMM03S0 +frecuentemos frecuentar VMM01P0 +frecuenten frecuentar VMM03P0 +fregad fregar VMM02P0 +fregando fregar VMG0000 +fregar fregar VMN0000 +fregotea fregotear VMM02S0 +fregotead fregotear VMM02P0 +fregoteando fregotear VMG0000 +fregotear fregotear VMN0000 +fregotee fregotear VMM03S0 +fregoteemos fregotear VMM01P0 +fregoteen fregotear VMM03P0 +freguemos fregar VMM01P0 +frena frenar VMM02S0 +frenad frenar VMM02P0 +frenando frenar VMG0000 +frenar frenar VMN0000 +frene frenar VMM03S0 +frenemos frenar VMM01P0 +frenen frenar VMM03P0 +fresa fresar VMM02S0 +fresad fresar VMM02P0 +fresando fresar VMG0000 +fresar fresar VMN0000 +frese fresar VMM03S0 +fresemos fresar VMM01P0 +fresen fresar VMM03P0 +freza frezar VMM02S0 +frezad frezar VMM02P0 +frezando frezar VMG0000 +frezar frezar VMN0000 +freíd freír VMM02P0 +freír freír VMN0000 +friamos freír VMM01P0 +frica fricar VMM02S0 +fricad fricar VMM02P0 +fricando fricar VMG0000 +fricar fricar VMN0000 +fricciona friccionar VMM02S0 +friccionad friccionar VMM02P0 +friccionando friccionar VMG0000 +friccionar friccionar VMN0000 +friccione friccionar VMM03S0 +friccionemos friccionar VMM01P0 +friccionen friccionar VMM03P0 +friega fregar VMM02S0 +friegue fregar VMM03S0 +frieguen fregar VMM03P0 +friendo freír VMG0000 +frique fricar VMM03S0 +friquemos fricar VMM01P0 +friquen fricar VMM03P0 +frisa frisar VMM02S0 +frisad frisar VMM02P0 +frisando frisar VMG0000 +frisar frisar VMN0000 +frise frisar VMM03S0 +frisemos frisar VMM01P0 +frisen frisar VMM03P0 +frivolice frivolizar VMM03S0 +frivolicemos frivolizar VMM01P0 +frivolicen frivolizar VMM03P0 +frivoliza frivolizar VMM02S0 +frivolizad frivolizar VMM02P0 +frivolizando frivolizar VMG0000 +frivolizar frivolizar VMN0000 +frota frotar VMM02S0 +frotad frotar VMM02P0 +frotando frotar VMG0000 +frotar frotar VMN0000 +frote frotar VMM03S0 +frotemos frotar VMM01P0 +froten frotar VMM03P0 +fructifica fructificar VMM02S0 +fructificad fructificar VMM02P0 +fructificando fructificar VMG0000 +fructificar fructificar VMN0000 +fructifique fructificar VMM03S0 +fructifiquemos fructificar VMM01P0 +fructifiquen fructificar VMM03P0 +fruid fruir VMM02P0 +fruir fruir VMN0000 +frunce fruncir VMM02S0 +fruncid fruncir VMM02P0 +frunciendo fruncir VMG0000 +fruncir fruncir VMN0000 +frunza fruncir VMM03S0 +frunzamos fruncir VMM01P0 +frunzan fruncir VMM03P0 +frustra frustrar VMM02S0 +frustrad frustrar VMM02P0 +frustrando frustrar VMG0000 +frustrar frustrar VMN0000 +frustre frustrar VMM03S0 +frustremos frustrar VMM01P0 +frustren frustrar VMM03P0 +fruya fruir VMM03S0 +fruyamos fruir VMM01P0 +fruyan fruir VMM03P0 +fruye fruir VMM02S0 +fruyendo fruir VMG0000 +fría freír VMM03S0 +frían freír VMM03P0 +fríe freír VMM02S0 +fucila fucilar VMM02S0 +fucilad fucilar VMM02P0 +fucilando fucilar VMG0000 +fucilar fucilar VMN0000 +fucile fucilar VMM03S0 +fucilemos fucilar VMM01P0 +fucilen fucilar VMM03P0 +fuella follar VMM02S0 +fuelle follar VMM03S0 +fuellen follar VMM03P0 +fuerce forzar VMM03S0 +fuercen forzar VMM03P0 +fuerza forzar VMM02S0 +fuga fugar VMM02S0 +fugad fugar VMM02P0 +fugando fugar VMG0000 +fugar fugar VMN0000 +fugue fugar VMM03S0 +fuguemos fugar VMM01P0 +fuguen fugar VMM03P0 +fulge fulgir VMM02S0 +fulgid fulgir VMM02P0 +fulgiendo fulgir VMG0000 +fulgir fulgir VMN0000 +fulgura fulgurar VMM02S0 +fulgurad fulgurar VMM02P0 +fulgurando fulgurar VMG0000 +fulgurar fulgurar VMN0000 +fulgure fulgurar VMM03S0 +fulguremos fulgurar VMM01P0 +fulguren fulgurar VMM03P0 +fulja fulgir VMM03S0 +fuljamos fulgir VMM01P0 +fuljan fulgir VMM03P0 +fulmina fulminar VMM02S0 +fulminad fulminar VMM02P0 +fulminando fulminar VMG0000 +fulminar fulminar VMN0000 +fulmine fulminar VMM03S0 +fulminemos fulminar VMM01P0 +fulminen fulminar VMM03P0 +fuma fumar VMM02S0 +fumad fumar VMM02P0 +fumando fumar VMG0000 +fumar fumar VMN0000 +fume fumar VMM03S0 +fumemos fumar VMM01P0 +fumen fumar VMM03P0 +fumiga fumigar VMM02S0 +fumigad fumigar VMM02P0 +fumigando fumigar VMG0000 +fumigar fumigar VMN0000 +fumigue fumigar VMM03S0 +fumiguemos fumigar VMM01P0 +fumiguen fumigar VMM03P0 +funciona funcionar VMM02S0 +funcionad funcionar VMM02P0 +funcionando funcionar VMG0000 +funcionar funcionar VMN0000 +funcione funcionar VMM03S0 +funcionemos funcionar VMM01P0 +funcionen funcionar VMM03P0 +funda fundar VMM02S0 +funda fundir VMM03S0 +fundad fundar VMM02P0 +fundamenta fundamentar VMM02S0 +fundamentad fundamentar VMM02P0 +fundamentando fundamentar VMG0000 +fundamentar fundamentar VMN0000 +fundamente fundamentar VMM03S0 +fundamentemos fundamentar VMM01P0 +fundamenten fundamentar VMM03P0 +fundamos fundir VMM01P0 +fundan fundir VMM03P0 +fundando fundar VMG0000 +fundar fundar VMN0000 +funde fundar VMM03S0 +funde fundir VMM02S0 +fundemos fundar VMM01P0 +funden fundar VMM03P0 +fundid fundir VMM02P0 +fundiendo fundir VMG0000 +fundir fundir VMN0000 +funge fungir VMM02S0 +fungid fungir VMM02P0 +fungiendo fungir VMG0000 +fungir fungir VMN0000 +funja fungir VMM03S0 +funjamos fungir VMM01P0 +funjan fungir VMM03P0 +fusila fusilar VMM02S0 +fusilad fusilar VMM02P0 +fusilando fusilar VMG0000 +fusilar fusilar VMN0000 +fusile fusilar VMM03S0 +fusilemos fusilar VMM01P0 +fusilen fusilar VMM03P0 +fusiona fusionar VMM02S0 +fusionad fusionar VMM02P0 +fusionando fusionar VMG0000 +fusionar fusionar VMN0000 +fusione fusionar VMM03S0 +fusionemos fusionar VMM01P0 +fusionen fusionar VMM03P0 +fustiga fustigar VMM02S0 +fustigad fustigar VMM02P0 +fustigando fustigar VMG0000 +fustigar fustigar VMN0000 +fustigue fustigar VMM03S0 +fustiguemos fustigar VMM01P0 +fustiguen fustigar VMM03P0 +fía fiar VMM02S0 +fíe fiar VMM03S0 +fíen fiar VMM03P0 +gafa gafar VMM02S0 +gafad gafar VMM02P0 +gafando gafar VMG0000 +gafar gafar VMN0000 +gafe gafar VMM03S0 +gafemos gafar VMM01P0 +gafen gafar VMM03P0 +gaguea gaguear VMM02S0 +gaguead gaguear VMM02P0 +gagueando gaguear VMG0000 +gaguear gaguear VMN0000 +gaguee gaguear VMM03S0 +gagueemos gaguear VMM01P0 +gagueen gaguear VMM03P0 +galantea galantear VMM02S0 +galantead galantear VMM02P0 +galanteando galantear VMG0000 +galantear galantear VMN0000 +galantee galantear VMM03S0 +galanteemos galantear VMM01P0 +galanteen galantear VMM03P0 +galardona galardonar VMM02S0 +galardonad galardonar VMM02P0 +galardonando galardonar VMG0000 +galardonar galardonar VMN0000 +galardone galardonar VMM03S0 +galardonemos galardonar VMM01P0 +galardonen galardonar VMM03P0 +galiba galibar VMM02S0 +galibad galibar VMM02P0 +galibando galibar VMG0000 +galibar galibar VMN0000 +galibe galibar VMM03S0 +galibemos galibar VMM01P0 +galiben galibar VMM03P0 +galla gallar VMM02S0 +gallad gallar VMM02P0 +gallando gallar VMG0000 +gallar gallar VMN0000 +gallardea gallardear VMM02S0 +gallardead gallardear VMM02P0 +gallardeando gallardear VMG0000 +gallardear gallardear VMN0000 +gallardee gallardear VMM03S0 +gallardeemos gallardear VMM01P0 +gallardeen gallardear VMM03P0 +galle gallar VMM03S0 +gallea gallear VMM02S0 +gallead gallear VMM02P0 +galleando gallear VMG0000 +gallear gallear VMN0000 +gallee gallear VMM03S0 +galleemos gallear VMM01P0 +galleen gallear VMM03P0 +gallemos gallar VMM01P0 +gallen gallar VMM03P0 +gallofea gallofear VMM02S0 +gallofead gallofear VMM02P0 +gallofeando gallofear VMG0000 +gallofear gallofear VMN0000 +gallofee gallofear VMM03S0 +gallofeemos gallofear VMM01P0 +gallofeen gallofear VMM03P0 +galonea galonear VMM02S0 +galonead galonear VMM02P0 +galoneando galonear VMG0000 +galonear galonear VMN0000 +galonee galonear VMM03S0 +galoneemos galonear VMM01P0 +galoneen galonear VMM03P0 +galopa galopar VMM02S0 +galopad galopar VMM02P0 +galopando galopar VMG0000 +galopar galopar VMN0000 +galope galopar VMM03S0 +galopea galopear VMM02S0 +galopead galopear VMM02P0 +galopeando galopear VMG0000 +galopear galopear VMN0000 +galopee galopear VMM03S0 +galopeemos galopear VMM01P0 +galopeen galopear VMM03P0 +galopemos galopar VMM01P0 +galopen galopar VMM03P0 +galucha galuchar VMM02S0 +galuchad galuchar VMM02P0 +galuchando galuchar VMG0000 +galuchar galuchar VMN0000 +galuche galuchar VMM03S0 +galuchemos galuchar VMM01P0 +galuchen galuchar VMM03P0 +galvanice galvanizar VMM03S0 +galvanicemos galvanizar VMM01P0 +galvanicen galvanizar VMM03P0 +galvaniza galvanizar VMM02S0 +galvanizad galvanizar VMM02P0 +galvanizando galvanizar VMG0000 +galvanizar galvanizar VMN0000 +gambetea gambetear VMM02S0 +gambetead gambetear VMM02P0 +gambeteando gambetear VMG0000 +gambetear gambetear VMN0000 +gambetee gambetear VMM03S0 +gambeteemos gambetear VMM01P0 +gambeteen gambetear VMM03P0 +gana ganar VMM02S0 +ganad ganar VMM02P0 +ganando ganar VMG0000 +ganar ganar VMN0000 +gandulea gandulear VMM02S0 +gandulead gandulear VMM02P0 +ganduleando gandulear VMG0000 +gandulear gandulear VMN0000 +gandulee gandulear VMM03S0 +ganduleemos gandulear VMM01P0 +ganduleen gandulear VMM03P0 +gane ganar VMM03S0 +ganemos ganar VMM01P0 +ganen ganar VMM03P0 +gangrena gangrenar VMM02S0 +gangrenad gangrenar VMM02P0 +gangrenando gangrenar VMG0000 +gangrenar gangrenar VMN0000 +gangrene gangrenar VMM03S0 +gangrenemos gangrenar VMM01P0 +gangrenen gangrenar VMM03P0 +ganguea ganguear VMM02S0 +ganguead ganguear VMM02P0 +gangueando ganguear VMG0000 +ganguear ganguear VMN0000 +ganguee ganguear VMM03S0 +gangueemos ganguear VMM01P0 +gangueen ganguear VMM03P0 +gansea gansear VMM02S0 +gansead gansear VMM02P0 +ganseando gansear VMG0000 +gansear gansear VMN0000 +gansee gansear VMM03S0 +ganseemos gansear VMM01P0 +ganseen gansear VMM03P0 +garabatea garabatear VMM02S0 +garabatead garabatear VMM02P0 +garabateando garabatear VMG0000 +garabatear garabatear VMN0000 +garabatee garabatear VMM03S0 +garabateemos garabatear VMM01P0 +garabateen garabatear VMM03P0 +garantice garantizar VMM03S0 +garanticemos garantizar VMM01P0 +garanticen garantizar VMM03P0 +garantid garantir VMM02P0 +garantiendo garantir VMG0000 +garantir garantir VMN0000 +garantiza garantizar VMM02S0 +garantizad garantizar VMM02P0 +garantizando garantizar VMG0000 +garantizar garantizar VMN0000 +garapiña garapiñar VMM02S0 +garapiñad garapiñar VMM02P0 +garapiñando garapiñar VMG0000 +garapiñar garapiñar VMN0000 +garapiñe garapiñar VMM03S0 +garapiñemos garapiñar VMM01P0 +garapiñen garapiñar VMM03P0 +garbea garbear VMM02S0 +garbead garbear VMM02P0 +garbeando garbear VMG0000 +garbear garbear VMN0000 +garbee garbear VMM03S0 +garbeemos garbear VMM01P0 +garbeen garbear VMM03P0 +garbilla garbillar VMM02S0 +garbillad garbillar VMM02P0 +garbillando garbillar VMG0000 +garbillar garbillar VMN0000 +garbille garbillar VMM03S0 +garbillemos garbillar VMM01P0 +garbillen garbillar VMM03P0 +garfea garfear VMM02S0 +garfead garfear VMM02P0 +garfeando garfear VMG0000 +garfear garfear VMN0000 +garfee garfear VMM03S0 +garfeemos garfear VMM01P0 +garfeen garfear VMM03P0 +gargajea gargajear VMM02S0 +gargajead gargajear VMM02P0 +gargajeando gargajear VMG0000 +gargajear gargajear VMN0000 +gargajee gargajear VMM03S0 +gargajeemos gargajear VMM01P0 +gargajeen gargajear VMM03P0 +gargantea gargantear VMM02S0 +gargantead gargantear VMM02P0 +garganteando gargantear VMG0000 +gargantear gargantear VMN0000 +gargantee gargantear VMM03S0 +garganteemos gargantear VMM01P0 +garganteen gargantear VMM03P0 +gargarice gargarizar VMM03S0 +gargaricemos gargarizar VMM01P0 +gargaricen gargarizar VMM03P0 +gargariza gargarizar VMM02S0 +gargarizad gargarizar VMM02P0 +gargarizando gargarizar VMG0000 +gargarizar gargarizar VMN0000 +garla garlar VMM02S0 +garlad garlar VMM02P0 +garlando garlar VMG0000 +garlar garlar VMN0000 +garle garlar VMM03S0 +garlemos garlar VMM01P0 +garlen garlar VMM03P0 +garra garrar VMM02S0 +garrad garrar VMM02P0 +garrafiña garrafiñar VMM02S0 +garrafiñad garrafiñar VMM02P0 +garrafiñando garrafiñar VMG0000 +garrafiñar garrafiñar VMN0000 +garrafiñe garrafiñar VMM03S0 +garrafiñemos garrafiñar VMM01P0 +garrafiñen garrafiñar VMM03P0 +garrando garrar VMG0000 +garrapatea garrapatear VMM02S0 +garrapatead garrapatear VMM02P0 +garrapateando garrapatear VMG0000 +garrapatear garrapatear VMN0000 +garrapatee garrapatear VMM03S0 +garrapateemos garrapatear VMM01P0 +garrapateen garrapatear VMM03P0 +garrapiña garrapiñar VMM02S0 +garrapiñad garrapiñar VMM02P0 +garrapiñando garrapiñar VMG0000 +garrapiñar garrapiñar VMN0000 +garrapiñe garrapiñar VMM03S0 +garrapiñemos garrapiñar VMM01P0 +garrapiñen garrapiñar VMM03P0 +garrar garrar VMN0000 +garre garrar VMM03S0 +garrea garrear VMM02S0 +garread garrear VMM02P0 +garreando garrear VMG0000 +garrear garrear VMN0000 +garree garrear VMM03S0 +garreemos garrear VMM01P0 +garreen garrear VMM03P0 +garremos garrar VMM01P0 +garren garrar VMM03P0 +garrocha garrochar VMM02S0 +garrochad garrochar VMM02P0 +garrochando garrochar VMG0000 +garrochar garrochar VMN0000 +garroche garrochar VMM03S0 +garrochea garrochear VMM02S0 +garrochead garrochear VMM02P0 +garrocheando garrochear VMG0000 +garrochear garrochear VMN0000 +garrochee garrochear VMM03S0 +garrocheemos garrochear VMM01P0 +garrocheen garrochear VMM03P0 +garrochemos garrochar VMM01P0 +garrochen garrochar VMM03P0 +garrotea garrotear VMM02S0 +garrotead garrotear VMM02P0 +garroteando garrotear VMG0000 +garrotear garrotear VMN0000 +garrotee garrotear VMM03S0 +garroteemos garrotear VMM01P0 +garroteen garrotear VMM03P0 +garua garuar VMM02S0 +garuad garuar VMM02P0 +garuando garuar VMG0000 +garuar garuar VMN0000 +garue garuar VMM03S0 +garuemos garuar VMM01P0 +garuen garuar VMM03P0 +garzonea garzonear VMM02S0 +garzonead garzonear VMM02P0 +garzoneando garzonear VMG0000 +garzonear garzonear VMN0000 +gasea gasear VMM02S0 +gasead gasear VMM02P0 +gaseando gasear VMG0000 +gasear gasear VMN0000 +gasee gasear VMM03S0 +gaseemos gasear VMM01P0 +gaseen gasear VMM03P0 +gasifica gasificar VMM02S0 +gasificad gasificar VMM02P0 +gasificando gasificar VMG0000 +gasificar gasificar VMN0000 +gasifique gasificar VMM03S0 +gasifiquemos gasificar VMM01P0 +gasifiquen gasificar VMM03P0 +gasta gastar VMM02S0 +gastad gastar VMM02P0 +gastando gastar VMG0000 +gastar gastar VMN0000 +gaste gastar VMM03S0 +gastemos gastar VMM01P0 +gasten gastar VMM03P0 +gatea gatear VMM02S0 +gatead gatear VMM02P0 +gateando gatear VMG0000 +gatear gatear VMN0000 +gatee gatear VMM03S0 +gateemos gatear VMM01P0 +gateen gatear VMM03P0 +gavilla gavillar VMM02S0 +gavillad gavillar VMM02P0 +gavillando gavillar VMG0000 +gavillar gavillar VMN0000 +gaville gavillar VMM03S0 +gavillemos gavillar VMM01P0 +gavillen gavillar VMM03P0 +gaya gayar VMM02S0 +gayad gayar VMM02P0 +gayando gayar VMG0000 +gayar gayar VMN0000 +gaye gayar VMM03S0 +gayemos gayar VMM01P0 +gayen gayar VMM03P0 +gazmia gazmiar VMM02S0 +gazmiad gazmiar VMM02P0 +gazmiando gazmiar VMG0000 +gazmiar gazmiar VMN0000 +gazmie gazmiar VMM03S0 +gazmiemos gazmiar VMM01P0 +gazmien gazmiar VMM03P0 +gaña gañir VMM03S0 +gañamos gañir VMM01P0 +gañan gañir VMM03P0 +gañe gañir VMM02S0 +gañendo gañir VMG0000 +gañid gañir VMM02P0 +gañir gañir VMN0000 +gelatinice gelatinizar VMM03S0 +gelatinicemos gelatinizar VMM01P0 +gelatinicen gelatinizar VMM03P0 +gelatiniza gelatinizar VMM02S0 +gelatinizad gelatinizar VMM02P0 +gelatinizando gelatinizar VMG0000 +gelatinizar gelatinizar VMN0000 +gelifica gelificar VMM02S0 +gelificad gelificar VMM02P0 +gelificando gelificar VMG0000 +gelificar gelificar VMN0000 +gelifique gelificar VMM03S0 +gelifiquemos gelificar VMM01P0 +gelifiquen gelificar VMM03P0 +gemid gemir VMM02P0 +gemina geminar VMM02S0 +geminad geminar VMM02P0 +geminando geminar VMG0000 +geminar geminar VMN0000 +gemine geminar VMM03S0 +geminemos geminar VMM01P0 +geminen geminar VMM03P0 +gemiquea gemiquear VMM02S0 +gemiquead gemiquear VMM02P0 +gemiqueando gemiquear VMG0000 +gemiquear gemiquear VMN0000 +gemiquee gemiquear VMM03S0 +gemiqueemos gemiquear VMM01P0 +gemiqueen gemiquear VMM03P0 +gemir gemir VMN0000 +genera generar VMM02S0 +generad generar VMM02P0 +generalice generalizar VMM03S0 +generalicemos generalizar VMM01P0 +generalicen generalizar VMM03P0 +generaliza generalizar VMM02S0 +generalizad generalizar VMM02P0 +generalizando generalizar VMG0000 +generalizar generalizar VMN0000 +generando generar VMG0000 +generar generar VMN0000 +genere generar VMM03S0 +generemos generar VMM01P0 +generen generar VMM03P0 +germanice germanizar VMM03S0 +germanicemos germanizar VMM01P0 +germanicen germanizar VMM03P0 +germaniza germanizar VMM02S0 +germanizad germanizar VMM02P0 +germanizando germanizar VMG0000 +germanizar germanizar VMN0000 +germina germinar VMM02S0 +germinad germinar VMM02P0 +germinando germinar VMG0000 +germinar germinar VMN0000 +germine germinar VMM03S0 +germinemos germinar VMM01P0 +germinen germinar VMM03P0 +gesta gestar VMM02S0 +gestad gestar VMM02P0 +gestando gestar VMG0000 +gestar gestar VMN0000 +geste gestar VMM03S0 +gestea gestear VMM02S0 +gestead gestear VMM02P0 +gesteando gestear VMG0000 +gestear gestear VMN0000 +gestee gestear VMM03S0 +gesteemos gestear VMM01P0 +gesteen gestear VMM03P0 +gestemos gestar VMM01P0 +gesten gestar VMM03P0 +gesticula gesticular VMM02S0 +gesticulad gesticular VMM02P0 +gesticulando gesticular VMG0000 +gesticular gesticular VMN0000 +gesticule gesticular VMM03S0 +gesticulemos gesticular VMM01P0 +gesticulen gesticular VMM03P0 +gestiona gestionar VMM02S0 +gestionad gestionar VMM02P0 +gestionando gestionar VMG0000 +gestionar gestionar VMN0000 +gestione gestionar VMM03S0 +gestionemos gestionar VMM01P0 +gestionen gestionar VMM03P0 +giba gibar VMM02S0 +gibad gibar VMM02P0 +gibando gibar VMG0000 +gibar gibar VMN0000 +gibe gibar VMM03S0 +gibemos gibar VMM01P0 +giben gibar VMM03P0 +gima gemir VMM03S0 +gimamos gemir VMM01P0 +giman gemir VMM03P0 +gime gemir VMM02S0 +gimiendo gemir VMG0000 +gimotea gimotear VMM02S0 +gimotead gimotear VMM02P0 +gimoteando gimotear VMG0000 +gimotear gimotear VMN0000 +gimotee gimotear VMM03S0 +gimoteemos gimotear VMM01P0 +gimoteen gimotear VMM03P0 +gira girar VMM02S0 +girad girar VMM02P0 +girando girar VMG0000 +girar girar VMN0000 +gire girar VMM03S0 +giremos girar VMM01P0 +giren girar VMM03P0 +gitanea gitanear VMM02S0 +gitanead gitanear VMM02P0 +gitaneando gitanear VMG0000 +gitanear gitanear VMN0000 +gitanee gitanear VMM03S0 +gitaneemos gitanear VMM01P0 +gitaneen gitanear VMM03P0 +glasea glasear VMM02S0 +glasead glasear VMM02P0 +glaseando glasear VMG0000 +glasear glasear VMN0000 +glasee glasear VMM03S0 +glaseemos glasear VMM01P0 +glaseen glasear VMM03P0 +globalice globalizar VMM03S0 +globalicemos globalizar VMM01P0 +globalicen globalizar VMM03P0 +globaliza globalizar VMM02S0 +globalizad globalizar VMM02P0 +globalizando globalizar VMG0000 +globalizar globalizar VMN0000 +gloriad gloriar VMM02P0 +gloriando gloriar VMG0000 +gloriar gloriar VMN0000 +gloriemos gloriar VMM01P0 +glorifica glorificar VMM02S0 +glorificad glorificar VMM02P0 +glorificando glorificar VMG0000 +glorificar glorificar VMN0000 +glorifique glorificar VMM03S0 +glorifiquemos glorificar VMM01P0 +glorifiquen glorificar VMM03P0 +gloría gloriar VMM02S0 +gloríe gloriar VMM03S0 +gloríen gloriar VMM03P0 +glosa glosar VMM02S0 +glosad glosar VMM02P0 +glosando glosar VMG0000 +glosar glosar VMN0000 +glose glosar VMM03S0 +glosemos glosar VMM01P0 +glosen glosar VMM03P0 +glotonea glotonear VMM02S0 +glotonead glotonear VMM02P0 +glotoneando glotonear VMG0000 +glotonear glotonear VMN0000 +glotonee glotonear VMM03S0 +glotoneemos glotonear VMM01P0 +glotoneen glotonear VMM03P0 +gluglutea gluglutear VMM02S0 +gluglutead gluglutear VMM02P0 +glugluteando gluglutear VMG0000 +gluglutear gluglutear VMN0000 +gluglutee gluglutear VMM03S0 +glugluteemos gluglutear VMM01P0 +glugluteen gluglutear VMM03P0 +gobernad gobernar VMM02P0 +gobernando gobernar VMG0000 +gobernar gobernar VMN0000 +gobernemos gobernar VMM01P0 +gobierna gobernar VMM02S0 +gobierne gobernar VMM03S0 +gobiernen gobernar VMM03P0 +goce gozar VMM03S0 +gocemos gozar VMM01P0 +gocen gozar VMM03P0 +gofra gofrar VMM02S0 +gofrad gofrar VMM02P0 +gofrando gofrar VMG0000 +gofrar gofrar VMN0000 +gofre gofrar VMM03S0 +gofremos gofrar VMM01P0 +gofren gofrar VMM03P0 +golea golear VMM02S0 +golead golear VMM02P0 +goleando golear VMG0000 +golear golear VMN0000 +golee golear VMM03S0 +goleemos golear VMM01P0 +goleen golear VMM03P0 +golfea golfear VMM02S0 +golfead golfear VMM02P0 +golfeando golfear VMG0000 +golfear golfear VMN0000 +golfee golfear VMM03S0 +golfeemos golfear VMM01P0 +golfeen golfear VMM03P0 +golosea golosear VMM02S0 +golosead golosear VMM02P0 +goloseando golosear VMG0000 +golosear golosear VMN0000 +golosee golosear VMM03S0 +goloseemos golosear VMM01P0 +goloseen golosear VMM03P0 +golosina golosinar VMM02S0 +golosinad golosinar VMM02P0 +golosinando golosinar VMG0000 +golosinar golosinar VMN0000 +golosine golosinar VMM03S0 +golosinea golosinear VMM02S0 +golosinead golosinear VMM02P0 +golosineando golosinear VMG0000 +golosinear golosinear VMN0000 +golosinee golosinear VMM03S0 +golosineemos golosinear VMM01P0 +golosineen golosinear VMM03P0 +golosinemos golosinar VMM01P0 +golosinen golosinar VMM03P0 +golpea golpear VMM02S0 +golpead golpear VMM02P0 +golpeando golpear VMG0000 +golpear golpear VMN0000 +golpee golpear VMM03S0 +golpeemos golpear VMM01P0 +golpeen golpear VMM03P0 +golpetea golpetear VMM02S0 +golpetead golpetear VMM02P0 +golpeteando golpetear VMG0000 +golpetear golpetear VMN0000 +golpetee golpetear VMM03S0 +golpeteemos golpetear VMM01P0 +golpeteen golpetear VMM03P0 +gorgoja gorgojar VMM02S0 +gorgojad gorgojar VMM02P0 +gorgojando gorgojar VMG0000 +gorgojar gorgojar VMN0000 +gorgoje gorgojar VMM03S0 +gorgojea gorgojear VMM02S0 +gorgojead gorgojear VMM02P0 +gorgojeando gorgojear VMG0000 +gorgojear gorgojear VMN0000 +gorgojee gorgojear VMM03S0 +gorgojeemos gorgojear VMM01P0 +gorgojeen gorgojear VMM03P0 +gorgojemos gorgojar VMM01P0 +gorgojen gorgojar VMM03P0 +gorgoritea gorgoritear VMM02S0 +gorgoritead gorgoritear VMM02P0 +gorgoriteando gorgoritear VMG0000 +gorgoritear gorgoritear VMN0000 +gorgoritee gorgoritear VMM03S0 +gorgoriteemos gorgoritear VMM01P0 +gorgoriteen gorgoritear VMM03P0 +gorgotea gorgotear VMM02S0 +gorgotead gorgotear VMM02P0 +gorgoteando gorgotear VMG0000 +gorgotear gorgotear VMN0000 +gorgotee gorgotear VMM03S0 +gorgoteemos gorgotear VMM01P0 +gorgoteen gorgotear VMM03P0 +gorjea gorjear VMM02S0 +gorjead gorjear VMM02P0 +gorjeando gorjear VMG0000 +gorjear gorjear VMN0000 +gorjee gorjear VMM03S0 +gorjeemos gorjear VMM01P0 +gorjeen gorjear VMM03P0 +gorrea gorrear VMM02S0 +gorread gorrear VMM02P0 +gorreando gorrear VMG0000 +gorrear gorrear VMN0000 +gorree gorrear VMM03S0 +gorreemos gorrear VMM01P0 +gorreen gorrear VMM03P0 +gorronea gorronear VMM02S0 +gorronead gorronear VMM02P0 +gorroneando gorronear VMG0000 +gorronear gorronear VMN0000 +gorronee gorronear VMM03S0 +gorroneemos gorronear VMM01P0 +gorroneen gorronear VMM03P0 +gotea gotear VMM02S0 +gotead gotear VMM02P0 +goteando gotear VMG0000 +gotear gotear VMN0000 +gotee gotear VMM03S0 +goteemos gotear VMM01P0 +goteen gotear VMM03P0 +goza gozar VMM02S0 +gozad gozar VMM02P0 +gozando gozar VMG0000 +gozar gozar VMN0000 +graba grabar VMM02S0 +grabad grabar VMM02P0 +grabando grabar VMG0000 +grabar grabar VMN0000 +grabe grabar VMM03S0 +grabemos grabar VMM01P0 +graben grabar VMM03P0 +graceja gracejar VMM02S0 +gracejad gracejar VMM02P0 +gracejando gracejar VMG0000 +gracejar gracejar VMN0000 +graceje gracejar VMM03S0 +gracejemos gracejar VMM01P0 +gracejen gracejar VMM03P0 +grada gradar VMM02S0 +gradad gradar VMM02P0 +gradando gradar VMG0000 +gradar gradar VMN0000 +grade gradar VMM03S0 +grademos gradar VMM01P0 +graden gradar VMM03P0 +graduad graduar VMM02P0 +graduando graduar VMG0000 +graduar graduar VMN0000 +graduemos graduar VMM01P0 +gradúa graduar VMM02S0 +gradúe graduar VMM03S0 +gradúen graduar VMM03P0 +grajea grajear VMM02S0 +grajead grajear VMM02P0 +grajeando grajear VMG0000 +grajear grajear VMN0000 +grajee grajear VMM03S0 +grajeemos grajear VMM01P0 +grajeen grajear VMM03P0 +grana granar VMM02S0 +granad granar VMM02P0 +granando granar VMG0000 +granar granar VMN0000 +grane granar VMM03S0 +granea granear VMM02S0 +granead granear VMM02P0 +graneando granear VMG0000 +granear granear VMN0000 +granee granear VMM03S0 +graneemos granear VMM01P0 +graneen granear VMM03P0 +granemos granar VMM01P0 +granen granar VMM03P0 +granice granizar VMM03S0 +granicemos granizar VMM01P0 +granicen granizar VMM03P0 +graniza granizar VMM02S0 +granizad granizar VMM02P0 +granizando granizar VMG0000 +granizar granizar VMN0000 +granjea granjear VMM02S0 +granjead granjear VMM02P0 +granjeando granjear VMG0000 +granjear granjear VMN0000 +granjee granjear VMM03S0 +granjeemos granjear VMM01P0 +granjeen granjear VMM03P0 +granula granular VMM02S0 +granulad granular VMM02P0 +granulando granular VMG0000 +granular granular VMN0000 +granule granular VMM03S0 +granulemos granular VMM01P0 +granulen granular VMM03P0 +grapa grapar VMM02S0 +grapad grapar VMM02P0 +grapando grapar VMG0000 +grapar grapar VMN0000 +grape grapar VMM03S0 +grapemos grapar VMM01P0 +grapen grapar VMM03P0 +grata gratar VMM02S0 +gratad gratar VMM02P0 +gratando gratar VMG0000 +gratar gratar VMN0000 +grate gratar VMM03S0 +gratemos gratar VMM01P0 +graten gratar VMM03P0 +gratifica gratificar VMM02S0 +gratificad gratificar VMM02P0 +gratificando gratificar VMG0000 +gratificar gratificar VMN0000 +gratifique gratificar VMM03S0 +gratifiquemos gratificar VMM01P0 +gratifiquen gratificar VMM03P0 +gratina gratinar VMM02S0 +gratinad gratinar VMM02P0 +gratinando gratinar VMG0000 +gratinar gratinar VMN0000 +gratine gratinar VMM03S0 +gratinemos gratinar VMM01P0 +gratinen gratinar VMM03P0 +grava gravar VMM02S0 +gravad gravar VMM02P0 +gravando gravar VMG0000 +gravar gravar VMN0000 +grave gravar VMM03S0 +gravemos gravar VMM01P0 +graven gravar VMM03P0 +gravita gravitar VMM02S0 +gravitad gravitar VMM02P0 +gravitando gravitar VMG0000 +gravitar gravitar VMN0000 +gravite gravitar VMM03S0 +gravitemos gravitar VMM01P0 +graviten gravitar VMM03P0 +grazna graznar VMM02S0 +graznad graznar VMM02P0 +graznando graznar VMG0000 +graznar graznar VMN0000 +grazne graznar VMM03S0 +graznemos graznar VMM01P0 +graznen graznar VMM03P0 +grecice grecizar VMM03S0 +grecicemos grecizar VMM01P0 +grecicen grecizar VMM03P0 +greciza grecizar VMM02S0 +grecizad grecizar VMM02P0 +grecizando grecizar VMG0000 +grecizar grecizar VMN0000 +grieta grietar VMM02S0 +grietad grietar VMM02P0 +grietando grietar VMG0000 +grietar grietar VMN0000 +griete grietar VMM03S0 +grietemos grietar VMM01P0 +grieten grietar VMM03P0 +grilla grillar VMM02S0 +grillad grillar VMM02P0 +grillando grillar VMG0000 +grillar grillar VMN0000 +grille grillar VMM03S0 +grillemos grillar VMM01P0 +grillen grillar VMM03P0 +grita gritar VMM02S0 +gritad gritar VMM02P0 +gritando gritar VMG0000 +gritar gritar VMN0000 +grite gritar VMM03S0 +gritemos gritar VMM01P0 +griten gritar VMM03P0 +gruid gruir VMM02P0 +gruir gruir VMN0000 +gruja grujir VMM03S0 +grujamos grujir VMM01P0 +grujan grujir VMM03P0 +gruje grujir VMM02S0 +grujid grujir VMM02P0 +grujiendo grujir VMG0000 +grujir grujir VMN0000 +gruya gruir VMM03S0 +gruyamos gruir VMM01P0 +gruyan gruir VMM03P0 +gruye gruir VMM02S0 +gruyendo gruir VMG0000 +gruña gruñir VMM03S0 +gruñamos gruñir VMM01P0 +gruñan gruñir VMM03P0 +gruñe gruñir VMM02S0 +gruñendo gruñir VMG0000 +gruñid gruñir VMM02P0 +gruñir gruñir VMN0000 +guachapea guachapear VMM02S0 +guachapead guachapear VMM02P0 +guachapeando guachapear VMG0000 +guachapear guachapear VMN0000 +guachapee guachapear VMM03S0 +guachapeemos guachapear VMM01P0 +guachapeen guachapear VMM03P0 +guadaña guadañar VMM02S0 +guadañad guadañar VMM02P0 +guadañando guadañar VMG0000 +guadañar guadañar VMN0000 +guadañe guadañar VMM03S0 +guadañemos guadañar VMM01P0 +guadañen guadañar VMM03P0 +gualdrapea gualdrapear VMM02S0 +gualdrapead gualdrapear VMM02P0 +gualdrapeando gualdrapear VMG0000 +gualdrapear gualdrapear VMN0000 +gualdrapee gualdrapear VMM03S0 +gualdrapeemos gualdrapear VMM01P0 +gualdrapeen gualdrapear VMM03P0 +guantea guantear VMM02S0 +guantead guantear VMM02P0 +guanteando guantear VMG0000 +guantear guantear VMN0000 +guantee guantear VMM03S0 +guanteemos guantear VMM01P0 +guanteen guantear VMM03P0 +guapea guapear VMM02S0 +guapead guapear VMM02P0 +guapeando guapear VMG0000 +guapear guapear VMN0000 +guapee guapear VMM03S0 +guapeemos guapear VMM01P0 +guapeen guapear VMM03P0 +guarda guardar VMM02S0 +guardad guardar VMM02P0 +guardando guardar VMG0000 +guardar guardar VMN0000 +guarde guardar VMM03S0 +guardemos guardar VMM01P0 +guarden guardar VMM03P0 +guarece guarecer VMM02S0 +guareced guarecer VMM02P0 +guarecer guarecer VMN0000 +guareciendo guarecer VMG0000 +guarezca guarecer VMM03S0 +guarezcamos guarecer VMM01P0 +guarezcan guarecer VMM03P0 +guarna guarnir VMM03S0 +guarnamos guarnir VMM01P0 +guarnan guarnir VMM03P0 +guarne guarnir VMM02S0 +guarnece guarnecer VMM02S0 +guarneced guarnecer VMM02P0 +guarnecer guarnecer VMN0000 +guarneciendo guarnecer VMG0000 +guarnezca guarnecer VMM03S0 +guarnezcamos guarnecer VMM01P0 +guarnezcan guarnecer VMM03P0 +guarniciona guarnicionar VMM02S0 +guarnicionad guarnicionar VMM02P0 +guarnicionando guarnicionar VMG0000 +guarnicionar guarnicionar VMN0000 +guarnicione guarnicionar VMM03S0 +guarnicionemos guarnicionar VMM01P0 +guarnicionen guarnicionar VMM03P0 +guarnid guarnir VMM02P0 +guarniendo guarnir VMG0000 +guarnir guarnir VMN0000 +guasea guasear VMM02S0 +guasead guasear VMM02P0 +guaseando guasear VMG0000 +guasear guasear VMN0000 +guasee guasear VMM03S0 +guaseemos guasear VMM01P0 +guaseen guasear VMM03P0 +guatea guatear VMM02S0 +guatead guatear VMM02P0 +guateando guatear VMG0000 +guatear guatear VMN0000 +guatee guatear VMM03S0 +guateemos guatear VMM01P0 +guateen guatear VMM03P0 +guerrea guerrear VMM02S0 +guerread guerrear VMM02P0 +guerreando guerrear VMG0000 +guerrear guerrear VMN0000 +guerree guerrear VMM03S0 +guerreemos guerrear VMM01P0 +guerreen guerrear VMM03P0 +guerrillea guerrillear VMM02S0 +guerrillead guerrillear VMM02P0 +guerrilleando guerrillear VMG0000 +guerrillear guerrillear VMN0000 +guerrillee guerrillear VMM03S0 +guerrilleemos guerrillear VMM01P0 +guerrilleen guerrillear VMM03P0 +guiad guiar VMM02P0 +guiando guiar VMG0000 +guiar guiar VMN0000 +guiemos guiar VMM01P0 +guilla guillar VMM02S0 +guillad guillar VMM02P0 +guillando guillar VMG0000 +guillar guillar VMN0000 +guille guillar VMM03S0 +guillemos guillar VMM01P0 +guillen guillar VMM03P0 +guillotina guillotinar VMM02S0 +guillotinad guillotinar VMM02P0 +guillotinando guillotinar VMG0000 +guillotinar guillotinar VMN0000 +guillotine guillotinar VMM03S0 +guillotinemos guillotinar VMM01P0 +guillotinen guillotinar VMM03P0 +guincha guinchar VMM02S0 +guinchad guinchar VMM02P0 +guinchando guinchar VMG0000 +guinchar guinchar VMN0000 +guinche guinchar VMM03S0 +guinchemos guinchar VMM01P0 +guinchen guinchar VMM03P0 +guinda guindar VMM02S0 +guindad guindar VMM02P0 +guindando guindar VMG0000 +guindar guindar VMN0000 +guinde guindar VMM03S0 +guindemos guindar VMM01P0 +guinden guindar VMM03P0 +guipa guipar VMM02S0 +guipad guipar VMM02P0 +guipando guipar VMG0000 +guipar guipar VMN0000 +guipe guipar VMM03S0 +guipemos guipar VMM01P0 +guipen guipar VMM03P0 +guisa guisar VMM02S0 +guisad guisar VMM02P0 +guisando guisar VMG0000 +guisar guisar VMN0000 +guise guisar VMM03S0 +guisemos guisar VMM01P0 +guisen guisar VMM03P0 +guita guitar VMM02S0 +guitad guitar VMM02P0 +guitando guitar VMG0000 +guitar guitar VMN0000 +guite guitar VMM03S0 +guitemos guitar VMM01P0 +guiten guitar VMM03P0 +guitonea guitonear VMM02S0 +guitonead guitonear VMM02P0 +guitoneando guitonear VMG0000 +guitonear guitonear VMN0000 +guitonee guitonear VMM03S0 +guitoneemos guitonear VMM01P0 +guitoneen guitonear VMM03P0 +guiña guiñar VMM02S0 +guiñad guiñar VMM02P0 +guiñando guiñar VMG0000 +guiñar guiñar VMN0000 +guiñe guiñar VMM03S0 +guiñemos guiñar VMM01P0 +guiñen guiñar VMM03P0 +gulusmea gulusmear VMM02S0 +gulusmead gulusmear VMM02P0 +gulusmeando gulusmear VMG0000 +gulusmear gulusmear VMN0000 +gulusmee gulusmear VMM03S0 +gulusmeemos gulusmear VMM01P0 +gulusmeen gulusmear VMM03P0 +gusanea gusanear VMM02S0 +gusanead gusanear VMM02P0 +gusaneando gusanear VMG0000 +gusanear gusanear VMN0000 +gusanee gusanear VMM03S0 +gusaneemos gusanear VMM01P0 +gusaneen gusanear VMM03P0 +gusta gustar VMM02S0 +gustad gustar VMM02P0 +gustando gustar VMG0000 +gustar gustar VMN0000 +guste gustar VMM03S0 +gustemos gustar VMM01P0 +gusten gustar VMM03P0 +guía guiar VMM02S0 +guíe guiar VMM03S0 +guíen guiar VMM03P0 +haber haber VAN0000 +habiendo haber VAG0000 +habilita habilitar VMM02S0 +habilitad habilitar VMM02P0 +habilitando habilitar VMG0000 +habilitar habilitar VMN0000 +habilite habilitar VMM03S0 +habilitemos habilitar VMM01P0 +habiliten habilitar VMM03P0 +habita habitar VMM02S0 +habitad habitar VMM02P0 +habitando habitar VMG0000 +habitar habitar VMN0000 +habite habitar VMM03S0 +habitemos habitar VMM01P0 +habiten habitar VMM03P0 +habituad habituar VMM02P0 +habituando habituar VMG0000 +habituar habituar VMN0000 +habituemos habituar VMM01P0 +habitúa habituar VMM02S0 +habitúe habituar VMM03S0 +habitúen habituar VMM03P0 +habla hablar VMM02S0 +hablad hablar VMM02P0 +hablando hablar VMG0000 +hablar hablar VMN0000 +hable hablar VMM03S0 +hablemos hablar VMM01P0 +hablen hablar VMM03P0 +haced hacer VMM02P0 +hacendad hacendar VMM02P0 +hacendando hacendar VMG0000 +hacendar hacendar VMN0000 +hacendemos hacendar VMM01P0 +hacer hacer VMN0000 +hacha hachar VMM02S0 +hachad hachar VMM02P0 +hachando hachar VMG0000 +hachar hachar VMN0000 +hache hachar VMM03S0 +hachea hachear VMM02S0 +hachead hachear VMM02P0 +hacheando hachear VMG0000 +hachear hachear VMN0000 +hachee hachear VMM03S0 +hacheemos hachear VMM01P0 +hacheen hachear VMM03P0 +hachemos hachar VMM01P0 +hachen hachar VMM03P0 +hacienda hacendar VMM02S0 +haciende hacendar VMM03S0 +hacienden hacendar VMM03P0 +haciendo hacer VMG0000 +hacina hacinar VMM02S0 +hacinad hacinar VMM02P0 +hacinando hacinar VMG0000 +hacinar hacinar VMN0000 +hacine hacinar VMM03S0 +hacinemos hacinar VMM01P0 +hacinen hacinar VMM03P0 +haga hacer VMM03S0 +hagamos hacer VMM01P0 +hagan hacer VMM03P0 +hala halar VMM02S0 +halad halar VMM02P0 +halaga halagar VMM02S0 +halagad halagar VMM02P0 +halagando halagar VMG0000 +halagar halagar VMN0000 +halague halagar VMM03S0 +halaguemos halagar VMM01P0 +halaguen halagar VMM03P0 +halando halar VMG0000 +halar halar VMN0000 +hale halar VMM03S0 +halemos halar VMM01P0 +halen halar VMM03P0 +halla hallar VMM02S0 +hallad hallar VMM02P0 +hallando hallar VMG0000 +hallar hallar VMN0000 +halle hallar VMM03S0 +hallemos hallar VMM01P0 +hallen hallar VMM03P0 +halogena halogenar VMM02S0 +halogenad halogenar VMM02P0 +halogenando halogenar VMG0000 +halogenar halogenar VMN0000 +halogene halogenar VMM03S0 +halogenemos halogenar VMM01P0 +halogenen halogenar VMM03P0 +hamaquea hamaquear VMM02S0 +hamaquead hamaquear VMM02P0 +hamaqueando hamaquear VMG0000 +hamaquear hamaquear VMN0000 +hamaquee hamaquear VMM03S0 +hamaqueemos hamaquear VMM01P0 +hamaqueen hamaquear VMM03P0 +hambrea hambrear VMM02S0 +hambread hambrear VMM02P0 +hambreando hambrear VMG0000 +hambrear hambrear VMN0000 +hambree hambrear VMM03S0 +hambreemos hambrear VMM01P0 +hambreen hambrear VMM03P0 +handicapa handicapar VMM02S0 +handicapad handicapar VMM02P0 +handicapando handicapar VMG0000 +handicapar handicapar VMN0000 +handicape handicapar VMM03S0 +handicapemos handicapar VMM01P0 +handicapen handicapar VMM03P0 +haraganea haraganear VMM02S0 +haraganead haraganear VMM02P0 +haraganeando haraganear VMG0000 +haraganear haraganear VMN0000 +haraganee haraganear VMM03S0 +haraganeemos haraganear VMM01P0 +haraganeen haraganear VMM03P0 +harmonice harmonizar VMM03S0 +harmonicemos harmonizar VMM01P0 +harmonicen harmonizar VMM03P0 +harmoniza harmonizar VMM02S0 +harmonizad harmonizar VMM02P0 +harmonizando harmonizar VMG0000 +harmonizar harmonizar VMN0000 +haronea haronear VMM02S0 +haronead haronear VMM02P0 +haroneando haronear VMG0000 +haronear haronear VMN0000 +haronee haronear VMM03S0 +haroneemos haronear VMM01P0 +haroneen haronear VMM03P0 +harta hartar VMM02S0 +hartad hartar VMM02P0 +hartando hartar VMG0000 +hartar hartar VMN0000 +harte hartar VMM03S0 +hartemos hartar VMM01P0 +harten hartar VMM03P0 +hastiad hastiar VMM02P0 +hastiando hastiar VMG0000 +hastiar hastiar VMN0000 +hastiemos hastiar VMM01P0 +hastía hastiar VMM02S0 +hastíe hastiar VMM03S0 +hastíen hastiar VMM03P0 +hatea hatear VMM02S0 +hatead hatear VMM02P0 +hateando hatear VMG0000 +hatear hatear VMN0000 +hatee hatear VMM03S0 +hateemos hatear VMM01P0 +hateen hatear VMM03P0 +haz hacer VMM02S0 +hebraice hebraizar VMM03S0 +hebraicemos hebraizar VMM01P0 +hebraicen hebraizar VMM03P0 +hebraiza hebraizar VMM02S0 +hebraizad hebraizar VMM02P0 +hebraizando hebraizar VMG0000 +hebraizar hebraizar VMN0000 +hechice hechizar VMM03S0 +hechicemos hechizar VMM01P0 +hechicen hechizar VMM03P0 +hechiza hechizar VMM02S0 +hechizad hechizar VMM02P0 +hechizando hechizar VMG0000 +hechizar hechizar VMN0000 +hedamos heder VMM01P0 +heded heder VMM02P0 +heder heder VMN0000 +hediendo heder VMG0000 +helad helar VMM02P0 +helando helar VMG0000 +helar helar VMN0000 +helemos helar VMM01P0 +helenice helenizar VMM03S0 +helenicemos helenizar VMM01P0 +helenicen helenizar VMM03P0 +heleniza helenizar VMM02S0 +helenizad helenizar VMM02P0 +helenizando helenizar VMG0000 +helenizar helenizar VMN0000 +henchid henchir VMM02P0 +henchir henchir VMN0000 +hendamos hender VMM01P0 +hendamos hendir VMM01P0 +hended hender VMM02P0 +hender hender VMN0000 +hendid hendir VMM02P0 +hendiendo hender VMG0000 +hendiendo hendir VMG0000 +hendir hendir VMN0000 +henifica henificar VMM02S0 +henificad henificar VMM02P0 +henificando henificar VMG0000 +henificar henificar VMN0000 +henifique henificar VMM03S0 +henifiquemos henificar VMM01P0 +henifiquen henificar VMM03P0 +herbad herbar VMM02P0 +herbaja herbajar VMM02S0 +herbajad herbajar VMM02P0 +herbajando herbajar VMG0000 +herbajar herbajar VMN0000 +herbaje herbajar VMM03S0 +herbajemos herbajar VMM01P0 +herbajen herbajar VMM03P0 +herbando herbar VMG0000 +herbar herbar VMN0000 +herbece herbecer VMM02S0 +herbeced herbecer VMM02P0 +herbecer herbecer VMN0000 +herbeciendo herbecer VMG0000 +herbezca herbecer VMM03S0 +herbezcamos herbecer VMM01P0 +herbezcan herbecer VMM03P0 +herborice herborizar VMM03S0 +herboricemos herborizar VMM01P0 +herboricen herborizar VMM03P0 +herboriza herborizar VMM02S0 +herborizad herborizar VMM02P0 +herborizando herborizar VMG0000 +herborizar herborizar VMN0000 +hereda heredar VMM02S0 +heredad heredar VMM02P0 +heredando heredar VMG0000 +heredar heredar VMN0000 +herede heredar VMM03S0 +heredemos heredar VMM01P0 +hereden heredar VMM03P0 +herid herir VMM02P0 +herir herir VMN0000 +hermana hermanar VMM02S0 +hermanad hermanar VMM02P0 +hermanando hermanar VMG0000 +hermanar hermanar VMN0000 +hermane hermanar VMM03S0 +hermanemos hermanar VMM01P0 +hermanen hermanar VMM03P0 +hermetice hermetizar VMM03S0 +hermeticemos hermetizar VMM01P0 +hermeticen hermetizar VMM03P0 +hermetiza hermetizar VMM02S0 +hermetizad hermetizar VMM02P0 +hermetizando hermetizar VMG0000 +hermetizar hermetizar VMN0000 +hermosea hermosear VMM02S0 +hermosead hermosear VMM02P0 +hermoseando hermosear VMG0000 +hermosear hermosear VMN0000 +hermosee hermosear VMM03S0 +hermoseemos hermosear VMM01P0 +hermoseen hermosear VMM03P0 +hernia herniar VMM02S0 +herniad herniar VMM02P0 +herniando herniar VMG0000 +herniar herniar VMN0000 +hernie herniar VMM03S0 +herniemos herniar VMM01P0 +hernien herniar VMM03P0 +herrad herrar VMM02P0 +herrando herrar VMG0000 +herrar herrar VMN0000 +herremos herrar VMM01P0 +herretea herretear VMM02S0 +herretead herretear VMM02P0 +herreteando herretear VMG0000 +herretear herretear VMN0000 +herretee herretear VMM03S0 +herreteemos herretear VMM01P0 +herreteen herretear VMM03P0 +herrumbra herrumbrar VMM02S0 +herrumbrad herrumbrar VMM02P0 +herrumbrando herrumbrar VMG0000 +herrumbrar herrumbrar VMN0000 +herrumbre herrumbrar VMM03S0 +herrumbremos herrumbrar VMM01P0 +herrumbren herrumbrar VMM03P0 +hervid hervir VMM02P0 +hervir hervir VMN0000 +heñid heñir VMM02P0 +heñir heñir VMN0000 +hiberna hibernar VMM02S0 +hibernad hibernar VMM02P0 +hibernando hibernar VMG0000 +hibernar hibernar VMN0000 +hiberne hibernar VMM03S0 +hibernemos hibernar VMM01P0 +hibernen hibernar VMM03P0 +hibrida hibridar VMM02S0 +hibridad hibridar VMM02P0 +hibridando hibridar VMG0000 +hibridar hibridar VMN0000 +hibride hibridar VMM03S0 +hibridemos hibridar VMM01P0 +hibriden hibridar VMM03P0 +hibridice hibridizar VMM03S0 +hibridicemos hibridizar VMM01P0 +hibridicen hibridizar VMM03P0 +hibridiza hibridizar VMM02S0 +hibridizad hibridizar VMM02P0 +hibridizando hibridizar VMG0000 +hibridizar hibridizar VMN0000 +hidrata hidratar VMM02S0 +hidratad hidratar VMM02P0 +hidratando hidratar VMG0000 +hidratar hidratar VMN0000 +hidrate hidratar VMM03S0 +hidratemos hidratar VMM01P0 +hidraten hidratar VMM03P0 +hidrogena hidrogenar VMM02S0 +hidrogenad hidrogenar VMM02P0 +hidrogenando hidrogenar VMG0000 +hidrogenar hidrogenar VMN0000 +hidrogene hidrogenar VMM03S0 +hidrogenemos hidrogenar VMM01P0 +hidrogenen hidrogenar VMM03P0 +hidrolice hidrolizar VMM03S0 +hidrolicemos hidrolizar VMM01P0 +hidrolicen hidrolizar VMM03P0 +hidroliza hidrolizar VMM02S0 +hidrolizad hidrolizar VMM02P0 +hidrolizando hidrolizar VMG0000 +hidrolizar hidrolizar VMN0000 +hieda heder VMM03S0 +hiedan heder VMM03P0 +hiede heder VMM02S0 +hiela helar VMM02S0 +hiele helar VMM03S0 +hielen helar VMM03P0 +hienda hender VMM03S0 +hienda hendir VMM03S0 +hiendan hender VMM03P0 +hiendan hendir VMM03P0 +hiende hender VMM02S0 +hiende hendir VMM02S0 +hiera herir VMM03S0 +hieran herir VMM03P0 +hierba herbar VMM02S0 +hiere herir VMM02S0 +hierra herrar VMM02S0 +hierre herrar VMM03S0 +hierren herrar VMM03P0 +hierva hervir VMM03S0 +hiervan hervir VMM03P0 +hierve hervir VMM02S0 +higienice higienizar VMM03S0 +higienicemos higienizar VMM01P0 +higienicen higienizar VMM03P0 +higieniza higienizar VMM02S0 +higienizad higienizar VMM02P0 +higienizando higienizar VMG0000 +higienizar higienizar VMN0000 +hila hilar VMM02S0 +hilad hilar VMM02P0 +hilando hilar VMG0000 +hilar hilar VMN0000 +hile hilar VMM03S0 +hilemos hilar VMM01P0 +hilen hilar VMM03P0 +hilvana hilvanar VMM02S0 +hilvanad hilvanar VMM02P0 +hilvanando hilvanar VMG0000 +hilvanar hilvanar VMN0000 +hilvane hilvanar VMM03S0 +hilvanemos hilvanar VMM01P0 +hilvanen hilvanar VMM03P0 +himpla himplar VMM02S0 +himplad himplar VMM02P0 +himplando himplar VMG0000 +himplar himplar VMN0000 +himple himplar VMM03S0 +himplemos himplar VMM01P0 +himplen himplar VMM03P0 +hinca hincar VMM02S0 +hincad hincar VMM02P0 +hincando hincar VMG0000 +hincar hincar VMN0000 +hincha henchir VMM03S0 +hincha hinchar VMM02S0 +hinchad hinchar VMM02P0 +hinchamos henchir VMM01P0 +hinchan henchir VMM03P0 +hinchando hinchar VMG0000 +hinchar hinchar VMN0000 +hinche henchir VMM02S0 +hinche hinchar VMM03S0 +hinchemos hinchar VMM01P0 +hinchen hinchar VMM03P0 +hinchiendo henchir VMG0000 +hinque hincar VMM03S0 +hinquemos hincar VMM01P0 +hinquen hincar VMM03P0 +hipa hipar VMM02S0 +hipad hipar VMM02P0 +hipando hipar VMG0000 +hipar hipar VMN0000 +hipe hipar VMM03S0 +hipemos hipar VMM01P0 +hipen hipar VMM03P0 +hipertrofia hipertrofiar VMM02S0 +hipertrofiad hipertrofiar VMM02P0 +hipertrofiando hipertrofiar VMG0000 +hipertrofiar hipertrofiar VMN0000 +hipertrofie hipertrofiar VMM03S0 +hipertrofiemos hipertrofiar VMM01P0 +hipertrofien hipertrofiar VMM03P0 +hipnotice hipnotizar VMM03S0 +hipnoticemos hipnotizar VMM01P0 +hipnoticen hipnotizar VMM03P0 +hipnotiza hipnotizar VMM02S0 +hipnotizad hipnotizar VMM02P0 +hipnotizando hipnotizar VMG0000 +hipnotizar hipnotizar VMN0000 +hipoteca hipotecar VMM02S0 +hipotecad hipotecar VMM02P0 +hipotecando hipotecar VMG0000 +hipotecar hipotecar VMN0000 +hipoteque hipotecar VMM03S0 +hipotequemos hipotecar VMM01P0 +hipotequen hipotecar VMM03P0 +hiramos herir VMM01P0 +hiriendo herir VMG0000 +hirvamos hervir VMM01P0 +hirviendo hervir VMG0000 +hisopa hisopar VMM02S0 +hisopad hisopar VMM02P0 +hisopando hisopar VMG0000 +hisopar hisopar VMN0000 +hisope hisopar VMM03S0 +hisopea hisopear VMM02S0 +hisopead hisopear VMM02P0 +hisopeando hisopear VMG0000 +hisopear hisopear VMN0000 +hisopee hisopear VMM03S0 +hisopeemos hisopear VMM01P0 +hisopeen hisopear VMM03P0 +hisopemos hisopar VMM01P0 +hisopen hisopar VMM03P0 +hispanice hispanizar VMM03S0 +hispanicemos hispanizar VMM01P0 +hispanicen hispanizar VMM03P0 +hispaniza hispanizar VMM02S0 +hispanizad hispanizar VMM02P0 +hispanizando hispanizar VMG0000 +hispanizar hispanizar VMN0000 +historiad historiar VMM02P0 +historiando historiar VMG0000 +historiar historiar VMN0000 +historiemos historiar VMM01P0 +historía historiar VMM02S0 +historíe historiar VMM03S0 +historíen historiar VMM03P0 +hita hitar VMM02S0 +hitad hitar VMM02P0 +hitando hitar VMG0000 +hitar hitar VMN0000 +hite hitar VMM03S0 +hitemos hitar VMM01P0 +hiten hitar VMM03P0 +hiña heñir VMM03S0 +hiñamos heñir VMM01P0 +hiñan heñir VMM03P0 +hiñe heñir VMM02S0 +hiñendo heñir VMG0000 +hoce hozar VMM03S0 +hocemos hozar VMM01P0 +hocen hozar VMM03P0 +hocica hocicar VMM02S0 +hocicad hocicar VMM02P0 +hocicando hocicar VMG0000 +hocicar hocicar VMN0000 +hocique hocicar VMM03S0 +hociquemos hocicar VMM01P0 +hociquen hocicar VMM03P0 +hojaldra hojaldrar VMM02S0 +hojaldrad hojaldrar VMM02P0 +hojaldrando hojaldrar VMG0000 +hojaldrar hojaldrar VMN0000 +hojaldre hojaldrar VMM03S0 +hojaldremos hojaldrar VMM01P0 +hojaldren hojaldrar VMM03P0 +hojea hojear VMM02S0 +hojead hojear VMM02P0 +hojeando hojear VMG0000 +hojear hojear VMN0000 +hojee hojear VMM03S0 +hojeemos hojear VMM01P0 +hojeen hojear VMM03P0 +holgad holgar VMM02P0 +holgando holgar VMG0000 +holgar holgar VMN0000 +holgazanea holgazanear VMM02S0 +holgazanead holgazanear VMM02P0 +holgazaneando holgazanear VMG0000 +holgazanear holgazanear VMN0000 +holgazanee holgazanear VMM03S0 +holgazaneemos holgazanear VMM01P0 +holgazaneen holgazanear VMM03P0 +holguemos holgar VMM01P0 +hollad hollar VMM02P0 +hollando hollar VMG0000 +hollar hollar VMN0000 +hollemos hollar VMM01P0 +hombrea hombrear VMM02S0 +hombread hombrear VMM02P0 +hombreando hombrear VMG0000 +hombrear hombrear VMN0000 +hombree hombrear VMM03S0 +hombreemos hombrear VMM01P0 +hombreen hombrear VMM03P0 +homenajea homenajear VMM02S0 +homenajead homenajear VMM02P0 +homenajeando homenajear VMG0000 +homenajear homenajear VMN0000 +homenajee homenajear VMM03S0 +homenajeemos homenajear VMM01P0 +homenajeen homenajear VMM03P0 +homogeneice homogeneizar VMM03S0 +homogeneicemos homogeneizar VMM01P0 +homogeneicen homogeneizar VMM03P0 +homogeneiza homogeneizar VMM02S0 +homogeneizad homogeneizar VMM02P0 +homogeneizando homogeneizar VMG0000 +homogeneizar homogeneizar VMN0000 +homologa homologar VMM02S0 +homologad homologar VMM02P0 +homologando homologar VMG0000 +homologar homologar VMN0000 +homologue homologar VMM03S0 +homologuemos homologar VMM01P0 +homologuen homologar VMM03P0 +hondea hondear VMM02S0 +hondead hondear VMM02P0 +hondeando hondear VMG0000 +hondear hondear VMN0000 +hondee hondear VMM03S0 +hondeemos hondear VMM01P0 +hondeen hondear VMM03P0 +honesta honestar VMM02S0 +honestad honestar VMM02P0 +honestando honestar VMG0000 +honestar honestar VMN0000 +honeste honestar VMM03S0 +honestemos honestar VMM01P0 +honesten honestar VMM03P0 +honora honorar VMM02S0 +honorad honorar VMM02P0 +honorando honorar VMG0000 +honorar honorar VMN0000 +honore honorar VMM03S0 +honoremos honorar VMM01P0 +honoren honorar VMM03P0 +honra honrar VMM02S0 +honrad honrar VMM02P0 +honrando honrar VMG0000 +honrar honrar VMN0000 +honre honrar VMM03S0 +honremos honrar VMM01P0 +honren honrar VMM03P0 +hopea hopear VMM02S0 +hopead hopear VMM02P0 +hopeando hopear VMG0000 +hopear hopear VMN0000 +hopee hopear VMM03S0 +hopeemos hopear VMM01P0 +hopeen hopear VMM03P0 +horada horadar VMM02S0 +horadad horadar VMM02P0 +horadando horadar VMG0000 +horadar horadar VMN0000 +horade horadar VMM03S0 +horademos horadar VMM01P0 +horaden horadar VMM03P0 +hormigona hormigonar VMM02S0 +hormigonad hormigonar VMM02P0 +hormigonando hormigonar VMG0000 +hormigonar hormigonar VMN0000 +hormigone hormigonar VMM03S0 +hormigonemos hormigonar VMM01P0 +hormigonen hormigonar VMM03P0 +hormiguea hormiguear VMM02S0 +hormiguead hormiguear VMM02P0 +hormigueando hormiguear VMG0000 +hormiguear hormiguear VMN0000 +hormiguee hormiguear VMM03S0 +hormigueemos hormiguear VMM01P0 +hormigueen hormiguear VMM03P0 +hornaguea hornaguear VMM02S0 +hornaguead hornaguear VMM02P0 +hornagueando hornaguear VMG0000 +hornaguear hornaguear VMN0000 +hornaguee hornaguear VMM03S0 +hornagueemos hornaguear VMM01P0 +hornagueen hornaguear VMM03P0 +hornea hornear VMM02S0 +hornead hornear VMM02P0 +horneando hornear VMG0000 +hornear hornear VMN0000 +hornee hornear VMM03S0 +horneemos hornear VMM01P0 +horneen hornear VMM03P0 +horra horrar VMM02S0 +horrad horrar VMM02P0 +horrando horrar VMG0000 +horrar horrar VMN0000 +horre horrar VMM03S0 +horremos horrar VMM01P0 +horren horrar VMM03P0 +horripila horripilar VMM02S0 +horripilad horripilar VMM02P0 +horripilando horripilar VMG0000 +horripilar horripilar VMN0000 +horripile horripilar VMM03S0 +horripilemos horripilar VMM01P0 +horripilen horripilar VMM03P0 +horrorice horrorizar VMM03S0 +horroricemos horrorizar VMM01P0 +horroricen horrorizar VMM03P0 +horroriza horrorizar VMM02S0 +horrorizad horrorizar VMM02P0 +horrorizando horrorizar VMG0000 +horrorizar horrorizar VMN0000 +hospeda hospedar VMM02S0 +hospedad hospedar VMM02P0 +hospedando hospedar VMG0000 +hospedar hospedar VMN0000 +hospede hospedar VMM03S0 +hospedemos hospedar VMM01P0 +hospeden hospedar VMM03P0 +hospitalice hospitalizar VMM03S0 +hospitalicemos hospitalizar VMM01P0 +hospitalicen hospitalizar VMM03P0 +hospitaliza hospitalizar VMM02S0 +hospitalizad hospitalizar VMM02P0 +hospitalizando hospitalizar VMG0000 +hospitalizar hospitalizar VMN0000 +hostiga hostigar VMM02S0 +hostigad hostigar VMM02P0 +hostigando hostigar VMG0000 +hostigar hostigar VMN0000 +hostigue hostigar VMM03S0 +hostiguemos hostigar VMM01P0 +hostiguen hostigar VMM03P0 +hostilice hostilizar VMM03S0 +hostilicemos hostilizar VMM01P0 +hostilicen hostilizar VMM03P0 +hostiliza hostilizar VMM02S0 +hostilizad hostilizar VMM02P0 +hostilizando hostilizar VMG0000 +hostilizar hostilizar VMN0000 +hoza hozar VMM02S0 +hozad hozar VMM02P0 +hozando hozar VMG0000 +hozar hozar VMN0000 +huchea huchear VMM02S0 +huchead huchear VMM02P0 +hucheando huchear VMG0000 +huchear huchear VMN0000 +huchee huchear VMM03S0 +hucheemos huchear VMM01P0 +hucheen huchear VMM03P0 +huela oler VMM03S0 +huelan oler VMM03P0 +huele oler VMM02S0 +huelga holgar VMM02S0 +huelgue holgar VMM03S0 +huelguen holgar VMM03P0 +huella hollar VMM02S0 +huelle hollar VMM03S0 +huellen hollar VMM03P0 +hueva huevar VMM02S0 +huevad huevar VMM02P0 +huevando huevar VMG0000 +huevar huevar VMN0000 +hueve huevar VMM03S0 +huevemos huevar VMM01P0 +hueven huevar VMM03P0 +huid huir VMM02P0 +huir huir VMN0000 +humana humanar VMM02S0 +humanad humanar VMM02P0 +humanando humanar VMG0000 +humanar humanar VMN0000 +humane humanar VMM03S0 +humanemos humanar VMM01P0 +humanen humanar VMM03P0 +humanice humanizar VMM03S0 +humanicemos humanizar VMM01P0 +humanicen humanizar VMM03P0 +humaniza humanizar VMM02S0 +humanizad humanizar VMM02P0 +humanizando humanizar VMG0000 +humanizar humanizar VMN0000 +humea humear VMM02S0 +humead humear VMM02P0 +humeando humear VMG0000 +humear humear VMN0000 +humecta humectar VMM02S0 +humectad humectar VMM02P0 +humectando humectar VMG0000 +humectar humectar VMN0000 +humecte humectar VMM03S0 +humectemos humectar VMM01P0 +humecten humectar VMM03P0 +humedece humedecer VMM02S0 +humedeced humedecer VMM02P0 +humedecer humedecer VMN0000 +humedeciendo humedecer VMG0000 +humedezca humedecer VMM03S0 +humedezcamos humedecer VMM01P0 +humedezcan humedecer VMM03P0 +humee humear VMM03S0 +humeemos humear VMM01P0 +humeen humear VMM03P0 +humilla humillar VMM02S0 +humillad humillar VMM02P0 +humillando humillar VMG0000 +humillar humillar VMN0000 +humille humillar VMM03S0 +humillemos humillar VMM01P0 +humillen humillar VMM03P0 +hunda hundir VMM03S0 +hundamos hundir VMM01P0 +hundan hundir VMM03P0 +hunde hundir VMM02S0 +hundid hundir VMM02P0 +hundiendo hundir VMG0000 +hundir hundir VMN0000 +hurga hurgar VMM02S0 +hurgad hurgar VMM02P0 +hurgando hurgar VMG0000 +hurgar hurgar VMN0000 +hurgonea hurgonear VMM02S0 +hurgonead hurgonear VMM02P0 +hurgoneando hurgonear VMG0000 +hurgonear hurgonear VMN0000 +hurgonee hurgonear VMM03S0 +hurgoneemos hurgonear VMM01P0 +hurgoneen hurgonear VMM03P0 +hurgue hurgar VMM03S0 +hurguemos hurgar VMM01P0 +hurguen hurgar VMM03P0 +hurguetea hurguetear VMM02S0 +hurguetead hurguetear VMM02P0 +hurgueteando hurguetear VMG0000 +hurguetear hurguetear VMN0000 +hurguetee hurguetear VMM03S0 +hurgueteemos hurguetear VMM01P0 +hurgueteen hurguetear VMM03P0 +huronea huronear VMM02S0 +huronead huronear VMM02P0 +huroneando huronear VMG0000 +huronear huronear VMN0000 +huronee huronear VMM03S0 +huroneemos huronear VMM01P0 +huroneen huronear VMM03P0 +hurta hurtar VMM02S0 +hurtad hurtar VMM02P0 +hurtando hurtar VMG0000 +hurtar hurtar VMN0000 +hurte hurtar VMM03S0 +hurtemos hurtar VMM01P0 +hurten hurtar VMM03P0 +husmea husmear VMM02S0 +husmead husmear VMM02P0 +husmeando husmear VMG0000 +husmear husmear VMN0000 +husmee husmear VMM03S0 +husmeemos husmear VMM01P0 +husmeen husmear VMM03P0 +huya huir VMM03S0 +huyamos huir VMM01P0 +huyan huir VMM03P0 +huye huir VMM02S0 +huyendo huir VMG0000 +ice izar VMM03S0 +icemos izar VMM01P0 +icen izar VMM03P0 +id ir VMM02P0 +idea idear VMM02S0 +idead idear VMM02P0 +idealice idealizar VMM03S0 +idealicemos idealizar VMM01P0 +idealicen idealizar VMM03P0 +idealiza idealizar VMM02S0 +idealizad idealizar VMM02P0 +idealizando idealizar VMG0000 +idealizar idealizar VMN0000 +ideando idear VMG0000 +idear idear VMN0000 +idee idear VMM03S0 +ideemos idear VMM01P0 +ideen idear VMM03P0 +identifica identificar VMM02S0 +identificad identificar VMM02P0 +identificando identificar VMG0000 +identificar identificar VMN0000 +identifique identificar VMM03S0 +identifiquemos identificar VMM01P0 +identifiquen identificar VMM03P0 +ideologice ideologizar VMM03S0 +ideologicemos ideologizar VMM01P0 +ideologicen ideologizar VMM03P0 +ideologiza ideologizar VMM02S0 +ideologizad ideologizar VMM02P0 +ideologizando ideologizar VMG0000 +ideologizar ideologizar VMN0000 +idiotice idiotizar VMM03S0 +idioticemos idiotizar VMM01P0 +idioticen idiotizar VMM03P0 +idiotiza idiotizar VMM02S0 +idiotizad idiotizar VMM02P0 +idiotizando idiotizar VMG0000 +idiotizar idiotizar VMN0000 +idolatra idolatrar VMM02S0 +idolatrad idolatrar VMM02P0 +idolatrando idolatrar VMG0000 +idolatrar idolatrar VMN0000 +idolatre idolatrar VMM03S0 +idolatremos idolatrar VMM01P0 +idolatren idolatrar VMM03P0 +ignifuga ignifugar VMM02S0 +ignifugad ignifugar VMM02P0 +ignifugando ignifugar VMG0000 +ignifugar ignifugar VMN0000 +ignifugue ignifugar VMM03S0 +ignifuguemos ignifugar VMM01P0 +ignifuguen ignifugar VMM03P0 +ignora ignorar VMM02S0 +ignorad ignorar VMM02P0 +ignorando ignorar VMG0000 +ignorar ignorar VMN0000 +ignore ignorar VMM03S0 +ignoremos ignorar VMM01P0 +ignoren ignorar VMM03P0 +iguala igualar VMM02S0 +igualad igualar VMM02P0 +igualando igualar VMG0000 +igualar igualar VMN0000 +iguale igualar VMM03S0 +igualemos igualar VMM01P0 +igualen igualar VMM03P0 +ijadea ijadear VMM02S0 +ijadead ijadear VMM02P0 +ijadeando ijadear VMG0000 +ijadear ijadear VMN0000 +ijadee ijadear VMM03S0 +ijadeemos ijadear VMM01P0 +ijadeen ijadear VMM03P0 +ilegalice ilegalizar VMM03S0 +ilegalicemos ilegalizar VMM01P0 +ilegalicen ilegalizar VMM03P0 +ilegaliza ilegalizar VMM02S0 +ilegalizad ilegalizar VMM02P0 +ilegalizando ilegalizar VMG0000 +ilegalizar ilegalizar VMN0000 +ilegitima ilegitimar VMM02S0 +ilegitimad ilegitimar VMM02P0 +ilegitimando ilegitimar VMG0000 +ilegitimar ilegitimar VMN0000 +ilegitime ilegitimar VMM03S0 +ilegitimemos ilegitimar VMM01P0 +ilegitimen ilegitimar VMM03P0 +ilumina iluminar VMM02S0 +iluminad iluminar VMM02P0 +iluminando iluminar VMG0000 +iluminar iluminar VMN0000 +ilumine iluminar VMM03S0 +iluminemos iluminar VMM01P0 +iluminen iluminar VMM03P0 +ilusiona ilusionar VMM02S0 +ilusionad ilusionar VMM02P0 +ilusionando ilusionar VMG0000 +ilusionar ilusionar VMN0000 +ilusione ilusionar VMM03S0 +ilusionemos ilusionar VMM01P0 +ilusionen ilusionar VMM03P0 +ilustra ilustrar VMM02S0 +ilustrad ilustrar VMM02P0 +ilustrando ilustrar VMG0000 +ilustrar ilustrar VMN0000 +ilustre ilustrar VMM03S0 +ilustremos ilustrar VMM01P0 +ilustren ilustrar VMM03P0 +imagina imaginar VMM02S0 +imaginad imaginar VMM02P0 +imaginando imaginar VMG0000 +imaginar imaginar VMN0000 +imagine imaginar VMM03S0 +imaginemos imaginar VMM01P0 +imaginen imaginar VMM03P0 +imana imanar VMM02S0 +imanad imanar VMM02P0 +imanando imanar VMG0000 +imanar imanar VMN0000 +imane imanar VMM03S0 +imanemos imanar VMM01P0 +imanen imanar VMM03P0 +imanta imantar VMM02S0 +imantad imantar VMM02P0 +imantando imantar VMG0000 +imantar imantar VMN0000 +imante imantar VMM03S0 +imantemos imantar VMM01P0 +imanten imantar VMM03P0 +imbrica imbricar VMM02S0 +imbricad imbricar VMM02P0 +imbricando imbricar VMG0000 +imbricar imbricar VMN0000 +imbrique imbricar VMM03S0 +imbriquemos imbricar VMM01P0 +imbriquen imbricar VMM03P0 +imbuid imbuir VMM02P0 +imbuir imbuir VMN0000 +imbuya imbuir VMM03S0 +imbuyamos imbuir VMM01P0 +imbuyan imbuir VMM03P0 +imbuye imbuir VMM02S0 +imbuyendo imbuir VMG0000 +imita imitar VMM02S0 +imitad imitar VMM02P0 +imitando imitar VMG0000 +imitar imitar VMN0000 +imite imitar VMM03S0 +imitemos imitar VMM01P0 +imiten imitar VMM03P0 +impacienta impacientar VMM02S0 +impacientad impacientar VMM02P0 +impacientando impacientar VMG0000 +impacientar impacientar VMN0000 +impaciente impacientar VMM03S0 +impacientemos impacientar VMM01P0 +impacienten impacientar VMM03P0 +impacta impactar VMM02S0 +impactad impactar VMM02P0 +impactando impactar VMG0000 +impactar impactar VMN0000 +impacte impactar VMM03S0 +impactemos impactar VMM01P0 +impacten impactar VMM03P0 +imparta impartir VMM03S0 +impartamos impartir VMM01P0 +impartan impartir VMM03P0 +imparte impartir VMM02S0 +impartid impartir VMM02P0 +impartiendo impartir VMG0000 +impartir impartir VMN0000 +impedid impedir VMM02P0 +impedir impedir VMN0000 +impela impeler VMM03S0 +impelamos impeler VMM01P0 +impelan impeler VMM03P0 +impele impeler VMM02S0 +impeled impeler VMM02P0 +impeler impeler VMN0000 +impeliendo impeler VMG0000 +impenda impender VMM03S0 +impendamos impender VMM01P0 +impendan impender VMM03P0 +impende impender VMM02S0 +impended impender VMM02P0 +impender impender VMN0000 +impendiendo impender VMG0000 +impera imperar VMM02S0 +imperad imperar VMM02P0 +imperando imperar VMG0000 +imperar imperar VMN0000 +impere imperar VMM03S0 +imperemos imperar VMM01P0 +imperen imperar VMM03P0 +impermeabilice impermeabilizar VMM03S0 +impermeabilicemos impermeabilizar VMM01P0 +impermeabilicen impermeabilizar VMM03P0 +impermeabiliza impermeabilizar VMM02S0 +impermeabilizad impermeabilizar VMM02P0 +impermeabilizando impermeabilizar VMG0000 +impermeabilizar impermeabilizar VMN0000 +impersonalice impersonalizar VMM03S0 +impersonalicemos impersonalizar VMM01P0 +impersonalicen impersonalizar VMM03P0 +impersonaliza impersonalizar VMM02S0 +impersonalizad impersonalizar VMM02P0 +impersonalizando impersonalizar VMG0000 +impersonalizar impersonalizar VMN0000 +impetra impetrar VMM02S0 +impetrad impetrar VMM02P0 +impetrando impetrar VMG0000 +impetrar impetrar VMN0000 +impetre impetrar VMM03S0 +impetremos impetrar VMM01P0 +impetren impetrar VMM03P0 +impida impedir VMM03S0 +impidamos impedir VMM01P0 +impidan impedir VMM03P0 +impide impedir VMM02S0 +impidiendo impedir VMG0000 +implanta implantar VMM02S0 +implantad implantar VMM02P0 +implantando implantar VMG0000 +implantar implantar VMN0000 +implante implantar VMM03S0 +implantemos implantar VMM01P0 +implanten implantar VMM03P0 +implementa implementar VMM02S0 +implementad implementar VMM02P0 +implementando implementar VMG0000 +implementar implementar VMN0000 +implemente implementar VMM03S0 +implementemos implementar VMM01P0 +implementen implementar VMM03P0 +implica implicar VMM02S0 +implicad implicar VMM02P0 +implicando implicar VMG0000 +implicar implicar VMN0000 +implique implicar VMM03S0 +impliquemos implicar VMM01P0 +impliquen implicar VMM03P0 +implora implorar VMM02S0 +implorad implorar VMM02P0 +implorando implorar VMG0000 +implorar implorar VMN0000 +implore implorar VMM03S0 +imploremos implorar VMM01P0 +imploren implorar VMM03P0 +imponed imponer VMM02P0 +imponer imponer VMN0000 +imponga imponer VMM03S0 +impongamos imponer VMM01P0 +impongan imponer VMM03P0 +imponiendo imponer VMG0000 +importa importar VMM02S0 +importad importar VMM02P0 +importando importar VMG0000 +importar importar VMN0000 +importe importar VMM03S0 +importemos importar VMM01P0 +importen importar VMM03P0 +importuna importunar VMM02S0 +importunad importunar VMM02P0 +importunando importunar VMG0000 +importunar importunar VMN0000 +importune importunar VMM03S0 +importunemos importunar VMM01P0 +importunen importunar VMM03P0 +imposibilita imposibilitar VMM02S0 +imposibilitad imposibilitar VMM02P0 +imposibilitando imposibilitar VMG0000 +imposibilitar imposibilitar VMN0000 +imposibilite imposibilitar VMM03S0 +imposibilitemos imposibilitar VMM01P0 +imposibiliten imposibilitar VMM03P0 +imposta impostar VMM02S0 +impostad impostar VMM02P0 +impostando impostar VMG0000 +impostar impostar VMN0000 +imposte impostar VMM03S0 +impostemos impostar VMM01P0 +imposten impostar VMM03P0 +impreca imprecar VMM02S0 +imprecad imprecar VMM02P0 +imprecando imprecar VMG0000 +imprecar imprecar VMN0000 +impregna impregnar VMM02S0 +impregnad impregnar VMM02P0 +impregnando impregnar VMG0000 +impregnar impregnar VMN0000 +impregne impregnar VMM03S0 +impregnemos impregnar VMM01P0 +impregnen impregnar VMM03P0 +impreque imprecar VMM03S0 +imprequemos imprecar VMM01P0 +imprequen imprecar VMM03P0 +impresiona impresionar VMM02S0 +impresionad impresionar VMM02P0 +impresionando impresionar VMG0000 +impresionar impresionar VMN0000 +impresione impresionar VMM03S0 +impresionemos impresionar VMM01P0 +impresionen impresionar VMM03P0 +imprima imprimar VMM02S0 +imprima imprimir VMM03S0 +imprimad imprimar VMM02P0 +imprimamos imprimir VMM01P0 +impriman imprimir VMM03P0 +imprimando imprimar VMG0000 +imprimar imprimar VMN0000 +imprime imprimar VMM03S0 +imprime imprimir VMM02S0 +imprimemos imprimar VMM01P0 +imprimen imprimar VMM03P0 +imprimid imprimir VMM02P0 +imprimiendo imprimir VMG0000 +imprimir imprimir VMN0000 +improbad improbar VMM02P0 +improbando improbar VMG0000 +improbar improbar VMN0000 +improbemos improbar VMM01P0 +improvisa improvisar VMM02S0 +improvisad improvisar VMM02P0 +improvisando improvisar VMG0000 +improvisar improvisar VMN0000 +improvise improvisar VMM03S0 +improvisemos improvisar VMM01P0 +improvisen improvisar VMM03P0 +imprueba improbar VMM02S0 +impruebe improbar VMM03S0 +imprueben improbar VMM03P0 +impugna impugnar VMM02S0 +impugnad impugnar VMM02P0 +impugnando impugnar VMG0000 +impugnar impugnar VMN0000 +impugne impugnar VMM03S0 +impugnemos impugnar VMM01P0 +impugnen impugnar VMM03P0 +impulsa impulsar VMM02S0 +impulsad impulsar VMM02P0 +impulsando impulsar VMG0000 +impulsar impulsar VMN0000 +impulse impulsar VMM03S0 +impulsemos impulsar VMM01P0 +impulsen impulsar VMM03P0 +impurifica impurificar VMM02S0 +impurificad impurificar VMM02P0 +impurificando impurificar VMG0000 +impurificar impurificar VMN0000 +impurifique impurificar VMM03S0 +impurifiquemos impurificar VMM01P0 +impurifiquen impurificar VMM03P0 +imputa imputar VMM02S0 +imputad imputar VMM02P0 +imputando imputar VMG0000 +imputar imputar VMN0000 +impute imputar VMM03S0 +imputemos imputar VMM01P0 +imputen imputar VMM03P0 +impón imponer VMM02S0 +inactiva inactivar VMM02S0 +inactivad inactivar VMM02P0 +inactivando inactivar VMG0000 +inactivar inactivar VMN0000 +inactive inactivar VMM03S0 +inactivemos inactivar VMM01P0 +inactiven inactivar VMM03P0 +inaugura inaugurar VMM02S0 +inaugurad inaugurar VMM02P0 +inaugurando inaugurar VMG0000 +inaugurar inaugurar VMN0000 +inaugure inaugurar VMM03S0 +inauguremos inaugurar VMM01P0 +inauguren inaugurar VMM03P0 +incapacita incapacitar VMM02S0 +incapacitad incapacitar VMM02P0 +incapacitando incapacitar VMG0000 +incapacitar incapacitar VMN0000 +incapacite incapacitar VMM03S0 +incapacitemos incapacitar VMM01P0 +incapaciten incapacitar VMM03P0 +incardina incardinar VMM02S0 +incardinad incardinar VMM02P0 +incardinando incardinar VMG0000 +incardinar incardinar VMN0000 +incardine incardinar VMM03S0 +incardinemos incardinar VMM01P0 +incardinen incardinar VMM03P0 +incauta incautar VMM02S0 +incautad incautar VMM02P0 +incautando incautar VMG0000 +incautar incautar VMN0000 +incaute incautar VMM03S0 +incautemos incautar VMM01P0 +incauten incautar VMM03P0 +incendia incendiar VMM02S0 +incendiad incendiar VMM02P0 +incendiando incendiar VMG0000 +incendiar incendiar VMN0000 +incendie incendiar VMM03S0 +incendiemos incendiar VMM01P0 +incendien incendiar VMM03P0 +incensad incensar VMM02P0 +incensando incensar VMG0000 +incensar incensar VMN0000 +incensemos incensar VMM01P0 +incentiva incentivar VMM02S0 +incentivad incentivar VMM02P0 +incentivando incentivar VMG0000 +incentivar incentivar VMN0000 +incentive incentivar VMM03S0 +incentivemos incentivar VMM01P0 +incentiven incentivar VMM03P0 +incida incidir VMM03S0 +incidamos incidir VMM01P0 +incidan incidir VMM03P0 +incide incidir VMM02S0 +incidid incidir VMM02P0 +incidiendo incidir VMG0000 +incidir incidir VMN0000 +inciensa incensar VMM02S0 +inciense incensar VMM03S0 +inciensen incensar VMM03P0 +incinera incinerar VMM02S0 +incinerad incinerar VMM02P0 +incinerando incinerar VMG0000 +incinerar incinerar VMN0000 +incinere incinerar VMM03S0 +incineremos incinerar VMM01P0 +incineren incinerar VMM03P0 +incita incitar VMM02S0 +incitad incitar VMM02P0 +incitando incitar VMG0000 +incitar incitar VMN0000 +incite incitar VMM03S0 +incitemos incitar VMM01P0 +inciten incitar VMM03P0 +inclina inclinar VMM02S0 +inclinad inclinar VMM02P0 +inclinando inclinar VMG0000 +inclinar inclinar VMN0000 +incline inclinar VMM03S0 +inclinemos inclinar VMM01P0 +inclinen inclinar VMM03P0 +incluid incluir VMM02P0 +incluir incluir VMN0000 +incluya incluir VMM03S0 +incluyamos incluir VMM01P0 +incluyan incluir VMM03P0 +incluye incluir VMM02S0 +incluyendo incluir VMG0000 +incoa incoar VMM02S0 +incoad incoar VMM02P0 +incoando incoar VMG0000 +incoar incoar VMN0000 +incoe incoar VMM03S0 +incoemos incoar VMM01P0 +incoen incoar VMM03P0 +incominique incomunicar VMM03S0 +incominiquemos incomunicar VMM01P0 +incominiquen incomunicar VMM03P0 +incomoda incomodar VMM02S0 +incomodad incomodar VMM02P0 +incomodando incomodar VMG0000 +incomodar incomodar VMN0000 +incomode incomodar VMM03S0 +incomodemos incomodar VMM01P0 +incomoden incomodar VMM03P0 +incomunica incomunicar VMM02S0 +incomunicad incomunicar VMM02P0 +incomunicando incomunicar VMG0000 +incomunicar incomunicar VMN0000 +incordia incordiar VMM02S0 +incordiad incordiar VMM02P0 +incordiando incordiar VMG0000 +incordiar incordiar VMN0000 +incordie incordiar VMM03S0 +incordiemos incordiar VMM01P0 +incordien incordiar VMM03P0 +incorpora incorporar VMM02S0 +incorporad incorporar VMM02P0 +incorporando incorporar VMG0000 +incorporar incorporar VMN0000 +incorpore incorporar VMM03S0 +incorporemos incorporar VMM01P0 +incorporen incorporar VMM03P0 +incrasa incrasar VMM02S0 +incrasad incrasar VMM02P0 +incrasando incrasar VMG0000 +incrasar incrasar VMN0000 +incrase incrasar VMM03S0 +incrasemos incrasar VMM01P0 +incrasen incrasar VMM03P0 +incrementa incrementar VMM02S0 +incrementad incrementar VMM02P0 +incrementando incrementar VMG0000 +incrementar incrementar VMN0000 +incremente incrementar VMM03S0 +incrementemos incrementar VMM01P0 +incrementen incrementar VMM03P0 +increpa increpar VMM02S0 +increpad increpar VMM02P0 +increpando increpar VMG0000 +increpar increpar VMN0000 +increpe increpar VMM03S0 +increpemos increpar VMM01P0 +increpen increpar VMM03P0 +incrimina incriminar VMM02S0 +incriminad incriminar VMM02P0 +incriminando incriminar VMG0000 +incriminar incriminar VMN0000 +incrimine incriminar VMM03S0 +incriminemos incriminar VMM01P0 +incriminen incriminar VMM03P0 +incrusta incrustar VMM02S0 +incrustad incrustar VMM02P0 +incrustando incrustar VMG0000 +incrustar incrustar VMN0000 +incruste incrustar VMM03S0 +incrustemos incrustar VMM01P0 +incrusten incrustar VMM03P0 +incuba incubar VMM02S0 +incubad incubar VMM02P0 +incubando incubar VMG0000 +incubar incubar VMN0000 +incube incubar VMM03S0 +incubemos incubar VMM01P0 +incuben incubar VMM03P0 +inculca inculcar VMM02S0 +inculcad inculcar VMM02P0 +inculcando inculcar VMG0000 +inculcar inculcar VMN0000 +inculpa inculpar VMM02S0 +inculpad inculpar VMM02P0 +inculpando inculpar VMG0000 +inculpar inculpar VMN0000 +inculpe inculpar VMM03S0 +inculpemos inculpar VMM01P0 +inculpen inculpar VMM03P0 +inculque inculcar VMM03S0 +inculquemos inculcar VMM01P0 +inculquen inculcar VMM03P0 +incumba incumbir VMM03S0 +incumbamos incumbir VMM01P0 +incumban incumbir VMM03P0 +incumbe incumbir VMM02S0 +incumbid incumbir VMM02P0 +incumbiendo incumbir VMG0000 +incumbir incumbir VMN0000 +incumpla incumplir VMM03S0 +incumplamos incumplir VMM01P0 +incumplan incumplir VMM03P0 +incumple incumplir VMM02S0 +incumplid incumplir VMM02P0 +incumpliendo incumplir VMG0000 +incumplir incumplir VMN0000 +incurra incurrir VMM03S0 +incurramos incurrir VMM01P0 +incurran incurrir VMM03P0 +incurre incurrir VMM02S0 +incurrid incurrir VMM02P0 +incurriendo incurrir VMG0000 +incurrir incurrir VMN0000 +incursiona incursionar VMM02S0 +incursionad incursionar VMM02P0 +incursionando incursionar VMG0000 +incursionar incursionar VMN0000 +incursione incursionar VMM03S0 +incursionemos incursionar VMM01P0 +incursionen incursionar VMM03P0 +indaga indagar VMM02S0 +indagad indagar VMM02P0 +indagando indagar VMG0000 +indagar indagar VMN0000 +indague indagar VMM03S0 +indaguemos indagar VMM01P0 +indaguen indagar VMM03P0 +indemnice indemnizar VMM03S0 +indemnicemos indemnizar VMM01P0 +indemnicen indemnizar VMM03P0 +indemniza indemnizar VMM02S0 +indemnizad indemnizar VMM02P0 +indemnizando indemnizar VMG0000 +indemnizar indemnizar VMN0000 +independice independizar VMM03S0 +independicemos independizar VMM01P0 +independicen independizar VMM03P0 +independiza independizar VMM02S0 +independizad independizar VMM02P0 +independizando independizar VMG0000 +independizar independizar VMN0000 +indexa indexar VMM02S0 +indexad indexar VMM02P0 +indexando indexar VMG0000 +indexar indexar VMN0000 +indexe indexar VMM03S0 +indexemos indexar VMM01P0 +indexen indexar VMM03P0 +indica indicar VMM02S0 +indicad indicar VMM02P0 +indicando indicar VMG0000 +indicar indicar VMN0000 +indicia indiciar VMM02S0 +indiciad indiciar VMM02P0 +indiciando indiciar VMG0000 +indiciar indiciar VMN0000 +indicie indiciar VMM03S0 +indiciemos indiciar VMM01P0 +indicien indiciar VMM03P0 +indigesta indigestar VMM02S0 +indigestad indigestar VMM02P0 +indigestando indigestar VMG0000 +indigestar indigestar VMN0000 +indigeste indigestar VMM03S0 +indigestemos indigestar VMM01P0 +indigesten indigestar VMM03P0 +indigna indignar VMM02S0 +indignad indignar VMM02P0 +indignando indignar VMG0000 +indignar indignar VMN0000 +indigne indignar VMM03S0 +indignemos indignar VMM01P0 +indignen indignar VMM03P0 +indique indicar VMM03S0 +indiquemos indicar VMM01P0 +indiquen indicar VMM03P0 +indisciplina indisciplinar VMM02S0 +indisciplinad indisciplinar VMM02P0 +indisciplinando indisciplinar VMG0000 +indisciplinar indisciplinar VMN0000 +indiscipline indisciplinar VMM03S0 +indisciplinemos indisciplinar VMM01P0 +indisciplinen indisciplinar VMM03P0 +indisponed indisponer VMM02P0 +indisponer indisponer VMN0000 +indisponga indisponer VMM03S0 +indispongamos indisponer VMM01P0 +indispongan indisponer VMM03P0 +indisponiendo indisponer VMG0000 +indispón indisponer VMM02S0 +individuad individuar VMM02P0 +individualice individualizar VMM03S0 +individualicemos individualizar VMM01P0 +individualicen individualizar VMM03P0 +individualiza individualizar VMM02S0 +individualizad individualizar VMM02P0 +individualizando individualizar VMG0000 +individualizar individualizar VMN0000 +individuando individuar VMG0000 +individuar individuar VMN0000 +individuemos individuar VMM01P0 +individúa individuar VMM02S0 +individúe individuar VMM03S0 +individúen individuar VMM03P0 +induce inducir VMM02S0 +inducid inducir VMM02P0 +induciendo inducir VMG0000 +inducir inducir VMN0000 +indulgencia indulgenciar VMM02S0 +indulgenciad indulgenciar VMM02P0 +indulgenciando indulgenciar VMG0000 +indulgenciar indulgenciar VMN0000 +indulgencie indulgenciar VMM03S0 +indulgenciemos indulgenciar VMM01P0 +indulgencien indulgenciar VMM03P0 +indulta indultar VMM02S0 +indultad indultar VMM02P0 +indultando indultar VMG0000 +indultar indultar VMN0000 +indulte indultar VMM03S0 +indultemos indultar VMM01P0 +indulten indultar VMM03P0 +indura indurar VMM02S0 +indurad indurar VMM02P0 +indurando indurar VMG0000 +indurar indurar VMN0000 +indure indurar VMM03S0 +induremos indurar VMM01P0 +induren indurar VMM03P0 +industria industriar VMM02S0 +industriad industriar VMM02P0 +industrialice industrializar VMM03S0 +industrialicemos industrializar VMM01P0 +industrialicen industrializar VMM03P0 +industrializa industrializar VMM02S0 +industrializad industrializar VMM02P0 +industrializando industrializar VMG0000 +industrializar industrializar VMN0000 +industriando industriar VMG0000 +industriar industriar VMN0000 +industrie industriar VMM03S0 +industriemos industriar VMM01P0 +industrien industriar VMM03P0 +induzca inducir VMM03S0 +induzcamos inducir VMM01P0 +induzcan inducir VMM03P0 +inerva inervar VMM02S0 +inervad inervar VMM02P0 +inervando inervar VMG0000 +inervar inervar VMN0000 +inerve inervar VMM03S0 +inervemos inervar VMM01P0 +inerven inervar VMM03P0 +infama infamar VMM02S0 +infamad infamar VMM02P0 +infamando infamar VMG0000 +infamar infamar VMN0000 +infame infamar VMM03S0 +infamemos infamar VMM01P0 +infamen infamar VMM03P0 +infarta infartar VMM02S0 +infartad infartar VMM02P0 +infartando infartar VMG0000 +infartar infartar VMN0000 +infarte infartar VMM03S0 +infartemos infartar VMM01P0 +infarten infartar VMM03P0 +infatuad infatuar VMM02P0 +infatuando infatuar VMG0000 +infatuar infatuar VMN0000 +infatuemos infatuar VMM01P0 +infatúa infatuar VMM02S0 +infatúe infatuar VMM03S0 +infatúen infatuar VMM03P0 +infecta infectar VMM02S0 +infectad infectar VMM02P0 +infectando infectar VMG0000 +infectar infectar VMN0000 +infecte infectar VMM03S0 +infectemos infectar VMM01P0 +infecten infectar VMM03P0 +inferid inferir VMM02P0 +inferir inferir VMN0000 +infesta infestar VMM02S0 +infestad infestar VMM02P0 +infestando infestar VMG0000 +infestar infestar VMN0000 +infeste infestar VMM03S0 +infestemos infestar VMM01P0 +infesten infestar VMM03P0 +infibula infibular VMM02S0 +infibulad infibular VMM02P0 +infibulando infibular VMG0000 +infibular infibular VMN0000 +infibule infibular VMM03S0 +infibulemos infibular VMM01P0 +infibulen infibular VMM03P0 +inficiona inficionar VMM02S0 +inficionad inficionar VMM02P0 +inficionando inficionar VMG0000 +inficionar inficionar VMN0000 +inficione inficionar VMM03S0 +inficionemos inficionar VMM01P0 +inficionen inficionar VMM03P0 +infiera inferir VMM03S0 +infieran inferir VMM03P0 +infiere inferir VMM02S0 +infiltra infiltrar VMM02S0 +infiltrad infiltrar VMM02P0 +infiltrando infiltrar VMG0000 +infiltrar infiltrar VMN0000 +infiltre infiltrar VMM03S0 +infiltremos infiltrar VMM01P0 +infiltren infiltrar VMM03P0 +infiramos inferir VMM01P0 +infiriendo inferir VMG0000 +infirma infirmar VMM02S0 +infirmad infirmar VMM02P0 +infirmando infirmar VMG0000 +infirmar infirmar VMN0000 +infirme infirmar VMM03S0 +infirmemos infirmar VMM01P0 +infirmen infirmar VMM03P0 +infla inflar VMM02S0 +inflad inflar VMM02P0 +inflama inflamar VMM02S0 +inflamad inflamar VMM02P0 +inflamando inflamar VMG0000 +inflamar inflamar VMN0000 +inflame inflamar VMM03S0 +inflamemos inflamar VMM01P0 +inflamen inflamar VMM03P0 +inflando inflar VMG0000 +inflar inflar VMN0000 +infle inflar VMM03S0 +inflemos inflar VMM01P0 +inflen inflar VMM03P0 +inflige infligir VMM02S0 +infligid infligir VMM02P0 +infligiendo infligir VMG0000 +infligir infligir VMN0000 +inflija infligir VMM03S0 +inflijamos infligir VMM01P0 +inflijan infligir VMM03P0 +influencia influenciar VMM02S0 +influenciad influenciar VMM02P0 +influenciando influenciar VMG0000 +influenciar influenciar VMN0000 +influencie influenciar VMM03S0 +influenciemos influenciar VMM01P0 +influencien influenciar VMM03P0 +influid influir VMM02P0 +influir influir VMN0000 +influya influir VMM03S0 +influyamos influir VMM01P0 +influyan influir VMM03P0 +influye influir VMM02S0 +influyendo influir VMG0000 +informa informar VMM02S0 +informad informar VMM02P0 +informando informar VMG0000 +informar informar VMN0000 +informatice informatizar VMM03S0 +informaticemos informatizar VMM01P0 +informaticen informatizar VMM03P0 +informatiza informatizar VMM02S0 +informatizad informatizar VMM02P0 +informatizando informatizar VMG0000 +informatizar informatizar VMN0000 +informe informar VMM03S0 +informemos informar VMM01P0 +informen informar VMM03P0 +infrautilice infrautilizar VMM03S0 +infrautilicemos infrautilizar VMM01P0 +infrautilicen infrautilizar VMM03P0 +infrautiliza infrautilizar VMM02S0 +infrautilizad infrautilizar VMM02P0 +infrautilizando infrautilizar VMG0000 +infrautilizar infrautilizar VMN0000 +infravalora infravalorar VMM02S0 +infravalorad infravalorar VMM02P0 +infravalorando infravalorar VMG0000 +infravalorar infravalorar VMN0000 +infravalore infravalorar VMM03S0 +infravaloremos infravalorar VMM01P0 +infravaloren infravalorar VMM03P0 +infringe infringir VMM02S0 +infringid infringir VMM02P0 +infringiendo infringir VMG0000 +infringir infringir VMN0000 +infrinja infringir VMM03S0 +infrinjamos infringir VMM01P0 +infrinjan infringir VMM03P0 +infunda infundir VMM03S0 +infundamos infundir VMM01P0 +infundan infundir VMM03P0 +infunde infundir VMM02S0 +infundid infundir VMM02P0 +infundiendo infundir VMG0000 +infundir infundir VMN0000 +ingenia ingeniar VMM02S0 +ingeniad ingeniar VMM02P0 +ingeniando ingeniar VMG0000 +ingeniar ingeniar VMN0000 +ingenie ingeniar VMM03S0 +ingeniemos ingeniar VMM01P0 +ingenien ingeniar VMM03P0 +ingerid ingerir VMM02P0 +ingerir ingerir VMN0000 +ingiera ingerir VMM03S0 +ingieran ingerir VMM03P0 +ingiere ingerir VMM02S0 +ingiramos ingerir VMM01P0 +ingiriendo ingerir VMG0000 +ingresa ingresar VMM02S0 +ingresad ingresar VMM02P0 +ingresando ingresar VMG0000 +ingresar ingresar VMN0000 +ingrese ingresar VMM03S0 +ingresemos ingresar VMM01P0 +ingresen ingresar VMM03P0 +ingurgita ingurgitar VMM02S0 +ingurgitad ingurgitar VMM02P0 +ingurgitando ingurgitar VMG0000 +ingurgitar ingurgitar VMN0000 +ingurgite ingurgitar VMM03S0 +ingurgitemos ingurgitar VMM01P0 +ingurgiten ingurgitar VMM03P0 +inhabilita inhabilitar VMM02S0 +inhabilitad inhabilitar VMM02P0 +inhabilitando inhabilitar VMG0000 +inhabilitar inhabilitar VMN0000 +inhabilite inhabilitar VMM03S0 +inhabilitemos inhabilitar VMM01P0 +inhabiliten inhabilitar VMM03P0 +inhala inhalar VMM02S0 +inhalad inhalar VMM02P0 +inhalando inhalar VMG0000 +inhalar inhalar VMN0000 +inhale inhalar VMM03S0 +inhalemos inhalar VMM01P0 +inhalen inhalar VMM03P0 +inhiba inhibir VMM03S0 +inhibamos inhibir VMM01P0 +inhiban inhibir VMM03P0 +inhibe inhibir VMM02S0 +inhibid inhibir VMM02P0 +inhibiendo inhibir VMG0000 +inhibir inhibir VMN0000 +inhuma inhumar VMM02S0 +inhumad inhumar VMM02P0 +inhumando inhumar VMG0000 +inhumar inhumar VMN0000 +inhume inhumar VMM03S0 +inhumemos inhumar VMM01P0 +inhumen inhumar VMM03P0 +inicia iniciar VMM02S0 +iniciad iniciar VMM02P0 +inicialice inicializar VMM03S0 +inicialicemos inicializar VMM01P0 +inicialicen inicializar VMM03P0 +inicializa inicializar VMM02S0 +inicializad inicializar VMM02P0 +inicializando inicializar VMG0000 +inicializar inicializar VMN0000 +iniciando iniciar VMG0000 +iniciar iniciar VMN0000 +inicie iniciar VMM03S0 +iniciemos iniciar VMM01P0 +inicien iniciar VMM03P0 +injerid injerir VMM02P0 +injerir injerir VMN0000 +injerta injertar VMM02S0 +injertad injertar VMM02P0 +injertando injertar VMG0000 +injertar injertar VMN0000 +injerte injertar VMM03S0 +injertemos injertar VMM01P0 +injerten injertar VMM03P0 +injiera injerir VMM03S0 +injieran injerir VMM03P0 +injiere injerir VMM02S0 +injiramos injerir VMM01P0 +injiriendo injerir VMG0000 +injuria injuriar VMM02S0 +injuriad injuriar VMM02P0 +injuriando injuriar VMG0000 +injuriar injuriar VMN0000 +injurie injuriar VMM03S0 +injuriemos injuriar VMM01P0 +injurien injuriar VMM03P0 +inmerge inmergir VMM02S0 +inmergid inmergir VMM02P0 +inmergiendo inmergir VMG0000 +inmergir inmergir VMN0000 +inmerja inmergir VMM03S0 +inmerjamos inmergir VMM01P0 +inmerjan inmergir VMM03P0 +inmigra inmigrar VMM02S0 +inmigrad inmigrar VMM02P0 +inmigrando inmigrar VMG0000 +inmigrar inmigrar VMN0000 +inmigre inmigrar VMM03S0 +inmigremos inmigrar VMM01P0 +inmigren inmigrar VMM03P0 +inmiscuid inmiscuir VMM02P0 +inmiscuir inmiscuir VMN0000 +inmiscuya inmiscuir VMM03S0 +inmiscuyamos inmiscuir VMM01P0 +inmiscuyan inmiscuir VMM03P0 +inmiscuye inmiscuir VMM02S0 +inmiscuyendo inmiscuir VMG0000 +inmola inmolar VMM02S0 +inmolad inmolar VMM02P0 +inmolando inmolar VMG0000 +inmolar inmolar VMN0000 +inmole inmolar VMM03S0 +inmolemos inmolar VMM01P0 +inmolen inmolar VMM03P0 +inmortalice inmortalizar VMM03S0 +inmortalicemos inmortalizar VMM01P0 +inmortalicen inmortalizar VMM03P0 +inmortaliza inmortalizar VMM02S0 +inmortalizad inmortalizar VMM02P0 +inmortalizando inmortalizar VMG0000 +inmortalizar inmortalizar VMN0000 +inmovilice inmovilizar VMM03S0 +inmovilicemos inmovilizar VMM01P0 +inmovilicen inmovilizar VMM03P0 +inmoviliza inmovilizar VMM02S0 +inmovilizad inmovilizar VMM02P0 +inmovilizando inmovilizar VMG0000 +inmovilizar inmovilizar VMN0000 +inmunice inmunizar VMM03S0 +inmunicemos inmunizar VMM01P0 +inmunicen inmunizar VMM03P0 +inmuniza inmunizar VMM02S0 +inmunizad inmunizar VMM02P0 +inmunizando inmunizar VMG0000 +inmunizar inmunizar VMN0000 +inmuta inmutar VMM02S0 +inmutad inmutar VMM02P0 +inmutando inmutar VMG0000 +inmutar inmutar VMN0000 +inmute inmutar VMM03S0 +inmutemos inmutar VMM01P0 +inmuten inmutar VMM03P0 +innova innovar VMM02S0 +innovad innovar VMM02P0 +innovando innovar VMG0000 +innovar innovar VMN0000 +innove innovar VMM03S0 +innovemos innovar VMM01P0 +innoven innovar VMM03P0 +inocula inocular VMM02S0 +inoculad inocular VMM02P0 +inoculando inocular VMG0000 +inocular inocular VMN0000 +inocule inocular VMM03S0 +inoculemos inocular VMM01P0 +inoculen inocular VMM03P0 +inquiera inquirir VMM03S0 +inquieran inquirir VMM03P0 +inquiere inquirir VMM02S0 +inquieta inquietar VMM02S0 +inquietad inquietar VMM02P0 +inquietando inquietar VMG0000 +inquietar inquietar VMN0000 +inquiete inquietar VMM03S0 +inquietemos inquietar VMM01P0 +inquieten inquietar VMM03P0 +inquiramos inquirir VMM01P0 +inquirid inquirir VMM02P0 +inquiriendo inquirir VMG0000 +inquirir inquirir VMN0000 +insacula insacular VMM02S0 +insaculad insacular VMM02P0 +insaculando insacular VMG0000 +insacular insacular VMN0000 +insacule insacular VMM03S0 +insaculemos insacular VMM01P0 +insaculen insacular VMM03P0 +insaliva insalivar VMM02S0 +insalivad insalivar VMM02P0 +insalivando insalivar VMG0000 +insalivar insalivar VMN0000 +insalive insalivar VMM03S0 +insalivemos insalivar VMM01P0 +insaliven insalivar VMM03P0 +inscriba inscribir VMM03S0 +inscribamos inscribir VMM01P0 +inscriban inscribir VMM03P0 +inscribe inscribir VMM02S0 +inscribid inscribir VMM02P0 +inscribiendo inscribir VMG0000 +inscribir inscribir VMN0000 +insemina inseminar VMM02S0 +inseminad inseminar VMM02P0 +inseminando inseminar VMG0000 +inseminar inseminar VMN0000 +insemine inseminar VMM03S0 +inseminemos inseminar VMM01P0 +inseminen inseminar VMM03P0 +insensibilice insensibilizar VMM03S0 +insensibilicemos insensibilizar VMM01P0 +insensibilicen insensibilizar VMM03P0 +insensibiliza insensibilizar VMM02S0 +insensibilizad insensibilizar VMM02P0 +insensibilizando insensibilizar VMG0000 +insensibilizar insensibilizar VMN0000 +inserid inserir VMM02P0 +inserir inserir VMN0000 +inserta insertar VMM02S0 +insertad insertar VMM02P0 +insertando insertar VMG0000 +insertar insertar VMN0000 +inserte insertar VMM03S0 +insertemos insertar VMM01P0 +inserten insertar VMM03P0 +insidia insidiar VMM02S0 +insidiad insidiar VMM02P0 +insidiando insidiar VMG0000 +insidiar insidiar VMN0000 +insidie insidiar VMM03S0 +insidiemos insidiar VMM01P0 +insidien insidiar VMM03P0 +insiera inserir VMM03S0 +insieran inserir VMM03P0 +insiere inserir VMM02S0 +insinuad insinuar VMM02P0 +insinuando insinuar VMG0000 +insinuar insinuar VMN0000 +insinuemos insinuar VMM01P0 +insinúa insinuar VMM02S0 +insinúe insinuar VMM03S0 +insinúen insinuar VMM03P0 +insiramos inserir VMM01P0 +insiriendo inserir VMG0000 +insista insistir VMM03S0 +insistamos insistir VMM01P0 +insistan insistir VMM03P0 +insiste insistir VMM02S0 +insistid insistir VMM02P0 +insistiendo insistir VMG0000 +insistir insistir VMN0000 +insola insolar VMM02S0 +insolad insolar VMM02P0 +insolando insolar VMG0000 +insolar insolar VMN0000 +insole insolar VMM03S0 +insolemos insolar VMM01P0 +insolen insolar VMM03P0 +insolenta insolentar VMM02S0 +insolentad insolentar VMM02P0 +insolentando insolentar VMG0000 +insolentar insolentar VMN0000 +insolente insolentar VMM03S0 +insolentemos insolentar VMM01P0 +insolenten insolentar VMM03P0 +insonorice insonorizar VMM03S0 +insonoricemos insonorizar VMM01P0 +insonoricen insonorizar VMM03P0 +insonoriza insonorizar VMM02S0 +insonorizad insonorizar VMM02P0 +insonorizando insonorizar VMG0000 +insonorizar insonorizar VMN0000 +inspecciona inspeccionar VMM02S0 +inspeccionad inspeccionar VMM02P0 +inspeccionando inspeccionar VMG0000 +inspeccionar inspeccionar VMN0000 +inspeccione inspeccionar VMM03S0 +inspeccionemos inspeccionar VMM01P0 +inspeccionen inspeccionar VMM03P0 +inspira inspirar VMM02S0 +inspirad inspirar VMM02P0 +inspirando inspirar VMG0000 +inspirar inspirar VMN0000 +inspire inspirar VMM03S0 +inspiremos inspirar VMM01P0 +inspiren inspirar VMM03P0 +insta instar VMM02S0 +instad instar VMM02P0 +instala instalar VMM02S0 +instalad instalar VMM02P0 +instalando instalar VMG0000 +instalar instalar VMN0000 +instale instalar VMM03S0 +instalemos instalar VMM01P0 +instalen instalar VMM03P0 +instando instar VMG0000 +instar instar VMN0000 +instaura instaurar VMM02S0 +instaurad instaurar VMM02P0 +instaurando instaurar VMG0000 +instaurar instaurar VMN0000 +instaure instaurar VMM03S0 +instauremos instaurar VMM01P0 +instauren instaurar VMM03P0 +inste instar VMM03S0 +instemos instar VMM01P0 +insten instar VMM03P0 +instiga instigar VMM02S0 +instigad instigar VMM02P0 +instigando instigar VMG0000 +instigar instigar VMN0000 +instigue instigar VMM03S0 +instiguemos instigar VMM01P0 +instiguen instigar VMM03P0 +instila instilar VMM02S0 +instilad instilar VMM02P0 +instilando instilar VMG0000 +instilar instilar VMN0000 +instile instilar VMM03S0 +instilemos instilar VMM01P0 +instilen instilar VMM03P0 +institucionalice institucionalizar VMM03S0 +institucionalicemos institucionalizar VMM01P0 +institucionalicen institucionalizar VMM03P0 +institucionaliza institucionalizar VMM02S0 +institucionalizad institucionalizar VMM02P0 +institucionalizando institucionalizar VMG0000 +institucionalizar institucionalizar VMN0000 +instituid instituir VMM02P0 +instituir instituir VMN0000 +instituya instituir VMM03S0 +instituyamos instituir VMM01P0 +instituyan instituir VMM03P0 +instituye instituir VMM02S0 +instituyendo instituir VMG0000 +instruid instruir VMM02P0 +instruir instruir VMN0000 +instrumenta instrumentar VMM02S0 +instrumentad instrumentar VMM02P0 +instrumentalice instrumentalizar VMM03S0 +instrumentalicemos instrumentalizar VMM01P0 +instrumentalicen instrumentalizar VMM03P0 +instrumentaliza instrumentalizar VMM02S0 +instrumentalizad instrumentalizar VMM02P0 +instrumentalizando instrumentalizar VMG0000 +instrumentalizar instrumentalizar VMN0000 +instrumentando instrumentar VMG0000 +instrumentar instrumentar VMN0000 +instrumente instrumentar VMM03S0 +instrumentemos instrumentar VMM01P0 +instrumenten instrumentar VMM03P0 +instruya instruir VMM03S0 +instruyamos instruir VMM01P0 +instruyan instruir VMM03P0 +instruye instruir VMM02S0 +instruyendo instruir VMG0000 +insubordina insubordinar VMM02S0 +insubordinad insubordinar VMM02P0 +insubordinando insubordinar VMG0000 +insubordinar insubordinar VMN0000 +insubordine insubordinar VMM03S0 +insubordinemos insubordinar VMM01P0 +insubordinen insubordinar VMM03P0 +insufla insuflar VMM02S0 +insuflad insuflar VMM02P0 +insuflando insuflar VMG0000 +insuflar insuflar VMN0000 +insufle insuflar VMM03S0 +insuflemos insuflar VMM01P0 +insuflen insuflar VMM03P0 +insulta insultar VMM02S0 +insultad insultar VMM02P0 +insultando insultar VMG0000 +insultar insultar VMN0000 +insulte insultar VMM03S0 +insultemos insultar VMM01P0 +insulten insultar VMM03P0 +insurrecciona insurreccionar VMM02S0 +insurreccionad insurreccionar VMM02P0 +insurreccionando insurreccionar VMG0000 +insurreccionar insurreccionar VMN0000 +insurreccione insurreccionar VMM03S0 +insurreccionemos insurreccionar VMM01P0 +insurreccionen insurreccionar VMM03P0 +integra integrar VMM02S0 +integrad integrar VMM02P0 +integrando integrar VMG0000 +integrar integrar VMN0000 +integre integrar VMM03S0 +integremos integrar VMM01P0 +integren integrar VMM03P0 +intensa intensar VMM02S0 +intensad intensar VMM02P0 +intensando intensar VMG0000 +intensar intensar VMN0000 +intense intensar VMM03S0 +intensemos intensar VMM01P0 +intensen intensar VMM03P0 +intensifica intensificar VMM02S0 +intensificad intensificar VMM02P0 +intensificando intensificar VMG0000 +intensificar intensificar VMN0000 +intensifique intensificar VMM03S0 +intensifiquemos intensificar VMM01P0 +intensifiquen intensificar VMM03P0 +intenta intentar VMM02S0 +intentad intentar VMM02P0 +intentando intentar VMG0000 +intentar intentar VMN0000 +intente intentar VMM03S0 +intentemos intentar VMM01P0 +intenten intentar VMM03P0 +interactuad interactuar VMM02P0 +interactuando interactuar VMG0000 +interactuar interactuar VMN0000 +interactuemos interactuar VMM01P0 +interactúa interactuar VMM02S0 +interactúe interactuar VMM03S0 +interactúen interactuar VMM03P0 +intercala intercalar VMM02S0 +intercalad intercalar VMM02P0 +intercalando intercalar VMG0000 +intercalar intercalar VMN0000 +intercale intercalar VMM03S0 +intercalemos intercalar VMM01P0 +intercalen intercalar VMM03P0 +intercambia intercambiar VMM02S0 +intercambiad intercambiar VMM02P0 +intercambiando intercambiar VMG0000 +intercambiar intercambiar VMN0000 +intercambie intercambiar VMM03S0 +intercambiemos intercambiar VMM01P0 +intercambien intercambiar VMM03P0 +interceda interceder VMM03S0 +intercedamos interceder VMM01P0 +intercedan interceder VMM03P0 +intercede interceder VMM02S0 +interceded interceder VMM02P0 +interceder interceder VMN0000 +intercediendo interceder VMG0000 +intercepta interceptar VMM02S0 +interceptad interceptar VMM02P0 +interceptando interceptar VMG0000 +interceptar interceptar VMN0000 +intercepte interceptar VMM03S0 +interceptemos interceptar VMM01P0 +intercepten interceptar VMM03P0 +interconecta interconectar VMM02S0 +interconectad interconectar VMM02P0 +interconectando interconectar VMG0000 +interconectar interconectar VMN0000 +interconecte interconectar VMM03S0 +interconectemos interconectar VMM01P0 +interconecten interconectar VMM03P0 +interesa interesar VMM02S0 +interesad interesar VMM02P0 +interesando interesar VMG0000 +interesar interesar VMN0000 +interese interesar VMM03S0 +interesemos interesar VMM01P0 +interesen interesar VMM03P0 +interferid interferir VMM02P0 +interferir interferir VMN0000 +interfiera interferir VMM03S0 +interfieran interferir VMM03P0 +interfiere interferir VMM02S0 +interfiramos interferir VMM01P0 +interfiriendo interferir VMG0000 +interfolia interfoliar VMM02S0 +interfoliad interfoliar VMM02P0 +interfoliando interfoliar VMG0000 +interfoliar interfoliar VMN0000 +interfolie interfoliar VMM03S0 +interfoliemos interfoliar VMM01P0 +interfolien interfoliar VMM03P0 +interlinea interlinear VMM02S0 +interlinead interlinear VMM02P0 +interlineando interlinear VMG0000 +interlinear interlinear VMN0000 +interlinee interlinear VMM03S0 +interlineemos interlinear VMM01P0 +interlineen interlinear VMM03P0 +intermedia intermediar VMM02S0 +intermediad intermediar VMM02P0 +intermediando intermediar VMG0000 +intermediar intermediar VMN0000 +intermedie intermediar VMM03S0 +intermediemos intermediar VMM01P0 +intermedien intermediar VMM03P0 +interna internar VMM02S0 +internacionalice internacionalizar VMM03S0 +internacionalicemos internacionalizar VMM01P0 +internacionalicen internacionalizar VMM03P0 +internacionaliza internacionalizar VMM02S0 +internacionalizad internacionalizar VMM02P0 +internacionalizando internacionalizar VMG0000 +internacionalizar internacionalizar VMN0000 +internad internar VMM02P0 +internando internar VMG0000 +internar internar VMN0000 +interne internar VMM03S0 +internemos internar VMM01P0 +internen internar VMM03P0 +interpagina interpaginar VMM02S0 +interpaginad interpaginar VMM02P0 +interpaginando interpaginar VMG0000 +interpaginar interpaginar VMN0000 +interpagine interpaginar VMM03S0 +interpaginemos interpaginar VMM01P0 +interpaginen interpaginar VMM03P0 +interpela interpelar VMM02S0 +interpelad interpelar VMM02P0 +interpelando interpelar VMG0000 +interpelar interpelar VMN0000 +interpele interpelar VMM03S0 +interpelemos interpelar VMM01P0 +interpelen interpelar VMM03P0 +interpola interpolar VMM02S0 +interpolad interpolar VMM02P0 +interpolando interpolar VMG0000 +interpolar interpolar VMN0000 +interpole interpolar VMM03S0 +interpolemos interpolar VMM01P0 +interpolen interpolar VMM03P0 +interponed interponer VMM02P0 +interponer interponer VMN0000 +interponga interponer VMM03S0 +interpongamos interponer VMM01P0 +interpongan interponer VMM03P0 +interponiendo interponer VMG0000 +interpreta interpretar VMM02S0 +interpretad interpretar VMM02P0 +interpretando interpretar VMG0000 +interpretar interpretar VMN0000 +interprete interpretar VMM03S0 +interpretemos interpretar VMM01P0 +interpreten interpretar VMM03P0 +interpón interponer VMM02S0 +interrelaciona interrelacionar VMM02S0 +interrelacionad interrelacionar VMM02P0 +interrelacionando interrelacionar VMG0000 +interrelacionar interrelacionar VMN0000 +interrelacione interrelacionar VMM03S0 +interrelacionemos interrelacionar VMM01P0 +interrelacionen interrelacionar VMM03P0 +interroga interrogar VMM02S0 +interrogad interrogar VMM02P0 +interrogando interrogar VMG0000 +interrogar interrogar VMN0000 +interrogue interrogar VMM03S0 +interroguemos interrogar VMM01P0 +interroguen interrogar VMM03P0 +interrumpa interrumpir VMM03S0 +interrumpamos interrumpir VMM01P0 +interrumpan interrumpir VMM03P0 +interrumpe interrumpir VMM02S0 +interrumpid interrumpir VMM02P0 +interrumpiendo interrumpir VMG0000 +interrumpir interrumpir VMN0000 +interseca intersecar VMM02S0 +intersecad intersecar VMM02P0 +intersecando intersecar VMG0000 +intersecar intersecar VMN0000 +interseque intersecar VMM03S0 +intersequemos intersecar VMM01P0 +intersequen intersecar VMM03P0 +interven intervenir VMM02S0 +intervenga intervenir VMM03S0 +intervengamos intervenir VMM01P0 +intervengan intervenir VMM03P0 +intervenid intervenir VMM02P0 +intervenir intervenir VMN0000 +interviniendo intervenir VMG0000 +interviuva interviuvar VMM02S0 +interviuvad interviuvar VMM02P0 +interviuvando interviuvar VMG0000 +interviuvar interviuvar VMN0000 +intesta intestar VMM02S0 +intestad intestar VMM02P0 +intestando intestar VMG0000 +intestar intestar VMN0000 +inteste intestar VMM03S0 +intestemos intestar VMM01P0 +intesten intestar VMM03P0 +intima intimar VMM02S0 +intimad intimar VMM02P0 +intimando intimar VMG0000 +intimar intimar VMN0000 +intime intimar VMM03S0 +intimemos intimar VMM01P0 +intimen intimar VMM03P0 +intimida intimidar VMM02S0 +intimidad intimidar VMM02P0 +intimidando intimidar VMG0000 +intimidar intimidar VMN0000 +intimide intimidar VMM03S0 +intimidemos intimidar VMM01P0 +intimiden intimidar VMM03P0 +intitula intitular VMM02S0 +intitulad intitular VMM02P0 +intitulando intitular VMG0000 +intitular intitular VMN0000 +intitule intitular VMM03S0 +intitulemos intitular VMM01P0 +intitulen intitular VMM03P0 +intoxica intoxicar VMM02S0 +intoxicad intoxicar VMM02P0 +intoxicando intoxicar VMG0000 +intoxicar intoxicar VMN0000 +intoxique intoxicar VMM03S0 +intoxiquemos intoxicar VMM01P0 +intoxiquen intoxicar VMM03P0 +intranquilice intranquilizar VMM03S0 +intranquilicemos intranquilizar VMM01P0 +intranquilicen intranquilizar VMM03P0 +intranquiliza intranquilizar VMM02S0 +intranquilizad intranquilizar VMM02P0 +intranquilizando intranquilizar VMG0000 +intranquilizar intranquilizar VMN0000 +intriga intrigar VMM02S0 +intrigad intrigar VMM02P0 +intrigando intrigar VMG0000 +intrigar intrigar VMN0000 +intrigue intrigar VMM03S0 +intriguemos intrigar VMM01P0 +intriguen intrigar VMM03P0 +intrinca intrincar VMM02S0 +intrincad intrincar VMM02P0 +intrincando intrincar VMG0000 +intrincar intrincar VMN0000 +intrinque intrincar VMM03S0 +intrinquemos intrincar VMM01P0 +intrinquen intrincar VMM03P0 +introduce introducir VMM02S0 +introducid introducir VMM02P0 +introduciendo introducir VMG0000 +introducir introducir VMN0000 +introduzca introducir VMM03S0 +introduzcamos introducir VMM01P0 +introduzcan introducir VMM03P0 +intuba intubar VMM02S0 +intubad intubar VMM02P0 +intubando intubar VMG0000 +intubar intubar VMN0000 +intube intubar VMM03S0 +intubemos intubar VMM01P0 +intuben intubar VMM03P0 +intuid intuir VMM02P0 +intuir intuir VMN0000 +intuya intuir VMM03S0 +intuyamos intuir VMM01P0 +intuyan intuir VMM03P0 +intuye intuir VMM02S0 +intuyendo intuir VMG0000 +inunda inundar VMM02S0 +inundad inundar VMM02P0 +inundando inundar VMG0000 +inundar inundar VMN0000 +inunde inundar VMM03S0 +inundemos inundar VMM01P0 +inunden inundar VMM03P0 +inutilice inutilizar VMM03S0 +inutilicemos inutilizar VMM01P0 +inutilicen inutilizar VMM03P0 +inutiliza inutilizar VMM02S0 +inutilizad inutilizar VMM02P0 +inutilizando inutilizar VMG0000 +inutilizar inutilizar VMN0000 +invada invadir VMM03S0 +invadamos invadir VMM01P0 +invadan invadir VMM03P0 +invade invadir VMM02S0 +invadid invadir VMM02P0 +invadiendo invadir VMG0000 +invadir invadir VMN0000 +invagina invaginar VMM02S0 +invaginad invaginar VMM02P0 +invaginando invaginar VMG0000 +invaginar invaginar VMN0000 +invagine invaginar VMM03S0 +invaginemos invaginar VMM01P0 +invaginen invaginar VMM03P0 +invalida invalidar VMM02S0 +invalidad invalidar VMM02P0 +invalidando invalidar VMG0000 +invalidar invalidar VMN0000 +invalide invalidar VMM03S0 +invalidemos invalidar VMM01P0 +invaliden invalidar VMM03P0 +inventa inventar VMM02S0 +inventad inventar VMM02P0 +inventando inventar VMG0000 +inventar inventar VMN0000 +inventariad inventariar VMM02P0 +inventariando inventariar VMG0000 +inventariar inventariar VMN0000 +inventariemos inventariar VMM01P0 +inventaría inventariar VMM02S0 +inventaríe inventariar VMM03S0 +inventaríen inventariar VMM03P0 +invente inventar VMM03S0 +inventemos inventar VMM01P0 +inventen inventar VMM03P0 +inverna invernar VMM02S0 +invernad invernar VMM02P0 +invernando invernar VMG0000 +invernar invernar VMN0000 +inverne invernar VMM03S0 +invernemos invernar VMM01P0 +invernen invernar VMM03P0 +invertid invertir VMM02P0 +invertir invertir VMN0000 +investid investir VMM02P0 +investiga investigar VMM02S0 +investigad investigar VMM02P0 +investigando investigar VMG0000 +investigar investigar VMN0000 +investigue investigar VMM03S0 +investiguemos investigar VMM01P0 +investiguen investigar VMM03P0 +investir investir VMN0000 +invierta invertir VMM03S0 +inviertan invertir VMM03P0 +invierte invertir VMM02S0 +invirtamos invertir VMM01P0 +invirtiendo invertir VMG0000 +invista investir VMM03S0 +invistamos investir VMM01P0 +invistan investir VMM03P0 +inviste investir VMM02S0 +invistiendo investir VMG0000 +invita invitar VMM02S0 +invitad invitar VMM02P0 +invitando invitar VMG0000 +invitar invitar VMN0000 +invite invitar VMM03S0 +invitemos invitar VMM01P0 +inviten invitar VMM03P0 +invoca invocar VMM02S0 +invocad invocar VMM02P0 +invocando invocar VMG0000 +invocar invocar VMN0000 +involucra involucrar VMM02S0 +involucrad involucrar VMM02P0 +involucrando involucrar VMG0000 +involucrar involucrar VMN0000 +involucre involucrar VMM03S0 +involucremos involucrar VMM01P0 +involucren involucrar VMM03P0 +invoque invocar VMM03S0 +invoquemos invocar VMM01P0 +invoquen invocar VMM03P0 +inyecta inyectar VMM02S0 +inyectad inyectar VMM02P0 +inyectando inyectar VMG0000 +inyectar inyectar VMN0000 +inyecte inyectar VMM03S0 +inyectemos inyectar VMM01P0 +inyecten inyectar VMM03P0 +ionice ionizar VMM03S0 +ionicemos ionizar VMM01P0 +ionicen ionizar VMM03P0 +ioniza ionizar VMM02S0 +ionizad ionizar VMM02P0 +ionizando ionizar VMG0000 +ionizar ionizar VMN0000 +ir ir VMN0000 +irga erguir VMM03S0 +irgamos erguir VMM01P0 +irgan erguir VMM03P0 +irgue erguir VMM02S0 +irguiendo erguir VMG0000 +irisa irisar VMM02S0 +irisad irisar VMM02P0 +irisando irisar VMG0000 +irisar irisar VMN0000 +irise irisar VMM03S0 +irisemos irisar VMM01P0 +irisen irisar VMM03P0 +ironice ironizar VMM03S0 +ironicemos ironizar VMM01P0 +ironicen ironizar VMM03P0 +ironiza ironizar VMM02S0 +ironizad ironizar VMM02P0 +ironizando ironizar VMG0000 +ironizar ironizar VMN0000 +irradia irradiar VMM02S0 +irradiad irradiar VMM02P0 +irradiando irradiar VMG0000 +irradiar irradiar VMN0000 +irradie irradiar VMM03S0 +irradiemos irradiar VMM01P0 +irradien irradiar VMM03P0 +irriga irrigar VMM02S0 +irrigad irrigar VMM02P0 +irrigando irrigar VMG0000 +irrigar irrigar VMN0000 +irrigue irrigar VMM03S0 +irriguemos irrigar VMM01P0 +irriguen irrigar VMM03P0 +irrita irritar VMM02S0 +irritad irritar VMM02P0 +irritando irritar VMG0000 +irritar irritar VMN0000 +irrite irritar VMM03S0 +irritemos irritar VMM01P0 +irriten irritar VMM03P0 +irroga irrogar VMM02S0 +irrogad irrogar VMM02P0 +irrogando irrogar VMG0000 +irrogar irrogar VMN0000 +irrogue irrogar VMM03S0 +irroguemos irrogar VMM01P0 +irroguen irrogar VMM03P0 +irrumpa irrumpir VMM03S0 +irrumpamos irrumpir VMM01P0 +irrumpan irrumpir VMM03P0 +irrumpe irrumpir VMM02S0 +irrumpid irrumpir VMM02P0 +irrumpiendo irrumpir VMG0000 +irrumpir irrumpir VMN0000 +islamice islamizar VMM03S0 +islamicemos islamizar VMM01P0 +islamicen islamizar VMM03P0 +islamiza islamizar VMM02S0 +islamizad islamizar VMM02P0 +islamizando islamizar VMG0000 +islamizar islamizar VMN0000 +italianice italianizar VMM03S0 +italianicemos italianizar VMM01P0 +italianicen italianizar VMM03P0 +italianiza italianizar VMM02S0 +italianizad italianizar VMM02P0 +italianizando italianizar VMG0000 +italianizar italianizar VMN0000 +itera iterar VMM02S0 +iterad iterar VMM02P0 +iterando iterar VMG0000 +iterar iterar VMN0000 +itere iterar VMM03S0 +iteremos iterar VMM01P0 +iteren iterar VMM03P0 +iza izar VMM02S0 +izad izar VMM02P0 +izando izar VMG0000 +izar izar VMN0000 +izquierdea izquierdear VMM02S0 +izquierdead izquierdear VMM02P0 +izquierdeando izquierdear VMG0000 +izquierdear izquierdear VMN0000 +izquierdee izquierdear VMM03S0 +izquierdeemos izquierdear VMM01P0 +izquierdeen izquierdear VMM03P0 +jabalcona jabalconar VMM02S0 +jabalconad jabalconar VMM02P0 +jabalconando jabalconar VMG0000 +jabalconar jabalconar VMN0000 +jabalcone jabalconar VMM03S0 +jabalconemos jabalconar VMM01P0 +jabalconen jabalconar VMM03P0 +jabardea jabardear VMM02S0 +jabardead jabardear VMM02P0 +jabardeando jabardear VMG0000 +jabardear jabardear VMN0000 +jabardee jabardear VMM03S0 +jabardeemos jabardear VMM01P0 +jabardeen jabardear VMM03P0 +jabona jabonar VMM02S0 +jabonad jabonar VMM02P0 +jabonando jabonar VMG0000 +jabonar jabonar VMN0000 +jabone jabonar VMM03S0 +jabonemos jabonar VMM01P0 +jabonen jabonar VMM03P0 +jacarea jacarear VMM02S0 +jacaread jacarear VMM02P0 +jacareando jacarear VMG0000 +jacarear jacarear VMN0000 +jacaree jacarear VMM03S0 +jacareemos jacarear VMM01P0 +jacareen jacarear VMM03P0 +jacta jactar VMM02S0 +jactad jactar VMM02P0 +jactando jactar VMG0000 +jactar jactar VMN0000 +jacte jactar VMM03S0 +jactemos jactar VMM01P0 +jacten jactar VMM03P0 +jadea jadear VMM02S0 +jadead jadear VMM02P0 +jadeando jadear VMG0000 +jadear jadear VMN0000 +jadee jadear VMM03S0 +jadeemos jadear VMM01P0 +jadeen jadear VMM03P0 +jaece jaezar VMM03S0 +jaecemos jaezar VMM01P0 +jaecen jaezar VMM03P0 +jaeza jaezar VMM02S0 +jaezad jaezar VMM02P0 +jaezando jaezar VMG0000 +jaezar jaezar VMN0000 +jaharra jaharrar VMM02S0 +jaharrad jaharrar VMM02P0 +jaharrando jaharrar VMG0000 +jaharrar jaharrar VMN0000 +jaharre jaharrar VMM03S0 +jaharremos jaharrar VMM01P0 +jaharren jaharrar VMM03P0 +jala jalar VMM02S0 +jalad jalar VMM02P0 +jalando jalar VMG0000 +jalar jalar VMN0000 +jalbega jalbegar VMM02S0 +jalbegad jalbegar VMM02P0 +jalbegando jalbegar VMG0000 +jalbegar jalbegar VMN0000 +jalbegue jalbegar VMM03S0 +jalbeguemos jalbegar VMM01P0 +jalbeguen jalbegar VMM03P0 +jale jalar VMM03S0 +jalea jalear VMM02S0 +jalead jalear VMM02P0 +jaleando jalear VMG0000 +jalear jalear VMN0000 +jalee jalear VMM03S0 +jaleemos jalear VMM01P0 +jaleen jalear VMM03P0 +jalemos jalar VMM01P0 +jalen jalar VMM03P0 +jalona jalonar VMM02S0 +jalonad jalonar VMM02P0 +jalonando jalonar VMG0000 +jalonar jalonar VMN0000 +jalone jalonar VMM03S0 +jalonemos jalonar VMM01P0 +jalonen jalonar VMM03P0 +jama jamar VMM02S0 +jamad jamar VMM02P0 +jamando jamar VMG0000 +jamar jamar VMN0000 +jame jamar VMM03S0 +jamemos jamar VMM01P0 +jamen jamar VMM03P0 +jaquea jaquear VMM02S0 +jaquead jaquear VMM02P0 +jaqueando jaquear VMG0000 +jaquear jaquear VMN0000 +jaquee jaquear VMM03S0 +jaqueemos jaquear VMM01P0 +jaqueen jaquear VMM03P0 +jarabea jarabear VMM02S0 +jarabead jarabear VMM02P0 +jarabeando jarabear VMG0000 +jarabear jarabear VMN0000 +jarabee jarabear VMM03S0 +jarabeemos jarabear VMM01P0 +jarabeen jarabear VMM03P0 +jaranea jaranear VMM02S0 +jaranead jaranear VMM02P0 +jaraneando jaranear VMG0000 +jaranear jaranear VMN0000 +jaranee jaranear VMM03S0 +jaraneemos jaranear VMM01P0 +jaraneen jaranear VMM03P0 +jarcia jarciar VMM02S0 +jarciad jarciar VMM02P0 +jarciando jarciar VMG0000 +jarciar jarciar VMN0000 +jarcie jarciar VMM03S0 +jarciemos jarciar VMM01P0 +jarcien jarciar VMM03P0 +jaropa jaropar VMM02S0 +jaropad jaropar VMM02P0 +jaropando jaropar VMG0000 +jaropar jaropar VMN0000 +jarope jaropar VMM03S0 +jaropea jaropear VMM02S0 +jaropead jaropear VMM02P0 +jaropeando jaropear VMG0000 +jaropear jaropear VMN0000 +jaropee jaropear VMM03S0 +jaropeemos jaropear VMM01P0 +jaropeen jaropear VMM03P0 +jaropemos jaropar VMM01P0 +jaropen jaropar VMM03P0 +jarrea jarrear VMM02S0 +jarread jarrear VMM02P0 +jarreando jarrear VMG0000 +jarrear jarrear VMN0000 +jarree jarrear VMM03S0 +jarreemos jarrear VMM01P0 +jarreen jarrear VMM03P0 +jaspea jaspear VMM02S0 +jaspead jaspear VMM02P0 +jaspeando jaspear VMG0000 +jaspear jaspear VMN0000 +jaspee jaspear VMM03S0 +jaspeemos jaspear VMM01P0 +jaspeen jaspear VMM03P0 +jerarquice jerarquizar VMM03S0 +jerarquicemos jerarquizar VMM01P0 +jerarquicen jerarquizar VMM03P0 +jerarquiza jerarquizar VMM02S0 +jerarquizad jerarquizar VMM02P0 +jerarquizando jerarquizar VMG0000 +jerarquizar jerarquizar VMN0000 +jeremiquea jeremiquear VMM02S0 +jeremiquead jeremiquear VMM02P0 +jeremiqueando jeremiquear VMG0000 +jeremiquear jeremiquear VMN0000 +jeremiquee jeremiquear VMM03S0 +jeremiqueemos jeremiquear VMM01P0 +jeremiqueen jeremiquear VMM03P0 +jeringa jeringar VMM02S0 +jeringad jeringar VMM02P0 +jeringando jeringar VMG0000 +jeringar jeringar VMN0000 +jeringue jeringar VMM03S0 +jeringuemos jeringar VMM01P0 +jeringuen jeringar VMM03P0 +jesusea jesusear VMM02S0 +jesusead jesusear VMM02P0 +jesuseando jesusear VMG0000 +jesusear jesusear VMN0000 +jesusee jesusear VMM03S0 +jesuseemos jesusear VMM01P0 +jesuseen jesusear VMM03P0 +jinetea jinetear VMM02S0 +jinetead jinetear VMM02P0 +jineteando jinetear VMG0000 +jinetear jinetear VMN0000 +jinetee jinetear VMM03S0 +jineteemos jinetear VMM01P0 +jineteen jinetear VMM03P0 +joda joder VMM03S0 +jodamos joder VMM01P0 +jodan joder VMM03P0 +jode joder VMM02S0 +joded joder VMM02P0 +joder joder VMN0000 +jodiendo joder VMG0000 +jonjaba jonjabar VMM02S0 +jonjabad jonjabar VMM02P0 +jonjabando jonjabar VMG0000 +jonjabar jonjabar VMN0000 +jonjabe jonjabar VMM03S0 +jonjabemos jonjabar VMM01P0 +jonjaben jonjabar VMM03P0 +joroba jorobar VMM02S0 +jorobad jorobar VMM02P0 +jorobando jorobar VMG0000 +jorobar jorobar VMN0000 +jorobe jorobar VMM03S0 +jorobemos jorobar VMM01P0 +joroben jorobar VMM03P0 +jorra jorrar VMM02S0 +jorrad jorrar VMM02P0 +jorrando jorrar VMG0000 +jorrar jorrar VMN0000 +jorre jorrar VMM03S0 +jorremos jorrar VMM01P0 +jorren jorrar VMM03P0 +jubila jubilar VMM02S0 +jubilad jubilar VMM02P0 +jubilando jubilar VMG0000 +jubilar jubilar VMN0000 +jubile jubilar VMM03S0 +jubilemos jubilar VMM01P0 +jubilen jubilar VMM03P0 +judaicemos judaizar VMM01P0 +judaizad judaizar VMM02P0 +judaizando judaizar VMG0000 +judaizar judaizar VMN0000 +judaíce judaizar VMM03S0 +judaícen judaizar VMM03P0 +judaíza judaizar VMM02S0 +juega jugar VMM02S0 +juegue jugar VMM03S0 +jueguen jugar VMM03P0 +juerguea juerguear VMM02S0 +juerguead juerguear VMM02P0 +juergueando juerguear VMG0000 +juerguear juerguear VMN0000 +juerguee juerguear VMM03S0 +juergueemos juerguear VMM01P0 +juergueen juerguear VMM03P0 +jugad jugar VMM02P0 +jugando jugar VMG0000 +jugar jugar VMN0000 +juguemos jugar VMM01P0 +juguetea juguetear VMM02S0 +juguetead juguetear VMM02P0 +jugueteando juguetear VMG0000 +juguetear juguetear VMN0000 +juguetee juguetear VMM03S0 +jugueteemos juguetear VMM01P0 +jugueteen juguetear VMM03P0 +julepea julepear VMM02S0 +julepead julepear VMM02P0 +julepeando julepear VMG0000 +julepear julepear VMN0000 +julepee julepear VMM03S0 +julepeemos julepear VMM01P0 +julepeen julepear VMM03P0 +juma jumar VMM02S0 +jumad jumar VMM02P0 +jumando jumar VMG0000 +jumar jumar VMN0000 +jume jumar VMM03S0 +jumemos jumar VMM01P0 +jumen jumar VMM03P0 +junta juntar VMM02S0 +juntad juntar VMM02P0 +juntando juntar VMG0000 +juntar juntar VMN0000 +junte juntar VMM03S0 +juntemos juntar VMM01P0 +junten juntar VMM03P0 +jura jurar VMM02S0 +jurad jurar VMM02P0 +juramenta juramentar VMM02S0 +juramentad juramentar VMM02P0 +juramentando juramentar VMG0000 +juramentar juramentar VMN0000 +juramente juramentar VMM03S0 +juramentemos juramentar VMM01P0 +juramenten juramentar VMM03P0 +jurando jurar VMG0000 +jurar jurar VMN0000 +jure jurar VMM03S0 +juremos jurar VMM01P0 +juren jurar VMM03P0 +justa justar VMM02S0 +justad justar VMM02P0 +justando justar VMG0000 +justar justar VMN0000 +juste justar VMM03S0 +justemos justar VMM01P0 +justen justar VMM03P0 +justifica justificar VMM02S0 +justificad justificar VMM02P0 +justificando justificar VMG0000 +justificar justificar VMN0000 +justifique justificar VMM03S0 +justifiquemos justificar VMM01P0 +justifiquen justificar VMM03P0 +justiprecia justipreciar VMM02S0 +justipreciad justipreciar VMM02P0 +justipreciando justipreciar VMG0000 +justipreciar justipreciar VMN0000 +justiprecie justipreciar VMM03S0 +justipreciemos justipreciar VMM01P0 +justiprecien justipreciar VMM03P0 +juzga juzgar VMM02S0 +juzgad juzgar VMM02P0 +juzgando juzgar VMG0000 +juzgar juzgar VMN0000 +juzgue juzgar VMM03S0 +juzguemos juzgar VMM01P0 +juzguen juzgar VMM03P0 +kilometra kilometrar VMM02S0 +kilometrad kilometrar VMM02P0 +kilometrando kilometrar VMG0000 +kilometrar kilometrar VMN0000 +kilometre kilometrar VMM03S0 +kilometremos kilometrar VMM01P0 +kilometren kilometrar VMM03P0 +labialice labializar VMM03S0 +labialicemos labializar VMM01P0 +labialicen labializar VMM03P0 +labializa labializar VMM02S0 +labializad labializar VMM02P0 +labializando labializar VMG0000 +labializar labializar VMN0000 +labora laborar VMM02S0 +laborad laborar VMM02P0 +laborando laborar VMG0000 +laborar laborar VMN0000 +labore laborar VMM03S0 +laborea laborear VMM02S0 +laboread laborear VMM02P0 +laboreando laborear VMG0000 +laborear laborear VMN0000 +laboree laborear VMM03S0 +laboreemos laborear VMM01P0 +laboreen laborear VMM03P0 +laboremos laborar VMM01P0 +laboren laborar VMM03P0 +labra labrar VMM02S0 +labrad labrar VMM02P0 +labrando labrar VMG0000 +labrar labrar VMN0000 +labre labrar VMM03S0 +labremos labrar VMM01P0 +labren labrar VMM03P0 +lace lazar VMM03S0 +lacea lacear VMM02S0 +lacead lacear VMM02P0 +laceando lacear VMG0000 +lacear lacear VMN0000 +lacee lacear VMM03S0 +laceemos lacear VMM01P0 +laceen lacear VMM03P0 +lacemos lazar VMM01P0 +lacen lazar VMM03P0 +lacera lacerar VMM02S0 +lacerad lacerar VMM02P0 +lacerando lacerar VMG0000 +lacerar lacerar VMN0000 +lacere lacerar VMM03S0 +laceremos lacerar VMM01P0 +laceren lacerar VMM03P0 +lacra lacrar VMM02S0 +lacrad lacrar VMM02P0 +lacrando lacrar VMG0000 +lacrar lacrar VMN0000 +lacre lacrar VMM03S0 +lacremos lacrar VMM01P0 +lacren lacrar VMM03P0 +lacta lactar VMM02S0 +lactad lactar VMM02P0 +lactando lactar VMG0000 +lactar lactar VMN0000 +lacte lactar VMM03S0 +lactemos lactar VMM01P0 +lacten lactar VMM03P0 +ladea ladear VMM02S0 +ladead ladear VMM02P0 +ladeando ladear VMG0000 +ladear ladear VMN0000 +ladee ladear VMM03S0 +ladeemos ladear VMM01P0 +ladeen ladear VMM03P0 +ladra ladrar VMM02S0 +ladrad ladrar VMM02P0 +ladrando ladrar VMG0000 +ladrar ladrar VMN0000 +ladre ladrar VMM03S0 +ladremos ladrar VMM01P0 +ladren ladrar VMM03P0 +ladrilla ladrillar VMM02S0 +ladrillad ladrillar VMM02P0 +ladrillando ladrillar VMG0000 +ladrillar ladrillar VMN0000 +ladrille ladrillar VMM03S0 +ladrillemos ladrillar VMM01P0 +ladrillen ladrillar VMM03P0 +ladronea ladronear VMM02S0 +ladronead ladronear VMM02P0 +ladroneando ladronear VMG0000 +ladronear ladronear VMN0000 +ladronee ladronear VMM03S0 +ladroneemos ladronear VMM01P0 +ladroneen ladronear VMM03P0 +lagartea lagartear VMM02S0 +lagartead lagartear VMM02P0 +lagarteando lagartear VMG0000 +lagartear lagartear VMN0000 +lagartee lagartear VMM03S0 +lagarteemos lagartear VMM01P0 +lagarteen lagartear VMM03P0 +lagotea lagotear VMM02S0 +lagotead lagotear VMM02P0 +lagoteando lagotear VMG0000 +lagotear lagotear VMN0000 +lagotee lagotear VMM03S0 +lagoteemos lagotear VMM01P0 +lagoteen lagotear VMM03P0 +lagrima lagrimar VMM02S0 +lagrimad lagrimar VMM02P0 +lagrimando lagrimar VMG0000 +lagrimar lagrimar VMN0000 +lagrime lagrimar VMM03S0 +lagrimea lagrimear VMM02S0 +lagrimead lagrimear VMM02P0 +lagrimeando lagrimear VMG0000 +lagrimear lagrimear VMN0000 +lagrimee lagrimear VMM03S0 +lagrimeemos lagrimear VMM01P0 +lagrimeen lagrimear VMM03P0 +lagrimemos lagrimar VMM01P0 +lagrimen lagrimar VMM03P0 +laicice laicizar VMM03S0 +laicicemos laicizar VMM01P0 +laicicen laicizar VMM03P0 +laiciza laicizar VMM02S0 +laicizad laicizar VMM02P0 +laicizando laicizar VMG0000 +laicizar laicizar VMN0000 +lama lamer VMM03S0 +lamamos lamer VMM01P0 +laman lamer VMM03P0 +lamba lamber VMM03S0 +lambamos lamber VMM01P0 +lamban lamber VMM03P0 +lambe lamber VMM02S0 +lambed lamber VMM02P0 +lamber lamber VMN0000 +lambiendo lamber VMG0000 +lame lamer VMM02S0 +lamed lamer VMM02P0 +lamenta lamentar VMM02S0 +lamentad lamentar VMM02P0 +lamentando lamentar VMG0000 +lamentar lamentar VMN0000 +lamente lamentar VMM03S0 +lamentemos lamentar VMM01P0 +lamenten lamentar VMM03P0 +lamer lamer VMN0000 +lamiendo lamer VMG0000 +lamina laminar VMM02S0 +laminad laminar VMM02P0 +laminando laminar VMG0000 +laminar laminar VMN0000 +lamine laminar VMM03S0 +laminemos laminar VMM01P0 +laminen laminar VMM03P0 +lamisca lamiscar VMM02S0 +lamiscad lamiscar VMM02P0 +lamiscando lamiscar VMG0000 +lamiscar lamiscar VMN0000 +lamisque lamiscar VMM03S0 +lamisquemos lamiscar VMM01P0 +lamisquen lamiscar VMM03P0 +lamotea lamotear VMM02S0 +lamotead lamotear VMM02P0 +lamoteando lamotear VMG0000 +lamotear lamotear VMN0000 +lampacea lampacear VMM02S0 +lampacead lampacear VMM02P0 +lampaceando lampacear VMG0000 +lampacear lampacear VMN0000 +lampacee lampacear VMM03S0 +lampaceemos lampacear VMM01P0 +lampaceen lampacear VMM03P0 +lamprea lamprear VMM02S0 +lampread lamprear VMM02P0 +lampreando lamprear VMG0000 +lamprear lamprear VMN0000 +lampree lamprear VMM03S0 +lampreemos lamprear VMM01P0 +lampreen lamprear VMM03P0 +lance lanzar VMM03S0 +lancea lancear VMM02S0 +lancead lancear VMM02P0 +lanceando lancear VMG0000 +lancear lancear VMN0000 +lancee lancear VMM03S0 +lanceemos lancear VMM01P0 +lanceen lancear VMM03P0 +lancemos lanzar VMM01P0 +lancen lanzar VMM03P0 +lancina lancinar VMM02S0 +lancinad lancinar VMM02P0 +lancinando lancinar VMG0000 +lancinar lancinar VMN0000 +lancine lancinar VMM03S0 +lancinemos lancinar VMM01P0 +lancinen lancinar VMM03P0 +languidece languidecer VMM02S0 +languideced languidecer VMM02P0 +languidecer languidecer VMN0000 +languideciendo languidecer VMG0000 +languidezca languidecer VMM03S0 +languidezcamos languidecer VMM01P0 +languidezcan languidecer VMM03P0 +lanza lanzar VMM02S0 +lanzad lanzar VMM02P0 +lanzando lanzar VMG0000 +lanzar lanzar VMN0000 +lapida lapidar VMM02S0 +lapidad lapidar VMM02P0 +lapidando lapidar VMG0000 +lapidar lapidar VMN0000 +lapide lapidar VMM03S0 +lapidemos lapidar VMM01P0 +lapiden lapidar VMM03P0 +lapidifica lapidificar VMM02S0 +lapidificad lapidificar VMM02P0 +lapidificando lapidificar VMG0000 +lapidificar lapidificar VMN0000 +lapidifique lapidificar VMM03S0 +lapidifiquemos lapidificar VMM01P0 +lapidifiquen lapidificar VMM03P0 +laquea laquear VMM02S0 +laquead laquear VMM02P0 +laqueando laquear VMG0000 +laquear laquear VMN0000 +laquee laquear VMM03S0 +laqueemos laquear VMM01P0 +laqueen laquear VMM03P0 +larda lardar VMM02S0 +lardad lardar VMM02P0 +lardando lardar VMG0000 +lardar lardar VMN0000 +larde lardar VMM03S0 +lardea lardear VMM02S0 +lardead lardear VMM02P0 +lardeando lardear VMG0000 +lardear lardear VMN0000 +lardee lardear VMM03S0 +lardeemos lardear VMM01P0 +lardeen lardear VMM03P0 +lardemos lardar VMM01P0 +larden lardar VMM03P0 +larga largar VMM02S0 +largad largar VMM02P0 +largando largar VMG0000 +largar largar VMN0000 +largue largar VMM03S0 +larguemos largar VMM01P0 +larguen largar VMM03P0 +lasca lascar VMM02S0 +lascad lascar VMM02P0 +lascando lascar VMG0000 +lascar lascar VMN0000 +lasque lascar VMM03S0 +lasquemos lascar VMM01P0 +lasquen lascar VMM03P0 +lasta lastar VMM02S0 +lastad lastar VMM02P0 +lastando lastar VMG0000 +lastar lastar VMN0000 +laste lastar VMM03S0 +lastemos lastar VMM01P0 +lasten lastar VMM03P0 +lastima lastimar VMM02S0 +lastimad lastimar VMM02P0 +lastimando lastimar VMG0000 +lastimar lastimar VMN0000 +lastime lastimar VMM03S0 +lastimemos lastimar VMM01P0 +lastimen lastimar VMM03P0 +lastra lastrar VMM02S0 +lastrad lastrar VMM02P0 +lastrando lastrar VMG0000 +lastrar lastrar VMN0000 +lastre lastrar VMM03S0 +lastremos lastrar VMM01P0 +lastren lastrar VMM03P0 +lata latir VMM03S0 +latamos latir VMM01P0 +latan latir VMM03P0 +late latir VMM02S0 +latid latir VMM02P0 +latiendo latir VMG0000 +latiguea latiguear VMM02S0 +latiguead latiguear VMM02P0 +latigueando latiguear VMG0000 +latiguear latiguear VMN0000 +latiguee latiguear VMM03S0 +latigueemos latiguear VMM01P0 +latigueen latiguear VMM03P0 +latina latinar VMM02S0 +latinad latinar VMM02P0 +latinando latinar VMG0000 +latinar latinar VMN0000 +latine latinar VMM03S0 +latinea latinear VMM02S0 +latinead latinear VMM02P0 +latineando latinear VMG0000 +latinear latinear VMN0000 +latinee latinear VMM03S0 +latineemos latinear VMM01P0 +latineen latinear VMM03P0 +latinemos latinar VMM01P0 +latinen latinar VMM03P0 +latinice latinizar VMM03S0 +latinicemos latinizar VMM01P0 +latinicen latinizar VMM03P0 +latiniza latinizar VMM02S0 +latinizad latinizar VMM02P0 +latinizando latinizar VMG0000 +latinizar latinizar VMN0000 +latir latir VMN0000 +lauda laudar VMM02S0 +laudad laudar VMM02P0 +laudando laudar VMG0000 +laudar laudar VMN0000 +laude laudar VMM03S0 +laudemos laudar VMM01P0 +lauden laudar VMM03P0 +laurea laurear VMM02S0 +lauread laurear VMM02P0 +laureando laurear VMG0000 +laurear laurear VMN0000 +lauree laurear VMM03S0 +laureemos laurear VMM01P0 +laureen laurear VMM03P0 +lava lavar VMM02S0 +lavad lavar VMM02P0 +lavando lavar VMG0000 +lavar lavar VMN0000 +lave lavar VMM03S0 +lavemos lavar VMM01P0 +laven lavar VMM03P0 +lavotea lavotear VMM02S0 +lavotead lavotear VMM02P0 +lavoteando lavotear VMG0000 +lavotear lavotear VMN0000 +lavotee lavotear VMM03S0 +lavoteemos lavotear VMM01P0 +lavoteen lavotear VMM03P0 +laxa laxar VMM02S0 +laxad laxar VMM02P0 +laxando laxar VMG0000 +laxar laxar VMN0000 +laxe laxar VMM03S0 +laxemos laxar VMM01P0 +laxen laxar VMM03P0 +laya layar VMM02S0 +layad layar VMM02P0 +layando layar VMG0000 +layar layar VMN0000 +laye layar VMM03S0 +layemos layar VMM01P0 +layen layar VMM03P0 +laza lazar VMM02S0 +lazad lazar VMM02P0 +lazando lazar VMG0000 +lazar lazar VMN0000 +laña lañar VMM02S0 +lañad lañar VMM02P0 +lañando lañar VMG0000 +lañar lañar VMN0000 +lañe lañar VMM03S0 +lañemos lañar VMM01P0 +lañen lañar VMM03P0 +lea leer VMM03S0 +leamos leer VMM01P0 +lean leer VMM03P0 +lee leer VMM02S0 +leed leer VMM02P0 +leer leer VMN0000 +lega legar VMM02S0 +legad legar VMM02P0 +legalice legalizar VMM03S0 +legalicemos legalizar VMM01P0 +legalicen legalizar VMM03P0 +legaliza legalizar VMM02S0 +legalizad legalizar VMM02P0 +legalizando legalizar VMG0000 +legalizar legalizar VMN0000 +legando legar VMG0000 +legar legar VMN0000 +legisla legislar VMM02S0 +legislad legislar VMM02P0 +legislando legislar VMG0000 +legislar legislar VMN0000 +legisle legislar VMM03S0 +legislemos legislar VMM01P0 +legislen legislar VMM03P0 +legitima legitimar VMM02S0 +legitimad legitimar VMM02P0 +legitimando legitimar VMG0000 +legitimar legitimar VMN0000 +legitime legitimar VMM03S0 +legitimemos legitimar VMM01P0 +legitimen legitimar VMM03P0 +legra legrar VMM02S0 +legrad legrar VMM02P0 +legrando legrar VMG0000 +legrar legrar VMN0000 +legre legrar VMM03S0 +legremos legrar VMM01P0 +legren legrar VMM03P0 +legue legar VMM03S0 +leguemos legar VMM01P0 +leguen legar VMM03P0 +lenifica lenificar VMM02S0 +lenificad lenificar VMM02P0 +lenificando lenificar VMG0000 +lenificar lenificar VMN0000 +lenifique lenificar VMM03S0 +lenifiquemos lenificar VMM01P0 +lenifiquen lenificar VMM03P0 +lesiona lesionar VMM02S0 +lesionad lesionar VMM02P0 +lesionando lesionar VMG0000 +lesionar lesionar VMN0000 +lesione lesionar VMM03S0 +lesionemos lesionar VMM01P0 +lesionen lesionar VMM03P0 +letifica letificar VMM02S0 +letificad letificar VMM02P0 +letificando letificar VMG0000 +letificar letificar VMN0000 +letifique letificar VMM03S0 +letifiquemos letificar VMM01P0 +letifiquen letificar VMM03P0 +leuda leudar VMM02S0 +leudad leudar VMM02P0 +leudando leudar VMG0000 +leudar leudar VMN0000 +leude leudar VMM03S0 +leudemos leudar VMM01P0 +leuden leudar VMM03P0 +leva levar VMM02S0 +levad levar VMM02P0 +levando levar VMG0000 +levanta levantar VMM02S0 +levantad levantar VMM02P0 +levantando levantar VMG0000 +levantar levantar VMN0000 +levante levantar VMM03S0 +levantemos levantar VMM01P0 +levanten levantar VMM03P0 +levar levar VMN0000 +leve levar VMM03S0 +levemos levar VMM01P0 +leven levar VMM03P0 +leviga levigar VMM02S0 +levigad levigar VMM02P0 +levigando levigar VMG0000 +levigar levigar VMN0000 +levigue levigar VMM03S0 +leviguemos levigar VMM01P0 +leviguen levigar VMM03P0 +lexicalice lexicalizar VMM03S0 +lexicalicemos lexicalizar VMM01P0 +lexicalicen lexicalizar VMM03P0 +lexicaliza lexicalizar VMM02S0 +lexicalizad lexicalizar VMM02P0 +lexicalizando lexicalizar VMG0000 +lexicalizar lexicalizar VMN0000 +leyendo leer VMG0000 +liad liar VMM02P0 +liando liar VMG0000 +liar liar VMN0000 +liba libar VMM02S0 +libad libar VMM02P0 +libando libar VMG0000 +libar libar VMN0000 +libe libar VMM03S0 +libela libelar VMM02S0 +libelad libelar VMM02P0 +libelando libelar VMG0000 +libelar libelar VMN0000 +libele libelar VMM03S0 +libelemos libelar VMM01P0 +libelen libelar VMM03P0 +libemos libar VMM01P0 +liben libar VMM03P0 +libera liberar VMM02S0 +liberad liberar VMM02P0 +liberalice liberalizar VMM03S0 +liberalicemos liberalizar VMM01P0 +liberalicen liberalizar VMM03P0 +liberaliza liberalizar VMM02S0 +liberalizad liberalizar VMM02P0 +liberalizando liberalizar VMG0000 +liberalizar liberalizar VMN0000 +liberando liberar VMG0000 +liberar liberar VMN0000 +libere liberar VMM03S0 +liberemos liberar VMM01P0 +liberen liberar VMM03P0 +liberta libertar VMM02S0 +libertad libertar VMM02P0 +libertando libertar VMG0000 +libertar libertar VMN0000 +liberte libertar VMM03S0 +libertemos libertar VMM01P0 +liberten libertar VMM03P0 +libra librar VMM02S0 +librad librar VMM02P0 +librando librar VMG0000 +librar librar VMN0000 +libre librar VMM03S0 +libremos librar VMM01P0 +libren librar VMM03P0 +licencia licenciar VMM02S0 +licenciad licenciar VMM02P0 +licenciando licenciar VMG0000 +licenciar licenciar VMN0000 +licencie licenciar VMM03S0 +licenciemos licenciar VMM01P0 +licencien licenciar VMM03P0 +licita licitar VMM02S0 +licitad licitar VMM02P0 +licitando licitar VMG0000 +licitar licitar VMN0000 +licite licitar VMM03S0 +licitemos licitar VMM01P0 +liciten licitar VMM03P0 +licuad licuar VMM02P0 +licuando licuar VMG0000 +licuar licuar VMN0000 +licueface licuefacer VMM02S0 +licuefaced licuefacer VMM02P0 +licuefacer licuefacer VMN0000 +licuefaciendo licuefacer VMG0000 +licuefaga licuefacer VMM03S0 +licuefagamos licuefacer VMM01P0 +licuefagan licuefacer VMM03P0 +licuefaz licuefacer VMM02S0 +licuemos licuar VMM01P0 +licúa licuar VMM02S0 +licúe licuar VMM03S0 +licúen licuar VMM03P0 +lidera liderar VMM02S0 +liderad liderar VMM02P0 +liderando liderar VMG0000 +liderar liderar VMN0000 +lidere liderar VMM03S0 +lideremos liderar VMM01P0 +lideren liderar VMM03P0 +lidia lidiar VMM02S0 +lidiad lidiar VMM02P0 +lidiando lidiar VMG0000 +lidiar lidiar VMN0000 +lidie lidiar VMM03S0 +lidiemos lidiar VMM01P0 +lidien lidiar VMM03P0 +liemos liar VMM01P0 +lifta liftar VMM02S0 +liftad liftar VMM02P0 +liftando liftar VMG0000 +liftar liftar VMN0000 +lifte liftar VMM03S0 +liftemos liftar VMM01P0 +liften liftar VMM03P0 +liga ligar VMM02S0 +ligad ligar VMM02P0 +ligando ligar VMG0000 +ligar ligar VMN0000 +lignifica lignificar VMM02S0 +lignificad lignificar VMM02P0 +lignificando lignificar VMG0000 +lignificar lignificar VMN0000 +lignifique lignificar VMM03S0 +lignifiquemos lignificar VMM01P0 +lignifiquen lignificar VMM03P0 +ligue ligar VMM03S0 +liguemos ligar VMM01P0 +liguen ligar VMM03P0 +lija lijar VMM02S0 +lijad lijar VMM02P0 +lijando lijar VMG0000 +lijar lijar VMN0000 +lije lijar VMM03S0 +lijemos lijar VMM01P0 +lijen lijar VMM03P0 +lima limar VMM02S0 +limad limar VMM02P0 +limando limar VMG0000 +limar limar VMN0000 +lime limar VMM03S0 +limemos limar VMM01P0 +limen limar VMM03P0 +limita limitar VMM02S0 +limitad limitar VMM02P0 +limitando limitar VMG0000 +limitar limitar VMN0000 +limite limitar VMM03S0 +limitemos limitar VMM01P0 +limiten limitar VMM03P0 +limosnea limosnear VMM02S0 +limosnead limosnear VMM02P0 +limosneando limosnear VMG0000 +limosnear limosnear VMN0000 +limosnee limosnear VMM03S0 +limosneemos limosnear VMM01P0 +limosneen limosnear VMM03P0 +limpia limpiar VMM02S0 +limpiad limpiar VMM02P0 +limpiando limpiar VMG0000 +limpiar limpiar VMN0000 +limpie limpiar VMM03S0 +limpiemos limpiar VMM01P0 +limpien limpiar VMM03P0 +lincea lincear VMM02S0 +lincead lincear VMM02P0 +linceando lincear VMG0000 +lincear lincear VMN0000 +lincee lincear VMM03S0 +linceemos lincear VMM01P0 +linceen lincear VMM03P0 +lincha linchar VMM02S0 +linchad linchar VMM02P0 +linchando linchar VMG0000 +linchar linchar VMN0000 +linche linchar VMM03S0 +linchemos linchar VMM01P0 +linchen linchar VMM03P0 +linda lindar VMM02S0 +lindad lindar VMM02P0 +lindando lindar VMG0000 +lindar lindar VMN0000 +linde lindar VMM03S0 +lindemos lindar VMM01P0 +linden lindar VMM03P0 +linea linear VMM02S0 +linead linear VMM02P0 +lineando linear VMG0000 +linear linear VMN0000 +linee linear VMM03S0 +lineemos linear VMM01P0 +lineen linear VMM03P0 +liofilice liofilizar VMM03S0 +liofilicemos liofilizar VMM01P0 +liofilicen liofilizar VMM03P0 +liofiliza liofilizar VMM02S0 +liofilizad liofilizar VMM02P0 +liofilizando liofilizar VMG0000 +liofilizar liofilizar VMN0000 +liquida liquidar VMM02S0 +liquidad liquidar VMM02P0 +liquidando liquidar VMG0000 +liquidar liquidar VMN0000 +liquide liquidar VMM03S0 +liquidemos liquidar VMM01P0 +liquiden liquidar VMM03P0 +lisia lisiar VMM02S0 +lisiad lisiar VMM02P0 +lisiando lisiar VMG0000 +lisiar lisiar VMN0000 +lisie lisiar VMM03S0 +lisiemos lisiar VMM01P0 +lisien lisiar VMM03P0 +lisonjea lisonjear VMM02S0 +lisonjead lisonjear VMM02P0 +lisonjeando lisonjear VMG0000 +lisonjear lisonjear VMN0000 +lisonjee lisonjear VMM03S0 +lisonjeemos lisonjear VMM01P0 +lisonjeen lisonjear VMM03P0 +lista listar VMM02S0 +listad listar VMM02P0 +listando listar VMG0000 +listar listar VMN0000 +liste listar VMM03S0 +listemos listar VMM01P0 +listen listar VMM03P0 +listona listonar VMM02S0 +listonad listonar VMM02P0 +listonando listonar VMG0000 +listonar listonar VMN0000 +listone listonar VMM03S0 +listonemos listonar VMM01P0 +listonen listonar VMM03P0 +lita litar VMM02S0 +litad litar VMM02P0 +litando litar VMG0000 +litar litar VMN0000 +lite litar VMM03S0 +litemos litar VMM01P0 +liten litar VMM03P0 +litiga litigar VMM02S0 +litigad litigar VMM02P0 +litigando litigar VMG0000 +litigar litigar VMN0000 +litigue litigar VMM03S0 +litiguemos litigar VMM01P0 +litiguen litigar VMM03P0 +litofotografiad litofotografiar VMM02P0 +litofotografiando litofotografiar VMG0000 +litofotografiar litofotografiar VMN0000 +litofotografiemos litofotografiar VMM01P0 +litofotografía litofotografiar VMM02S0 +litofotografíe litofotografiar VMM03S0 +litofotografíen litofotografiar VMM03P0 +litografiad litografiar VMM02P0 +litografiando litografiar VMG0000 +litografiar litografiar VMN0000 +litografiemos litografiar VMM01P0 +litografía litografiar VMM02S0 +litografíe litografiar VMM03S0 +litografíen litografiar VMM03P0 +liuda liudar VMM02S0 +liudad liudar VMM02P0 +liudando liudar VMG0000 +liudar liudar VMN0000 +liude liudar VMM03S0 +liudemos liudar VMM01P0 +liuden liudar VMM03P0 +lividece lividecer VMM02S0 +livideced lividecer VMM02P0 +lividecer lividecer VMN0000 +livideciendo lividecer VMG0000 +lividezca lividecer VMM03S0 +lividezcamos lividecer VMM01P0 +lividezcan lividecer VMM03P0 +lixivia lixiviar VMM02S0 +lixiviad lixiviar VMM02P0 +lixiviando lixiviar VMG0000 +lixiviar lixiviar VMN0000 +lixivie lixiviar VMM03S0 +lixiviemos lixiviar VMM01P0 +lixivien lixiviar VMM03P0 +llaga llagar VMM02S0 +llagad llagar VMM02P0 +llagando llagar VMG0000 +llagar llagar VMN0000 +llague llagar VMM03S0 +llaguemos llagar VMM01P0 +llaguen llagar VMM03P0 +llama llamar VMM02S0 +llamad llamar VMM02P0 +llamando llamar VMG0000 +llamar llamar VMN0000 +llame llamar VMM03S0 +llamea llamear VMM02S0 +llamead llamear VMM02P0 +llameando llamear VMG0000 +llamear llamear VMN0000 +llamee llamear VMM03S0 +llameemos llamear VMM01P0 +llameen llamear VMM03P0 +llamemos llamar VMM01P0 +llamen llamar VMM03P0 +llega llegar VMM02S0 +llegad llegar VMM02P0 +llegando llegar VMG0000 +llegar llegar VMN0000 +llegue llegar VMM03S0 +lleguemos llegar VMM01P0 +lleguen llegar VMM03P0 +llena llenar VMM02S0 +llenad llenar VMM02P0 +llenando llenar VMG0000 +llenar llenar VMN0000 +llene llenar VMM03S0 +llenemos llenar VMM01P0 +llenen llenar VMM03P0 +lleuda lleudar VMM02S0 +lleudad lleudar VMM02P0 +lleudando lleudar VMG0000 +lleudar lleudar VMN0000 +lleude lleudar VMM03S0 +lleudemos lleudar VMM01P0 +lleuden lleudar VMM03P0 +lleva llevar VMM02S0 +llevad llevar VMM02P0 +llevando llevar VMG0000 +llevar llevar VMN0000 +lleve llevar VMM03S0 +llevemos llevar VMM01P0 +lleven llevar VMM03P0 +llora llorar VMM02S0 +llorad llorar VMM02P0 +llorando llorar VMG0000 +llorar llorar VMN0000 +llore llorar VMM03S0 +lloremos llorar VMM01P0 +lloren llorar VMM03P0 +lloriquea lloriquear VMM02S0 +lloriquead lloriquear VMM02P0 +lloriqueando lloriquear VMG0000 +lloriquear lloriquear VMN0000 +lloriquee lloriquear VMM03S0 +lloriqueemos lloriquear VMM01P0 +lloriqueen lloriquear VMM03P0 +llover llover VMN0000 +lloviendo llover VMG0000 +llovizna lloviznar VMM02S0 +lloviznad lloviznar VMM02P0 +lloviznando lloviznar VMG0000 +lloviznar lloviznar VMN0000 +llovizne lloviznar VMM03S0 +lloviznemos lloviznar VMM01P0 +lloviznen lloviznar VMM03P0 +loa loar VMM02S0 +load loar VMM02P0 +loando loar VMG0000 +loar loar VMN0000 +lobreguece lobreguecer VMM02S0 +lobregueced lobreguecer VMM02P0 +lobreguecer lobreguecer VMN0000 +lobregueciendo lobreguecer VMG0000 +lobreguezca lobreguecer VMM03S0 +lobreguezcamos lobreguecer VMM01P0 +lobreguezcan lobreguecer VMM03P0 +localice localizar VMM03S0 +localicemos localizar VMM01P0 +localicen localizar VMM03P0 +localiza localizar VMM02S0 +localizad localizar VMM02P0 +localizando localizar VMG0000 +localizar localizar VMN0000 +loe loar VMM03S0 +loemos loar VMM01P0 +loen loar VMM03P0 +logra lograr VMM02S0 +lograd lograr VMM02P0 +logrando lograr VMG0000 +lograr lograr VMN0000 +logre lograr VMM03S0 +logrea logrear VMM02S0 +logread logrear VMM02P0 +logreando logrear VMG0000 +logrear logrear VMN0000 +logree logrear VMM03S0 +logreemos logrear VMM01P0 +logreen logrear VMM03P0 +logremos lograr VMM01P0 +logren lograr VMM03P0 +lomea lomear VMM02S0 +lomead lomear VMM02P0 +lomeando lomear VMG0000 +lomear lomear VMN0000 +lomee lomear VMM03S0 +lomeemos lomear VMM01P0 +lomeen lomear VMM03P0 +loquea loquear VMM02S0 +loquead loquear VMM02P0 +loqueando loquear VMG0000 +loquear loquear VMN0000 +loquee loquear VMM03S0 +loqueemos loquear VMM01P0 +loqueen loquear VMM03P0 +losa losar VMM02S0 +losad losar VMM02P0 +losando losar VMG0000 +losar losar VMN0000 +lose losar VMM03S0 +losemos losar VMM01P0 +losen losar VMM03P0 +lubrica lubricar VMM02S0 +lubricad lubricar VMM02P0 +lubricando lubricar VMG0000 +lubricar lubricar VMN0000 +lubrifica lubrificar VMM02S0 +lubrificad lubrificar VMM02P0 +lubrificando lubrificar VMG0000 +lubrificar lubrificar VMN0000 +lubrifique lubrificar VMM03S0 +lubrifiquemos lubrificar VMM01P0 +lubrifiquen lubrificar VMM03P0 +lubrique lubricar VMM03S0 +lubriquemos lubricar VMM01P0 +lubriquen lubricar VMM03P0 +luce lucir VMM02S0 +lucha luchar VMM02S0 +luchad luchar VMM02P0 +luchando luchar VMG0000 +luchar luchar VMN0000 +luche luchar VMM03S0 +luchemos luchar VMM01P0 +luchen luchar VMM03P0 +lucid lucir VMM02P0 +luciendo lucir VMG0000 +lucir lucir VMN0000 +lucra lucrar VMM02S0 +lucrad lucrar VMM02P0 +lucrando lucrar VMG0000 +lucrar lucrar VMN0000 +lucre lucrar VMM03S0 +lucremos lucrar VMM01P0 +lucren lucrar VMM03P0 +lucubra lucubrar VMM02S0 +lucubrad lucubrar VMM02P0 +lucubrando lucubrar VMG0000 +lucubrar lucubrar VMN0000 +lucubre lucubrar VMM03S0 +lucubremos lucubrar VMM01P0 +lucubren lucubrar VMM03P0 +luda ludir VMM03S0 +ludamos ludir VMM01P0 +ludan ludir VMM03P0 +lude ludir VMM02S0 +ludid ludir VMM02P0 +ludiendo ludir VMG0000 +ludir ludir VMN0000 +luid luir VMM02P0 +luir luir VMN0000 +lujuria lujuriar VMM02S0 +lujuriad lujuriar VMM02P0 +lujuriando lujuriar VMG0000 +lujuriar lujuriar VMN0000 +lujurie lujuriar VMM03S0 +lujuriemos lujuriar VMM01P0 +lujurien lujuriar VMM03P0 +lustra lustrar VMM02S0 +lustrad lustrar VMM02P0 +lustrando lustrar VMG0000 +lustrar lustrar VMN0000 +lustre lustrar VMM03S0 +lustremos lustrar VMM01P0 +lustren lustrar VMM03P0 +luxa luxar VMM02S0 +luxad luxar VMM02P0 +luxando luxar VMG0000 +luxar luxar VMN0000 +luxe luxar VMM03S0 +luxemos luxar VMM01P0 +luxen luxar VMM03P0 +luya luir VMM03S0 +luyamos luir VMM01P0 +luyan luir VMM03P0 +luye luir VMM02S0 +luyendo luir VMG0000 +luzca lucir VMM03S0 +luzcamos lucir VMM01P0 +luzcan lucir VMM03P0 +lía liar VMM02S0 +líe liar VMM03S0 +líen liar VMM03P0 +maca macar VMM02S0 +macad macar VMM02P0 +macadamice macadamizar VMM03S0 +macadamicemos macadamizar VMM01P0 +macadamicen macadamizar VMM03P0 +macadamiza macadamizar VMM02S0 +macadamizad macadamizar VMM02P0 +macadamizando macadamizar VMG0000 +macadamizar macadamizar VMN0000 +macando macar VMG0000 +macanea macanear VMM02S0 +macanead macanear VMM02P0 +macaneando macanear VMG0000 +macanear macanear VMN0000 +macanee macanear VMM03S0 +macaneemos macanear VMM01P0 +macaneen macanear VMM03P0 +macar macar VMN0000 +mace mazar VMM03S0 +macea macear VMM02S0 +macead macear VMM02P0 +maceando macear VMG0000 +macear macear VMN0000 +macee macear VMM03S0 +maceemos macear VMM01P0 +maceen macear VMM03P0 +macemos mazar VMM01P0 +macen mazar VMM03P0 +macera macerar VMM02S0 +macerad macerar VMM02P0 +macerando macerar VMG0000 +macerar macerar VMN0000 +macere macerar VMM03S0 +maceremos macerar VMM01P0 +maceren macerar VMM03P0 +macha machar VMM02S0 +machaca machacar VMM02S0 +machacad machacar VMM02P0 +machacando machacar VMG0000 +machacar machacar VMN0000 +machad machar VMM02P0 +machando machar VMG0000 +machaque machacar VMM03S0 +machaquemos machacar VMM01P0 +machaquen machacar VMM03P0 +machar machar VMN0000 +mache machar VMM03S0 +machea machear VMM02S0 +machead machear VMM02P0 +macheando machear VMG0000 +machear machear VMN0000 +machee machear VMM03S0 +macheemos machear VMM01P0 +macheen machear VMM03P0 +machemos machar VMM01P0 +machen machar VMM03P0 +machetea machetear VMM02S0 +machetead machetear VMM02P0 +macheteando machetear VMG0000 +machetear machetear VMN0000 +machetee machetear VMM03S0 +macheteemos machetear VMM01P0 +macheteen machetear VMM03P0 +machihembra machihembrar VMM02S0 +machihembrad machihembrar VMM02P0 +machihembrando machihembrar VMG0000 +machihembrar machihembrar VMN0000 +machihembre machihembrar VMM03S0 +machihembremos machihembrar VMM01P0 +machihembren machihembrar VMM03P0 +machuca machucar VMM02S0 +machucad machucar VMM02P0 +machucando machucar VMG0000 +machucar machucar VMN0000 +machuque machucar VMM03S0 +machuquemos machucar VMM01P0 +machuquen machucar VMM03P0 +macice macizar VMM03S0 +macicemos macizar VMM01P0 +macicen macizar VMM03P0 +maciza macizar VMM02S0 +macizad macizar VMM02P0 +macizando macizar VMG0000 +macizar macizar VMN0000 +macolla macollar VMM02S0 +macollad macollar VMM02P0 +macollando macollar VMG0000 +macollar macollar VMN0000 +macolle macollar VMM03S0 +macollemos macollar VMM01P0 +macollen macollar VMM03P0 +macula macular VMM02S0 +maculad macular VMM02P0 +maculando macular VMG0000 +macular macular VMN0000 +macule macular VMM03S0 +maculemos macular VMM01P0 +maculen macular VMM03P0 +madera maderar VMM02S0 +maderad maderar VMM02P0 +maderando maderar VMG0000 +maderar maderar VMN0000 +madere maderar VMM03S0 +maderemos maderar VMM01P0 +maderen maderar VMM03P0 +madruga madrugar VMM02S0 +madrugad madrugar VMM02P0 +madrugando madrugar VMG0000 +madrugar madrugar VMN0000 +madrugue madrugar VMM03S0 +madruguemos madrugar VMM01P0 +madruguen madrugar VMM03P0 +madura madurar VMM02S0 +madurad madurar VMM02P0 +madurando madurar VMG0000 +madurar madurar VMN0000 +madure madurar VMM03S0 +maduremos madurar VMM01P0 +maduren madurar VMM03P0 +maestrea maestrear VMM02S0 +maestread maestrear VMM02P0 +maestreando maestrear VMG0000 +maestrear maestrear VMN0000 +maestree maestrear VMM03S0 +maestreemos maestrear VMM01P0 +maestreen maestrear VMM03P0 +magancea magancear VMM02S0 +magancead magancear VMM02P0 +maganceando magancear VMG0000 +magancear magancear VMN0000 +magancee magancear VMM03S0 +maganceemos magancear VMM01P0 +maganceen magancear VMM03P0 +magnetice magnetizar VMM03S0 +magneticemos magnetizar VMM01P0 +magneticen magnetizar VMM03P0 +magnetiza magnetizar VMM02S0 +magnetizad magnetizar VMM02P0 +magnetizando magnetizar VMG0000 +magnetizar magnetizar VMN0000 +magnifica magnificar VMM02S0 +magnificad magnificar VMM02P0 +magnificando magnificar VMG0000 +magnificar magnificar VMN0000 +magnifique magnificar VMM03S0 +magnifiquemos magnificar VMM01P0 +magnifiquen magnificar VMM03P0 +magrea magrear VMM02S0 +magread magrear VMM02P0 +magreando magrear VMG0000 +magrear magrear VMN0000 +magree magrear VMM03S0 +magreemos magrear VMM01P0 +magreen magrear VMM03P0 +magulla magullar VMM02S0 +magullad magullar VMM02P0 +magullando magullar VMG0000 +magullar magullar VMN0000 +magulle magullar VMM03S0 +magullemos magullar VMM01P0 +magullen magullar VMM03P0 +mahometice mahometizar VMM03S0 +mahometicemos mahometizar VMM01P0 +mahometicen mahometizar VMM03P0 +mahometiza mahometizar VMM02S0 +mahometizad mahometizar VMM02P0 +mahometizando mahometizar VMG0000 +mahometizar mahometizar VMN0000 +maja majar VMM02S0 +majad majar VMM02P0 +majadea majadear VMM02S0 +majadead majadear VMM02P0 +majadeando majadear VMG0000 +majadear majadear VMN0000 +majadee majadear VMM03S0 +majadeemos majadear VMM01P0 +majadeen majadear VMM03P0 +majando majar VMG0000 +majar majar VMN0000 +maje majar VMM03S0 +majemos majar VMM01P0 +majen majar VMM03P0 +malacostumbra malacostumbrar VMM02S0 +malacostumbrad malacostumbrar VMM02P0 +malacostumbrando malacostumbrar VMG0000 +malacostumbrar malacostumbrar VMN0000 +malacostumbre malacostumbrar VMM03S0 +malacostumbremos malacostumbrar VMM01P0 +malacostumbren malacostumbrar VMM03P0 +malaxa malaxar VMM02S0 +malaxad malaxar VMM02P0 +malaxando malaxar VMG0000 +malaxar malaxar VMN0000 +malaxe malaxar VMM03S0 +malaxemos malaxar VMM01P0 +malaxen malaxar VMM03P0 +malbarata malbaratar VMM02S0 +malbaratad malbaratar VMM02P0 +malbaratando malbaratar VMG0000 +malbaratar malbaratar VMN0000 +malbarate malbaratar VMM03S0 +malbaratemos malbaratar VMM01P0 +malbaraten malbaratar VMM03P0 +malcasa malcasar VMM02S0 +malcasad malcasar VMM02P0 +malcasando malcasar VMG0000 +malcasar malcasar VMN0000 +malcase malcasar VMM03S0 +malcasemos malcasar VMM01P0 +malcasen malcasar VMM03P0 +malcoma malcomer VMM03S0 +malcomamos malcomer VMM01P0 +malcoman malcomer VMM03P0 +malcome malcomer VMM02S0 +malcomed malcomer VMM02P0 +malcomer malcomer VMN0000 +malcomiendo malcomer VMG0000 +malcriad malcriar VMM02P0 +malcriando malcriar VMG0000 +malcriar malcriar VMN0000 +malcriemos malcriar VMM01P0 +malcría malcriar VMM02S0 +malcríe malcriar VMM03S0 +malcríen malcriar VMM03P0 +maldecid maldecir VMM02P0 +maldecir maldecir VMN0000 +maldice maldecir VMM02S0 +maldiciendo maldecir VMG0000 +maldiga maldecir VMM03S0 +maldigamos maldecir VMM01P0 +maldigan maldecir VMM03P0 +malea malear VMM02S0 +maleabilice maleabilizar VMM03S0 +maleabilicemos maleabilizar VMM01P0 +maleabilicen maleabilizar VMM03P0 +maleabiliza maleabilizar VMM02S0 +maleabilizad maleabilizar VMM02P0 +maleabilizando maleabilizar VMG0000 +maleabilizar maleabilizar VMN0000 +malead malear VMM02P0 +maleando malear VMG0000 +malear malear VMN0000 +malee malear VMM03S0 +maleemos malear VMM01P0 +maleen malear VMM03P0 +maleficia maleficiar VMM02S0 +maleficiad maleficiar VMM02P0 +maleficiando maleficiar VMG0000 +maleficiar maleficiar VMN0000 +maleficie maleficiar VMM03S0 +maleficiemos maleficiar VMM01P0 +maleficien maleficiar VMM03P0 +malentendamos malentender VMM01P0 +malentended malentender VMM02P0 +malentender malentender VMN0000 +malentendiendo malentender VMG0000 +malentienda malentender VMM03S0 +malentiendan malentender VMM03P0 +malentiende malentender VMM02S0 +malgasta malgastar VMM02S0 +malgastad malgastar VMM02P0 +malgastando malgastar VMG0000 +malgastar malgastar VMN0000 +malgaste malgastar VMM03S0 +malgastemos malgastar VMM01P0 +malgasten malgastar VMM03P0 +malherid malherir VMM02P0 +malherir malherir VMN0000 +malhiera malherir VMM03S0 +malhieran malherir VMM03P0 +malhiere malherir VMM02S0 +malhiramos malherir VMM01P0 +malhiriendo malherir VMG0000 +malhumora malhumorar VMM02S0 +malhumorad malhumorar VMM02P0 +malhumorando malhumorar VMG0000 +malhumorar malhumorar VMN0000 +malhumore malhumorar VMM03S0 +malhumoremos malhumorar VMM01P0 +malhumoren malhumorar VMM03P0 +malicia maliciar VMM02S0 +maliciad maliciar VMM02P0 +maliciando maliciar VMG0000 +maliciar maliciar VMN0000 +malicie maliciar VMM03S0 +maliciemos maliciar VMM01P0 +malicien maliciar VMM03P0 +malinterpreta malinterpretar VMM02S0 +malinterpretad malinterpretar VMM02P0 +malinterpretando malinterpretar VMG0000 +malinterpretar malinterpretar VMN0000 +malinterprete malinterpretar VMM03S0 +malinterpretemos malinterpretar VMM01P0 +malinterpreten malinterpretar VMM03P0 +malla mallar VMM02S0 +mallad mallar VMM02P0 +mallando mallar VMG0000 +mallar mallar VMN0000 +malle mallar VMM03S0 +mallemos mallar VMM01P0 +mallen mallar VMM03P0 +malogra malograr VMM02S0 +malograd malograr VMM02P0 +malogrando malograr VMG0000 +malograr malograr VMN0000 +malogre malograr VMM03S0 +malogremos malograr VMM01P0 +malogren malograr VMM03P0 +maloquea maloquear VMM02S0 +maloquead maloquear VMM02P0 +maloqueando maloquear VMG0000 +maloquear maloquear VMN0000 +maloquee maloquear VMM03S0 +maloqueemos maloquear VMM01P0 +maloqueen maloquear VMM03P0 +malpara malparar VMM02S0 +malpara malparir VMM03S0 +malparad malparar VMM02P0 +malparamos malparir VMM01P0 +malparan malparir VMM03P0 +malparando malparar VMG0000 +malparar malparar VMN0000 +malpare malparar VMM03S0 +malpare malparir VMM02S0 +malparemos malparar VMM01P0 +malparen malparar VMM03P0 +malparid malparir VMM02P0 +malpariendo malparir VMG0000 +malparir malparir VMN0000 +malqueramos malquerer VMM01P0 +malquered malquerer VMM02P0 +malquerer malquerer VMN0000 +malqueriendo malquerer VMG0000 +malquiera malquerer VMM03S0 +malquieran malquerer VMM03P0 +malquiere malquerer VMM02S0 +malquista malquistar VMM02S0 +malquistad malquistar VMM02P0 +malquistando malquistar VMG0000 +malquistar malquistar VMN0000 +malquiste malquistar VMM03S0 +malquistemos malquistar VMM01P0 +malquisten malquistar VMM03P0 +maltea maltear VMM02S0 +maltead maltear VMM02P0 +malteando maltear VMG0000 +maltear maltear VMN0000 +maltee maltear VMM03S0 +malteemos maltear VMM01P0 +malteen maltear VMM03P0 +maltrae maltraer VMM02S0 +maltraed maltraer VMM02P0 +maltraer maltraer VMN0000 +maltraiga maltraer VMM03S0 +maltraigamos maltraer VMM01P0 +maltraigan maltraer VMM03P0 +maltrata maltratar VMM02S0 +maltratad maltratar VMM02P0 +maltratando maltratar VMG0000 +maltratar maltratar VMN0000 +maltrate maltratar VMM03S0 +maltratemos maltratar VMM01P0 +maltraten maltratar VMM03P0 +maltrayendo maltraer VMG0000 +malvenda malvender VMM03S0 +malvendamos malvender VMM01P0 +malvendan malvender VMM03P0 +malvende malvender VMM02S0 +malvended malvender VMM02P0 +malvender malvender VMN0000 +malvendiendo malvender VMG0000 +malversa malversar VMM02S0 +malversad malversar VMM02P0 +malversando malversar VMG0000 +malversar malversar VMN0000 +malverse malversar VMM03S0 +malversemos malversar VMM01P0 +malversen malversar VMM03P0 +malviva malvivir VMM03S0 +malvivamos malvivir VMM01P0 +malvivan malvivir VMM03P0 +malvive malvivir VMM02S0 +malvivid malvivir VMM02P0 +malviviendo malvivir VMG0000 +malvivir malvivir VMN0000 +mama mamar VMM02S0 +mamad mamar VMM02P0 +mamando mamar VMG0000 +mamar mamar VMN0000 +mame mamar VMM03S0 +mamemos mamar VMM01P0 +mamen mamar VMM03P0 +mampostea mampostear VMM02S0 +mampostead mampostear VMM02P0 +mamposteando mampostear VMG0000 +mampostear mampostear VMN0000 +mampostee mampostear VMM03S0 +mamposteemos mampostear VMM01P0 +mamposteen mampostear VMM03P0 +mampresa mampresar VMM02S0 +mampresad mampresar VMM02P0 +mampresando mampresar VMG0000 +mampresar mampresar VMN0000 +mamprese mampresar VMM03S0 +mampresemos mampresar VMM01P0 +mampresen mampresar VMM03P0 +mamulla mamullar VMM02S0 +mamullad mamullar VMM02P0 +mamullando mamullar VMG0000 +mamullar mamullar VMN0000 +mamulle mamullar VMM03S0 +mamullemos mamullar VMM01P0 +mamullen mamullar VMM03P0 +mana manar VMM02S0 +mana manir VMM03S0 +manad manar VMM02P0 +manamos manir VMM01P0 +manan manir VMM03P0 +manando manar VMG0000 +manar manar VMN0000 +manca mancar VMM02S0 +mancad mancar VMM02P0 +mancando mancar VMG0000 +mancar mancar VMN0000 +mancha manchar VMM02S0 +manchad manchar VMM02P0 +manchando manchar VMG0000 +manchar manchar VMN0000 +manche manchar VMM03S0 +manchemos manchar VMM01P0 +manchen manchar VMM03P0 +mancilla mancillar VMM02S0 +mancillad mancillar VMM02P0 +mancillando mancillar VMG0000 +mancillar mancillar VMN0000 +mancille mancillar VMM03S0 +mancillemos mancillar VMM01P0 +mancillen mancillar VMM03P0 +mancipa mancipar VMM02S0 +mancipad mancipar VMM02P0 +mancipando mancipar VMG0000 +mancipar mancipar VMN0000 +mancipe mancipar VMM03S0 +mancipemos mancipar VMM01P0 +mancipen mancipar VMM03P0 +mancomuna mancomunar VMM02S0 +mancomunad mancomunar VMM02P0 +mancomunando mancomunar VMG0000 +mancomunar mancomunar VMN0000 +mancomune mancomunar VMM03S0 +mancomunemos mancomunar VMM01P0 +mancomunen mancomunar VMM03P0 +mancornad mancornar VMM02P0 +mancornando mancornar VMG0000 +mancornar mancornar VMN0000 +mancornemos mancornar VMM01P0 +mancuerna mancornar VMM02S0 +mancuerne mancornar VMM03S0 +mancuernen mancornar VMM03P0 +manda mandar VMM02S0 +mandad mandar VMM02P0 +mandando mandar VMG0000 +mandar mandar VMN0000 +mande mandar VMM03S0 +mandemos mandar VMM01P0 +manden mandar VMM03P0 +mandila mandilar VMM02S0 +mandilad mandilar VMM02P0 +mandilando mandilar VMG0000 +mandilar mandilar VMN0000 +mandile mandilar VMM03S0 +mandilemos mandilar VMM01P0 +mandilen mandilar VMM03P0 +mandrila mandrilar VMM02S0 +mandrilad mandrilar VMM02P0 +mandrilando mandrilar VMG0000 +mandrilar mandrilar VMN0000 +mandrile mandrilar VMM03S0 +mandrilemos mandrilar VMM01P0 +mandrilen mandrilar VMM03P0 +manduca manducar VMM02S0 +manducad manducar VMM02P0 +manducando manducar VMG0000 +manducar manducar VMN0000 +manduque manducar VMM03S0 +manduquemos manducar VMM01P0 +manduquen manducar VMM03P0 +mane manar VMM03S0 +mane manir VMM02S0 +manea manear VMM02S0 +manead manear VMM02P0 +maneando manear VMG0000 +manear manear VMN0000 +manee manear VMM03S0 +maneemos manear VMM01P0 +maneen manear VMM03P0 +maneja manejar VMM02S0 +manejad manejar VMM02P0 +manejando manejar VMG0000 +manejar manejar VMN0000 +maneje manejar VMM03S0 +manejemos manejar VMM01P0 +manejen manejar VMM03P0 +manemos manar VMM01P0 +manen manar VMM03P0 +manga mangar VMM02S0 +mangad mangar VMM02P0 +mangando mangar VMG0000 +manganea manganear VMM02S0 +manganead manganear VMM02P0 +manganeando manganear VMG0000 +manganear manganear VMN0000 +manganee manganear VMM03S0 +manganeemos manganear VMM01P0 +manganeen manganear VMM03P0 +mangar mangar VMN0000 +mangonea mangonear VMM02S0 +mangonead mangonear VMM02P0 +mangoneando mangonear VMG0000 +mangonear mangonear VMN0000 +mangonee mangonear VMM03S0 +mangoneemos mangonear VMM01P0 +mangoneen mangonear VMM03P0 +mangue mangar VMM03S0 +manguea manguear VMM02S0 +manguead manguear VMM02P0 +mangueando manguear VMG0000 +manguear manguear VMN0000 +manguee manguear VMM03S0 +mangueemos manguear VMM01P0 +mangueen manguear VMM03P0 +manguemos mangar VMM01P0 +manguen mangar VMM03P0 +maniata maniatar VMM02S0 +maniatad maniatar VMM02P0 +maniatando maniatar VMG0000 +maniatar maniatar VMN0000 +maniate maniatar VMM03S0 +maniatemos maniatar VMM01P0 +maniaten maniatar VMM03P0 +manid manir VMM02P0 +maniendo manir VMG0000 +manifestad manifestar VMM02P0 +manifestando manifestar VMG0000 +manifestar manifestar VMN0000 +manifestemos manifestar VMM01P0 +manifiesta manifestar VMM02S0 +manifieste manifestar VMM03S0 +manifiesten manifestar VMM03P0 +maniobra maniobrar VMM02S0 +maniobrad maniobrar VMM02P0 +maniobrando maniobrar VMG0000 +maniobrar maniobrar VMN0000 +maniobre maniobrar VMM03S0 +maniobremos maniobrar VMM01P0 +maniobren maniobrar VMM03P0 +manipula manipular VMM02S0 +manipulad manipular VMM02P0 +manipulando manipular VMG0000 +manipular manipular VMN0000 +manipule manipular VMM03S0 +manipulemos manipular VMM01P0 +manipulen manipular VMM03P0 +manir manir VMN0000 +manosea manosear VMM02S0 +manosead manosear VMM02P0 +manoseando manosear VMG0000 +manosear manosear VMN0000 +manosee manosear VMM03S0 +manoseemos manosear VMM01P0 +manoseen manosear VMM03P0 +manotea manotear VMM02S0 +manotead manotear VMM02P0 +manoteando manotear VMG0000 +manotear manotear VMN0000 +manotee manotear VMM03S0 +manoteemos manotear VMM01P0 +manoteen manotear VMM03P0 +manque mancar VMM03S0 +manquea manquear VMM02S0 +manquead manquear VMM02P0 +manqueando manquear VMG0000 +manquear manquear VMN0000 +manquee manquear VMM03S0 +manqueemos manquear VMM01P0 +manqueen manquear VMM03P0 +manquemos mancar VMM01P0 +manquen mancar VMM03P0 +mantea mantear VMM02S0 +mantead mantear VMM02P0 +manteando mantear VMG0000 +mantear mantear VMN0000 +mantee mantear VMM03S0 +manteemos mantear VMM01P0 +manteen mantear VMM03P0 +mantened mantener VMM02P0 +mantener mantener VMN0000 +mantenga mantener VMM03S0 +mantengamos mantener VMM01P0 +mantengan mantener VMM03P0 +manteniendo mantener VMG0000 +mantén mantener VMM02S0 +manufactura manufacturar VMM02S0 +manufacturad manufacturar VMM02P0 +manufacturando manufacturar VMG0000 +manufacturar manufacturar VMN0000 +manufacture manufacturar VMM03S0 +manufacturemos manufacturar VMM01P0 +manufacturen manufacturar VMM03P0 +manumita manumitir VMM03S0 +manumitamos manumitir VMM01P0 +manumitan manumitir VMM03P0 +manumite manumitir VMM02S0 +manumitid manumitir VMM02P0 +manumitiendo manumitir VMG0000 +manumitir manumitir VMN0000 +manuscriba manuscribir VMM03S0 +manuscribamos manuscribir VMM01P0 +manuscriban manuscribir VMM03P0 +manuscribe manuscribir VMM02S0 +manuscribid manuscribir VMM02P0 +manuscribiendo manuscribir VMG0000 +manuscribir manuscribir VMN0000 +manutened manutener VMM02P0 +manutener manutener VMN0000 +manutenga manutener VMM03S0 +manutengamos manutener VMM01P0 +manutengan manutener VMM03P0 +manuteniendo manutener VMG0000 +manutén manutener VMM02S0 +maque macar VMM03S0 +maquea maquear VMM02S0 +maquead maquear VMM02P0 +maqueando maquear VMG0000 +maquear maquear VMN0000 +maquee maquear VMM03S0 +maqueemos maquear VMM01P0 +maqueen maquear VMM03P0 +maquemos macar VMM01P0 +maquen macar VMM03P0 +maquila maquilar VMM02S0 +maquilad maquilar VMM02P0 +maquilando maquilar VMG0000 +maquilar maquilar VMN0000 +maquile maquilar VMM03S0 +maquilemos maquilar VMM01P0 +maquilen maquilar VMM03P0 +maquilla maquillar VMM02S0 +maquillad maquillar VMM02P0 +maquillando maquillar VMG0000 +maquillar maquillar VMN0000 +maquille maquillar VMM03S0 +maquillemos maquillar VMM01P0 +maquillen maquillar VMM03P0 +maquina maquinar VMM02S0 +maquinad maquinar VMM02P0 +maquinando maquinar VMG0000 +maquinar maquinar VMN0000 +maquine maquinar VMM03S0 +maquinemos maquinar VMM01P0 +maquinen maquinar VMM03P0 +maravilla maravillar VMM02S0 +maravillad maravillar VMM02P0 +maravillando maravillar VMG0000 +maravillar maravillar VMN0000 +maraville maravillar VMM03S0 +maravillemos maravillar VMM01P0 +maravillen maravillar VMM03P0 +marca marcar VMM02S0 +marcad marcar VMM02P0 +marcando marcar VMG0000 +marcar marcar VMN0000 +marcha marchar VMM02S0 +marchad marchar VMM02P0 +marchama marchamar VMM02S0 +marchamad marchamar VMM02P0 +marchamando marchamar VMG0000 +marchamar marchamar VMN0000 +marchame marchamar VMM03S0 +marchamemos marchamar VMM01P0 +marchamen marchamar VMM03P0 +marchando marchar VMG0000 +marchar marchar VMN0000 +marche marchar VMM03S0 +marchemos marchar VMM01P0 +marchen marchar VMM03P0 +marchita marchitar VMM02S0 +marchitad marchitar VMM02P0 +marchitando marchitar VMG0000 +marchitar marchitar VMN0000 +marchite marchitar VMM03S0 +marchitemos marchitar VMM01P0 +marchiten marchitar VMM03P0 +marea marear VMM02S0 +maread marear VMM02P0 +mareando marear VMG0000 +marear marear VMN0000 +maree marear VMM03S0 +mareemos marear VMM01P0 +mareen marear VMM03P0 +marga margar VMM02S0 +margad margar VMM02P0 +margando margar VMG0000 +margar margar VMN0000 +margina marginar VMM02S0 +marginad marginar VMM02P0 +marginando marginar VMG0000 +marginar marginar VMN0000 +margine marginar VMM03S0 +marginemos marginar VMM01P0 +marginen marginar VMM03P0 +margue margar VMM03S0 +marguemos margar VMM01P0 +marguen margar VMM03P0 +marida maridar VMM02S0 +maridad maridar VMM02P0 +maridando maridar VMG0000 +maridar maridar VMN0000 +maride maridar VMM03S0 +maridemos maridar VMM01P0 +mariden maridar VMM03P0 +marina marinar VMM02S0 +marinad marinar VMM02P0 +marinando marinar VMG0000 +marinar marinar VMN0000 +marine marinar VMM03S0 +marinea marinear VMM02S0 +marinead marinear VMM02P0 +marineando marinear VMG0000 +marinear marinear VMN0000 +marinee marinear VMM03S0 +marineemos marinear VMM01P0 +marineen marinear VMM03P0 +marinemos marinar VMM01P0 +marinen marinar VMM03P0 +mariposea mariposear VMM02S0 +mariposead mariposear VMM02P0 +mariposeando mariposear VMG0000 +mariposear mariposear VMN0000 +mariposee mariposear VMM03S0 +mariposeemos mariposear VMM01P0 +mariposeen mariposear VMM03P0 +marisca mariscar VMM02S0 +mariscad mariscar VMM02P0 +mariscando mariscar VMG0000 +mariscar mariscar VMN0000 +marisque mariscar VMM03S0 +marisquemos mariscar VMM01P0 +marisquen mariscar VMM03P0 +marque marcar VMM03S0 +marquemos marcar VMM01P0 +marquen marcar VMM03P0 +marra marrar VMM02S0 +marrad marrar VMM02P0 +marrando marrar VMG0000 +marrar marrar VMN0000 +marre marrar VMM03S0 +marremos marrar VMM01P0 +marren marrar VMM03P0 +martilla martillar VMM02S0 +martillad martillar VMM02P0 +martillando martillar VMG0000 +martillar martillar VMN0000 +martille martillar VMM03S0 +martillea martillear VMM02S0 +martillead martillear VMM02P0 +martilleando martillear VMG0000 +martillear martillear VMN0000 +martillee martillear VMM03S0 +martilleemos martillear VMM01P0 +martilleen martillear VMM03P0 +martillemos martillar VMM01P0 +martillen martillar VMM03P0 +martirice martirizar VMM03S0 +martiricemos martirizar VMM01P0 +martiricen martirizar VMM03P0 +martiriza martirizar VMM02S0 +martirizad martirizar VMM02P0 +martirizando martirizar VMG0000 +martirizar martirizar VMN0000 +masacra masacrar VMM02S0 +masacrad masacrar VMM02P0 +masacrando masacrar VMG0000 +masacrar masacrar VMN0000 +masacre masacrar VMM03S0 +masacremos masacrar VMM01P0 +masacren masacrar VMM03P0 +masca mascar VMM02S0 +mascad mascar VMM02P0 +mascando mascar VMG0000 +mascar mascar VMN0000 +mascuja mascujar VMM02S0 +mascujad mascujar VMM02P0 +mascujando mascujar VMG0000 +mascujar mascujar VMN0000 +mascuje mascujar VMM03S0 +mascujemos mascujar VMM01P0 +mascujen mascujar VMM03P0 +masculla mascullar VMM02S0 +mascullad mascullar VMM02P0 +mascullando mascullar VMG0000 +mascullar mascullar VMN0000 +masculle mascullar VMM03S0 +mascullemos mascullar VMM01P0 +mascullen mascullar VMM03P0 +masifica masificar VMM02S0 +masificad masificar VMM02P0 +masificando masificar VMG0000 +masificar masificar VMN0000 +masifique masificar VMM03S0 +masifiquemos masificar VMM01P0 +masifiquen masificar VMM03P0 +masque mascar VMM03S0 +masquemos mascar VMM01P0 +masquen mascar VMM03P0 +mastica masticar VMM02S0 +masticad masticar VMM02P0 +masticando masticar VMG0000 +masticar masticar VMN0000 +mastique masticar VMM03S0 +mastiquemos masticar VMM01P0 +mastiquen masticar VMM03P0 +masturba masturbar VMM02S0 +masturbad masturbar VMM02P0 +masturbando masturbar VMG0000 +masturbar masturbar VMN0000 +masturbe masturbar VMM03S0 +masturbemos masturbar VMM01P0 +masturben masturbar VMM03P0 +mata matar VMM02S0 +matad matar VMM02P0 +matando matar VMG0000 +matar matar VMN0000 +mate matar VMM03S0 +matea matear VMM02S0 +matead matear VMM02P0 +mateando matear VMG0000 +matear matear VMN0000 +matee matear VMM03S0 +mateemos matear VMM01P0 +mateen matear VMM03P0 +matemos matar VMM01P0 +maten matar VMM03P0 +materialice materializar VMM03S0 +materialicemos materializar VMM01P0 +materialicen materializar VMM03P0 +materializa materializar VMM02S0 +materializad materializar VMM02P0 +materializando materializar VMG0000 +materializar materializar VMN0000 +matice matizar VMM03S0 +maticemos matizar VMM01P0 +maticen matizar VMM03P0 +matiza matizar VMM02S0 +matizad matizar VMM02P0 +matizando matizar VMG0000 +matizar matizar VMN0000 +matonea matonear VMM02S0 +matonead matonear VMM02P0 +matoneando matonear VMG0000 +matonear matonear VMN0000 +matonee matonear VMM03S0 +matoneemos matonear VMM01P0 +matoneen matonear VMM03P0 +matraquea matraquear VMM02S0 +matraquead matraquear VMM02P0 +matraqueando matraquear VMG0000 +matraquear matraquear VMN0000 +matraquee matraquear VMM03S0 +matraqueemos matraquear VMM01P0 +matraqueen matraquear VMM03P0 +matrice matrizar VMM03S0 +matricemos matrizar VMM01P0 +matricen matrizar VMM03P0 +matricula matricular VMM02S0 +matriculad matricular VMM02P0 +matriculando matricular VMG0000 +matricular matricular VMN0000 +matricule matricular VMM03S0 +matriculemos matricular VMM01P0 +matriculen matricular VMM03P0 +matrimonia matrimoniar VMM02S0 +matrimoniad matrimoniar VMM02P0 +matrimoniando matrimoniar VMG0000 +matrimoniar matrimoniar VMN0000 +matrimonie matrimoniar VMM03S0 +matrimoniemos matrimoniar VMM01P0 +matrimonien matrimoniar VMM03P0 +matriza matrizar VMM02S0 +matrizad matrizar VMM02P0 +matrizando matrizar VMG0000 +matrizar matrizar VMN0000 +matutea matutear VMM02S0 +matutead matutear VMM02P0 +matuteando matutear VMG0000 +matutear matutear VMN0000 +matutee matutear VMM03S0 +matuteemos matutear VMM01P0 +matuteen matutear VMM03P0 +maullad maullar VMM02P0 +maullando maullar VMG0000 +maullar maullar VMN0000 +maullemos maullar VMM01P0 +maximice maximizar VMM03S0 +maximicemos maximizar VMM01P0 +maximicen maximizar VMM03P0 +maximiza maximizar VMM02S0 +maximizad maximizar VMM02P0 +maximizando maximizar VMG0000 +maximizar maximizar VMN0000 +maya mayar VMM02S0 +mayad mayar VMM02P0 +mayando mayar VMG0000 +mayar mayar VMN0000 +maye mayar VMM03S0 +mayemos mayar VMM01P0 +mayen mayar VMM03P0 +maza mazar VMM02S0 +mazad mazar VMM02P0 +mazando mazar VMG0000 +mazar mazar VMN0000 +mazna maznar VMM02S0 +maznad maznar VMM02P0 +maznando maznar VMG0000 +maznar maznar VMN0000 +mazne maznar VMM03S0 +maznemos maznar VMM01P0 +maznen maznar VMM03P0 +mazonea mazonear VMM02S0 +mazonead mazonear VMM02P0 +mazoneando mazonear VMG0000 +mazonear mazonear VMN0000 +mazonee mazonear VMM03S0 +mazoneemos mazonear VMM01P0 +mazoneen mazonear VMM03P0 +mañanea mañanear VMM02S0 +mañanead mañanear VMM02P0 +mañaneando mañanear VMG0000 +mañanear mañanear VMN0000 +mañanee mañanear VMM03S0 +mañaneemos mañanear VMM01P0 +mañaneen mañanear VMM03P0 +mañea mañear VMM02S0 +mañead mañear VMM02P0 +mañeando mañear VMG0000 +mañear mañear VMN0000 +mañee mañear VMM03S0 +mañeemos mañear VMM01P0 +mañeen mañear VMM03P0 +maúlla maullar VMM02S0 +maúlle maullar VMM03S0 +maúllen maullar VMM03P0 +mea mear VMM02S0 +mead mear VMM02P0 +meando mear VMG0000 +mear mear VMN0000 +mecanice mecanizar VMM03S0 +mecanicemos mecanizar VMM01P0 +mecanicen mecanizar VMM03P0 +mecaniza mecanizar VMM02S0 +mecanizad mecanizar VMM02P0 +mecanizando mecanizar VMG0000 +mecanizar mecanizar VMN0000 +mecanografiad mecanografiar VMM02P0 +mecanografiando mecanografiar VMG0000 +mecanografiar mecanografiar VMN0000 +mecanografiemos mecanografiar VMM01P0 +mecanografía mecanografiar VMM02S0 +mecanografíe mecanografiar VMM03S0 +mecanografíen mecanografiar VMM03P0 +mece mecer VMM02S0 +meced mecer VMM02P0 +mecer mecer VMN0000 +mecha mechar VMM02S0 +mechad mechar VMM02P0 +mechando mechar VMG0000 +mechar mechar VMN0000 +meche mechar VMM03S0 +mechemos mechar VMM01P0 +mechen mechar VMM03P0 +meciendo mecer VMG0000 +media mediar VMM02S0 +mediad mediar VMM02P0 +mediando mediar VMG0000 +mediar mediar VMN0000 +mediatice mediatizar VMM03S0 +mediaticemos mediatizar VMM01P0 +mediaticen mediatizar VMM03P0 +mediatiza mediatizar VMM02S0 +mediatizad mediatizar VMM02P0 +mediatizando mediatizar VMG0000 +mediatizar mediatizar VMN0000 +medica medicar VMM02S0 +medicad medicar VMM02P0 +medicando medicar VMG0000 +medicar medicar VMN0000 +medicina medicinar VMM02S0 +medicinad medicinar VMM02P0 +medicinando medicinar VMG0000 +medicinar medicinar VMN0000 +medicine medicinar VMM03S0 +medicinemos medicinar VMM01P0 +medicinen medicinar VMM03P0 +medid medir VMM02P0 +medie mediar VMM03S0 +mediemos mediar VMM01P0 +medien mediar VMM03P0 +medique medicar VMM03S0 +mediquemos medicar VMM01P0 +mediquen medicar VMM03P0 +medir medir VMN0000 +medita meditar VMM02S0 +meditad meditar VMM02P0 +meditando meditar VMG0000 +meditar meditar VMN0000 +medite meditar VMM03S0 +meditemos meditar VMM01P0 +mediten meditar VMM03P0 +medra medrar VMM02S0 +medrad medrar VMM02P0 +medrando medrar VMG0000 +medrar medrar VMN0000 +medre medrar VMM03S0 +medremos medrar VMM01P0 +medren medrar VMM03P0 +mee mear VMM03S0 +meemos mear VMM01P0 +meen mear VMM03P0 +mejora mejorar VMM02S0 +mejorad mejorar VMM02P0 +mejorando mejorar VMG0000 +mejorar mejorar VMN0000 +mejore mejorar VMM03S0 +mejoremos mejorar VMM01P0 +mejoren mejorar VMM03P0 +melad melar VMM02P0 +melancolice melancolizar VMM03S0 +melancolicemos melancolizar VMM01P0 +melancolicen melancolizar VMM03P0 +melancoliza melancolizar VMM02S0 +melancolizad melancolizar VMM02P0 +melancolizando melancolizar VMG0000 +melancolizar melancolizar VMN0000 +melando melar VMG0000 +melar melar VMN0000 +melemos melar VMM01P0 +melifica melificar VMM02S0 +melificad melificar VMM02P0 +melificando melificar VMG0000 +melificar melificar VMN0000 +melifique melificar VMM03S0 +melifiquemos melificar VMM01P0 +melifiquen melificar VMM03P0 +mella mellar VMM02S0 +mellad mellar VMM02P0 +mellando mellar VMG0000 +mellar mellar VMN0000 +melle mellar VMM03S0 +mellemos mellar VMM01P0 +mellen mellar VMM03P0 +memora memorar VMM02S0 +memorad memorar VMM02P0 +memorando memorar VMG0000 +memorar memorar VMN0000 +memore memorar VMM03S0 +memoremos memorar VMM01P0 +memoren memorar VMM03P0 +memorice memorizar VMM03S0 +memoricemos memorizar VMM01P0 +memoricen memorizar VMM03P0 +memoriza memorizar VMM02S0 +memorizad memorizar VMM02P0 +memorizando memorizar VMG0000 +memorizar memorizar VMN0000 +menciona mencionar VMM02S0 +mencionad mencionar VMM02P0 +mencionando mencionar VMG0000 +mencionar mencionar VMN0000 +mencione mencionar VMM03S0 +mencionemos mencionar VMM01P0 +mencionen mencionar VMM03P0 +mendiga mendigar VMM02S0 +mendigad mendigar VMM02P0 +mendigando mendigar VMG0000 +mendigar mendigar VMN0000 +mendigue mendigar VMM03S0 +mendiguemos mendigar VMM01P0 +mendiguen mendigar VMM03P0 +menea menear VMM02S0 +menead menear VMM02P0 +meneando menear VMG0000 +menear menear VMN0000 +menee menear VMM03S0 +meneemos menear VMM01P0 +meneen menear VMM03P0 +mengua menguar VMM02S0 +menguad menguar VMM02P0 +menguando menguar VMG0000 +menguar menguar VMN0000 +mengüe menguar VMM03S0 +mengüemos menguar VMM01P0 +mengüen menguar VMM03P0 +menoscaba menoscabar VMM02S0 +menoscabad menoscabar VMM02P0 +menoscabando menoscabar VMG0000 +menoscabar menoscabar VMN0000 +menoscabe menoscabar VMM03S0 +menoscabemos menoscabar VMM01P0 +menoscaben menoscabar VMM03P0 +menosprecia menospreciar VMM02S0 +menospreciad menospreciar VMM02P0 +menospreciando menospreciar VMG0000 +menospreciar menospreciar VMN0000 +menosprecie menospreciar VMM03S0 +menospreciemos menospreciar VMM01P0 +menosprecien menospreciar VMM03P0 +menstruad menstruar VMM02P0 +menstruando menstruar VMG0000 +menstruar menstruar VMN0000 +menstruemos menstruar VMM01P0 +menstrúa menstruar VMM02S0 +menstrúe menstruar VMM03S0 +menstrúen menstruar VMM03P0 +mensura mensurar VMM02S0 +mensurad mensurar VMM02P0 +mensurando mensurar VMG0000 +mensurar mensurar VMN0000 +mensure mensurar VMM03S0 +mensuremos mensurar VMM01P0 +mensuren mensurar VMM03P0 +mentad mentar VMM02P0 +mentalice mentalizar VMM03S0 +mentalicemos mentalizar VMM01P0 +mentalicen mentalizar VMM03P0 +mentaliza mentalizar VMM02S0 +mentalizad mentalizar VMM02P0 +mentalizando mentalizar VMG0000 +mentalizar mentalizar VMN0000 +mentando mentar VMG0000 +mentar mentar VMN0000 +mentemos mentar VMM01P0 +mentid mentir VMM02P0 +mentir mentir VMN0000 +menudea menudear VMM02S0 +menudead menudear VMM02P0 +menudeando menudear VMG0000 +menudear menudear VMN0000 +menudee menudear VMM03S0 +menudeemos menudear VMM01P0 +menudeen menudear VMM03P0 +mera merar VMM02S0 +merad merar VMM02P0 +merando merar VMG0000 +merar merar VMN0000 +merca mercar VMM02S0 +mercad mercar VMM02P0 +mercadea mercadear VMM02S0 +mercadead mercadear VMM02P0 +mercadeando mercadear VMG0000 +mercadear mercadear VMN0000 +mercadee mercadear VMM03S0 +mercadeemos mercadear VMM01P0 +mercadeen mercadear VMM03P0 +mercando mercar VMG0000 +mercantilice mercantilizar VMM03S0 +mercantilicemos mercantilizar VMM01P0 +mercantilicen mercantilizar VMM03P0 +mercantiliza mercantilizar VMM02S0 +mercantilizad mercantilizar VMM02P0 +mercantilizando mercantilizar VMG0000 +mercantilizar mercantilizar VMN0000 +mercar mercar VMN0000 +mercerice mercerizar VMM03S0 +mercericemos mercerizar VMM01P0 +mercericen mercerizar VMM03P0 +merceriza mercerizar VMM02S0 +mercerizad mercerizar VMM02P0 +mercerizando mercerizar VMG0000 +mercerizar mercerizar VMN0000 +mere merar VMM03S0 +merece merecer VMM02S0 +mereced merecer VMM02P0 +merecer merecer VMN0000 +mereciendo merecer VMG0000 +meremos merar VMM01P0 +meren merar VMM03P0 +merendad merendar VMM02P0 +merendando merendar VMG0000 +merendar merendar VMN0000 +merendemos merendar VMM01P0 +merezca merecer VMM03S0 +merezcamos merecer VMM01P0 +merezcan merecer VMM03P0 +merienda merendar VMM02S0 +meriende merendar VMM03S0 +merienden merendar VMM03P0 +merma mermar VMM02S0 +mermad mermar VMM02P0 +mermando mermar VMG0000 +mermar mermar VMN0000 +merme mermar VMM03S0 +mermemos mermar VMM01P0 +mermen mermar VMM03P0 +merodea merodear VMM02S0 +merodead merodear VMM02P0 +merodeando merodear VMG0000 +merodear merodear VMN0000 +merodee merodear VMM03S0 +merodeemos merodear VMM01P0 +merodeen merodear VMM03P0 +merque mercar VMM03S0 +merquemos mercar VMM01P0 +merquen mercar VMM03P0 +mesa mesar VMM02S0 +mesad mesar VMM02P0 +mesando mesar VMG0000 +mesar mesar VMN0000 +mese mesar VMM03S0 +mesemos mesar VMM01P0 +mesen mesar VMM03P0 +mestice mestizar VMM03S0 +mesticemos mestizar VMM01P0 +mesticen mestizar VMM03P0 +mestiza mestizar VMM02S0 +mestizad mestizar VMM02P0 +mestizando mestizar VMG0000 +mestizar mestizar VMN0000 +mesura mesurar VMM02S0 +mesurad mesurar VMM02P0 +mesurando mesurar VMG0000 +mesurar mesurar VMN0000 +mesure mesurar VMM03S0 +mesuremos mesurar VMM01P0 +mesuren mesurar VMM03P0 +meta meter VMM03S0 +metaforice metaforizar VMM03S0 +metaforicemos metaforizar VMM01P0 +metaforicen metaforizar VMM03P0 +metaforiza metaforizar VMM02S0 +metaforizad metaforizar VMM02P0 +metaforizando metaforizar VMG0000 +metaforizar metaforizar VMN0000 +metalice metalizar VMM03S0 +metalicemos metalizar VMM01P0 +metalicen metalizar VMM03P0 +metaliza metalizar VMM02S0 +metalizad metalizar VMM02P0 +metalizando metalizar VMG0000 +metalizar metalizar VMN0000 +metamorfosea metamorfosear VMM02S0 +metamorfosead metamorfosear VMM02P0 +metamorfoseando metamorfosear VMG0000 +metamorfosear metamorfosear VMN0000 +metamorfosee metamorfosear VMM03S0 +metamorfoseemos metamorfosear VMM01P0 +metamorfoseen metamorfosear VMM03P0 +metamos meter VMM01P0 +metan meter VMM03P0 +mete meter VMM02S0 +meted meter VMM02P0 +meteorice meteorizar VMM03S0 +meteoricemos meteorizar VMM01P0 +meteoricen meteorizar VMM03P0 +meteoriza meteorizar VMM02S0 +meteorizad meteorizar VMM02P0 +meteorizando meteorizar VMG0000 +meteorizar meteorizar VMN0000 +meter meter VMN0000 +metiendo meter VMG0000 +metodice metodizar VMM03S0 +metodicemos metodizar VMM01P0 +metodicen metodizar VMM03P0 +metodiza metodizar VMM02S0 +metodizad metodizar VMM02P0 +metodizando metodizar VMG0000 +metodizar metodizar VMN0000 +metrifica metrificar VMM02S0 +metrificad metrificar VMM02P0 +metrificando metrificar VMG0000 +metrificar metrificar VMN0000 +metrifique metrificar VMM03S0 +metrifiquemos metrificar VMM01P0 +metrifiquen metrificar VMM03P0 +meza mecer VMM03S0 +mezamos mecer VMM01P0 +mezan mecer VMM03P0 +mezcla mezclar VMM02S0 +mezclad mezclar VMM02P0 +mezclando mezclar VMG0000 +mezclar mezclar VMN0000 +mezcle mezclar VMM03S0 +mezclemos mezclar VMM01P0 +mezclen mezclar VMM03P0 +miad miar VMM02P0 +miando miar VMG0000 +miar miar VMN0000 +miaña miañar VMM02S0 +miañad miañar VMM02P0 +miañando miañar VMG0000 +miañar miañar VMN0000 +miañe miañar VMM03S0 +miañemos miañar VMM01P0 +miañen miañar VMM03P0 +microfilma microfilmar VMM02S0 +microfilmad microfilmar VMM02P0 +microfilmando microfilmar VMG0000 +microfilmar microfilmar VMN0000 +microfilme microfilmar VMM03S0 +microfilmemos microfilmar VMM01P0 +microfilmen microfilmar VMM03P0 +mida medir VMM03S0 +midamos medir VMM01P0 +midan medir VMM03P0 +mide medir VMM02S0 +midiendo medir VMG0000 +miela melar VMM02S0 +miele melar VMM03S0 +mielen melar VMM03P0 +miemos miar VMM01P0 +mienta mentar VMM02S0 +mienta mentir VMM03S0 +mientan mentir VMM03P0 +miente mentar VMM03S0 +miente mentir VMM02S0 +mienten mentar VMM03P0 +miga migar VMM02S0 +migad migar VMM02P0 +migando migar VMG0000 +migar migar VMN0000 +migra migrar VMM02S0 +migrad migrar VMM02P0 +migrando migrar VMG0000 +migrar migrar VMN0000 +migre migrar VMM03S0 +migremos migrar VMM01P0 +migren migrar VMM03P0 +migue migar VMM03S0 +miguemos migar VMM01P0 +miguen migar VMM03P0 +milita militar VMM02S0 +militad militar VMM02P0 +militando militar VMG0000 +militar militar VMN0000 +militarice militarizar VMM03S0 +militaricemos militarizar VMM01P0 +militaricen militarizar VMM03P0 +militariza militarizar VMM02S0 +militarizad militarizar VMM02P0 +militarizando militarizar VMG0000 +militarizar militarizar VMN0000 +milite militar VMM03S0 +militemos militar VMM01P0 +militen militar VMM03P0 +milpea milpear VMM02S0 +milpead milpear VMM02P0 +milpeando milpear VMG0000 +milpear milpear VMN0000 +milpee milpear VMM03S0 +milpeemos milpear VMM01P0 +milpeen milpear VMM03P0 +mima mimar VMM02S0 +mimad mimar VMM02P0 +mimando mimar VMG0000 +mimar mimar VMN0000 +mimbrea mimbrear VMM02S0 +mimbread mimbrear VMM02P0 +mimbreando mimbrear VMG0000 +mimbrear mimbrear VMN0000 +mimbree mimbrear VMM03S0 +mimbreemos mimbrear VMM01P0 +mimbreen mimbrear VMM03P0 +mime mimar VMM03S0 +mimemos mimar VMM01P0 +mimen mimar VMM03P0 +mimetice mimetizar VMM03S0 +mimeticemos mimetizar VMM01P0 +mimeticen mimetizar VMM03P0 +mimetiza mimetizar VMM02S0 +mimetizad mimetizar VMM02P0 +mimetizando mimetizar VMG0000 +mimetizar mimetizar VMN0000 +mina minar VMM02S0 +minad minar VMM02P0 +minando minar VMG0000 +minar minar VMN0000 +mine minar VMM03S0 +minemos minar VMM01P0 +minen minar VMM03P0 +mineralice mineralizar VMM03S0 +mineralicemos mineralizar VMM01P0 +mineralicen mineralizar VMM03P0 +mineraliza mineralizar VMM02S0 +mineralizad mineralizar VMM02P0 +mineralizando mineralizar VMG0000 +mineralizar mineralizar VMN0000 +minia miniar VMM02S0 +miniad miniar VMM02P0 +miniando miniar VMG0000 +miniar miniar VMN0000 +minie miniar VMM03S0 +miniemos miniar VMM01P0 +minien miniar VMM03P0 +minimalice minimalizar VMM03S0 +minimalicemos minimalizar VMM01P0 +minimalicen minimalizar VMM03P0 +minimaliza minimalizar VMM02S0 +minimalizad minimalizar VMM02P0 +minimalizando minimalizar VMG0000 +minimalizar minimalizar VMN0000 +minimice minimizar VMM03S0 +minimicemos minimizar VMM01P0 +minimicen minimizar VMM03P0 +minimiza minimizar VMM02S0 +minimizad minimizar VMM02P0 +minimizando minimizar VMG0000 +minimizar minimizar VMN0000 +minora minorar VMM02S0 +minorad minorar VMM02P0 +minorando minorar VMG0000 +minorar minorar VMN0000 +minore minorar VMM03S0 +minoremos minorar VMM01P0 +minoren minorar VMM03P0 +mintamos mentir VMM01P0 +mintiendo mentir VMG0000 +minusvalora minusvalorar VMM02S0 +minusvalorad minusvalorar VMM02P0 +minusvalorando minusvalorar VMG0000 +minusvalorar minusvalorar VMN0000 +minusvalore minusvalorar VMM03S0 +minusvaloremos minusvalorar VMM01P0 +minusvaloren minusvalorar VMM03P0 +minuta minutar VMM02S0 +minutad minutar VMM02P0 +minutando minutar VMG0000 +minutar minutar VMN0000 +minute minutar VMM03S0 +minutemos minutar VMM01P0 +minuten minutar VMM03P0 +mira mirar VMM02S0 +mirad mirar VMM02P0 +mirando mirar VMG0000 +mirar mirar VMN0000 +mire mirar VMM03S0 +miremos mirar VMM01P0 +miren mirar VMM03P0 +miserea miserear VMM02S0 +miseread miserear VMM02P0 +misereando miserear VMG0000 +miserear miserear VMN0000 +miseree miserear VMM03S0 +misereemos miserear VMM01P0 +misereen miserear VMM03P0 +misiona misionar VMM02S0 +misionad misionar VMM02P0 +misionando misionar VMG0000 +misionar misionar VMN0000 +misione misionar VMM03S0 +misionemos misionar VMM01P0 +misionen misionar VMM03P0 +mista mistar VMM02S0 +mistad mistar VMM02P0 +mistando mistar VMG0000 +mistar mistar VMN0000 +miste mistar VMM03S0 +mistemos mistar VMM01P0 +misten mistar VMM03P0 +mistifica mistificar VMM02S0 +mistificad mistificar VMM02P0 +mistificando mistificar VMG0000 +mistificar mistificar VMN0000 +mistifique mistificar VMM03S0 +mistifiquemos mistificar VMM01P0 +mistifiquen mistificar VMM03P0 +mitifica mitificar VMM02S0 +mitificad mitificar VMM02P0 +mitificando mitificar VMG0000 +mitificar mitificar VMN0000 +mitifique mitificar VMM03S0 +mitifiquemos mitificar VMM01P0 +mitifiquen mitificar VMM03P0 +mitiga mitigar VMM02S0 +mitigad mitigar VMM02P0 +mitigando mitigar VMG0000 +mitigar mitigar VMN0000 +mitigue mitigar VMM03S0 +mitiguemos mitigar VMM01P0 +mitiguen mitigar VMM03P0 +mixtura mixturar VMM02S0 +mixturad mixturar VMM02P0 +mixturando mixturar VMG0000 +mixturar mixturar VMN0000 +mixture mixturar VMM03S0 +mixturemos mixturar VMM01P0 +mixturen mixturar VMM03P0 +moblad moblar VMM02P0 +moblando moblar VMG0000 +moblar moblar VMN0000 +moblemos moblar VMM01P0 +moca mocar VMM02S0 +mocad mocar VMM02P0 +mocando mocar VMG0000 +mocar mocar VMN0000 +mocea mocear VMM02S0 +mocead mocear VMM02P0 +moceando mocear VMG0000 +mocear mocear VMN0000 +mocee mocear VMM03S0 +moceemos mocear VMM01P0 +moceen mocear VMM03P0 +mocha mochar VMM02S0 +mochad mochar VMM02P0 +mochando mochar VMG0000 +mochar mochar VMN0000 +moche mochar VMM03S0 +mochemos mochar VMM01P0 +mochen mochar VMM03P0 +modela modelar VMM02S0 +modelad modelar VMM02P0 +modelando modelar VMG0000 +modelar modelar VMN0000 +modele modelar VMM03S0 +modelemos modelar VMM01P0 +modelen modelar VMM03P0 +modeliza modelizar VMM02S0 +modelizad modelizar VMM02P0 +modelizando modelizar VMG0000 +modelizar modelizar VMN0000 +modera moderar VMM02S0 +moderad moderar VMM02P0 +moderando moderar VMG0000 +moderar moderar VMN0000 +modere moderar VMM03S0 +moderemos moderar VMM01P0 +moderen moderar VMM03P0 +modernice modernizar VMM03S0 +modernicemos modernizar VMM01P0 +modernicen modernizar VMM03P0 +moderniza modernizar VMM02S0 +modernizad modernizar VMM02P0 +modernizando modernizar VMG0000 +modernizar modernizar VMN0000 +modifica modificar VMM02S0 +modificad modificar VMM02P0 +modificando modificar VMG0000 +modificar modificar VMN0000 +modifique modificar VMM03S0 +modifiquemos modificar VMM01P0 +modifiquen modificar VMM03P0 +modorra modorrar VMM02S0 +modorrad modorrar VMM02P0 +modorrando modorrar VMG0000 +modorrar modorrar VMN0000 +modorre modorrar VMM03S0 +modorremos modorrar VMM01P0 +modorren modorrar VMM03P0 +modula modular VMM02S0 +modulad modular VMM02P0 +modulando modular VMG0000 +modular modular VMN0000 +module modular VMM03S0 +modulemos modular VMM01P0 +modulen modular VMM03P0 +mofa mofar VMM02S0 +mofad mofar VMM02P0 +mofando mofar VMG0000 +mofar mofar VMN0000 +mofe mofar VMM03S0 +mofemos mofar VMM01P0 +mofen mofar VMM03P0 +mohatra mohatrar VMM02S0 +mohatrad mohatrar VMM02P0 +mohatrando mohatrar VMG0000 +mohatrar mohatrar VMN0000 +mohatre mohatrar VMM03S0 +mohatremos mohatrar VMM01P0 +mohatren mohatrar VMM03P0 +mohece mohecer VMM02S0 +moheced mohecer VMM02P0 +mohecer mohecer VMN0000 +moheciendo mohecer VMG0000 +mohezca mohecer VMM03S0 +mohezcamos mohecer VMM01P0 +mohezcan mohecer VMM03P0 +moja mojar VMM02S0 +mojad mojar VMM02P0 +mojando mojar VMG0000 +mojar mojar VMN0000 +moje mojar VMM03S0 +mojemos mojar VMM01P0 +mojen mojar VMM03P0 +mojona mojonar VMM02S0 +mojonad mojonar VMM02P0 +mojonando mojonar VMG0000 +mojonar mojonar VMN0000 +mojone mojonar VMM03S0 +mojonemos mojonar VMM01P0 +mojonen mojonar VMM03P0 +molamos moler VMM01P0 +molda moldar VMM02S0 +moldad moldar VMM02P0 +moldando moldar VMG0000 +moldar moldar VMN0000 +molde moldar VMM03S0 +moldea moldear VMM02S0 +moldead moldear VMM02P0 +moldeando moldear VMG0000 +moldear moldear VMN0000 +moldee moldear VMM03S0 +moldeemos moldear VMM01P0 +moldeen moldear VMM03P0 +moldemos moldar VMM01P0 +molden moldar VMM03P0 +moldura moldurar VMM02S0 +moldurad moldurar VMM02P0 +moldurando moldurar VMG0000 +moldurar moldurar VMN0000 +moldure moldurar VMM03S0 +molduremos moldurar VMM01P0 +molduren moldurar VMM03P0 +moled moler VMM02P0 +moler moler VMN0000 +molesta molestar VMM02S0 +molestad molestar VMM02P0 +molestando molestar VMG0000 +molestar molestar VMN0000 +moleste molestar VMM03S0 +molestemos molestar VMM01P0 +molesten molestar VMM03P0 +moliendo moler VMG0000 +molifica molificar VMM02S0 +molificad molificar VMM02P0 +molificando molificar VMG0000 +molificar molificar VMN0000 +molifique molificar VMM03S0 +molifiquemos molificar VMM01P0 +molifiquen molificar VMM03P0 +mollizna molliznar VMM02S0 +molliznad molliznar VMM02P0 +molliznando molliznar VMG0000 +molliznar molliznar VMN0000 +mollizne molliznar VMM03S0 +molliznea molliznear VMM02S0 +molliznead molliznear VMM02P0 +mollizneando molliznear VMG0000 +molliznear molliznear VMN0000 +molliznee molliznear VMM03S0 +mollizneemos molliznear VMM01P0 +mollizneen molliznear VMM03P0 +molliznemos molliznar VMM01P0 +molliznen molliznar VMM03P0 +moltura molturar VMM02S0 +molturad molturar VMM02P0 +molturando molturar VMG0000 +molturar molturar VMN0000 +molture molturar VMM03S0 +molturemos molturar VMM01P0 +molturen molturar VMM03P0 +momea momear VMM02S0 +momead momear VMM02P0 +momeando momear VMG0000 +momear momear VMN0000 +momee momear VMM03S0 +momeemos momear VMM01P0 +momeen momear VMM03P0 +momifica momificar VMM02S0 +momificad momificar VMM02P0 +momificando momificar VMG0000 +momificar momificar VMN0000 +momifique momificar VMM03S0 +momifiquemos momificar VMM01P0 +momifiquen momificar VMM03P0 +monda mondar VMM02S0 +mondad mondar VMM02P0 +mondando mondar VMG0000 +mondar mondar VMN0000 +monde mondar VMM03S0 +mondemos mondar VMM01P0 +monden mondar VMM03P0 +monea monear VMM02S0 +monead monear VMM02P0 +moneando monear VMG0000 +monear monear VMN0000 +moneda monedar VMM02S0 +monedad monedar VMM02P0 +monedando monedar VMG0000 +monedar monedar VMN0000 +monedea monedear VMM02S0 +monedead monedear VMM02P0 +monedeando monedear VMG0000 +monedear monedear VMN0000 +monedee monedear VMM03S0 +monedeemos monedear VMM01P0 +monedeen monedear VMM03P0 +monee monear VMM03S0 +moneemos monear VMM01P0 +moneen monear VMM03P0 +monetice monetizar VMM03S0 +moneticemos monetizar VMM01P0 +moneticen monetizar VMM03P0 +monetiza monetizar VMM02S0 +monetizad monetizar VMM02P0 +monetizando monetizar VMG0000 +monetizar monetizar VMN0000 +monitorice monitorizar VMM03S0 +monitoricemos monitorizar VMM01P0 +monitoricen monitorizar VMM03P0 +monitoriza monitorizar VMM02S0 +monitorizad monitorizar VMM02P0 +monitorizando monitorizar VMG0000 +monitorizar monitorizar VMN0000 +monologa monologar VMM02S0 +monologad monologar VMM02P0 +monologando monologar VMG0000 +monologar monologar VMN0000 +monologue monologar VMM03S0 +monologuemos monologar VMM01P0 +monologuen monologar VMM03P0 +monopolice monopolizar VMM03S0 +monopolicemos monopolizar VMM01P0 +monopolicen monopolizar VMM03P0 +monopoliza monopolizar VMM02S0 +monopolizad monopolizar VMM02P0 +monopolizando monopolizar VMG0000 +monopolizar monopolizar VMN0000 +monta montar VMM02S0 +montad montar VMM02P0 +montando montar VMG0000 +montar montar VMN0000 +monte montar VMM03S0 +montea montear VMM02S0 +montead montear VMM02P0 +monteando montear VMG0000 +montear montear VMN0000 +montee montear VMM03S0 +monteemos montear VMM01P0 +monteen montear VMM03P0 +montemos montar VMM01P0 +monten montar VMM03P0 +moque mocar VMM03S0 +moquea moquear VMM02S0 +moquead moquear VMM02P0 +moqueando moquear VMG0000 +moquear moquear VMN0000 +moquee moquear VMM03S0 +moqueemos moquear VMM01P0 +moqueen moquear VMM03P0 +moquemos mocar VMM01P0 +moquen mocar VMM03P0 +moquetea moquetear VMM02S0 +moquetead moquetear VMM02P0 +moqueteando moquetear VMG0000 +moquetear moquetear VMN0000 +moquetee moquetear VMM03S0 +moqueteemos moquetear VMM01P0 +moqueteen moquetear VMM03P0 +mora morar VMM02S0 +morad morar VMM02P0 +moralice moralizar VMM03S0 +moralicemos moralizar VMM01P0 +moralicen moralizar VMM03P0 +moraliza moralizar VMM02S0 +moralizad moralizar VMM02P0 +moralizando moralizar VMG0000 +moralizar moralizar VMN0000 +morando morar VMG0000 +morar morar VMN0000 +mordamos morder VMM01P0 +morded morder VMM02P0 +morder morder VMN0000 +mordica mordicar VMM02S0 +mordicad mordicar VMM02P0 +mordicando mordicar VMG0000 +mordicar mordicar VMN0000 +mordiendo morder VMG0000 +mordique mordicar VMM03S0 +mordiquemos mordicar VMM01P0 +mordiquen mordicar VMM03P0 +mordisca mordiscar VMM02S0 +mordiscad mordiscar VMM02P0 +mordiscando mordiscar VMG0000 +mordiscar mordiscar VMN0000 +mordisque mordiscar VMM03S0 +mordisquea mordisquear VMM02S0 +mordisquead mordisquear VMM02P0 +mordisqueando mordisquear VMG0000 +mordisquear mordisquear VMN0000 +mordisquee mordisquear VMM03S0 +mordisqueemos mordisquear VMM01P0 +mordisqueen mordisquear VMM03P0 +mordisquemos mordiscar VMM01P0 +mordisquen mordiscar VMM03P0 +more morar VMM03S0 +moremos morar VMM01P0 +moren morar VMM03P0 +morid morir VMM02P0 +morigera morigerar VMM02S0 +morigerad morigerar VMM02P0 +morigerando morigerar VMG0000 +morigerar morigerar VMN0000 +morigere morigerar VMM03S0 +morigeremos morigerar VMM01P0 +morigeren morigerar VMM03P0 +morir morir VMN0000 +mortifica mortificar VMM02S0 +mortificad mortificar VMM02P0 +mortificando mortificar VMG0000 +mortificar mortificar VMN0000 +mortifique mortificar VMM03S0 +mortifiquemos mortificar VMM01P0 +mortifiquen mortificar VMM03P0 +mosconea mosconear VMM02S0 +mosconead mosconear VMM02P0 +mosconeando mosconear VMG0000 +mosconear mosconear VMN0000 +mosconee mosconear VMM03S0 +mosconeemos mosconear VMM01P0 +mosconeen mosconear VMM03P0 +mosquea mosquear VMM02S0 +mosquead mosquear VMM02P0 +mosqueando mosquear VMG0000 +mosquear mosquear VMN0000 +mosquee mosquear VMM03S0 +mosqueemos mosquear VMM01P0 +mosqueen mosquear VMM03P0 +mostea mostear VMM02S0 +mostead mostear VMM02P0 +mosteando mostear VMG0000 +mostear mostear VMN0000 +mostee mostear VMM03S0 +mosteemos mostear VMM01P0 +mosteen mostear VMM03P0 +mostrad mostrar VMM02P0 +mostrando mostrar VMG0000 +mostrar mostrar VMN0000 +mostremos mostrar VMM01P0 +motea motear VMM02S0 +motead motear VMM02P0 +moteando motear VMG0000 +motear motear VMN0000 +motee motear VMM03S0 +moteemos motear VMM01P0 +moteen motear VMM03P0 +moteja motejar VMM02S0 +motejad motejar VMM02P0 +motejando motejar VMG0000 +motejar motejar VMN0000 +moteje motejar VMM03S0 +motejemos motejar VMM01P0 +motejen motejar VMM03P0 +motila motilar VMM02S0 +motilad motilar VMM02P0 +motilando motilar VMG0000 +motilar motilar VMN0000 +motile motilar VMM03S0 +motilemos motilar VMM01P0 +motilen motilar VMM03P0 +motiva motivar VMM02S0 +motivad motivar VMM02P0 +motivando motivar VMG0000 +motivar motivar VMN0000 +motive motivar VMM03S0 +motivemos motivar VMM01P0 +motiven motivar VMM03P0 +motorice motorizar VMM03S0 +motoricemos motorizar VMM01P0 +motoricen motorizar VMM03P0 +motoriza motorizar VMM02S0 +motorizad motorizar VMM02P0 +motorizando motorizar VMG0000 +motorizar motorizar VMN0000 +movamos mover VMM01P0 +moved mover VMM02P0 +mover mover VMN0000 +moviendo mover VMG0000 +movilice movilizar VMM03S0 +movilicemos movilizar VMM01P0 +movilicen movilizar VMM03P0 +moviliza movilizar VMM02S0 +movilizad movilizar VMM02P0 +movilizando movilizar VMG0000 +movilizar movilizar VMN0000 +muchachea muchachear VMM02S0 +muchachead muchachear VMM02P0 +muchacheando muchachear VMG0000 +muchachear muchachear VMN0000 +muchachee muchachear VMM03S0 +muchacheemos muchachear VMM01P0 +muchacheen muchachear VMM03P0 +muda mudar VMM02S0 +mudad mudar VMM02P0 +mudando mudar VMG0000 +mudar mudar VMN0000 +mude mudar VMM03S0 +mudemos mudar VMM01P0 +muden mudar VMM03P0 +muebla moblar VMM02S0 +mueble moblar VMM03S0 +mueblen moblar VMM03P0 +muela moler VMM03S0 +muelan moler VMM03P0 +muele moler VMM02S0 +muera morir VMM03S0 +mueran morir VMM03P0 +muerda morder VMM03S0 +muerdan morder VMM03P0 +muerde morder VMM02S0 +muere morir VMM02S0 +muestra mostrar VMM02S0 +muestre mostrar VMM03S0 +muestren mostrar VMM03P0 +mueva mover VMM03S0 +muevan mover VMM03P0 +mueve mover VMM02S0 +muge mugir VMM02S0 +mugid mugir VMM02P0 +mugiendo mugir VMG0000 +mugir mugir VMN0000 +muja mugir VMM03S0 +mujamos mugir VMM01P0 +mujan mugir VMM03P0 +mulla mullir VMM03S0 +mullamos mullir VMM01P0 +mullan mullir VMM03P0 +mulle mullir VMM02S0 +mullendo mullir VMG0000 +mullid mullir VMM02P0 +mullir mullir VMN0000 +multa multar VMM02S0 +multad multar VMM02P0 +multando multar VMG0000 +multar multar VMN0000 +multe multar VMM03S0 +multemos multar VMM01P0 +multen multar VMM03P0 +multiplexa multiplexar VMM02S0 +multiplexad multiplexar VMM02P0 +multiplexando multiplexar VMG0000 +multiplexar multiplexar VMN0000 +multiplexe multiplexar VMM03S0 +multiplexemos multiplexar VMM01P0 +multiplexen multiplexar VMM03P0 +multiplica multiplicar VMM02S0 +multiplicad multiplicar VMM02P0 +multiplicando multiplicar VMG0000 +multiplicar multiplicar VMN0000 +multiplique multiplicar VMM03S0 +multipliquemos multiplicar VMM01P0 +multipliquen multiplicar VMM03P0 +municiona municionar VMM02S0 +municionad municionar VMM02P0 +municionando municionar VMG0000 +municionar municionar VMN0000 +municione municionar VMM03S0 +municionemos municionar VMM01P0 +municionen municionar VMM03P0 +municipalice municipalizar VMM03S0 +municipalicemos municipalizar VMM01P0 +municipalicen municipalizar VMM03P0 +municipaliza municipalizar VMM02S0 +municipalizad municipalizar VMM02P0 +municipalizando municipalizar VMG0000 +municipalizar municipalizar VMN0000 +mura murar VMM02S0 +murad murar VMM02P0 +muramos morir VMM01P0 +murando murar VMG0000 +murar murar VMN0000 +mure murar VMM03S0 +muremos murar VMM01P0 +muren murar VMM03P0 +muriendo morir VMG0000 +murmuea murmuear VMM02S0 +murmuead murmuear VMM02P0 +murmueando murmuear VMG0000 +murmuear murmuear VMN0000 +murmulla murmullar VMM02S0 +murmullad murmullar VMM02P0 +murmullando murmullar VMG0000 +murmullar murmullar VMN0000 +murmulle murmullar VMM03S0 +murmullemos murmullar VMM01P0 +murmullen murmullar VMM03P0 +murmura murmurar VMM02S0 +murmurad murmurar VMM02P0 +murmurando murmurar VMG0000 +murmurar murmurar VMN0000 +murmure murmurar VMM03S0 +murmuremos murmurar VMM01P0 +murmuren murmurar VMM03P0 +musica musicar VMM02S0 +musicad musicar VMM02P0 +musicando musicar VMG0000 +musicar musicar VMN0000 +musique musicar VMM03S0 +musiquemos musicar VMM01P0 +musiquen musicar VMM03P0 +musita musitar VMM02S0 +musitad musitar VMM02P0 +musitando musitar VMG0000 +musitar musitar VMN0000 +musite musitar VMM03S0 +musitemos musitar VMM01P0 +musiten musitar VMM03P0 +mustia mustiar VMM02S0 +mustiad mustiar VMM02P0 +mustiando mustiar VMG0000 +mustiar mustiar VMN0000 +mustie mustiar VMM03S0 +mustiemos mustiar VMM01P0 +mustien mustiar VMM03P0 +muta mutar VMM02S0 +mutad mutar VMM02P0 +mutando mutar VMG0000 +mutar mutar VMN0000 +mute mutar VMM03S0 +mutemos mutar VMM01P0 +muten mutar VMM03P0 +mutila mutilar VMM02S0 +mutilad mutilar VMM02P0 +mutilando mutilar VMG0000 +mutilar mutilar VMN0000 +mutile mutilar VMM03S0 +mutilemos mutilar VMM01P0 +mutilen mutilar VMM03P0 +mía miar VMM02S0 +míe miar VMM03S0 +míen miar VMM03P0 +nace nacer VMM02S0 +naced nacer VMM02P0 +nacer nacer VMN0000 +naciendo nacer VMG0000 +nacionalice nacionalizar VMM03S0 +nacionalicemos nacionalizar VMM01P0 +nacionalicen nacionalizar VMM03P0 +nacionaliza nacionalizar VMM02S0 +nacionalizad nacionalizar VMM02P0 +nacionalizando nacionalizar VMG0000 +nacionalizar nacionalizar VMN0000 +nada nadar VMM02S0 +nadad nadar VMM02P0 +nadando nadar VMG0000 +nadar nadar VMN0000 +nade nadar VMM03S0 +nademos nadar VMM01P0 +naden nadar VMM03P0 +naja najar VMM02S0 +najad najar VMM02P0 +najando najar VMG0000 +najar najar VMN0000 +naje najar VMM03S0 +najemos najar VMM01P0 +najen najar VMM03P0 +narcotice narcotizar VMM03S0 +narcoticemos narcotizar VMM01P0 +narcoticen narcotizar VMM03P0 +narcotiza narcotizar VMM02S0 +narcotizad narcotizar VMM02P0 +narcotizando narcotizar VMG0000 +narcotizar narcotizar VMN0000 +narra narrar VMM02S0 +narrad narrar VMM02P0 +narrando narrar VMG0000 +narrar narrar VMN0000 +narre narrar VMM03S0 +narremos narrar VMM01P0 +narren narrar VMM03P0 +nasalice nasalizar VMM03S0 +nasalicemos nasalizar VMM01P0 +nasalicen nasalizar VMM03P0 +nasaliza nasalizar VMM02S0 +nasalizad nasalizar VMM02P0 +nasalizando nasalizar VMG0000 +nasalizar nasalizar VMN0000 +naturalice naturalizar VMM03S0 +naturalicemos naturalizar VMM01P0 +naturalicen naturalizar VMM03P0 +naturaliza naturalizar VMM02S0 +naturalizad naturalizar VMM02P0 +naturalizando naturalizar VMG0000 +naturalizar naturalizar VMN0000 +naufraga naufragar VMM02S0 +naufragad naufragar VMM02P0 +naufragando naufragar VMG0000 +naufragar naufragar VMN0000 +naufrague naufragar VMM03S0 +naufraguemos naufragar VMM01P0 +naufraguen naufragar VMM03P0 +nausea nausear VMM02S0 +nausead nausear VMM02P0 +nauseando nausear VMG0000 +nausear nausear VMN0000 +nausee nausear VMM03S0 +nauseemos nausear VMM01P0 +nauseen nausear VMM03P0 +navega navegar VMM02S0 +navegad navegar VMM02P0 +navegando navegar VMG0000 +navegar navegar VMN0000 +navegue navegar VMM03S0 +naveguemos navegar VMM01P0 +naveguen navegar VMM03P0 +nazca nacer VMM03S0 +nazcamos nacer VMM01P0 +nazcan nacer VMM03P0 +necea necear VMM02S0 +necead necear VMM02P0 +neceando necear VMG0000 +necear necear VMN0000 +necee necear VMM03S0 +neceemos necear VMM01P0 +neceen necear VMM03P0 +necesita necesitar VMM02S0 +necesitad necesitar VMM02P0 +necesitando necesitar VMG0000 +necesitar necesitar VMN0000 +necesite necesitar VMM03S0 +necesitemos necesitar VMM01P0 +necesiten necesitar VMM03P0 +negad negar VMM02P0 +negando negar VMG0000 +negar negar VMN0000 +neglige negligir VMM02S0 +negligid negligir VMM02P0 +negligiendo negligir VMG0000 +negligir negligir VMN0000 +neglija negligir VMM03S0 +neglijamos negligir VMM01P0 +neglijan negligir VMM03P0 +negocia negociar VMM02S0 +negociad negociar VMM02P0 +negociando negociar VMG0000 +negociar negociar VMN0000 +negocie negociar VMM03S0 +negociemos negociar VMM01P0 +negocien negociar VMM03P0 +negrea negrear VMM02S0 +negread negrear VMM02P0 +negreando negrear VMG0000 +negrear negrear VMN0000 +negrece negrecer VMM02S0 +negreced negrecer VMM02P0 +negrecer negrecer VMN0000 +negreciendo negrecer VMG0000 +negree negrear VMM03S0 +negreemos negrear VMM01P0 +negreen negrear VMM03P0 +negreguea negreguear VMM02S0 +negreguead negreguear VMM02P0 +negregueando negreguear VMG0000 +negreguear negreguear VMN0000 +negreguee negreguear VMM03S0 +negregueemos negreguear VMM01P0 +negregueen negreguear VMM03P0 +negrezca negrecer VMM03S0 +negrezcamos negrecer VMM01P0 +negrezcan negrecer VMM03P0 +neguemos negar VMM01P0 +nesga nesgar VMM02S0 +nesgad nesgar VMM02P0 +nesgando nesgar VMG0000 +nesgar nesgar VMN0000 +nesgue nesgar VMM03S0 +nesguemos nesgar VMM01P0 +nesguen nesgar VMM03P0 +neurotice neurotizar VMM03S0 +neuroticemos neurotizar VMM01P0 +neuroticen neurotizar VMM03P0 +neurotiza neurotizar VMM02S0 +neurotizad neurotizar VMM02P0 +neurotizando neurotizar VMG0000 +neurotizar neurotizar VMN0000 +neutralice neutralizar VMM03S0 +neutralicemos neutralizar VMM01P0 +neutralicen neutralizar VMM03P0 +neutraliza neutralizar VMM02S0 +neutralizad neutralizar VMM02P0 +neutralizando neutralizar VMG0000 +neutralizar neutralizar VMN0000 +nevando nevar VMG0000 +nevar nevar VMN0000 +neviscando neviscar VMG0000 +neviscar neviscar VMN0000 +nidifica nidificar VMM02S0 +nidificad nidificar VMM02P0 +nidificando nidificar VMG0000 +nidificar nidificar VMN0000 +nidifique nidificar VMM03S0 +nidifiquemos nidificar VMM01P0 +nidifiquen nidificar VMM03P0 +niega negar VMM02S0 +niegue negar VMM03S0 +nieguen negar VMM03P0 +niela nielar VMM02S0 +nielad nielar VMM02P0 +nielando nielar VMG0000 +nielar nielar VMN0000 +niele nielar VMM03S0 +nielemos nielar VMM01P0 +nielen nielar VMM03P0 +nimba nimbar VMM02S0 +nimbad nimbar VMM02P0 +nimbando nimbar VMG0000 +nimbar nimbar VMN0000 +nimbe nimbar VMM03S0 +nimbemos nimbar VMM01P0 +nimben nimbar VMM03P0 +niquela niquelar VMM02S0 +niquelad niquelar VMM02P0 +niquelando niquelar VMG0000 +niquelar niquelar VMN0000 +niquele niquelar VMM03S0 +niquelemos niquelar VMM01P0 +niquelen niquelar VMM03P0 +nitrata nitratar VMM02S0 +nitratad nitratar VMM02P0 +nitratando nitratar VMG0000 +nitratar nitratar VMN0000 +nitrate nitratar VMM03S0 +nitratemos nitratar VMM01P0 +nitraten nitratar VMM03P0 +nitrifica nitrificar VMM02S0 +nitrificad nitrificar VMM02P0 +nitrificando nitrificar VMG0000 +nitrificar nitrificar VMN0000 +nitrifique nitrificar VMM03S0 +nitrifiquemos nitrificar VMM01P0 +nitrifiquen nitrificar VMM03P0 +nitrura nitrurar VMM02S0 +nitrurad nitrurar VMM02P0 +nitrurando nitrurar VMG0000 +nitrurar nitrurar VMN0000 +nitrure nitrurar VMM03S0 +nitruremos nitrurar VMM01P0 +nitruren nitrurar VMM03P0 +nivela nivelar VMM02S0 +nivelad nivelar VMM02P0 +nivelando nivelar VMG0000 +nivelar nivelar VMN0000 +nivele nivelar VMM03S0 +nivelemos nivelar VMM01P0 +nivelen nivelar VMM03P0 +niñea niñear VMM02S0 +niñead niñear VMM02P0 +niñeando niñear VMG0000 +niñear niñear VMN0000 +niñee niñear VMM03S0 +niñeemos niñear VMM01P0 +niñeen niñear VMM03P0 +nombra nombrar VMM02S0 +nombrad nombrar VMM02P0 +nombrando nombrar VMG0000 +nombrar nombrar VMN0000 +nombre nombrar VMM03S0 +nombremos nombrar VMM01P0 +nombren nombrar VMM03P0 +nomina nominar VMM02S0 +nominad nominar VMM02P0 +nominalice nominalizar VMM03S0 +nominalicemos nominalizar VMM01P0 +nominalicen nominalizar VMM03P0 +nominaliza nominalizar VMM02S0 +nominalizad nominalizar VMM02P0 +nominalizando nominalizar VMG0000 +nominalizar nominalizar VMN0000 +nominando nominar VMG0000 +nominar nominar VMN0000 +nomine nominar VMM03S0 +nominemos nominar VMM01P0 +nominen nominar VMM03P0 +noquea noquear VMM02S0 +noquead noquear VMM02P0 +noqueando noquear VMG0000 +noquear noquear VMN0000 +noquee noquear VMM03S0 +noqueemos noquear VMM01P0 +noqueen noquear VMM03P0 +normalice normalizar VMM03S0 +normalicemos normalizar VMM01P0 +normalicen normalizar VMM03P0 +normaliza normalizar VMM02S0 +normalizad normalizar VMM02P0 +normalizando normalizar VMG0000 +normalizar normalizar VMN0000 +nortea nortear VMM02S0 +nortead nortear VMM02P0 +norteando nortear VMG0000 +nortear nortear VMN0000 +nortee nortear VMM03S0 +norteemos nortear VMM01P0 +norteen nortear VMM03P0 +nota notar VMM02S0 +notad notar VMM02P0 +notando notar VMG0000 +notar notar VMN0000 +note notar VMM03S0 +notemos notar VMM01P0 +noten notar VMM03P0 +noticia noticiar VMM02S0 +noticiad noticiar VMM02P0 +noticiando noticiar VMG0000 +noticiar noticiar VMN0000 +noticie noticiar VMM03S0 +noticiemos noticiar VMM01P0 +noticien noticiar VMM03P0 +notifica notificar VMM02S0 +notificad notificar VMM02P0 +notificando notificar VMG0000 +notificar notificar VMN0000 +notifique notificar VMM03S0 +notifiquemos notificar VMM01P0 +notifiquen notificar VMM03P0 +nova novar VMM02S0 +novad novar VMM02P0 +novando novar VMG0000 +novar novar VMN0000 +nove novar VMM03S0 +novela novelar VMM02S0 +novelad novelar VMM02P0 +novelando novelar VMG0000 +novelar novelar VMN0000 +novele novelar VMM03S0 +novelemos novelar VMM01P0 +novelen novelar VMM03P0 +novelice novelizar VMM03S0 +novelicemos novelizar VMM01P0 +novelicen novelizar VMM03P0 +noveliza novelizar VMM02S0 +novelizad novelizar VMM02P0 +novelizando novelizar VMG0000 +novelizar novelizar VMN0000 +novemos novar VMM01P0 +noven novar VMM03P0 +nubla nublar VMM02S0 +nublad nublar VMM02P0 +nublando nublar VMG0000 +nublar nublar VMN0000 +nuble nublar VMM03S0 +nublemos nublar VMM01P0 +nublen nublar VMM03P0 +numera numerar VMM02S0 +numerad numerar VMM02P0 +numerando numerar VMG0000 +numerar numerar VMN0000 +numere numerar VMM03S0 +numeremos numerar VMM01P0 +numeren numerar VMM03P0 +nutra nutrir VMM03S0 +nutramos nutrir VMM01P0 +nutran nutrir VMM03P0 +nutre nutrir VMM02S0 +nutrid nutrir VMM02P0 +nutriendo nutrir VMG0000 +nutrir nutrir VMN0000 +obceca obcecar VMM02S0 +obcecad obcecar VMM02P0 +obcecando obcecar VMG0000 +obcecar obcecar VMN0000 +obceque obcecar VMM03S0 +obcequemos obcecar VMM01P0 +obcequen obcecar VMM03P0 +obedece obedecer VMM02S0 +obedeced obedecer VMM02P0 +obedecer obedecer VMN0000 +obedeciendo obedecer VMG0000 +obedezca obedecer VMM03S0 +obedezcamos obedecer VMM01P0 +obedezcan obedecer VMM03P0 +objeta objetar VMM02S0 +objetad objetar VMM02P0 +objetando objetar VMG0000 +objetar objetar VMN0000 +objete objetar VMM03S0 +objetemos objetar VMM01P0 +objeten objetar VMM03P0 +objetiva objetivar VMM02S0 +objetivad objetivar VMM02P0 +objetivando objetivar VMG0000 +objetivar objetivar VMN0000 +objetive objetivar VMM03S0 +objetivemos objetivar VMM01P0 +objetiven objetivar VMM03P0 +oblicuad oblicuar VMM02P0 +oblicuando oblicuar VMG0000 +oblicuar oblicuar VMN0000 +oblicuemos oblicuar VMM01P0 +oblicúa oblicuar VMM02S0 +oblicúe oblicuar VMM03S0 +oblicúen oblicuar VMM03P0 +obliga obligar VMM02S0 +obligad obligar VMM02P0 +obligando obligar VMG0000 +obligar obligar VMN0000 +obligue obligar VMM03S0 +obliguemos obligar VMM01P0 +obliguen obligar VMM03P0 +oblitera obliterar VMM02S0 +obliterad obliterar VMM02P0 +obliterando obliterar VMG0000 +obliterar obliterar VMN0000 +oblitere obliterar VMM03S0 +obliteremos obliterar VMM01P0 +obliteren obliterar VMM03P0 +obnubila obnubilar VMM02S0 +obnubilad obnubilar VMM02P0 +obnubilando obnubilar VMG0000 +obnubilar obnubilar VMN0000 +obnubile obnubilar VMM03S0 +obnubilemos obnubilar VMM01P0 +obnubilen obnubilar VMM03P0 +obra obrar VMM02S0 +obrad obrar VMM02P0 +obrando obrar VMG0000 +obrar obrar VMN0000 +obre obrar VMM03S0 +obremos obrar VMM01P0 +obren obrar VMM03P0 +obscurece obscurecer VMM02S0 +obscureced obscurecer VMM02P0 +obscurecer obscurecer VMN0000 +obscureciendo obscurecer VMG0000 +obscurezca obscurecer VMM03S0 +obscurezcamos obscurecer VMM01P0 +obscurezcan obscurecer VMM03P0 +obseda obseder VMM03S0 +obsedamos obseder VMM01P0 +obsedan obseder VMM03P0 +obsede obseder VMM02S0 +obseded obseder VMM02P0 +obseder obseder VMN0000 +obsediendo obseder VMG0000 +obsequia obsequiar VMM02S0 +obsequiad obsequiar VMM02P0 +obsequiando obsequiar VMG0000 +obsequiar obsequiar VMN0000 +obsequie obsequiar VMM03S0 +obsequiemos obsequiar VMM01P0 +obsequien obsequiar VMM03P0 +observa observar VMM02S0 +observad observar VMM02P0 +observando observar VMG0000 +observar observar VMN0000 +observe observar VMM03S0 +observemos observar VMM01P0 +observen observar VMM03P0 +obsesiona obsesionar VMM02S0 +obsesionad obsesionar VMM02P0 +obsesionando obsesionar VMG0000 +obsesionar obsesionar VMN0000 +obsesione obsesionar VMM03S0 +obsesionemos obsesionar VMM01P0 +obsesionen obsesionar VMM03P0 +obsta obstar VMM02S0 +obstaculice obstaculizar VMM03S0 +obstaculicemos obstaculizar VMM01P0 +obstaculicen obstaculizar VMM03P0 +obstaculiza obstaculizar VMM02S0 +obstaculizad obstaculizar VMM02P0 +obstaculizando obstaculizar VMG0000 +obstaculizar obstaculizar VMN0000 +obstad obstar VMM02P0 +obstando obstar VMG0000 +obstar obstar VMN0000 +obste obstar VMM03S0 +obstemos obstar VMM01P0 +obsten obstar VMM03P0 +obstina obstinar VMM02S0 +obstinad obstinar VMM02P0 +obstinando obstinar VMG0000 +obstinar obstinar VMN0000 +obstine obstinar VMM03S0 +obstinemos obstinar VMM01P0 +obstinen obstinar VMM03P0 +obstruid obstruir VMM02P0 +obstruir obstruir VMN0000 +obstruya obstruir VMM03S0 +obstruyamos obstruir VMM01P0 +obstruyan obstruir VMM03P0 +obstruye obstruir VMM02S0 +obstruyendo obstruir VMG0000 +obtempera obtemperar VMM02S0 +obtemperad obtemperar VMM02P0 +obtemperando obtemperar VMG0000 +obtemperar obtemperar VMN0000 +obtempere obtemperar VMM03S0 +obtemperemos obtemperar VMM01P0 +obtemperen obtemperar VMM03P0 +obtened obtener VMM02P0 +obtener obtener VMN0000 +obtenga obtener VMM03S0 +obtengamos obtener VMM01P0 +obtengan obtener VMM03P0 +obteniendo obtener VMG0000 +obtura obturar VMM02S0 +obturad obturar VMM02P0 +obturando obturar VMG0000 +obturar obturar VMN0000 +obture obturar VMM03S0 +obturemos obturar VMM01P0 +obturen obturar VMM03P0 +obtén obtener VMM02S0 +obvia obviar VMM02S0 +obviad obviar VMM02P0 +obviando obviar VMG0000 +obviar obviar VMN0000 +obvie obviar VMM03S0 +obviemos obviar VMM01P0 +obvien obviar VMM03P0 +ocasiona ocasionar VMM02S0 +ocasionad ocasionar VMM02P0 +ocasionando ocasionar VMG0000 +ocasionar ocasionar VMN0000 +ocasione ocasionar VMM03S0 +ocasionemos ocasionar VMM01P0 +ocasionen ocasionar VMM03P0 +occidentalice occidentalizar VMM03S0 +occidentalicemos occidentalizar VMM01P0 +occidentalicen occidentalizar VMM03P0 +occidentaliza occidentalizar VMM02S0 +occidentalizad occidentalizar VMM02P0 +occidentalizando occidentalizar VMG0000 +occidentalizar occidentalizar VMN0000 +ociosea ociosear VMM02S0 +ociosead ociosear VMM02P0 +ocioseando ociosear VMG0000 +ociosear ociosear VMN0000 +ociosee ociosear VMM03S0 +ocioseemos ociosear VMM01P0 +ocioseen ociosear VMM03P0 +ocluid ocluir VMM02P0 +ocluir ocluir VMN0000 +ocluya ocluir VMM03S0 +ocluyamos ocluir VMM01P0 +ocluyan ocluir VMM03P0 +ocluye ocluir VMM02S0 +ocluyendo ocluir VMG0000 +octava octavar VMM02S0 +octavad octavar VMM02P0 +octavando octavar VMG0000 +octavar octavar VMN0000 +octuplica octuplicar VMM02S0 +octuplicad octuplicar VMM02P0 +octuplicando octuplicar VMG0000 +octuplicar octuplicar VMN0000 +octuplique octuplicar VMM03S0 +octupliquemos octuplicar VMM01P0 +octupliquen octuplicar VMM03P0 +oculta ocultar VMM02S0 +ocultad ocultar VMM02P0 +ocultando ocultar VMG0000 +ocultar ocultar VMN0000 +oculte ocultar VMM03S0 +ocultemos ocultar VMM01P0 +oculten ocultar VMM03P0 +ocupa ocupar VMM02S0 +ocupad ocupar VMM02P0 +ocupando ocupar VMG0000 +ocupar ocupar VMN0000 +ocupe ocupar VMM03S0 +ocupemos ocupar VMM01P0 +ocupen ocupar VMM03P0 +ocurra ocurrir VMM03S0 +ocurramos ocurrir VMM01P0 +ocurran ocurrir VMM03P0 +ocurre ocurrir VMM02S0 +ocurrid ocurrir VMM02P0 +ocurriendo ocurrir VMG0000 +ocurrir ocurrir VMN0000 +odia odiar VMM02S0 +odiad odiar VMM02P0 +odiando odiar VMG0000 +odiar odiar VMN0000 +odie odiar VMM03S0 +odiemos odiar VMM01P0 +odien odiar VMM03P0 +ofenda ofender VMM03S0 +ofendamos ofender VMM01P0 +ofendan ofender VMM03P0 +ofende ofender VMM02S0 +ofended ofender VMM02P0 +ofender ofender VMN0000 +ofendiendo ofender VMG0000 +oferta ofertar VMM02S0 +ofertad ofertar VMM02P0 +ofertando ofertar VMG0000 +ofertar ofertar VMN0000 +oferte ofertar VMM03S0 +ofertemos ofertar VMM01P0 +oferten ofertar VMM03P0 +oficia oficiar VMM02S0 +oficiad oficiar VMM02P0 +oficialice oficializar VMM03S0 +oficialicemos oficializar VMM01P0 +oficialicen oficializar VMM03P0 +oficializa oficializar VMM02S0 +oficializad oficializar VMM02P0 +oficializando oficializar VMG0000 +oficializar oficializar VMN0000 +oficiando oficiar VMG0000 +oficiar oficiar VMN0000 +oficie oficiar VMM03S0 +oficiemos oficiar VMM01P0 +oficien oficiar VMM03P0 +ofrece ofrecer VMM02S0 +ofreced ofrecer VMM02P0 +ofrecer ofrecer VMN0000 +ofreciendo ofrecer VMG0000 +ofrenda ofrendar VMM02S0 +ofrendad ofrendar VMM02P0 +ofrendando ofrendar VMG0000 +ofrendar ofrendar VMN0000 +ofrende ofrendar VMM03S0 +ofrendemos ofrendar VMM01P0 +ofrenden ofrendar VMM03P0 +ofrezca ofrecer VMM03S0 +ofrezcamos ofrecer VMM01P0 +ofrezcan ofrecer VMM03P0 +ofusca ofuscar VMM02S0 +ofuscad ofuscar VMM02P0 +ofuscando ofuscar VMG0000 +ofuscar ofuscar VMN0000 +ofusque ofuscar VMM03S0 +ofusquemos ofuscar VMM01P0 +ofusquen ofuscar VMM03P0 +oiga oír VMM03S0 +oigamos oír VMM01P0 +oigan oír VMM03P0 +ojala ojalar VMM02S0 +ojalad ojalar VMM02P0 +ojalando ojalar VMG0000 +ojalar ojalar VMN0000 +ojale ojalar VMM03S0 +ojalemos ojalar VMM01P0 +ojalen ojalar VMM03P0 +ojea ojear VMM02S0 +ojead ojear VMM02P0 +ojeando ojear VMG0000 +ojear ojear VMN0000 +ojee ojear VMM03S0 +ojeemos ojear VMM01P0 +ojeen ojear VMM03P0 +ojetea ojetear VMM02S0 +ojetead ojetear VMM02P0 +ojeteando ojetear VMG0000 +ojetear ojetear VMN0000 +ojetee ojetear VMM03S0 +ojeteemos ojetear VMM01P0 +ojeteen ojetear VMM03P0 +olamos oler VMM01P0 +olea olear VMM02S0 +olead olear VMM02P0 +oleando olear VMG0000 +olear olear VMN0000 +oled oler VMM02P0 +olee olear VMM03S0 +oleemos olear VMM01P0 +oleen olear VMM03P0 +oler oler VMN0000 +olfatea olfatear VMM02S0 +olfatead olfatear VMM02P0 +olfateando olfatear VMG0000 +olfatear olfatear VMN0000 +olfatee olfatear VMM03S0 +olfateemos olfatear VMM01P0 +olfateen olfatear VMM03P0 +oliendo oler VMG0000 +olisca oliscar VMM02S0 +oliscad oliscar VMM02P0 +oliscando oliscar VMG0000 +oliscar oliscar VMN0000 +olisque oliscar VMM03S0 +olisquea olisquear VMM02S0 +olisquead olisquear VMM02P0 +olisqueando olisquear VMG0000 +olisquear olisquear VMN0000 +olisquee olisquear VMM03S0 +olisqueemos olisquear VMM01P0 +olisqueen olisquear VMM03P0 +olisquemos oliscar VMM01P0 +olisquen oliscar VMM03P0 +oliva olivar VMM02S0 +olivad olivar VMM02P0 +olivando olivar VMG0000 +olivar olivar VMN0000 +olive olivar VMM03S0 +olivemos olivar VMM01P0 +oliven olivar VMM03P0 +olorice olorizar VMM03S0 +oloricemos olorizar VMM01P0 +oloricen olorizar VMM03P0 +oloriza olorizar VMM02S0 +olorizad olorizar VMM02P0 +olorizando olorizar VMG0000 +olorizar olorizar VMN0000 +olvida olvidar VMM02S0 +olvidad olvidar VMM02P0 +olvidando olvidar VMG0000 +olvidar olvidar VMN0000 +olvide olvidar VMM03S0 +olvidemos olvidar VMM01P0 +olviden olvidar VMM03P0 +omina ominar VMM02S0 +ominad ominar VMM02P0 +ominando ominar VMG0000 +ominar ominar VMN0000 +omine ominar VMM03S0 +ominemos ominar VMM01P0 +ominen ominar VMM03P0 +omita omitir VMM03S0 +omitamos omitir VMM01P0 +omitan omitir VMM03P0 +omite omitir VMM02S0 +omitid omitir VMM02P0 +omitiendo omitir VMG0000 +omitir omitir VMN0000 +ondea ondear VMM02S0 +ondead ondear VMM02P0 +ondeando ondear VMG0000 +ondear ondear VMN0000 +ondee ondear VMM03S0 +ondeemos ondear VMM01P0 +ondeen ondear VMM03P0 +ondula ondular VMM02S0 +ondulad ondular VMM02P0 +ondulando ondular VMG0000 +ondular ondular VMN0000 +ondule ondular VMM03S0 +ondulemos ondular VMM01P0 +ondulen ondular VMM03P0 +opaca opacar VMM02S0 +opacad opacar VMM02P0 +opacando opacar VMG0000 +opacar opacar VMN0000 +opalice opalizar VMM03S0 +opalicemos opalizar VMM01P0 +opalicen opalizar VMM03P0 +opaliza opalizar VMM02S0 +opalizad opalizar VMM02P0 +opalizando opalizar VMG0000 +opalizar opalizar VMN0000 +opaque opacar VMM03S0 +opaquemos opacar VMM01P0 +opaquen opacar VMM03P0 +opera operar VMM02S0 +operad operar VMM02P0 +operando operar VMG0000 +operar operar VMN0000 +opere operar VMM03S0 +operemos operar VMM01P0 +operen operar VMM03P0 +opila opilar VMM02S0 +opilad opilar VMM02P0 +opilando opilar VMG0000 +opilar opilar VMN0000 +opile opilar VMM03S0 +opilemos opilar VMM01P0 +opilen opilar VMM03P0 +opina opinar VMM02S0 +opinad opinar VMM02P0 +opinando opinar VMG0000 +opinar opinar VMN0000 +opine opinar VMM03S0 +opinemos opinar VMM01P0 +opinen opinar VMM03P0 +oponed oponer VMM02P0 +oponer oponer VMN0000 +oponga oponer VMM03S0 +opongamos oponer VMM01P0 +opongan oponer VMM03P0 +oponiendo oponer VMG0000 +oposita opositar VMM02S0 +opositad opositar VMM02P0 +opositando opositar VMG0000 +opositar opositar VMN0000 +oposite opositar VMM03S0 +opositemos opositar VMM01P0 +opositen opositar VMM03P0 +oprima oprimir VMM03S0 +oprimamos oprimir VMM01P0 +opriman oprimir VMM03P0 +oprime oprimir VMM02S0 +oprimid oprimir VMM02P0 +oprimiendo oprimir VMG0000 +oprimir oprimir VMN0000 +oprobia oprobiar VMM02S0 +oprobiad oprobiar VMM02P0 +oprobiando oprobiar VMG0000 +oprobiar oprobiar VMN0000 +oprobie oprobiar VMM03S0 +oprobiemos oprobiar VMM01P0 +oprobien oprobiar VMM03P0 +opta optar VMM02S0 +optad optar VMM02P0 +optando optar VMG0000 +optar optar VMN0000 +opte optar VMM03S0 +optemos optar VMM01P0 +opten optar VMM03P0 +optimice optimizar VMM03S0 +optimicemos optimizar VMM01P0 +optimicen optimizar VMM03P0 +optimiza optimizar VMM02S0 +optimizad optimizar VMM02P0 +optimizando optimizar VMG0000 +optimizar optimizar VMN0000 +opugna opugnar VMM02S0 +opugnad opugnar VMM02P0 +opugnando opugnar VMG0000 +opugnar opugnar VMN0000 +opugne opugnar VMM03S0 +opugnemos opugnar VMM01P0 +opugnen opugnar VMM03P0 +opón oponer VMM02S0 +ora orar VMM02S0 +orad orar VMM02P0 +orando orar VMG0000 +orar orar VMN0000 +orbita orbitar VMM02S0 +orbitad orbitar VMM02P0 +orbitando orbitar VMG0000 +orbitar orbitar VMN0000 +orbite orbitar VMM03S0 +orbitemos orbitar VMM01P0 +orbiten orbitar VMM03P0 +orce orzar VMM03S0 +orcemos orzar VMM01P0 +orcen orzar VMM03P0 +ordena ordenar VMM02S0 +ordenad ordenar VMM02P0 +ordenando ordenar VMG0000 +ordenar ordenar VMN0000 +ordene ordenar VMM03S0 +ordenemos ordenar VMM01P0 +ordenen ordenar VMM03P0 +ordeña ordeñar VMM02S0 +ordeñad ordeñar VMM02P0 +ordeñando ordeñar VMG0000 +ordeñar ordeñar VMN0000 +ordeñe ordeñar VMM03S0 +ordeñemos ordeñar VMM01P0 +ordeñen ordeñar VMM03P0 +ore orar VMM03S0 +orea orear VMM02S0 +oread orear VMM02P0 +oreando orear VMG0000 +orear orear VMN0000 +oree orear VMM03S0 +oreemos orear VMM01P0 +oreen orear VMM03P0 +orejea orejear VMM02S0 +orejead orejear VMM02P0 +orejeando orejear VMG0000 +orejear orejear VMN0000 +orejee orejear VMM03S0 +orejeemos orejear VMM01P0 +orejeen orejear VMM03P0 +oremos orar VMM01P0 +oren orar VMM03P0 +organice organizar VMM03S0 +organicemos organizar VMM01P0 +organicen organizar VMM03P0 +organiza organizar VMM02S0 +organizad organizar VMM02P0 +organizando organizar VMG0000 +organizar organizar VMN0000 +orienta orientar VMM02S0 +orientad orientar VMM02P0 +orientalice orientalizar VMM03S0 +orientalicemos orientalizar VMM01P0 +orientalicen orientalizar VMM03P0 +orientaliza orientalizar VMM02S0 +orientalizad orientalizar VMM02P0 +orientalizando orientalizar VMG0000 +orientalizar orientalizar VMN0000 +orientando orientar VMG0000 +orientar orientar VMN0000 +oriente orientar VMM03S0 +orientemos orientar VMM01P0 +orienten orientar VMM03P0 +orifica orificar VMM02S0 +orificad orificar VMM02P0 +orificando orificar VMG0000 +orificar orificar VMN0000 +orifique orificar VMM03S0 +orifiquemos orificar VMM01P0 +orifiquen orificar VMM03P0 +origina originar VMM02S0 +originad originar VMM02P0 +originando originar VMG0000 +originar originar VMN0000 +origine originar VMM03S0 +originemos originar VMM01P0 +originen originar VMM03P0 +orilla orillar VMM02S0 +orillad orillar VMM02P0 +orillando orillar VMG0000 +orillar orillar VMN0000 +orille orillar VMM03S0 +orillemos orillar VMM01P0 +orillen orillar VMM03P0 +orina orinar VMM02S0 +orinad orinar VMM02P0 +orinando orinar VMG0000 +orinar orinar VMN0000 +orine orinar VMM03S0 +orinemos orinar VMM01P0 +orinen orinar VMM03P0 +orla orlar VMM02S0 +orlad orlar VMM02P0 +orlando orlar VMG0000 +orlar orlar VMN0000 +orle orlar VMM03S0 +orlemos orlar VMM01P0 +orlen orlar VMM03P0 +orna ornar VMM02S0 +ornad ornar VMM02P0 +ornamenta ornamentar VMM02S0 +ornamentad ornamentar VMM02P0 +ornamentando ornamentar VMG0000 +ornamentar ornamentar VMN0000 +ornamente ornamentar VMM03S0 +ornamentemos ornamentar VMM01P0 +ornamenten ornamentar VMM03P0 +ornando ornar VMG0000 +ornar ornar VMN0000 +orne ornar VMM03S0 +ornemos ornar VMM01P0 +ornen ornar VMM03P0 +orquesta orquestar VMM02S0 +orquestad orquestar VMM02P0 +orquestando orquestar VMG0000 +orquestar orquestar VMN0000 +orqueste orquestar VMM03S0 +orquestemos orquestar VMM01P0 +orquesten orquestar VMM03P0 +ortografiad ortografiar VMM02P0 +ortografiando ortografiar VMG0000 +ortografiar ortografiar VMN0000 +ortografiemos ortografiar VMM01P0 +ortografía ortografiar VMM02S0 +ortografíe ortografiar VMM03S0 +ortografíen ortografiar VMM03P0 +orza orzar VMM02S0 +orzad orzar VMM02P0 +orzando orzar VMG0000 +orzar orzar VMN0000 +osa osar VMM02S0 +osad osar VMM02P0 +osando osar VMG0000 +osar osar VMN0000 +oscila oscilar VMM02S0 +oscilad oscilar VMM02P0 +oscilando oscilar VMG0000 +oscilar oscilar VMN0000 +oscile oscilar VMM03S0 +oscilemos oscilar VMM01P0 +oscilen oscilar VMM03P0 +oscurece oscurecer VMM02S0 +oscureced oscurecer VMM02P0 +oscurecer oscurecer VMN0000 +oscureciendo oscurecer VMG0000 +oscurezca oscurecer VMM03S0 +oscurezcamos oscurecer VMM01P0 +oscurezcan oscurecer VMM03P0 +ose osar VMM03S0 +osemos osar VMM01P0 +osen osar VMM03P0 +osifica osificar VMM02S0 +osificad osificar VMM02P0 +osificando osificar VMG0000 +osificar osificar VMN0000 +osifique osificar VMM03S0 +osifiquemos osificar VMM01P0 +osifiquen osificar VMM03P0 +ostenta ostentar VMM02S0 +ostentad ostentar VMM02P0 +ostentando ostentar VMG0000 +ostentar ostentar VMN0000 +ostente ostentar VMM03S0 +ostentemos ostentar VMM01P0 +ostenten ostentar VMM03P0 +otea otear VMM02S0 +otead otear VMM02P0 +oteando otear VMG0000 +otear otear VMN0000 +otee otear VMM03S0 +oteemos otear VMM01P0 +oteen otear VMM03P0 +otorga otorgar VMM02S0 +otorgad otorgar VMM02P0 +otorgando otorgar VMG0000 +otorgar otorgar VMN0000 +otorgue otorgar VMM03S0 +otorguemos otorgar VMM01P0 +otorguen otorgar VMM03P0 +otoña otoñar VMM02S0 +otoñad otoñar VMM02P0 +otoñando otoñar VMG0000 +otoñar otoñar VMN0000 +otoñe otoñar VMM03S0 +otoñemos otoñar VMM01P0 +otoñen otoñar VMM03P0 +ova ovar VMM02S0 +ovaciona ovacionar VMM02S0 +ovacionad ovacionar VMM02P0 +ovacionando ovacionar VMG0000 +ovacionar ovacionar VMN0000 +ovacione ovacionar VMM03S0 +ovacionemos ovacionar VMM01P0 +ovacionen ovacionar VMM03P0 +ovad ovar VMM02P0 +ovala ovalar VMM02S0 +ovalad ovalar VMM02P0 +ovalando ovalar VMG0000 +ovalar ovalar VMN0000 +ovale ovalar VMM03S0 +ovalemos ovalar VMM01P0 +ovalen ovalar VMM03P0 +ovando ovar VMG0000 +ovar ovar VMN0000 +ove ovar VMM03S0 +ovemos ovar VMM01P0 +oven ovar VMM03P0 +ovilla ovillar VMM02S0 +ovillad ovillar VMM02P0 +ovillando ovillar VMG0000 +ovillar ovillar VMN0000 +oville ovillar VMM03S0 +ovillemos ovillar VMM01P0 +ovillen ovillar VMM03P0 +oxea oxear VMM02S0 +oxead oxear VMM02P0 +oxeando oxear VMG0000 +oxear oxear VMN0000 +oxee oxear VMM03S0 +oxeemos oxear VMM01P0 +oxeen oxear VMM03P0 +oxida oxidar VMM02S0 +oxidad oxidar VMM02P0 +oxidando oxidar VMG0000 +oxidar oxidar VMN0000 +oxide oxidar VMM03S0 +oxidemos oxidar VMM01P0 +oxiden oxidar VMM03P0 +oxigena oxigenar VMM02S0 +oxigenad oxigenar VMM02P0 +oxigenando oxigenar VMG0000 +oxigenar oxigenar VMN0000 +oxigene oxigenar VMM03S0 +oxigenemos oxigenar VMM01P0 +oxigenen oxigenar VMM03P0 +oye oír VMM02S0 +oyendo oír VMG0000 +ozona ozonar VMM02S0 +ozonad ozonar VMM02P0 +ozonando ozonar VMG0000 +ozonar ozonar VMN0000 +ozonice ozonizar VMM03S0 +ozonicemos ozonizar VMM01P0 +ozonicen ozonizar VMM03P0 +ozonifica ozonificar VMM02S0 +ozonificad ozonificar VMM02P0 +ozonificando ozonificar VMG0000 +ozonificar ozonificar VMN0000 +ozoniza ozonizar VMM02S0 +ozonizad ozonizar VMM02P0 +ozonizando ozonizar VMG0000 +ozonizar ozonizar VMN0000 +ozonofique ozonificar VMM03S0 +ozonofiquemos ozonificar VMM01P0 +ozonofiquen ozonificar VMM03P0 +oíd oír VMM02P0 +oír oír VMN0000 +pabla pablar VMM02S0 +pablad pablar VMM02P0 +pablando pablar VMG0000 +pablar pablar VMN0000 +pable pablar VMM03S0 +pablemos pablar VMM01P0 +pablen pablar VMM03P0 +pace pacer VMM02S0 +paced pacer VMM02P0 +pacer pacer VMN0000 +paciendo pacer VMG0000 +pacifica pacificar VMM02S0 +pacificad pacificar VMM02P0 +pacificando pacificar VMG0000 +pacificar pacificar VMN0000 +pacifique pacificar VMM03S0 +pacifiquemos pacificar VMM01P0 +pacifiquen pacificar VMM03P0 +pacta pactar VMM02S0 +pactad pactar VMM02P0 +pactando pactar VMG0000 +pactar pactar VMN0000 +pacte pactar VMM03S0 +pactemos pactar VMM01P0 +pacten pactar VMM03P0 +padece padecer VMM02S0 +padeced padecer VMM02P0 +padecer padecer VMN0000 +padeciendo padecer VMG0000 +padezca padecer VMM03S0 +padezcamos padecer VMM01P0 +padezcan padecer VMM03P0 +padrea padrear VMM02S0 +padread padrear VMM02P0 +padreando padrear VMG0000 +padrear padrear VMN0000 +padree padrear VMM03S0 +padreemos padrear VMM01P0 +padreen padrear VMM03P0 +paga pagar VMM02S0 +pagad pagar VMM02P0 +pagando pagar VMG0000 +paganice paganizar VMM03S0 +paganicemos paganizar VMM01P0 +paganicen paganizar VMM03P0 +paganiza paganizar VMM02S0 +paganizad paganizar VMM02P0 +paganizando paganizar VMG0000 +paganizar paganizar VMN0000 +pagar pagar VMN0000 +pagina paginar VMM02S0 +paginad paginar VMM02P0 +paginando paginar VMG0000 +paginar paginar VMN0000 +pagine paginar VMM03S0 +paginemos paginar VMM01P0 +paginen paginar VMM03P0 +pague pagar VMM03S0 +paguemos pagar VMM01P0 +paguen pagar VMM03P0 +paira pairar VMM02S0 +pairad pairar VMM02P0 +pairando pairar VMG0000 +pairar pairar VMN0000 +paire pairar VMM03S0 +pairemos pairar VMM01P0 +pairen pairar VMM03P0 +pajarea pajarear VMM02S0 +pajaread pajarear VMM02P0 +pajareando pajarear VMG0000 +pajarear pajarear VMN0000 +pajaree pajarear VMM03S0 +pajareemos pajarear VMM01P0 +pajareen pajarear VMM03P0 +paladea paladear VMM02S0 +paladead paladear VMM02P0 +paladeando paladear VMG0000 +paladear paladear VMN0000 +paladee paladear VMM03S0 +paladeemos paladear VMM01P0 +paladeen paladear VMM03P0 +palatalice palatalizar VMM03S0 +palatalicemos palatalizar VMM01P0 +palatalicen palatalizar VMM03P0 +palataliza palatalizar VMM02S0 +palatalizad palatalizar VMM02P0 +palatalizando palatalizar VMG0000 +palatalizar palatalizar VMN0000 +palea palear VMM02S0 +palead palear VMM02P0 +paleando palear VMG0000 +palear palear VMN0000 +palee palear VMM03S0 +paleemos palear VMM01P0 +paleen palear VMM03P0 +paletea paletear VMM02S0 +paletead paletear VMM02P0 +paleteando paletear VMG0000 +paletear paletear VMN0000 +paletee paletear VMM03S0 +paleteemos paletear VMM01P0 +paleteen paletear VMM03P0 +paliad paliar VMM02P0 +paliando paliar VMG0000 +paliar paliar VMN0000 +palidece palidecer VMM02S0 +palideced palidecer VMM02P0 +palidecer palidecer VMN0000 +palideciendo palidecer VMG0000 +palidezca palidecer VMM03S0 +palidezcamos palidecer VMM01P0 +palidezcan palidecer VMM03P0 +paliemos paliar VMM01P0 +paliquea paliquear VMM02S0 +paliquead paliquear VMM02P0 +paliqueando paliquear VMG0000 +paliquear paliquear VMN0000 +paliquee paliquear VMM03S0 +paliqueemos paliquear VMM01P0 +paliqueen paliquear VMM03P0 +palla pallar VMM02S0 +pallad pallar VMM02P0 +pallando pallar VMG0000 +pallar pallar VMN0000 +palle pallar VMM03S0 +pallemos pallar VMM01P0 +pallen pallar VMM03P0 +palma palmar VMM02S0 +palmad palmar VMM02P0 +palmando palmar VMG0000 +palmar palmar VMN0000 +palme palmar VMM03S0 +palmea palmear VMM02S0 +palmead palmear VMM02P0 +palmeando palmear VMG0000 +palmear palmear VMN0000 +palmee palmear VMM03S0 +palmeemos palmear VMM01P0 +palmeen palmear VMM03P0 +palmemos palmar VMM01P0 +palmen palmar VMM03P0 +palmotea palmotear VMM02S0 +palmotead palmotear VMM02P0 +palmoteando palmotear VMG0000 +palmotear palmotear VMN0000 +palmotee palmotear VMM03S0 +palmoteemos palmotear VMM01P0 +palmoteen palmotear VMM03P0 +palotea palotear VMM02S0 +palotead palotear VMM02P0 +paloteando palotear VMG0000 +palotear palotear VMN0000 +palotee palotear VMM03S0 +paloteemos palotear VMM01P0 +paloteen palotear VMM03P0 +palpa palpar VMM02S0 +palpad palpar VMM02P0 +palpando palpar VMG0000 +palpar palpar VMN0000 +palpe palpar VMM03S0 +palpemos palpar VMM01P0 +palpen palpar VMM03P0 +palpita palpitar VMM02S0 +palpitad palpitar VMM02P0 +palpitando palpitar VMG0000 +palpitar palpitar VMN0000 +palpite palpitar VMM03S0 +palpitemos palpitar VMM01P0 +palpiten palpitar VMM03P0 +palía paliar VMM02S0 +palíe paliar VMM03S0 +palíen paliar VMM03P0 +pampea pampear VMM02S0 +pampead pampear VMM02P0 +pampeando pampear VMG0000 +pampear pampear VMN0000 +pampee pampear VMM03S0 +pampeemos pampear VMM01P0 +pampeen pampear VMM03P0 +pandea pandear VMM02S0 +pandead pandear VMM02P0 +pandeando pandear VMG0000 +pandear pandear VMN0000 +pandee pandear VMM03S0 +pandeemos pandear VMM01P0 +pandeen pandear VMM03P0 +panderetea panderetear VMM02S0 +panderetead panderetear VMM02P0 +pandereteando panderetear VMG0000 +panderetear panderetear VMN0000 +panderetee panderetear VMM03S0 +pandereteemos panderetear VMM01P0 +pandereteen panderetear VMM03P0 +panifica panificar VMM02S0 +panificad panificar VMM02P0 +panificando panificar VMG0000 +panificar panificar VMN0000 +panifique panificar VMM03S0 +panifiquemos panificar VMM01P0 +panifiquen panificar VMM03P0 +papa papar VMM02S0 +papad papar VMM02P0 +papando papar VMG0000 +papar papar VMN0000 +pape papar VMM03S0 +papelea papelear VMM02S0 +papelead papelear VMM02P0 +papeleando papelear VMG0000 +papelear papelear VMN0000 +papelee papelear VMM03S0 +papeleemos papelear VMM01P0 +papeleen papelear VMM03P0 +papeletea papeletear VMM02S0 +papeletead papeletear VMM02P0 +papeleteando papeletear VMG0000 +papeletear papeletear VMN0000 +papeletee papeletear VMM03S0 +papeleteemos papeletear VMM01P0 +papeleteen papeletear VMM03P0 +papeletice papeletizar VMM03S0 +papeleticemos papeletizar VMM01P0 +papeleticen papeletizar VMM03P0 +papeletiza papeletizar VMM02S0 +papeletizad papeletizar VMM02P0 +papeletizando papeletizar VMG0000 +papeletizar papeletizar VMN0000 +papelonea papelonear VMM02S0 +papelonead papelonear VMM02P0 +papeloneando papelonear VMG0000 +papelonear papelonear VMN0000 +papelonee papelonear VMM03S0 +papeloneemos papelonear VMM01P0 +papeloneen papelonear VMM03P0 +papemos papar VMM01P0 +papen papar VMM03P0 +paquea paquear VMM02S0 +paquead paquear VMM02P0 +paqueando paquear VMG0000 +paquear paquear VMN0000 +paquee paquear VMM03S0 +paqueemos paquear VMM01P0 +paqueen paquear VMM03P0 +para parar VMM02S0 +para parir VMM03S0 +parabolice parabolizar VMM03S0 +parabolicemos parabolizar VMM01P0 +parabolicen parabolizar VMM03P0 +paraboliza parabolizar VMM02S0 +parabolizad parabolizar VMM02P0 +parabolizando parabolizar VMG0000 +parabolizar parabolizar VMN0000 +parad parar VMM02P0 +parafina parafinar VMM02S0 +parafinad parafinar VMM02P0 +parafinando parafinar VMG0000 +parafinar parafinar VMN0000 +parafine parafinar VMM03S0 +parafinemos parafinar VMM01P0 +parafinen parafinar VMM03P0 +parafrasea parafrasear VMM02S0 +parafrasead parafrasear VMM02P0 +parafraseando parafrasear VMG0000 +parafrasear parafrasear VMN0000 +parafrasee parafrasear VMM03S0 +parafraseemos parafrasear VMM01P0 +parafraseen parafrasear VMM03P0 +parahusad parahusar VMM02P0 +parahusando parahusar VMG0000 +parahusar parahusar VMN0000 +parahusemos parahusar VMM01P0 +parahúsa parahusar VMM02S0 +parahúse parahusar VMM03S0 +parahúsen parahusar VMM03P0 +paralice paralizar VMM03S0 +paralicemos paralizar VMM01P0 +paralicen paralizar VMM03P0 +paraliza paralizar VMM02S0 +paralizad paralizar VMM02P0 +paralizando paralizar VMG0000 +paralizar paralizar VMN0000 +paralogice paralogizar VMM03S0 +paralogicemos paralogizar VMM01P0 +paralogicen paralogizar VMM03P0 +paralogiza paralogizar VMM02S0 +paralogizad paralogizar VMM02P0 +paralogizando paralogizar VMG0000 +paralogizar paralogizar VMN0000 +paramenta paramentar VMM02S0 +paramentad paramentar VMM02P0 +paramentando paramentar VMG0000 +paramentar paramentar VMN0000 +paramente paramentar VMM03S0 +paramentemos paramentar VMM01P0 +paramenten paramentar VMM03P0 +parametrice parametrizar VMM03S0 +parametricemos parametrizar VMM01P0 +parametricen parametrizar VMM03P0 +parametriza parametrizar VMM02S0 +parametrizad parametrizar VMM02P0 +parametrizando parametrizar VMG0000 +parametrizar parametrizar VMN0000 +paramos parir VMM01P0 +paran parir VMM03P0 +parando parar VMG0000 +parangona parangonar VMM02S0 +parangonad parangonar VMM02P0 +parangonando parangonar VMG0000 +parangonar parangonar VMN0000 +parangone parangonar VMM03S0 +parangonemos parangonar VMM01P0 +parangonen parangonar VMM03P0 +parapeta parapetar VMM02S0 +parapetad parapetar VMM02P0 +parapetando parapetar VMG0000 +parapetar parapetar VMN0000 +parapete parapetar VMM03S0 +parapetemos parapetar VMM01P0 +parapeten parapetar VMM03P0 +parar parar VMN0000 +parcela parcelar VMM02S0 +parcelad parcelar VMM02P0 +parcelando parcelar VMG0000 +parcelar parcelar VMN0000 +parcele parcelar VMM03S0 +parcelemos parcelar VMM01P0 +parcelen parcelar VMM03P0 +parchea parchear VMM02S0 +parchead parchear VMM02P0 +parcheando parchear VMG0000 +parchear parchear VMN0000 +parchee parchear VMM03S0 +parcheemos parchear VMM01P0 +parcheen parchear VMM03P0 +pardea pardear VMM02S0 +pardead pardear VMM02P0 +pardeando pardear VMG0000 +pardear pardear VMN0000 +pardee pardear VMM03S0 +pardeemos pardear VMM01P0 +pardeen pardear VMM03P0 +pare parar VMM03S0 +pare parir VMM02S0 +parea parear VMM02S0 +paread parear VMM02P0 +pareando parear VMG0000 +parear parear VMN0000 +parece parecer VMM02S0 +pareced parecer VMM02P0 +parecer parecer VMN0000 +pareciendo parecer VMG0000 +paree parear VMM03S0 +pareemos parear VMM01P0 +pareen parear VMM03P0 +paremos parar VMM01P0 +paren parar VMM03P0 +parezca parecer VMM03S0 +parezcamos parecer VMM01P0 +parezcan parecer VMM03P0 +parid parir VMM02P0 +pariendo parir VMG0000 +parifica parificar VMM02S0 +parificad parificar VMM02P0 +parificando parificar VMG0000 +parificar parificar VMN0000 +parifique parificar VMM03S0 +parifiquemos parificar VMM01P0 +parifiquen parificar VMM03P0 +parir parir VMN0000 +parla parlar VMM02S0 +parlad parlar VMM02P0 +parlamenta parlamentar VMM02S0 +parlamentad parlamentar VMM02P0 +parlamentando parlamentar VMG0000 +parlamentar parlamentar VMN0000 +parlamente parlamentar VMM03S0 +parlamentemos parlamentar VMM01P0 +parlamenten parlamentar VMM03P0 +parlando parlar VMG0000 +parlar parlar VMN0000 +parle parlar VMM03S0 +parlemos parlar VMM01P0 +parlen parlar VMM03P0 +parlotea parlotear VMM02S0 +parlotead parlotear VMM02P0 +parloteando parlotear VMG0000 +parlotear parlotear VMN0000 +parlotee parlotear VMM03S0 +parloteemos parlotear VMM01P0 +parloteen parlotear VMM03P0 +parodia parodiar VMM02S0 +parodiad parodiar VMM02P0 +parodiando parodiar VMG0000 +parodiar parodiar VMN0000 +parodie parodiar VMM03S0 +parodiemos parodiar VMM01P0 +parodien parodiar VMM03P0 +parpa parpar VMM02S0 +parpad parpar VMM02P0 +parpadea parpadear VMM02S0 +parpadead parpadear VMM02P0 +parpadeando parpadear VMG0000 +parpadear parpadear VMN0000 +parpadee parpadear VMM03S0 +parpadeemos parpadear VMM01P0 +parpadeen parpadear VMM03P0 +parpando parpar VMG0000 +parpar parpar VMN0000 +parpe parpar VMM03S0 +parpemos parpar VMM01P0 +parpen parpar VMM03P0 +parquea parquear VMM02S0 +parquead parquear VMM02P0 +parqueando parquear VMG0000 +parquear parquear VMN0000 +parquee parquear VMM03S0 +parqueemos parquear VMM01P0 +parqueen parquear VMM03P0 +parrafea parrafear VMM02S0 +parrafead parrafear VMM02P0 +parrafeando parrafear VMG0000 +parrafear parrafear VMN0000 +parrafee parrafear VMM03S0 +parrafeemos parrafear VMM01P0 +parrafeen parrafear VMM03P0 +parrandea parrandear VMM02S0 +parrandead parrandear VMM02P0 +parrandeando parrandear VMG0000 +parrandear parrandear VMN0000 +parrandee parrandear VMM03S0 +parrandeemos parrandear VMM01P0 +parrandeen parrandear VMM03P0 +parta partir VMM03S0 +partamos partir VMM01P0 +partan partir VMM03P0 +parte partir VMM02S0 +partea partear VMM02S0 +partead partear VMM02P0 +parteando partear VMG0000 +partear partear VMN0000 +partee partear VMM03S0 +parteemos partear VMM01P0 +parteen partear VMM03P0 +participa participar VMM02S0 +participad participar VMM02P0 +participando participar VMG0000 +participar participar VMN0000 +participe participar VMM03S0 +participemos participar VMM01P0 +participen participar VMM03P0 +particularice particularizar VMM03S0 +particularicemos particularizar VMM01P0 +particularicen particularizar VMM03P0 +particulariza particularizar VMM02S0 +particularizad particularizar VMM02P0 +particularizando particularizar VMG0000 +particularizar particularizar VMN0000 +partid partir VMM02P0 +partiendo partir VMG0000 +partir partir VMN0000 +pasa pasar VMM02S0 +pasad pasar VMM02P0 +pasamana pasamanar VMM02S0 +pasamanad pasamanar VMM02P0 +pasamanando pasamanar VMG0000 +pasamanar pasamanar VMN0000 +pasamane pasamanar VMM03S0 +pasamanemos pasamanar VMM01P0 +pasamanen pasamanar VMM03P0 +pasando pasar VMG0000 +pasaporta pasaportar VMM02S0 +pasaportad pasaportar VMM02P0 +pasaportando pasaportar VMG0000 +pasaportar pasaportar VMN0000 +pasaporte pasaportar VMM03S0 +pasaportemos pasaportar VMM01P0 +pasaporten pasaportar VMM03P0 +pasar pasar VMN0000 +pase pasar VMM03S0 +pasea pasear VMM02S0 +pasead pasear VMM02P0 +paseando pasear VMG0000 +pasear pasear VMN0000 +pasee pasear VMM03S0 +paseemos pasear VMM01P0 +paseen pasear VMM03P0 +pasemos pasar VMM01P0 +pasen pasar VMM03P0 +pasma pasmar VMM02S0 +pasmad pasmar VMM02P0 +pasmando pasmar VMG0000 +pasmar pasmar VMN0000 +pasme pasmar VMM03S0 +pasmemos pasmar VMM01P0 +pasmen pasmar VMM03P0 +pasta pastar VMM02S0 +pastad pastar VMM02P0 +pastando pastar VMG0000 +pastar pastar VMN0000 +paste pastar VMM03S0 +pastelea pastelear VMM02S0 +pastelead pastelear VMM02P0 +pasteleando pastelear VMG0000 +pastelear pastelear VMN0000 +pastelee pastelear VMM03S0 +pasteleemos pastelear VMM01P0 +pasteleen pastelear VMM03P0 +pastemos pastar VMM01P0 +pasten pastar VMM03P0 +pasterice pasterizar VMM03S0 +pastericemos pasterizar VMM01P0 +pastericen pasterizar VMM03P0 +pasteriza pasterizar VMM02S0 +pasterizad pasterizar VMM02P0 +pasterizando pasterizar VMG0000 +pasterizar pasterizar VMN0000 +pasteurice pasteurizar VMM03S0 +pasteuricemos pasteurizar VMM01P0 +pasteuricen pasteurizar VMM03P0 +pasteuriza pasteurizar VMM02S0 +pasteurizad pasteurizar VMM02P0 +pasteurizando pasteurizar VMG0000 +pasteurizar pasteurizar VMN0000 +pastorea pastorear VMM02S0 +pastoread pastorear VMM02P0 +pastoreando pastorear VMG0000 +pastorear pastorear VMN0000 +pastoree pastorear VMM03S0 +pastoreemos pastorear VMM01P0 +pastoreen pastorear VMM03P0 +patalea patalear VMM02S0 +patalead patalear VMM02P0 +pataleando patalear VMG0000 +patalear patalear VMN0000 +patalee patalear VMM03S0 +pataleemos patalear VMM01P0 +pataleen patalear VMM03P0 +pataletea pataletear VMM02S0 +pataletead pataletear VMM02P0 +pataleteando pataletear VMG0000 +pataletear pataletear VMN0000 +pataletee pataletear VMM03S0 +pataleteemos pataletear VMM01P0 +pataleteen pataletear VMM03P0 +patea patear VMM02S0 +patead patear VMM02P0 +pateando patear VMG0000 +patear patear VMN0000 +patee patear VMM03S0 +pateemos patear VMM01P0 +pateen patear VMM03P0 +patenta patentar VMM02S0 +patentad patentar VMM02P0 +patentando patentar VMG0000 +patentar patentar VMN0000 +patente patentar VMM03S0 +patentemos patentar VMM01P0 +patenten patentar VMM03P0 +patentice patentizar VMM03S0 +patenticemos patentizar VMM01P0 +patenticen patentizar VMM03P0 +patentiza patentizar VMM02S0 +patentizad patentizar VMM02P0 +patentizando patentizar VMG0000 +patentizar patentizar VMN0000 +patina patinar VMM02S0 +patinad patinar VMM02P0 +patinando patinar VMG0000 +patinar patinar VMN0000 +patine patinar VMM03S0 +patinemos patinar VMM01P0 +patinen patinar VMM03P0 +patiquebrad patiquebrar VMM02P0 +patiquebrando patiquebrar VMG0000 +patiquebrar patiquebrar VMN0000 +patiquebremos patiquebrar VMM01P0 +patiquiebra patiquebrar VMM02S0 +patiquiebre patiquebrar VMM03S0 +patiquiebren patiquebrar VMM03P0 +patrocina patrocinar VMM02S0 +patrocinad patrocinar VMM02P0 +patrocinando patrocinar VMG0000 +patrocinar patrocinar VMN0000 +patrocine patrocinar VMM03S0 +patrocinemos patrocinar VMM01P0 +patrocinen patrocinar VMM03P0 +patronea patronear VMM02S0 +patronead patronear VMM02P0 +patroneando patronear VMG0000 +patronear patronear VMN0000 +patronee patronear VMM03S0 +patroneemos patronear VMM01P0 +patroneen patronear VMM03P0 +patrulla patrullar VMM02S0 +patrullad patrullar VMM02P0 +patrullando patrullar VMG0000 +patrullar patrullar VMN0000 +patrulle patrullar VMM03S0 +patrullemos patrullar VMM01P0 +patrullen patrullar VMM03P0 +patulla patullar VMM02S0 +patullad patullar VMM02P0 +patullando patullar VMG0000 +patullar patullar VMN0000 +patulle patullar VMM03S0 +patullemos patullar VMM01P0 +patullen patullar VMM03P0 +paula paular VMM02S0 +paulad paular VMM02P0 +paulando paular VMG0000 +paular paular VMN0000 +paule paular VMM03S0 +paulemos paular VMM01P0 +paulen paular VMM03P0 +pausa pausar VMM02S0 +pausad pausar VMM02P0 +pausando pausar VMG0000 +pausar pausar VMN0000 +pause pausar VMM03S0 +pausemos pausar VMM01P0 +pausen pausar VMM03P0 +pauta pautar VMM02S0 +pautad pautar VMM02P0 +pautando pautar VMG0000 +pautar pautar VMN0000 +paute pautar VMM03S0 +pautemos pautar VMM01P0 +pauten pautar VMM03P0 +pavimenta pavimentar VMM02S0 +pavimentad pavimentar VMM02P0 +pavimentando pavimentar VMG0000 +pavimentar pavimentar VMN0000 +pavimente pavimentar VMM03S0 +pavimentemos pavimentar VMM01P0 +pavimenten pavimentar VMM03P0 +pavona pavonar VMM02S0 +pavonad pavonar VMM02P0 +pavonando pavonar VMG0000 +pavonar pavonar VMN0000 +pavone pavonar VMM03S0 +pavonea pavonear VMM02S0 +pavonead pavonear VMM02P0 +pavoneando pavonear VMG0000 +pavonear pavonear VMN0000 +pavonee pavonear VMM03S0 +pavoneemos pavonear VMM01P0 +pavoneen pavonear VMM03P0 +pavonemos pavonar VMM01P0 +pavonen pavonar VMM03P0 +pazca pacer VMM03S0 +pazcamos pacer VMM01P0 +pazcan pacer VMM03P0 +pea peer VMM03S0 +peamos peer VMM01P0 +pean peer VMM03P0 +peca pecar VMM02S0 +pecad pecar VMM02P0 +pecando pecar VMG0000 +pecar pecar VMN0000 +pecha pechar VMM02S0 +pechad pechar VMM02P0 +pechando pechar VMG0000 +pechar pechar VMN0000 +peche pechar VMM03S0 +pechemos pechar VMM01P0 +pechen pechar VMM03P0 +pedalea pedalear VMM02S0 +pedalead pedalear VMM02P0 +pedaleando pedalear VMG0000 +pedalear pedalear VMN0000 +pedalee pedalear VMM03S0 +pedaleemos pedalear VMM01P0 +pedaleen pedalear VMM03P0 +pedantea pedantear VMM02S0 +pedantead pedantear VMM02P0 +pedanteando pedantear VMG0000 +pedantear pedantear VMN0000 +pedantee pedantear VMM03S0 +pedanteemos pedantear VMM01P0 +pedanteen pedantear VMM03P0 +pede peder VMM02S0 +peded peder VMM02P0 +peder peder VMN0000 +pedid pedir VMM02P0 +pediendo peder VMG0000 +pedir pedir VMN0000 +pee peer VMM02S0 +peed peer VMM02P0 +peer peer VMN0000 +pega pegar VMM02S0 +pegad pegar VMM02P0 +pegando pegar VMG0000 +pegar pegar VMN0000 +pegue pegar VMM03S0 +peguemos pegar VMM01P0 +peguen pegar VMM03P0 +pegunta peguntar VMM02S0 +peguntad peguntar VMM02P0 +peguntando peguntar VMG0000 +peguntar peguntar VMN0000 +pegunte peguntar VMM03S0 +peguntemos peguntar VMM01P0 +pegunten peguntar VMM03P0 +peina peinar VMM02S0 +peinad peinar VMM02P0 +peinando peinar VMG0000 +peinar peinar VMN0000 +peine peinar VMM03S0 +peinemos peinar VMM01P0 +peinen peinar VMM03P0 +pela pelar VMM02S0 +pelad pelar VMM02P0 +pelambra pelambrar VMM02S0 +pelambrad pelambrar VMM02P0 +pelambrando pelambrar VMG0000 +pelambrar pelambrar VMN0000 +pelambre pelambrar VMM03S0 +pelambremos pelambrar VMM01P0 +pelambren pelambrar VMM03P0 +pelando pelar VMG0000 +pelar pelar VMN0000 +pele pelar VMM03S0 +pelea pelear VMM02S0 +pelead pelear VMM02P0 +peleando pelear VMG0000 +pelear pelear VMN0000 +pelecha pelechar VMM02S0 +pelechad pelechar VMM02P0 +pelechando pelechar VMG0000 +pelechar pelechar VMN0000 +peleche pelechar VMM03S0 +pelechemos pelechar VMM01P0 +pelechen pelechar VMM03P0 +pelee pelear VMM03S0 +peleemos pelear VMM01P0 +peleen pelear VMM03P0 +pelemos pelar VMM01P0 +pelen pelar VMM03P0 +peligra peligrar VMM02S0 +peligrad peligrar VMM02P0 +peligrando peligrar VMG0000 +peligrar peligrar VMN0000 +peligre peligrar VMM03S0 +peligremos peligrar VMM01P0 +peligren peligrar VMM03P0 +pellizca pellizcar VMM02S0 +pellizcad pellizcar VMM02P0 +pellizcando pellizcar VMG0000 +pellizcar pellizcar VMN0000 +pellizque pellizcar VMM03S0 +pellizquemos pellizcar VMM01P0 +pellizquen pellizcar VMM03P0 +pelotea pelotear VMM02S0 +pelotead pelotear VMM02P0 +peloteando pelotear VMG0000 +pelotear pelotear VMN0000 +pelotee pelotear VMM03S0 +peloteemos pelotear VMM01P0 +peloteen pelotear VMM03P0 +pena penar VMM02S0 +penad penar VMM02P0 +penalice penalizar VMM03S0 +penalicemos penalizar VMM01P0 +penalicen penalizar VMM03P0 +penaliza penalizar VMM02S0 +penalizad penalizar VMM02P0 +penalizando penalizar VMG0000 +penalizar penalizar VMN0000 +penando penar VMG0000 +penar penar VMN0000 +penda pender VMM03S0 +pendamos pender VMM01P0 +pendan pender VMM03P0 +pende pender VMM02S0 +pended pender VMM02P0 +pendencia pendenciar VMM02S0 +pendenciad pendenciar VMM02P0 +pendenciando pendenciar VMG0000 +pendenciar pendenciar VMN0000 +pendencie pendenciar VMM03S0 +pendenciemos pendenciar VMM01P0 +pendencien pendenciar VMM03P0 +pender pender VMN0000 +pendiendo pender VMG0000 +pendonea pendonear VMM02S0 +pendonead pendonear VMM02P0 +pendoneando pendonear VMG0000 +pendonear pendonear VMN0000 +pendonee pendonear VMM03S0 +pendoneemos pendonear VMM01P0 +pendoneen pendonear VMM03P0 +pene penar VMM03S0 +penemos penar VMM01P0 +penen penar VMM03P0 +penetra penetrar VMM02S0 +penetrad penetrar VMM02P0 +penetrando penetrar VMG0000 +penetrar penetrar VMN0000 +penetre penetrar VMM03S0 +penetremos penetrar VMM01P0 +penetren penetrar VMM03P0 +penitencia penitenciar VMM02S0 +penitenciad penitenciar VMM02P0 +penitenciando penitenciar VMG0000 +penitenciar penitenciar VMN0000 +penitencie penitenciar VMM03S0 +penitenciemos penitenciar VMM01P0 +penitencien penitenciar VMM03P0 +pensad pensar VMM02P0 +pensando pensar VMG0000 +pensar pensar VMN0000 +pensemos pensar VMM01P0 +pensiona pensionar VMM02S0 +pensionad pensionar VMM02P0 +pensionando pensionar VMG0000 +pensionar pensionar VMN0000 +pensione pensionar VMM03S0 +pensionemos pensionar VMM01P0 +pensionen pensionar VMM03P0 +peque pecar VMM03S0 +pequemos pecar VMM01P0 +pequen pecar VMM03P0 +peralta peraltar VMM02S0 +peraltad peraltar VMM02P0 +peraltando peraltar VMG0000 +peraltar peraltar VMN0000 +peralte peraltar VMM03S0 +peraltemos peraltar VMM01P0 +peralten peraltar VMM03P0 +percata percatar VMM02S0 +percatad percatar VMM02P0 +percatando percatar VMG0000 +percatar percatar VMN0000 +percate percatar VMM03S0 +percatemos percatar VMM01P0 +percaten percatar VMM03P0 +percha perchar VMM02S0 +perchad perchar VMM02P0 +perchando perchar VMG0000 +perchar perchar VMN0000 +perche perchar VMM03S0 +perchemos perchar VMM01P0 +perchen perchar VMM03P0 +perciba percibir VMM03S0 +percibamos percibir VMM01P0 +perciban percibir VMM03P0 +percibe percibir VMM02S0 +percibid percibir VMM02P0 +percibiendo percibir VMG0000 +percibir percibir VMN0000 +percuda percudir VMM03S0 +percudamos percudir VMM01P0 +percudan percudir VMM03P0 +percude percudir VMM02S0 +percudid percudir VMM02P0 +percudiendo percudir VMG0000 +percudir percudir VMN0000 +percuta percutir VMM03S0 +percutamos percutir VMM01P0 +percutan percutir VMM03P0 +percute percutir VMM02S0 +percutid percutir VMM02P0 +percutiendo percutir VMG0000 +percutir percutir VMN0000 +perdamos perder VMM01P0 +perded perder VMM02P0 +perder perder VMN0000 +perdiendo perder VMG0000 +perdona perdonar VMM02S0 +perdonad perdonar VMM02P0 +perdonando perdonar VMG0000 +perdonar perdonar VMN0000 +perdone perdonar VMM03S0 +perdonemos perdonar VMM01P0 +perdonen perdonar VMM03P0 +perdura perdurar VMM02S0 +perdurad perdurar VMM02P0 +perdurando perdurar VMG0000 +perdurar perdurar VMN0000 +perdure perdurar VMM03S0 +perduremos perdurar VMM01P0 +perduren perdurar VMM03P0 +perece perecer VMM02S0 +pereced perecer VMM02P0 +perecer perecer VMN0000 +pereciendo perecer VMG0000 +peregrina peregrinar VMM02S0 +peregrinad peregrinar VMM02P0 +peregrinando peregrinar VMG0000 +peregrinar peregrinar VMN0000 +peregrine peregrinar VMM03S0 +peregrinemos peregrinar VMM01P0 +peregrinen peregrinar VMM03P0 +perezca perecer VMM03S0 +perezcamos perecer VMM01P0 +perezcan perecer VMM03P0 +perfecciona perfeccionar VMM02S0 +perfeccionad perfeccionar VMM02P0 +perfeccionando perfeccionar VMG0000 +perfeccionar perfeccionar VMN0000 +perfeccione perfeccionar VMM03S0 +perfeccionemos perfeccionar VMM01P0 +perfeccionen perfeccionar VMM03P0 +perfila perfilar VMM02S0 +perfilad perfilar VMM02P0 +perfilando perfilar VMG0000 +perfilar perfilar VMN0000 +perfile perfilar VMM03S0 +perfilemos perfilar VMM01P0 +perfilen perfilar VMM03P0 +perfora perforar VMM02S0 +perforad perforar VMM02P0 +perforando perforar VMG0000 +perforar perforar VMN0000 +perfore perforar VMM03S0 +perforemos perforar VMM01P0 +perforen perforar VMM03P0 +perfuma perfumar VMM02S0 +perfumad perfumar VMM02P0 +perfumando perfumar VMG0000 +perfumar perfumar VMN0000 +perfume perfumar VMM03S0 +perfumemos perfumar VMM01P0 +perfumen perfumar VMM03P0 +pergeña pergeñar VMM02S0 +pergeñad pergeñar VMM02P0 +pergeñando pergeñar VMG0000 +pergeñar pergeñar VMN0000 +pergeñe pergeñar VMM03S0 +pergeñemos pergeñar VMM01P0 +pergeñen pergeñar VMM03P0 +periclita periclitar VMM02S0 +periclitad periclitar VMM02P0 +periclitando periclitar VMG0000 +periclitar periclitar VMN0000 +periclite periclitar VMM03S0 +periclitemos periclitar VMM01P0 +pericliten periclitar VMM03P0 +perifrasea perifrasear VMM02S0 +perifrasead perifrasear VMM02P0 +perifraseando perifrasear VMG0000 +perifrasear perifrasear VMN0000 +perifrasee perifrasear VMM03S0 +perifraseemos perifrasear VMM01P0 +perifraseen perifrasear VMM03P0 +periquea periquear VMM02S0 +periquead periquear VMM02P0 +periqueando periquear VMG0000 +periquear periquear VMN0000 +periquee periquear VMM03S0 +periqueemos periquear VMM01P0 +periqueen periquear VMM03P0 +perjudica perjudicar VMM02S0 +perjudicad perjudicar VMM02P0 +perjudicando perjudicar VMG0000 +perjudicar perjudicar VMN0000 +perjudique perjudicar VMM03S0 +perjudiquemos perjudicar VMM01P0 +perjudiquen perjudicar VMM03P0 +perjura perjurar VMM02S0 +perjurad perjurar VMM02P0 +perjurando perjurar VMG0000 +perjurar perjurar VMN0000 +perjure perjurar VMM03S0 +perjuremos perjurar VMM01P0 +perjuren perjurar VMM03P0 +perlonga perlongar VMM02S0 +perlongad perlongar VMM02P0 +perlongando perlongar VMG0000 +perlongar perlongar VMN0000 +perlongue perlongar VMM03S0 +perlonguemos perlongar VMM01P0 +perlonguen perlongar VMM03P0 +permanece permanecer VMM02S0 +permaneced permanecer VMM02P0 +permanecer permanecer VMN0000 +permaneciendo permanecer VMG0000 +permanezca permanecer VMM03S0 +permanezcamos permanecer VMM01P0 +permanezcan permanecer VMM03P0 +permita permitir VMM03S0 +permitamos permitir VMM01P0 +permitan permitir VMM03P0 +permite permitir VMM02S0 +permitid permitir VMM02P0 +permitiendo permitir VMG0000 +permitir permitir VMN0000 +permuta permutar VMM02S0 +permutad permutar VMM02P0 +permutando permutar VMG0000 +permutar permutar VMN0000 +permute permutar VMM03S0 +permutemos permutar VMM01P0 +permuten permutar VMM03P0 +pernea pernear VMM02S0 +pernead pernear VMM02P0 +perneando pernear VMG0000 +pernear pernear VMN0000 +pernee pernear VMM03S0 +perneemos pernear VMM01P0 +perneen pernear VMM03P0 +perniquebrad perniquebrar VMM02P0 +perniquebrando perniquebrar VMG0000 +perniquebrar perniquebrar VMN0000 +perniquebremos perniquebrar VMM01P0 +perniquiebra perniquebrar VMM02S0 +perniquiebre perniquebrar VMM03S0 +perniquiebren perniquebrar VMM03P0 +pernocta pernoctar VMM02S0 +pernoctad pernoctar VMM02P0 +pernoctando pernoctar VMG0000 +pernoctar pernoctar VMN0000 +pernocte pernoctar VMM03S0 +pernoctemos pernoctar VMM01P0 +pernocten pernoctar VMM03P0 +perora perorar VMM02S0 +perorad perorar VMM02P0 +perorando perorar VMG0000 +perorar perorar VMN0000 +perore perorar VMM03S0 +peroremos perorar VMM01P0 +peroren perorar VMM03P0 +peroxida peroxidar VMM02S0 +peroxidad peroxidar VMM02P0 +peroxidando peroxidar VMG0000 +peroxidar peroxidar VMN0000 +peroxide peroxidar VMM03S0 +peroxidemos peroxidar VMM01P0 +peroxiden peroxidar VMM03P0 +perpetra perpetrar VMM02S0 +perpetrad perpetrar VMM02P0 +perpetrando perpetrar VMG0000 +perpetrar perpetrar VMN0000 +perpetre perpetrar VMM03S0 +perpetremos perpetrar VMM01P0 +perpetren perpetrar VMM03P0 +perpetuad perpetuar VMM02P0 +perpetuando perpetuar VMG0000 +perpetuar perpetuar VMN0000 +perpetuemos perpetuar VMM01P0 +perpetúa perpetuar VMM02S0 +perpetúe perpetuar VMM03S0 +perpetúen perpetuar VMM03P0 +perquiera perquirir VMM03S0 +perquieran perquirir VMM03P0 +perquiere perquirir VMM02S0 +perquiramos perquirir VMM01P0 +perquirid perquirir VMM02P0 +perquiriendo perquirir VMG0000 +perquirir perquirir VMN0000 +perseguid perseguir VMM02P0 +perseguir perseguir VMN0000 +persevera perseverar VMM02S0 +perseverad perseverar VMM02P0 +perseverando perseverar VMG0000 +perseverar perseverar VMN0000 +persevere perseverar VMM03S0 +perseveremos perseverar VMM01P0 +perseveren perseverar VMM03P0 +persiga perseguir VMM03S0 +persigamos perseguir VMM01P0 +persigan perseguir VMM03P0 +persigna persignar VMM02S0 +persignad persignar VMM02P0 +persignando persignar VMG0000 +persignar persignar VMN0000 +persigne persignar VMM03S0 +persignemos persignar VMM01P0 +persignen persignar VMM03P0 +persigue perseguir VMM02S0 +persiguiendo perseguir VMG0000 +persista persistir VMM03S0 +persistamos persistir VMM01P0 +persistan persistir VMM03P0 +persiste persistir VMM02S0 +persistid persistir VMM02P0 +persistiendo persistir VMG0000 +persistir persistir VMN0000 +persona personar VMM02S0 +personad personar VMM02P0 +personalice personalizar VMM03S0 +personalicemos personalizar VMM01P0 +personalicen personalizar VMM03P0 +personaliza personalizar VMM02S0 +personalizad personalizar VMM02P0 +personalizando personalizar VMG0000 +personalizar personalizar VMN0000 +personando personar VMG0000 +personar personar VMN0000 +persone personar VMM03S0 +personemos personar VMM01P0 +personen personar VMM03P0 +personifica personificar VMM02S0 +personificad personificar VMM02P0 +personificando personificar VMG0000 +personificar personificar VMN0000 +personifique personificar VMM03S0 +personifiquemos personificar VMM01P0 +personifiquen personificar VMM03P0 +persuada persuadir VMM03S0 +persuadamos persuadir VMM01P0 +persuadan persuadir VMM03P0 +persuade persuadir VMM02S0 +persuadid persuadir VMM02P0 +persuadiendo persuadir VMG0000 +persuadir persuadir VMN0000 +pertenece pertenecer VMM02S0 +perteneced pertenecer VMM02P0 +pertenecer pertenecer VMN0000 +perteneciendo pertenecer VMG0000 +pertenezca pertenecer VMM03S0 +pertenezcamos pertenecer VMM01P0 +pertenezcan pertenecer VMM03P0 +pertrecha pertrechar VMM02S0 +pertrechad pertrechar VMM02P0 +pertrechando pertrechar VMG0000 +pertrechar pertrechar VMN0000 +pertreche pertrechar VMM03S0 +pertrechemos pertrechar VMM01P0 +pertrechen pertrechar VMM03P0 +perturba perturbar VMM02S0 +perturbad perturbar VMM02P0 +perturbando perturbar VMG0000 +perturbar perturbar VMN0000 +perturbe perturbar VMM03S0 +perturbemos perturbar VMM01P0 +perturben perturbar VMM03P0 +pervertid pervertir VMM02P0 +pervertir pervertir VMN0000 +pervierta pervertir VMM03S0 +perviertan pervertir VMM03P0 +pervierte pervertir VMM02S0 +pervirtamos pervertir VMM01P0 +pervirtiendo pervertir VMG0000 +perviva pervivir VMM03S0 +pervivamos pervivir VMM01P0 +pervivan pervivir VMM03P0 +pervive pervivir VMM02S0 +pervivid pervivir VMM02P0 +perviviendo pervivir VMG0000 +pervivir pervivir VMN0000 +pesa pesar VMM02S0 +pesad pesar VMM02P0 +pesando pesar VMG0000 +pesar pesar VMN0000 +pesca pescar VMM02S0 +pescad pescar VMM02P0 +pescando pescar VMG0000 +pescar pescar VMN0000 +pese pesar VMM03S0 +pesemos pesar VMM01P0 +pesen pesar VMM03P0 +pespunta pespuntar VMM02S0 +pespuntad pespuntar VMM02P0 +pespuntando pespuntar VMG0000 +pespuntar pespuntar VMN0000 +pespunte pespuntar VMM03S0 +pespuntea pespuntear VMM02S0 +pespuntead pespuntear VMM02P0 +pespunteando pespuntear VMG0000 +pespuntear pespuntear VMN0000 +pespuntee pespuntear VMM03S0 +pespunteemos pespuntear VMM01P0 +pespunteen pespuntear VMM03P0 +pespuntemos pespuntar VMM01P0 +pespunten pespuntar VMM03P0 +pesque pescar VMM03S0 +pesquemos pescar VMM01P0 +pesquen pescar VMM03P0 +pesquisa pesquisar VMM02S0 +pesquisad pesquisar VMM02P0 +pesquisando pesquisar VMG0000 +pesquisar pesquisar VMN0000 +pesquise pesquisar VMM03S0 +pesquisemos pesquisar VMM01P0 +pesquisen pesquisar VMM03P0 +pestañea pestañear VMM02S0 +pestañead pestañear VMM02P0 +pestañeando pestañear VMG0000 +pestañear pestañear VMN0000 +pestañee pestañear VMM03S0 +pestañeemos pestañear VMM01P0 +pestañeen pestañear VMM03P0 +peta petar VMM02S0 +petad petar VMM02P0 +petando petar VMG0000 +petar petar VMN0000 +petardea petardear VMM02S0 +petardead petardear VMM02P0 +petardeando petardear VMG0000 +petardear petardear VMN0000 +petardee petardear VMM03S0 +petardeemos petardear VMM01P0 +petardeen petardear VMM03P0 +pete petar VMM03S0 +petemos petar VMM01P0 +peten petar VMM03P0 +peticiona peticionar VMM02S0 +peticionad peticionar VMM02P0 +peticionando peticionar VMG0000 +peticionar peticionar VMN0000 +peticione peticionar VMM03S0 +peticionemos peticionar VMM01P0 +peticionen peticionar VMM03P0 +petrifica petrificar VMM02S0 +petrificad petrificar VMM02P0 +petrificando petrificar VMG0000 +petrificar petrificar VMN0000 +petrifique petrificar VMM03S0 +petrifiquemos petrificar VMM01P0 +petrifiquen petrificar VMM03P0 +petrolea petrolear VMM02S0 +petrolead petrolear VMM02P0 +petroleando petrolear VMG0000 +petrolear petrolear VMN0000 +petrolee petrolear VMM03S0 +petroleemos petrolear VMM01P0 +petroleen petrolear VMM03P0 +peyendo peer VMG0000 +piad piar VMM02P0 +piafa piafar VMM02S0 +piafad piafar VMM02P0 +piafando piafar VMG0000 +piafar piafar VMN0000 +piafe piafar VMM03S0 +piafemos piafar VMM01P0 +piafen piafar VMM03P0 +piala pialar VMM02S0 +pialad pialar VMM02P0 +pialando pialar VMG0000 +pialar pialar VMN0000 +piale pialar VMM03S0 +pialemos pialar VMM01P0 +pialen pialar VMM03P0 +piando piar VMG0000 +piar piar VMN0000 +pica picar VMM02S0 +picad picar VMM02P0 +picando picar VMG0000 +picanea picanear VMM02S0 +picanead picanear VMM02P0 +picaneando picanear VMG0000 +picanear picanear VMN0000 +picanee picanear VMM03S0 +picaneemos picanear VMM01P0 +picaneen picanear VMM03P0 +picar picar VMN0000 +picardea picardear VMM02S0 +picardead picardear VMM02P0 +picardeando picardear VMG0000 +picardear picardear VMN0000 +picardee picardear VMM03S0 +picardeemos picardear VMM01P0 +picardeen picardear VMM03P0 +picotea picotear VMM02S0 +picotead picotear VMM02P0 +picoteando picotear VMG0000 +picotear picotear VMN0000 +picotee picotear VMM03S0 +picoteemos picotear VMM01P0 +picoteen picotear VMM03P0 +pida pedir VMM03S0 +pidamos pedir VMM01P0 +pidan pedir VMM03P0 +pide pedir VMM02S0 +pidiendo pedir VMG0000 +piemos piar VMM01P0 +piensa pensar VMM02S0 +piense pensar VMM03S0 +piensen pensar VMM03P0 +pierda perder VMM03S0 +pierdan perder VMM03P0 +pierde perder VMM02S0 +pifia pifiar VMM02S0 +pifiad pifiar VMM02P0 +pifiando pifiar VMG0000 +pifiar pifiar VMN0000 +pifie pifiar VMM03S0 +pifiemos pifiar VMM01P0 +pifien pifiar VMM03P0 +pigmenta pigmentar VMM02S0 +pigmentad pigmentar VMM02P0 +pigmentando pigmentar VMG0000 +pigmentar pigmentar VMN0000 +pigmente pigmentar VMM03S0 +pigmentemos pigmentar VMM01P0 +pigmenten pigmentar VMM03P0 +pignora pignorar VMM02S0 +pignorad pignorar VMM02P0 +pignorando pignorar VMG0000 +pignorar pignorar VMN0000 +pignore pignorar VMM03S0 +pignoremos pignorar VMM01P0 +pignoren pignorar VMM03P0 +pila pilar VMM02S0 +pilad pilar VMM02P0 +pilando pilar VMG0000 +pilar pilar VMN0000 +pile pilar VMM03S0 +pilemos pilar VMM01P0 +pilen pilar VMM03P0 +pilla pillar VMM02S0 +pillad pillar VMM02P0 +pillando pillar VMG0000 +pillar pillar VMN0000 +pille pillar VMM03S0 +pillea pillear VMM02S0 +pillead pillear VMM02P0 +pilleando pillear VMG0000 +pillear pillear VMN0000 +pillee pillear VMM03S0 +pilleemos pillear VMM01P0 +pilleen pillear VMM03P0 +pillemos pillar VMM01P0 +pillen pillar VMM03P0 +pilota pilotar VMM02S0 +pilotad pilotar VMM02P0 +pilotando pilotar VMG0000 +pilotar pilotar VMN0000 +pilote pilotar VMM03S0 +pilotea pilotear VMM02S0 +pilotead pilotear VMM02P0 +piloteando pilotear VMG0000 +pilotear pilotear VMN0000 +pilotee pilotear VMM03S0 +piloteemos pilotear VMM01P0 +piloteen pilotear VMM03P0 +pilotemos pilotar VMM01P0 +piloten pilotar VMM03P0 +pimpla pimplar VMM02S0 +pimplad pimplar VMM02P0 +pimplando pimplar VMG0000 +pimplar pimplar VMN0000 +pimple pimplar VMM03S0 +pimplemos pimplar VMM01P0 +pimplen pimplar VMM03P0 +pimpollea pimpollear VMM02S0 +pimpollead pimpollear VMM02P0 +pimpolleando pimpollear VMG0000 +pimpollear pimpollear VMN0000 +pimpollece pimpollecer VMM02S0 +pimpolleced pimpollecer VMM02P0 +pimpollecer pimpollecer VMN0000 +pimpolleciendo pimpollecer VMG0000 +pimpollee pimpollear VMM03S0 +pimpolleemos pimpollear VMM01P0 +pimpolleen pimpollear VMM03P0 +pimpollezca pimpollecer VMM03S0 +pimpollezcamos pimpollecer VMM01P0 +pimpollezcan pimpollecer VMM03P0 +pince pinzar VMM03S0 +pincela pincelar VMM02S0 +pincelad pincelar VMM02P0 +pincelando pincelar VMG0000 +pincelar pincelar VMN0000 +pincele pincelar VMM03S0 +pincelemos pincelar VMM01P0 +pincelen pincelar VMM03P0 +pincemos pinzar VMM01P0 +pincen pinzar VMM03P0 +pincha pinchar VMM02S0 +pinchad pinchar VMM02P0 +pinchando pinchar VMG0000 +pinchar pinchar VMN0000 +pinche pinchar VMM03S0 +pinchemos pinchar VMM01P0 +pinchen pinchar VMM03P0 +pindonguea pindonguear VMM02S0 +pindonguead pindonguear VMM02P0 +pindongueando pindonguear VMG0000 +pindonguear pindonguear VMN0000 +pindonguee pindonguear VMM03S0 +pindongueemos pindonguear VMM01P0 +pindongueen pindonguear VMM03P0 +pinta pintar VMM02S0 +pintad pintar VMM02P0 +pintando pintar VMG0000 +pintar pintar VMN0000 +pintarraja pintarrajar VMM02S0 +pintarrajad pintarrajar VMM02P0 +pintarrajando pintarrajar VMG0000 +pintarrajar pintarrajar VMN0000 +pintarraje pintarrajar VMM03S0 +pintarrajea pintarrajear VMM02S0 +pintarrajead pintarrajear VMM02P0 +pintarrajeando pintarrajear VMG0000 +pintarrajear pintarrajear VMN0000 +pintarrajee pintarrajear VMM03S0 +pintarrajeemos pintarrajear VMM01P0 +pintarrajeen pintarrajear VMM03P0 +pintarrajemos pintarrajar VMM01P0 +pintarrajen pintarrajar VMM03P0 +pinte pintar VMM03S0 +pintea pintear VMM02S0 +pintead pintear VMM02P0 +pinteando pintear VMG0000 +pintear pintear VMN0000 +pintee pintear VMM03S0 +pinteemos pintear VMM01P0 +pinteen pintear VMM03P0 +pintemos pintar VMM01P0 +pinten pintar VMM03P0 +pintipara pintiparar VMM02S0 +pintiparad pintiparar VMM02P0 +pintiparando pintiparar VMG0000 +pintiparar pintiparar VMN0000 +pintipare pintiparar VMM03S0 +pintiparemos pintiparar VMM01P0 +pintiparen pintiparar VMM03P0 +pintonea pintonear VMM02S0 +pintonead pintonear VMM02P0 +pintoneando pintonear VMG0000 +pintonear pintonear VMN0000 +pintonee pintonear VMM03S0 +pintoneemos pintonear VMM01P0 +pintoneen pintonear VMM03P0 +pintorrea pintorrear VMM02S0 +pintorread pintorrear VMM02P0 +pintorreando pintorrear VMG0000 +pintorrear pintorrear VMN0000 +pintorree pintorrear VMM03S0 +pintorreemos pintorrear VMM01P0 +pintorreen pintorrear VMM03P0 +pinza pinzar VMM02S0 +pinzad pinzar VMM02P0 +pinzando pinzar VMG0000 +pinzar pinzar VMN0000 +piola piolar VMM02S0 +piolad piolar VMM02P0 +piolando piolar VMG0000 +piolar piolar VMN0000 +piole piolar VMM03S0 +piolemos piolar VMM01P0 +piolen piolar VMM03P0 +pipiad pipiar VMM02P0 +pipiando pipiar VMG0000 +pipiar pipiar VMN0000 +pipiemos pipiar VMM01P0 +pipía pipiar VMM02S0 +pipíe pipiar VMM03S0 +pipíen pipiar VMM03P0 +pique picar VMM03S0 +piquemos picar VMM01P0 +piquen picar VMM03P0 +pira pirar VMM02S0 +pirad pirar VMM02P0 +pirando pirar VMG0000 +pirar pirar VMN0000 +piratea piratear VMM02S0 +piratead piratear VMM02P0 +pirateando piratear VMG0000 +piratear piratear VMN0000 +piratee piratear VMM03S0 +pirateemos piratear VMM01P0 +pirateen piratear VMM03P0 +pirca pircar VMM02S0 +pircad pircar VMM02P0 +pircando pircar VMG0000 +pircar pircar VMN0000 +pire pirar VMM03S0 +piremos pirar VMM01P0 +piren pirar VMM03P0 +pirograba pirograbar VMM02S0 +pirograbad pirograbar VMM02P0 +pirograbando pirograbar VMG0000 +pirograbar pirograbar VMN0000 +pirograbe pirograbar VMM03S0 +pirograbemos pirograbar VMM01P0 +pirograben pirograbar VMM03P0 +piropea piropear VMM02S0 +piropead piropear VMM02P0 +piropeando piropear VMG0000 +piropear piropear VMN0000 +piropee piropear VMM03S0 +piropeemos piropear VMM01P0 +piropeen piropear VMM03P0 +pirque pircar VMM03S0 +pirquemos pircar VMM01P0 +pirquen pircar VMM03P0 +pirra pirrar VMM02S0 +pirrad pirrar VMM02P0 +pirrando pirrar VMG0000 +pirrar pirrar VMN0000 +pirre pirrar VMM03S0 +pirremos pirrar VMM01P0 +pirren pirrar VMM03P0 +piruetea piruetear VMM02S0 +piruetead piruetear VMM02P0 +pirueteando piruetear VMG0000 +piruetear piruetear VMN0000 +piruetee piruetear VMM03S0 +pirueteemos piruetear VMM01P0 +pirueteen piruetear VMM03P0 +pisa pisar VMM02S0 +pisad pisar VMM02P0 +pisando pisar VMG0000 +pisar pisar VMN0000 +pise pisar VMM03S0 +pisemos pisar VMM01P0 +pisen pisar VMM03P0 +pisonea pisonear VMM02S0 +pisonead pisonear VMM02P0 +pisoneando pisonear VMG0000 +pisonear pisonear VMN0000 +pisonee pisonear VMM03S0 +pisoneemos pisonear VMM01P0 +pisoneen pisonear VMM03P0 +pisotea pisotear VMM02S0 +pisotead pisotear VMM02P0 +pisoteando pisotear VMG0000 +pisotear pisotear VMN0000 +pisotee pisotear VMM03S0 +pisoteemos pisotear VMM01P0 +pisoteen pisotear VMM03P0 +pispa pispar VMM02S0 +pispad pispar VMM02P0 +pispando pispar VMG0000 +pispar pispar VMN0000 +pispe pispar VMM03S0 +pispemos pispar VMM01P0 +pispen pispar VMM03P0 +pista pistar VMM02S0 +pistad pistar VMM02P0 +pistando pistar VMG0000 +pistar pistar VMN0000 +piste pistar VMM03S0 +pistemos pistar VMM01P0 +pisten pistar VMM03P0 +pita pitar VMM02S0 +pitad pitar VMM02P0 +pitando pitar VMG0000 +pitar pitar VMN0000 +pite pitar VMM03S0 +pitemos pitar VMM01P0 +piten pitar VMM03P0 +pitorrea pitorrear VMM02S0 +pitorread pitorrear VMM02P0 +pitorreando pitorrear VMG0000 +pitorrear pitorrear VMN0000 +pitorree pitorrear VMM03S0 +pitorreemos pitorrear VMM01P0 +pitorreen pitorrear VMM03P0 +piula piular VMM02S0 +piulad piular VMM02P0 +piulando piular VMG0000 +piular piular VMN0000 +piule piular VMM03S0 +piulemos piular VMM01P0 +piulen piular VMM03P0 +pivota pivotar VMM02S0 +pivotad pivotar VMM02P0 +pivotando pivotar VMG0000 +pivotar pivotar VMN0000 +pivote pivotar VMM03S0 +pivotemos pivotar VMM01P0 +pivoten pivotar VMM03P0 +pizca pizcar VMM02S0 +pizcad pizcar VMM02P0 +pizcando pizcar VMG0000 +pizcar pizcar VMN0000 +pizque pizcar VMM03S0 +pizquemos pizcar VMM01P0 +pizquen pizcar VMM03P0 +piñonea piñonear VMM02S0 +piñonead piñonear VMM02P0 +piñoneando piñonear VMG0000 +piñonear piñonear VMN0000 +piñonee piñonear VMM03S0 +piñoneemos piñonear VMM01P0 +piñoneen piñonear VMM03P0 +place placer VMM02S0 +placea placear VMM02S0 +placead placear VMM02P0 +placeando placear VMG0000 +placear placear VMN0000 +placed placer VMM02P0 +placee placear VMM03S0 +placeemos placear VMM01P0 +placeen placear VMM03P0 +placer placer VMN0000 +placiendo placer VMG0000 +plaga plagar VMM02S0 +plagad plagar VMM02P0 +plagando plagar VMG0000 +plagar plagar VMN0000 +plagia plagiar VMM02S0 +plagiad plagiar VMM02P0 +plagiando plagiar VMG0000 +plagiar plagiar VMN0000 +plagie plagiar VMM03S0 +plagiemos plagiar VMM01P0 +plagien plagiar VMM03P0 +plague plagar VMM03S0 +plaguemos plagar VMM01P0 +plaguen plagar VMM03P0 +plancha planchar VMM02S0 +planchad planchar VMM02P0 +planchando planchar VMG0000 +planchar planchar VMN0000 +planche planchar VMM03S0 +planchemos planchar VMM01P0 +planchen planchar VMM03P0 +planea planear VMM02S0 +planead planear VMM02P0 +planeando planear VMG0000 +planear planear VMN0000 +planee planear VMM03S0 +planeemos planear VMM01P0 +planeen planear VMM03P0 +planifica planificar VMM02S0 +planificad planificar VMM02P0 +planificando planificar VMG0000 +planificar planificar VMN0000 +planifique planificar VMM03S0 +planifiquemos planificar VMM01P0 +planifiquen planificar VMM03P0 +planta plantar VMM02S0 +plantad plantar VMM02P0 +plantando plantar VMG0000 +plantar plantar VMN0000 +plante plantar VMM03S0 +plantea plantear VMM02S0 +plantead plantear VMM02P0 +planteando plantear VMG0000 +plantear plantear VMN0000 +plantee plantear VMM03S0 +planteemos plantear VMM01P0 +planteen plantear VMM03P0 +plantemos plantar VMM01P0 +planten plantar VMM03P0 +plantifica plantificar VMM02S0 +plantificad plantificar VMM02P0 +plantificando plantificar VMG0000 +plantificar plantificar VMN0000 +plantifique plantificar VMM03S0 +plantifiquemos plantificar VMM01P0 +plantifiquen plantificar VMM03P0 +plasma plasmar VMM02S0 +plasmad plasmar VMM02P0 +plasmando plasmar VMG0000 +plasmar plasmar VMN0000 +plasme plasmar VMM03S0 +plasmemos plasmar VMM01P0 +plasmen plasmar VMM03P0 +plastifica plastificar VMM02S0 +plastificad plastificar VMM02P0 +plastificando plastificar VMG0000 +plastificar plastificar VMN0000 +plastifique plastificar VMM03S0 +plastifiquemos plastificar VMM01P0 +plastifiquen plastificar VMM03P0 +platea platear VMM02S0 +platead platear VMM02P0 +plateando platear VMG0000 +platear platear VMN0000 +platee platear VMM03S0 +plateemos platear VMM01P0 +plateen platear VMM03P0 +platica platicar VMM02S0 +platicad platicar VMM02P0 +platicando platicar VMG0000 +platicar platicar VMN0000 +platina platinar VMM02S0 +platinad platinar VMM02P0 +platinando platinar VMG0000 +platinar platinar VMN0000 +platine platinar VMM03S0 +platinemos platinar VMM01P0 +platinen platinar VMM03P0 +platique platicar VMM03S0 +platiquemos platicar VMM01P0 +platiquen platicar VMM03P0 +plazca placer VMM03S0 +plazcamos placer VMM01P0 +plazcan placer VMM03P0 +plaña plañir VMM03S0 +plañamos plañir VMM01P0 +plañan plañir VMM03P0 +plañe plañir VMM02S0 +plañendo plañir VMG0000 +plañid plañir VMM02P0 +plañir plañir VMN0000 +plegad plegar VMM02P0 +plegando plegar VMG0000 +plegar plegar VMN0000 +pleguemos plegar VMM01P0 +pleitea pleitear VMM02S0 +pleitead pleitear VMM02P0 +pleiteando pleitear VMG0000 +pleitear pleitear VMN0000 +pleitee pleitear VMM03S0 +pleiteemos pleitear VMM01P0 +pleiteen pleitear VMM03P0 +pliega plegar VMM02S0 +pliegue plegar VMM03S0 +plieguen plegar VMM03P0 +plisa plisar VMM02S0 +plisad plisar VMM02P0 +plisando plisar VMG0000 +plisar plisar VMN0000 +plise plisar VMM03S0 +plisemos plisar VMM01P0 +plisen plisar VMM03P0 +ploma plomar VMM02S0 +plomad plomar VMM02P0 +plomando plomar VMG0000 +plomar plomar VMN0000 +plome plomar VMM03S0 +plomea plomear VMM02S0 +plomead plomear VMM02P0 +plomeando plomear VMG0000 +plomear plomear VMN0000 +plomee plomear VMM03S0 +plomeemos plomear VMM01P0 +plomeen plomear VMM03P0 +plomemos plomar VMM01P0 +plomen plomar VMM03P0 +plumea plumear VMM02S0 +plumead plumear VMM02P0 +plumeando plumear VMG0000 +plumear plumear VMN0000 +plumee plumear VMM03S0 +plumeemos plumear VMM01P0 +plumeen plumear VMM03P0 +pluralice pluralizar VMM03S0 +pluralicemos pluralizar VMM01P0 +pluralicen pluralizar VMM03P0 +pluraliza pluralizar VMM02S0 +pluralizad pluralizar VMM02P0 +pluralizando pluralizar VMG0000 +pluralizar pluralizar VMN0000 +poblad poblar VMM02P0 +poblando poblar VMG0000 +poblar poblar VMN0000 +poblemos poblar VMM01P0 +pobretea pobretear VMM02S0 +pobretead pobretear VMM02P0 +pobreteando pobretear VMG0000 +pobretear pobretear VMN0000 +pobretee pobretear VMM03S0 +pobreteemos pobretear VMM01P0 +pobreteen pobretear VMM03P0 +poda podar VMM02S0 +podad podar VMM02P0 +podamos poder VMM01P0 +podando podar VMG0000 +podar podar VMN0000 +pode podar VMM03S0 +poded poder VMM02P0 +podemos podar VMM01P0 +poden podar VMM03P0 +poder poder VMN0000 +podrece podrecer VMM02S0 +podreced podrecer VMM02P0 +podrecer podrecer VMN0000 +podreciendo podrecer VMG0000 +podrezca podrecer VMM03S0 +podrezcamos podrecer VMM01P0 +podrezcan podrecer VMM03P0 +poetice poetizar VMM03S0 +poeticemos poetizar VMM01P0 +poeticen poetizar VMM03P0 +poetiza poetizar VMM02S0 +poetizad poetizar VMM02P0 +poetizando poetizar VMG0000 +poetizar poetizar VMN0000 +polarice polarizar VMM03S0 +polaricemos polarizar VMM01P0 +polaricen polarizar VMM03P0 +polariza polarizar VMM02S0 +polarizad polarizar VMM02P0 +polarizando polarizar VMG0000 +polarizar polarizar VMN0000 +polca polcar VMM02S0 +polcad polcar VMM02P0 +polcando polcar VMG0000 +polcar polcar VMN0000 +polemice polemizar VMM03S0 +polemicemos polemizar VMM01P0 +polemicen polemizar VMM03P0 +polemiza polemizar VMM02S0 +polemizad polemizar VMM02P0 +polemizando polemizar VMG0000 +polemizar polemizar VMN0000 +polimerice polimerizar VMM03S0 +polimericemos polimerizar VMM01P0 +polimericen polimerizar VMM03P0 +polimeriza polimerizar VMM02S0 +polimerizad polimerizar VMM02P0 +polimerizando polimerizar VMG0000 +polimerizar polimerizar VMN0000 +polinice polinizar VMM03S0 +polinicemos polinizar VMM01P0 +polinicen polinizar VMM03P0 +poliniza polinizar VMM02S0 +polinizad polinizar VMM02P0 +polinizando polinizar VMG0000 +polinizar polinizar VMN0000 +politice politizar VMM03S0 +politicemos politizar VMM01P0 +politicen politizar VMM03P0 +politiquea politiquear VMM02S0 +politiquead politiquear VMM02P0 +politiqueando politiquear VMG0000 +politiquear politiquear VMN0000 +politiquee politiquear VMM03S0 +politiqueemos politiquear VMM01P0 +politiqueen politiquear VMM03P0 +politiza politizar VMM02S0 +politizad politizar VMM02P0 +politizando politizar VMG0000 +politizar politizar VMN0000 +pollea pollear VMM02S0 +pollead pollear VMM02P0 +polleando pollear VMG0000 +pollear pollear VMN0000 +pollee pollear VMM03S0 +polleemos pollear VMM01P0 +polleen pollear VMM03P0 +pololea pololear VMM02S0 +pololead pololear VMM02P0 +pololeando pololear VMG0000 +pololear pololear VMN0000 +pololee pololear VMM03S0 +pololeemos pololear VMM01P0 +pololeen pololear VMM03P0 +polque polcar VMM03S0 +polquemos polcar VMM01P0 +polquen polcar VMM03P0 +poltronice poltronizar VMM03S0 +poltronicemos poltronizar VMM01P0 +poltronicen poltronizar VMM03P0 +poltroniza poltronizar VMM02S0 +poltronizad poltronizar VMM02P0 +poltronizando poltronizar VMG0000 +poltronizar poltronizar VMN0000 +polvorea polvorear VMM02S0 +polvoread polvorear VMM02P0 +polvoreando polvorear VMG0000 +polvorear polvorear VMN0000 +polvoree polvorear VMM03S0 +polvoreemos polvorear VMM01P0 +polvoreen polvorear VMM03P0 +polvorice polvorizar VMM03S0 +polvoricemos polvorizar VMM01P0 +polvoricen polvorizar VMM03P0 +polvoriza polvorizar VMM02S0 +polvorizad polvorizar VMM02P0 +polvorizando polvorizar VMG0000 +polvorizar polvorizar VMN0000 +pompea pompear VMM02S0 +pompead pompear VMM02P0 +pompeando pompear VMG0000 +pompear pompear VMN0000 +pompee pompear VMM03S0 +pompeemos pompear VMM01P0 +pompeen pompear VMM03P0 +pomponea pomponear VMM02S0 +pomponead pomponear VMM02P0 +pomponeando pomponear VMG0000 +pomponear pomponear VMN0000 +pomponee pomponear VMM03S0 +pomponeemos pomponear VMM01P0 +pomponeen pomponear VMM03P0 +pon poner VMM02S0 +pondera ponderar VMM02S0 +ponderad ponderar VMM02P0 +ponderando ponderar VMG0000 +ponderar ponderar VMN0000 +pondere ponderar VMM03S0 +ponderemos ponderar VMM01P0 +ponderen ponderar VMM03P0 +poned poner VMM02P0 +poner poner VMN0000 +ponga poner VMM03S0 +pongamos poner VMM01P0 +pongan poner VMM03P0 +poniendo poner VMG0000 +pontea pontear VMM02S0 +pontead pontear VMM02P0 +ponteando pontear VMG0000 +pontear pontear VMN0000 +pontee pontear VMM03S0 +ponteemos pontear VMM01P0 +ponteen pontear VMM03P0 +pontifica pontificar VMM02S0 +pontificad pontificar VMM02P0 +pontificando pontificar VMG0000 +pontificar pontificar VMN0000 +pontifique pontificar VMM03S0 +pontifiquemos pontificar VMM01P0 +pontifiquen pontificar VMM03P0 +popularice popularizar VMM03S0 +popularicemos popularizar VMM01P0 +popularicen popularizar VMM03P0 +populariza popularizar VMM02S0 +popularizad popularizar VMM02P0 +popularizando popularizar VMG0000 +popularizar popularizar VMN0000 +pordiosea pordiosear VMM02S0 +pordiosead pordiosear VMM02P0 +pordioseando pordiosear VMG0000 +pordiosear pordiosear VMN0000 +pordiosee pordiosear VMM03S0 +pordioseemos pordiosear VMM01P0 +pordioseen pordiosear VMM03P0 +porfiad porfiar VMM02P0 +porfiando porfiar VMG0000 +porfiar porfiar VMN0000 +porfiemos porfiar VMM01P0 +porfirice porfirizar VMM03S0 +porfiricemos porfirizar VMM01P0 +porfiricen porfirizar VMM03P0 +porfiriza porfirizar VMM02S0 +porfirizad porfirizar VMM02P0 +porfirizando porfirizar VMG0000 +porfirizar porfirizar VMN0000 +porfía porfiar VMM02S0 +porfíe porfiar VMM03S0 +porfíen porfiar VMM03P0 +pormenorice pormenorizar VMM03S0 +pormenoricemos pormenorizar VMM01P0 +pormenoricen pormenorizar VMM03P0 +pormenoriza pormenorizar VMM02S0 +pormenorizad pormenorizar VMM02P0 +pormenorizando pormenorizar VMG0000 +pormenorizar pormenorizar VMN0000 +porta portar VMM02S0 +portad portar VMM02P0 +portando portar VMG0000 +portar portar VMN0000 +porte portar VMM03S0 +portea portear VMM02S0 +portead portear VMM02P0 +porteando portear VMG0000 +portear portear VMN0000 +portee portear VMM03S0 +porteemos portear VMM01P0 +porteen portear VMM03P0 +portemos portar VMM01P0 +porten portar VMM03P0 +posa posar VMM02S0 +posad posar VMM02P0 +posando posar VMG0000 +posar posar VMN0000 +pose posar VMM03S0 +posea poseer VMM03S0 +poseamos poseer VMM01P0 +posean poseer VMM03P0 +posee poseer VMM02S0 +poseed poseer VMM02P0 +poseer poseer VMN0000 +posemos posar VMM01P0 +posen posar VMM03P0 +posesiona posesionar VMM02S0 +posesionad posesionar VMM02P0 +posesionando posesionar VMG0000 +posesionar posesionar VMN0000 +posesione posesionar VMM03S0 +posesionemos posesionar VMM01P0 +posesionen posesionar VMM03P0 +poseyendo poseer VMG0000 +posibilita posibilitar VMM02S0 +posibilitad posibilitar VMM02P0 +posibilitando posibilitar VMG0000 +posibilitar posibilitar VMN0000 +posibilite posibilitar VMM03S0 +posibilitemos posibilitar VMM01P0 +posibiliten posibilitar VMM03P0 +posiciona posicionar VMM02S0 +posicionad posicionar VMM02P0 +posicionando posicionar VMG0000 +posicionar posicionar VMN0000 +posicione posicionar VMM03S0 +posicionemos posicionar VMM01P0 +posicionen posicionar VMM03P0 +posponed posponer VMM02P0 +posponer posponer VMN0000 +posponga posponer VMM03S0 +pospongamos posponer VMM01P0 +pospongan posponer VMM03P0 +posponiendo posponer VMG0000 +pospón posponer VMM02S0 +posterga postergar VMM02S0 +postergad postergar VMM02P0 +postergando postergar VMG0000 +postergar postergar VMN0000 +postergue postergar VMM03S0 +posterguemos postergar VMM01P0 +posterguen postergar VMM03P0 +postesa postesar VMM02S0 +postesad postesar VMM02P0 +postesando postesar VMG0000 +postesar postesar VMN0000 +postinea postinear VMM02S0 +postinead postinear VMM02P0 +postineando postinear VMG0000 +postinear postinear VMN0000 +postinee postinear VMM03S0 +postineemos postinear VMM01P0 +postineen postinear VMM03P0 +postra postrar VMM02S0 +postrad postrar VMM02P0 +postrando postrar VMG0000 +postrar postrar VMN0000 +postre postrar VMM03S0 +postremos postrar VMM01P0 +postren postrar VMM03P0 +postula postular VMM02S0 +postulad postular VMM02P0 +postulando postular VMG0000 +postular postular VMN0000 +postule postular VMM03S0 +postulemos postular VMM01P0 +postulen postular VMM03P0 +potabilice potabilizar VMM03S0 +potabilicemos potabilizar VMM01P0 +potabilicen potabilizar VMM03P0 +potabiliza potabilizar VMM02S0 +potabilizad potabilizar VMM02P0 +potabilizando potabilizar VMG0000 +potabilizar potabilizar VMN0000 +potencia potenciar VMM02S0 +potenciad potenciar VMM02P0 +potenciando potenciar VMG0000 +potenciar potenciar VMN0000 +potencie potenciar VMM03S0 +potenciemos potenciar VMM01P0 +potencien potenciar VMM03P0 +potrea potrear VMM02S0 +potread potrear VMM02P0 +potreando potrear VMG0000 +potrear potrear VMN0000 +potree potrear VMM03S0 +potreemos potrear VMM01P0 +potreen potrear VMM03P0 +practica practicar VMM02S0 +practicad practicar VMM02P0 +practicando practicar VMG0000 +practicar practicar VMN0000 +practique practicar VMM03S0 +practiquemos practicar VMM01P0 +practiquen practicar VMM03P0 +prebenda prebendar VMM02S0 +prebendad prebendar VMM02P0 +prebendando prebendar VMG0000 +prebendar prebendar VMN0000 +prebende prebendar VMM03S0 +prebendemos prebendar VMM01P0 +prebenden prebendar VMM03P0 +precalentad precalentar VMM02P0 +precalentando precalentar VMG0000 +precalentar precalentar VMN0000 +precalentemos precalentar VMM01P0 +precalienta precalentar VMM02S0 +precaliente precalentar VMM03S0 +precalienten precalentar VMM03P0 +precauciona precaucionar VMM02S0 +precaucionad precaucionar VMM02P0 +precaucionando precaucionar VMG0000 +precaucionar precaucionar VMN0000 +precaucione precaucionar VMM03S0 +precaucionemos precaucionar VMM01P0 +precaucionen precaucionar VMM03P0 +precautela precautelar VMM02S0 +precautelad precautelar VMM02P0 +precautelando precautelar VMG0000 +precautelar precautelar VMN0000 +precautele precautelar VMM03S0 +precautelemos precautelar VMM01P0 +precautelen precautelar VMM03P0 +precava precaver VMM03S0 +precavamos precaver VMM01P0 +precavan precaver VMM03P0 +precave precaver VMM02S0 +precaved precaver VMM02P0 +precaver precaver VMN0000 +precaviendo precaver VMG0000 +preceda preceder VMM03S0 +precedamos preceder VMM01P0 +precedan preceder VMM03P0 +precede preceder VMM02S0 +preceded preceder VMM02P0 +preceder preceder VMN0000 +precediendo preceder VMG0000 +preceptuad preceptuar VMM02P0 +preceptuando preceptuar VMG0000 +preceptuar preceptuar VMN0000 +preceptuemos preceptuar VMM01P0 +preceptúa preceptuar VMM02S0 +preceptúe preceptuar VMM03S0 +preceptúen preceptuar VMM03P0 +precia preciar VMM02S0 +preciad preciar VMM02P0 +preciando preciar VMG0000 +preciar preciar VMN0000 +precie preciar VMM03S0 +preciemos preciar VMM01P0 +precien preciar VMM03P0 +precinta precintar VMM02S0 +precintad precintar VMM02P0 +precintando precintar VMG0000 +precintar precintar VMN0000 +precinte precintar VMM03S0 +precintemos precintar VMM01P0 +precinten precintar VMM03P0 +precipita precipitar VMM02S0 +precipitad precipitar VMM02P0 +precipitando precipitar VMG0000 +precipitar precipitar VMN0000 +precipite precipitar VMM03S0 +precipitemos precipitar VMM01P0 +precipiten precipitar VMM03P0 +precisa precisar VMM02S0 +precisad precisar VMM02P0 +precisando precisar VMG0000 +precisar precisar VMN0000 +precise precisar VMM03S0 +precisemos precisar VMM01P0 +precisen precisar VMM03P0 +preconcebid preconcebir VMM02P0 +preconcebir preconcebir VMN0000 +preconciba preconcebir VMM03S0 +preconcibamos preconcebir VMM01P0 +preconciban preconcebir VMM03P0 +preconcibe preconcebir VMM02S0 +preconcibiendo preconcebir VMG0000 +preconice preconizar VMM03S0 +preconicemos preconizar VMM01P0 +preconicen preconizar VMM03P0 +preconiza preconizar VMM02S0 +preconizad preconizar VMM02P0 +preconizando preconizar VMG0000 +preconizar preconizar VMN0000 +preconoce preconocer VMM02S0 +preconoced preconocer VMM02P0 +preconocer preconocer VMN0000 +preconociendo preconocer VMG0000 +preconozca preconocer VMM03S0 +preconozcamos preconocer VMM01P0 +preconozcan preconocer VMM03P0 +predecid predecir VMM02P0 +predecir predecir VMN0000 +predefina predefinir VMM03S0 +predefinamos predefinir VMM01P0 +predefinan predefinir VMM03P0 +predefine predefinir VMM02S0 +predefinid predefinir VMM02P0 +predefiniendo predefinir VMG0000 +predefinir predefinir VMN0000 +predestina predestinar VMM02S0 +predestinad predestinar VMM02P0 +predestinando predestinar VMG0000 +predestinar predestinar VMN0000 +predestine predestinar VMM03S0 +predestinemos predestinar VMM01P0 +predestinen predestinar VMM03P0 +predetermina predeterminar VMM02S0 +predeterminad predeterminar VMM02P0 +predeterminando predeterminar VMG0000 +predeterminar predeterminar VMN0000 +predetermine predeterminar VMM03S0 +predeterminemos predeterminar VMM01P0 +predeterminen predeterminar VMM03P0 +predica predicar VMM02S0 +predicad predicar VMM02P0 +predicando predicar VMG0000 +predicar predicar VMN0000 +predice predecir VMM02S0 +prediciendo predecir VMG0000 +prediga predecir VMM03S0 +predigamos predecir VMM01P0 +predigan predecir VMM03P0 +predique predicar VMM03S0 +prediquemos predicar VMM01P0 +prediquen predicar VMM03P0 +predisponed predisponer VMM02P0 +predisponer predisponer VMN0000 +predisponga predisponer VMM03S0 +predispongamos predisponer VMM01P0 +predispongan predisponer VMM03P0 +predisponiendo predisponer VMG0000 +predispón predisponer VMM02S0 +predomina predominar VMM02S0 +predominad predominar VMM02P0 +predominando predominar VMG0000 +predominar predominar VMN0000 +predomine predominar VMM03S0 +predominemos predominar VMM01P0 +predominen predominar VMM03P0 +preelegid preelegir VMM02P0 +preelegir preelegir VMN0000 +preelige preelegir VMM02S0 +preeligiendo preelegir VMG0000 +preelija preelegir VMM03S0 +preelijamos preelegir VMM01P0 +preelijan preelegir VMM03P0 +preestablece preestablecer VMM02S0 +preestableced preestablecer VMM02P0 +preestablecer preestablecer VMN0000 +preestableciendo preestablecer VMG0000 +preestablezca preestablecer VMM03S0 +preestablezcamos preestablecer VMM01P0 +preestablezcan preestablecer VMM03P0 +preexista preexistir VMM03S0 +preexistamos preexistir VMM01P0 +preexistan preexistir VMM03P0 +preexiste preexistir VMM02S0 +preexistid preexistir VMM02P0 +preexistiendo preexistir VMG0000 +preexistir preexistir VMN0000 +prefabrica prefabricar VMM02S0 +prefabricad prefabricar VMM02P0 +prefabricando prefabricar VMG0000 +prefabricar prefabricar VMN0000 +prefabrique prefabricar VMM03S0 +prefabriquemos prefabricar VMM01P0 +prefabriquen prefabricar VMM03P0 +preferid preferir VMM02P0 +preferir preferir VMN0000 +prefiera preferir VMM03S0 +prefieran preferir VMM03P0 +prefiere preferir VMM02S0 +prefigura prefigurar VMM02S0 +prefigurad prefigurar VMM02P0 +prefigurando prefigurar VMG0000 +prefigurar prefigurar VMN0000 +prefigure prefigurar VMM03S0 +prefiguremos prefigurar VMM01P0 +prefiguren prefigurar VMM03P0 +prefija prefijar VMM02S0 +prefijad prefijar VMM02P0 +prefijando prefijar VMG0000 +prefijar prefijar VMN0000 +prefije prefijar VMM03S0 +prefijemos prefijar VMM01P0 +prefijen prefijar VMM03P0 +prefiramos preferir VMM01P0 +prefiriendo preferir VMG0000 +pregona pregonar VMM02S0 +pregonad pregonar VMM02P0 +pregonando pregonar VMG0000 +pregonar pregonar VMN0000 +pregone pregonar VMM03S0 +pregonemos pregonar VMM01P0 +pregonen pregonar VMM03P0 +pregunta preguntar VMM02S0 +preguntad preguntar VMM02P0 +preguntando preguntar VMG0000 +preguntar preguntar VMN0000 +pregunte preguntar VMM03S0 +preguntemos preguntar VMM01P0 +pregunten preguntar VMM03P0 +prejuzga prejuzgar VMM02S0 +prejuzgad prejuzgar VMM02P0 +prejuzgando prejuzgar VMG0000 +prejuzgar prejuzgar VMN0000 +prejuzgue prejuzgar VMM03S0 +prejuzguemos prejuzgar VMM01P0 +prejuzguen prejuzgar VMM03P0 +preludia preludiar VMM02S0 +preludiad preludiar VMM02P0 +preludiando preludiar VMG0000 +preludiar preludiar VMN0000 +preludie preludiar VMM03S0 +preludiemos preludiar VMM01P0 +preludien preludiar VMM03P0 +premedita premeditar VMM02S0 +premeditad premeditar VMM02P0 +premeditando premeditar VMG0000 +premeditar premeditar VMN0000 +premedite premeditar VMM03S0 +premeditemos premeditar VMM01P0 +premediten premeditar VMM03P0 +premia premiar VMM02S0 +premiad premiar VMM02P0 +premiando premiar VMG0000 +premiar premiar VMN0000 +premie premiar VMM03S0 +premiemos premiar VMM01P0 +premien premiar VMM03P0 +premorid premorir VMM02P0 +premorir premorir VMN0000 +premuera premorir VMM03S0 +premueran premorir VMM03P0 +premuere premorir VMM02S0 +premuramos premorir VMM01P0 +premuriendo premorir VMG0000 +prenda prendar VMM02S0 +prenda prender VMM03S0 +prendad prendar VMM02P0 +prendamos prender VMM01P0 +prendan prender VMM03P0 +prendando prendar VMG0000 +prendar prendar VMN0000 +prende prendar VMM03S0 +prende prender VMM02S0 +prended prender VMM02P0 +prendemos prendar VMM01P0 +prenden prendar VMM03P0 +prender prender VMN0000 +prendiendo prender VMG0000 +prensa prensar VMM02S0 +prensad prensar VMM02P0 +prensando prensar VMG0000 +prensar prensar VMN0000 +prense prensar VMM03S0 +prensemos prensar VMM01P0 +prensen prensar VMM03P0 +prenuncia prenunciar VMM02S0 +prenunciad prenunciar VMM02P0 +prenunciando prenunciar VMG0000 +prenunciar prenunciar VMN0000 +prenuncie prenunciar VMM03S0 +prenunciemos prenunciar VMM01P0 +prenuncien prenunciar VMM03P0 +preocupa preocupar VMM02S0 +preocupad preocupar VMM02P0 +preocupando preocupar VMG0000 +preocupar preocupar VMN0000 +preocupe preocupar VMM03S0 +preocupemos preocupar VMM01P0 +preocupen preocupar VMM03P0 +prepara preparar VMM02S0 +preparad preparar VMM02P0 +preparando preparar VMG0000 +preparar preparar VMN0000 +prepare preparar VMM03S0 +preparemos preparar VMM01P0 +preparen preparar VMM03P0 +prepondera preponderar VMM02S0 +preponderad preponderar VMM02P0 +preponderando preponderar VMG0000 +preponderar preponderar VMN0000 +prepondere preponderar VMM03S0 +preponderemos preponderar VMM01P0 +preponderen preponderar VMM03P0 +preponed preponer VMM02P0 +preponer preponer VMN0000 +preponga preponer VMM03S0 +prepongamos preponer VMM01P0 +prepongan preponer VMM03P0 +preponiendo preponer VMG0000 +prepón preponer VMM02S0 +presagia presagiar VMM02S0 +presagiad presagiar VMM02P0 +presagiando presagiar VMG0000 +presagiar presagiar VMN0000 +presagie presagiar VMM03S0 +presagiemos presagiar VMM01P0 +presagien presagiar VMM03P0 +prescinda prescindir VMM03S0 +prescindamos prescindir VMM01P0 +prescindan prescindir VMM03P0 +prescinde prescindir VMM02S0 +prescindid prescindir VMM02P0 +prescindiendo prescindir VMG0000 +prescindir prescindir VMN0000 +prescriba prescribir VMM03S0 +prescribamos prescribir VMM01P0 +prescriban prescribir VMM03P0 +prescribe prescribir VMM02S0 +prescribid prescribir VMM02P0 +prescribiendo prescribir VMG0000 +prescribir prescribir VMN0000 +preselecciona preseleccionar VMM02S0 +preseleccionad preseleccionar VMM02P0 +preseleccionando preseleccionar VMG0000 +preseleccionar preseleccionar VMN0000 +preseleccione preseleccionar VMM03S0 +preseleccionemos preseleccionar VMM01P0 +preseleccionen preseleccionar VMM03P0 +presencia presenciar VMM02S0 +presenciad presenciar VMM02P0 +presenciando presenciar VMG0000 +presenciar presenciar VMN0000 +presencie presenciar VMM03S0 +presenciemos presenciar VMM01P0 +presencien presenciar VMM03P0 +presenta presentar VMM02S0 +presentad presentar VMM02P0 +presentando presentar VMG0000 +presentar presentar VMN0000 +presente presentar VMM03S0 +presentemos presentar VMM01P0 +presenten presentar VMM03P0 +presentid presentir VMM02P0 +presentir presentir VMN0000 +preserva preservar VMM02S0 +preservad preservar VMM02P0 +preservando preservar VMG0000 +preservar preservar VMN0000 +preserve preservar VMM03S0 +preservemos preservar VMM01P0 +preserven preservar VMM03P0 +presida presidir VMM03S0 +presidamos presidir VMM01P0 +presidan presidir VMM03P0 +preside presidir VMM02S0 +presidid presidir VMM02P0 +presidiendo presidir VMG0000 +presidir presidir VMN0000 +presienta presentir VMM03S0 +presientan presentir VMM03P0 +presiente presentir VMM02S0 +presintamos presentir VMM01P0 +presintiendo presentir VMG0000 +presiona presionar VMM02S0 +presionad presionar VMM02P0 +presionando presionar VMG0000 +presionar presionar VMN0000 +presione presionar VMM03S0 +presionemos presionar VMM01P0 +presionen presionar VMM03P0 +presta prestar VMM02S0 +prestad prestar VMM02P0 +prestando prestar VMG0000 +prestar prestar VMN0000 +preste prestar VMM03S0 +prestemos prestar VMM01P0 +presten prestar VMM03P0 +prestigia prestigiar VMM02S0 +prestigiad prestigiar VMM02P0 +prestigiando prestigiar VMG0000 +prestigiar prestigiar VMN0000 +prestigie prestigiar VMM03S0 +prestigiemos prestigiar VMM01P0 +prestigien prestigiar VMM03P0 +presuma presumir VMM03S0 +presumamos presumir VMM01P0 +presuman presumir VMM03P0 +presume presumir VMM02S0 +presumid presumir VMM02P0 +presumiendo presumir VMG0000 +presumir presumir VMN0000 +presuponed presuponer VMM02P0 +presuponer presuponer VMN0000 +presuponga presuponer VMM03S0 +presupongamos presuponer VMM01P0 +presupongan presuponer VMM03P0 +presuponiendo presuponer VMG0000 +presupuesta presupuestar VMM02S0 +presupuestad presupuestar VMM02P0 +presupuestando presupuestar VMG0000 +presupuestar presupuestar VMN0000 +presupueste presupuestar VMM03S0 +presupuestemos presupuestar VMM01P0 +presupuesten presupuestar VMM03P0 +presupón presuponer VMM02S0 +presurice presurizar VMM03S0 +presuricemos presurizar VMM01P0 +presuricen presurizar VMM03P0 +presuriza presurizar VMM02S0 +presurizad presurizar VMM02P0 +presurizando presurizar VMG0000 +presurizar presurizar VMN0000 +pretenda pretender VMM03S0 +pretendamos pretender VMM01P0 +pretendan pretender VMM03P0 +pretende pretender VMM02S0 +pretended pretender VMM02P0 +pretender pretender VMN0000 +pretendiendo pretender VMG0000 +pretensa pretensar VMM02S0 +pretensad pretensar VMM02P0 +pretensando pretensar VMG0000 +pretensar pretensar VMN0000 +pretense pretensar VMM03S0 +pretensemos pretensar VMM01P0 +pretensen pretensar VMM03P0 +pretera preterir VMM03S0 +preteramos preterir VMM01P0 +preteran preterir VMM03P0 +pretere preterir VMM02S0 +preterid preterir VMM02P0 +preteriendo preterir VMG0000 +preterir preterir VMN0000 +pretexta pretextar VMM02S0 +pretextad pretextar VMM02P0 +pretextando pretextar VMG0000 +pretextar pretextar VMN0000 +pretexte pretextar VMM03S0 +pretextemos pretextar VMM01P0 +pretexten pretextar VMM03P0 +prevale prevaler VMM02S0 +prevalece prevalecer VMM02S0 +prevaleced prevalecer VMM02P0 +prevalecer prevalecer VMN0000 +prevaleciendo prevalecer VMG0000 +prevaled prevaler VMM02P0 +prevaler prevaler VMN0000 +prevalezca prevalecer VMM03S0 +prevalezcamos prevalecer VMM01P0 +prevalezcan prevalecer VMM03P0 +prevalga prevaler VMM03S0 +prevalgamos prevaler VMM01P0 +prevalgan prevaler VMM03P0 +prevaliendo prevaler VMG0000 +prevarica prevaricar VMM02S0 +prevaricad prevaricar VMM02P0 +prevaricando prevaricar VMG0000 +prevaricar prevaricar VMN0000 +prevarique prevaricar VMM03S0 +prevariquemos prevaricar VMM01P0 +prevariquen prevaricar VMM03P0 +prevea prever VMM03S0 +preveamos prever VMM01P0 +prevean prever VMM03P0 +preved prever VMM02P0 +preven prevenir VMM02S0 +prevenga prevenir VMM03S0 +prevengamos prevenir VMM01P0 +prevengan prevenir VMM03P0 +prevenid prevenir VMM02P0 +prevenir prevenir VMN0000 +prever prever VMN0000 +previendo prever VMG0000 +previniendo prevenir VMG0000 +prevé prever VMM02S0 +preña preñar VMM02S0 +preñad preñar VMM02P0 +preñando preñar VMG0000 +preñar preñar VMN0000 +preñe preñar VMM03S0 +preñemos preñar VMM01P0 +preñen preñar VMM03P0 +prima primar VMM02S0 +primad primar VMM02P0 +primando primar VMG0000 +primar primar VMN0000 +prime primar VMM03S0 +primemos primar VMM01P0 +primen primar VMM03P0 +primorea primorear VMM02S0 +primoread primorear VMM02P0 +primoreando primorear VMG0000 +primorear primorear VMN0000 +primoree primorear VMM03S0 +primoreemos primorear VMM01P0 +primoreen primorear VMM03P0 +principia principiar VMM02S0 +principiad principiar VMM02P0 +principiando principiar VMG0000 +principiar principiar VMN0000 +principie principiar VMM03S0 +principiemos principiar VMM01P0 +principien principiar VMM03P0 +pringa pringar VMM02S0 +pringad pringar VMM02P0 +pringando pringar VMG0000 +pringar pringar VMN0000 +pringue pringar VMM03S0 +pringuemos pringar VMM01P0 +pringuen pringar VMM03P0 +priorice priorizar VMM03S0 +prioricemos priorizar VMM01P0 +prioricen priorizar VMM03P0 +prioriza priorizar VMM02S0 +priorizad priorizar VMM02P0 +priorizando priorizar VMG0000 +priorizar priorizar VMN0000 +priva privar VMM02S0 +privad privar VMM02P0 +privando privar VMG0000 +privar privar VMN0000 +privatice privatizar VMM03S0 +privaticemos privatizar VMM01P0 +privaticen privatizar VMM03P0 +privatiza privatizar VMM02S0 +privatizad privatizar VMM02P0 +privatizando privatizar VMG0000 +privatizar privatizar VMN0000 +prive privar VMM03S0 +privemos privar VMM01P0 +priven privar VMM03P0 +privilegia privilegiar VMM02S0 +privilegiad privilegiar VMM02P0 +privilegiando privilegiar VMG0000 +privilegiar privilegiar VMN0000 +privilegie privilegiar VMM03S0 +privilegiemos privilegiar VMM01P0 +privilegien privilegiar VMM03P0 +probad probar VMM02P0 +probando probar VMG0000 +probar probar VMN0000 +probemos probar VMM01P0 +problematice problematizar VMM03S0 +problematicemos problematizar VMM01P0 +problematicen problematizar VMM03P0 +problematiza problematizar VMM02S0 +problematizad problematizar VMM02P0 +problematizando problematizar VMG0000 +problematizar problematizar VMN0000 +proceda proceder VMM03S0 +procedamos proceder VMM01P0 +procedan proceder VMM03P0 +procede proceder VMM02S0 +proceded proceder VMM02P0 +proceder proceder VMN0000 +procediendo proceder VMG0000 +procesa procesar VMM02S0 +procesad procesar VMM02P0 +procesando procesar VMG0000 +procesar procesar VMN0000 +procese procesar VMM03S0 +procesemos procesar VMM01P0 +procesen procesar VMM03P0 +proclama proclamar VMM02S0 +proclamad proclamar VMM02P0 +proclamando proclamar VMG0000 +proclamar proclamar VMN0000 +proclame proclamar VMM03S0 +proclamemos proclamar VMM01P0 +proclamen proclamar VMM03P0 +procrea procrear VMM02S0 +procread procrear VMM02P0 +procreando procrear VMG0000 +procrear procrear VMN0000 +procree procrear VMM03S0 +procreemos procrear VMM01P0 +procreen procrear VMM03P0 +procura procurar VMM02S0 +procurad procurar VMM02P0 +procurando procurar VMG0000 +procurar procurar VMN0000 +procure procurar VMM03S0 +procuremos procurar VMM01P0 +procuren procurar VMM03P0 +prodiga prodigar VMM02S0 +prodigad prodigar VMM02P0 +prodigando prodigar VMG0000 +prodigar prodigar VMN0000 +prodigue prodigar VMM03S0 +prodiguemos prodigar VMM01P0 +prodiguen prodigar VMM03P0 +produce producir VMM02S0 +producid producir VMM02P0 +produciendo producir VMG0000 +producir producir VMN0000 +produzca producir VMM03S0 +produzcamos producir VMM01P0 +produzcan producir VMM03P0 +profana profanar VMM02S0 +profanad profanar VMM02P0 +profanando profanar VMG0000 +profanar profanar VMN0000 +profane profanar VMM03S0 +profanemos profanar VMM01P0 +profanen profanar VMM03P0 +proferid proferir VMM02P0 +proferir proferir VMN0000 +profesa profesar VMM02S0 +profesad profesar VMM02P0 +profesando profesar VMG0000 +profesar profesar VMN0000 +profese profesar VMM03S0 +profesemos profesar VMM01P0 +profesen profesar VMM03P0 +profesionalice profesionalizar VMM03S0 +profesionalicemos profesionalizar VMM01P0 +profesionalicen profesionalizar VMM03P0 +profesionaliza profesionalizar VMM02S0 +profesionalizad profesionalizar VMM02P0 +profesionalizando profesionalizar VMG0000 +profesionalizar profesionalizar VMN0000 +profetice profetizar VMM03S0 +profeticemos profetizar VMM01P0 +profeticen profetizar VMM03P0 +profetiza profetizar VMM02S0 +profetizad profetizar VMM02P0 +profetizando profetizar VMG0000 +profetizar profetizar VMN0000 +profiera proferir VMM03S0 +profieran proferir VMM03P0 +profiere proferir VMM02S0 +profiramos proferir VMM01P0 +profiriendo proferir VMG0000 +profunda profundar VMM02S0 +profundad profundar VMM02P0 +profundando profundar VMG0000 +profundar profundar VMN0000 +profunde profundar VMM03S0 +profundemos profundar VMM01P0 +profunden profundar VMM03P0 +profundice profundizar VMM03S0 +profundicemos profundizar VMM01P0 +profundicen profundizar VMM03P0 +profundiza profundizar VMM02S0 +profundizad profundizar VMM02P0 +profundizando profundizar VMG0000 +profundizar profundizar VMN0000 +programa programar VMM02S0 +programad programar VMM02P0 +programando programar VMG0000 +programar programar VMN0000 +programe programar VMM03S0 +programemos programar VMM01P0 +programen programar VMM03P0 +progresa progresar VMM02S0 +progresad progresar VMM02P0 +progresando progresar VMG0000 +progresar progresar VMN0000 +progrese progresar VMM03S0 +progresemos progresar VMM01P0 +progresen progresar VMM03P0 +prohibamos prohibir VMM01P0 +prohibid prohibir VMM02P0 +prohibiendo prohibir VMG0000 +prohibir prohibir VMN0000 +prohijad prohijar VMM02P0 +prohijando prohijar VMG0000 +prohijar prohijar VMN0000 +prohijemos prohijar VMM01P0 +prohíba prohibir VMM03S0 +prohíban prohibir VMM03P0 +prohíbe prohibir VMM02S0 +prohíja prohijar VMM02S0 +prohíje prohijar VMM03S0 +prohíjen prohijar VMM03P0 +proletarice proletarizar VMM03S0 +proletaricemos proletarizar VMM01P0 +proletaricen proletarizar VMM03P0 +proletariza proletarizar VMM02S0 +proletarizad proletarizar VMM02P0 +proletarizando proletarizar VMG0000 +proletarizar proletarizar VMN0000 +prolifera proliferar VMM02S0 +proliferad proliferar VMM02P0 +proliferando proliferar VMG0000 +proliferar proliferar VMN0000 +prolifere proliferar VMM03S0 +proliferemos proliferar VMM01P0 +proliferen proliferar VMM03P0 +prologa prologar VMM02S0 +prologad prologar VMM02P0 +prologando prologar VMG0000 +prologar prologar VMN0000 +prologue prologar VMM03S0 +prologuemos prologar VMM01P0 +prologuen prologar VMM03P0 +prolonga prolongar VMM02S0 +prolongad prolongar VMM02P0 +prolongando prolongar VMG0000 +prolongar prolongar VMN0000 +prolongue prolongar VMM03S0 +prolonguemos prolongar VMM01P0 +prolonguen prolongar VMM03P0 +promedia promediar VMM02S0 +promediad promediar VMM02P0 +promediando promediar VMG0000 +promediar promediar VMN0000 +promedie promediar VMM03S0 +promediemos promediar VMM01P0 +promedien promediar VMM03P0 +prometa prometer VMM03S0 +prometamos prometer VMM01P0 +prometan prometer VMM03P0 +promete prometer VMM02S0 +prometed prometer VMM02P0 +prometer prometer VMN0000 +prometiendo prometer VMG0000 +promiscuad promiscuar VMM02P0 +promiscuando promiscuar VMG0000 +promiscuar promiscuar VMN0000 +promiscuemos promiscuar VMM01P0 +promiscúa promiscuar VMM02S0 +promiscúe promiscuar VMM03S0 +promiscúen promiscuar VMM03P0 +promociona promocionar VMM02S0 +promocionad promocionar VMM02P0 +promocionando promocionar VMG0000 +promocionar promocionar VMN0000 +promocione promocionar VMM03S0 +promocionemos promocionar VMM01P0 +promocionen promocionar VMM03P0 +promovamos promover VMM01P0 +promoved promover VMM02P0 +promover promover VMN0000 +promoviendo promover VMG0000 +promueva promover VMM03S0 +promuevan promover VMM03P0 +promueve promover VMM02S0 +promulga promulgar VMM02S0 +promulgad promulgar VMM02P0 +promulgando promulgar VMG0000 +promulgar promulgar VMN0000 +promulgue promulgar VMM03S0 +promulguemos promulgar VMM01P0 +promulguen promulgar VMM03P0 +pronostica pronosticar VMM02S0 +pronosticad pronosticar VMM02P0 +pronosticando pronosticar VMG0000 +pronosticar pronosticar VMN0000 +pronostique pronosticar VMM03S0 +pronostiquemos pronosticar VMM01P0 +pronostiquen pronosticar VMM03P0 +pronuncia pronunciar VMM02S0 +pronunciad pronunciar VMM02P0 +pronunciando pronunciar VMG0000 +pronunciar pronunciar VMN0000 +pronuncie pronunciar VMM03S0 +pronunciemos pronunciar VMM01P0 +pronuncien pronunciar VMM03P0 +propaga propagar VMM02S0 +propagad propagar VMM02P0 +propagando propagar VMG0000 +propagar propagar VMN0000 +propague propagar VMM03S0 +propaguemos propagar VMM01P0 +propaguen propagar VMM03P0 +propala propalar VMM02S0 +propalad propalar VMM02P0 +propalando propalar VMG0000 +propalar propalar VMN0000 +propale propalar VMM03S0 +propalemos propalar VMM01P0 +propalen propalar VMM03P0 +propasa propasar VMM02S0 +propasad propasar VMM02P0 +propasando propasar VMG0000 +propasar propasar VMN0000 +propase propasar VMM03S0 +propasemos propasar VMM01P0 +propasen propasar VMM03P0 +propenda propender VMM03S0 +propendamos propender VMM01P0 +propendan propender VMM03P0 +propende propender VMM02S0 +propended propender VMM02P0 +propender propender VMN0000 +propendiendo propender VMG0000 +propicia propiciar VMM02S0 +propiciad propiciar VMM02P0 +propiciando propiciar VMG0000 +propiciar propiciar VMN0000 +propicie propiciar VMM03S0 +propiciemos propiciar VMM01P0 +propicien propiciar VMM03P0 +propina propinar VMM02S0 +propinad propinar VMM02P0 +propinando propinar VMG0000 +propinar propinar VMN0000 +propine propinar VMM03S0 +propinemos propinar VMM01P0 +propinen propinar VMM03P0 +proponed proponer VMM02P0 +proponer proponer VMN0000 +proponga proponer VMM03S0 +propongamos proponer VMM01P0 +propongan proponer VMM03P0 +proponiendo proponer VMG0000 +proporciona proporcionar VMM02S0 +proporcionad proporcionar VMM02P0 +proporcionando proporcionar VMG0000 +proporcionar proporcionar VMN0000 +proporcione proporcionar VMM03S0 +proporcionemos proporcionar VMM01P0 +proporcionen proporcionar VMM03P0 +propugna propugnar VMM02S0 +propugnad propugnar VMM02P0 +propugnando propugnar VMG0000 +propugnar propugnar VMN0000 +propugne propugnar VMM03S0 +propugnemos propugnar VMM01P0 +propugnen propugnar VMM03P0 +propulsa propulsar VMM02S0 +propulsad propulsar VMM02P0 +propulsando propulsar VMG0000 +propulsar propulsar VMN0000 +propulse propulsar VMM03S0 +propulsemos propulsar VMM01P0 +propulsen propulsar VMM03P0 +propón proponer VMM02S0 +prorratea prorratear VMM02S0 +prorratead prorratear VMM02P0 +prorrateando prorratear VMG0000 +prorratear prorratear VMN0000 +prorratee prorratear VMM03S0 +prorrateemos prorratear VMM01P0 +prorrateen prorratear VMM03P0 +prorroga prorrogar VMM02S0 +prorrogad prorrogar VMM02P0 +prorrogando prorrogar VMG0000 +prorrogar prorrogar VMN0000 +prorrogue prorrogar VMM03S0 +prorroguemos prorrogar VMM01P0 +prorroguen prorrogar VMM03P0 +prorrumpa prorrumpir VMM03S0 +prorrumpamos prorrumpir VMM01P0 +prorrumpan prorrumpir VMM03P0 +prorrumpe prorrumpir VMM02S0 +prorrumpid prorrumpir VMM02P0 +prorrumpiendo prorrumpir VMG0000 +prorrumpir prorrumpir VMN0000 +proscriba proscribir VMM03S0 +proscribamos proscribir VMM01P0 +proscriban proscribir VMM03P0 +proscribe proscribir VMM02S0 +proscribid proscribir VMM02P0 +proscribiendo proscribir VMG0000 +proscribir proscribir VMN0000 +proseguid proseguir VMM02P0 +proseguir proseguir VMN0000 +prosifica prosificar VMM02S0 +prosificad prosificar VMM02P0 +prosificando prosificar VMG0000 +prosificar prosificar VMN0000 +prosifique prosificar VMM03S0 +prosifiquemos prosificar VMM01P0 +prosifiquen prosificar VMM03P0 +prosiga proseguir VMM03S0 +prosigamos proseguir VMM01P0 +prosigan proseguir VMM03P0 +prosigue proseguir VMM02S0 +prosiguiendo proseguir VMG0000 +prospecta prospectar VMM02S0 +prospectad prospectar VMM02P0 +prospectando prospectar VMG0000 +prospectar prospectar VMN0000 +prospecte prospectar VMM03S0 +prospectemos prospectar VMM01P0 +prospecten prospectar VMM03P0 +prospera prosperar VMM02S0 +prosperad prosperar VMM02P0 +prosperando prosperar VMG0000 +prosperar prosperar VMN0000 +prospere prosperar VMM03S0 +prosperemos prosperar VMM01P0 +prosperen prosperar VMM03P0 +prosterna prosternar VMM02S0 +prosternad prosternar VMM02P0 +prosternando prosternar VMG0000 +prosternar prosternar VMN0000 +prosterne prosternar VMM03S0 +prosternemos prosternar VMM01P0 +prosternen prosternar VMM03P0 +prostituid prostituir VMM02P0 +prostituir prostituir VMN0000 +prostituya prostituir VMM03S0 +prostituyamos prostituir VMM01P0 +prostituyan prostituir VMM03P0 +prostituye prostituir VMM02S0 +prostituyendo prostituir VMG0000 +protagonice protagonizar VMM03S0 +protagonicemos protagonizar VMM01P0 +protagonicen protagonizar VMM03P0 +protagoniza protagonizar VMM02S0 +protagonizad protagonizar VMM02P0 +protagonizando protagonizar VMG0000 +protagonizar protagonizar VMN0000 +protege proteger VMM02S0 +proteged proteger VMM02P0 +proteger proteger VMN0000 +protegiendo proteger VMG0000 +proteja proteger VMM03S0 +protejamos proteger VMM01P0 +protejan proteger VMM03P0 +protesta protestar VMM02S0 +protestad protestar VMM02P0 +protestando protestar VMG0000 +protestar protestar VMN0000 +proteste protestar VMM03S0 +protestemos protestar VMM01P0 +protesten protestar VMM03P0 +protocola protocolar VMM02S0 +protocolad protocolar VMM02P0 +protocolando protocolar VMG0000 +protocolar protocolar VMN0000 +protocole protocolar VMM03S0 +protocolemos protocolar VMM01P0 +protocolen protocolar VMM03P0 +protocolice protocolizar VMM03S0 +protocolicemos protocolizar VMM01P0 +protocolicen protocolizar VMM03P0 +protocoliza protocolizar VMM02S0 +protocolizad protocolizar VMM02P0 +protocolizando protocolizar VMG0000 +protocolizar protocolizar VMN0000 +prototipa prototipar VMM02S0 +prototipad prototipar VMM02P0 +prototipando prototipar VMG0000 +prototipar prototipar VMN0000 +provea proveer VMM03S0 +proveamos proveer VMM01P0 +provean proveer VMM03P0 +provee proveer VMM02S0 +proveed proveer VMM02P0 +proveer proveer VMN0000 +proven provenir VMM02S0 +provenga provenir VMM03S0 +provengamos provenir VMM01P0 +provengan provenir VMM03P0 +provenid provenir VMM02P0 +provenir provenir VMN0000 +proveyendo proveer VMG0000 +providencia providenciar VMM02S0 +providenciad providenciar VMM02P0 +providenciando providenciar VMG0000 +providenciar providenciar VMN0000 +providencie providenciar VMM03S0 +providenciemos providenciar VMM01P0 +providencien providenciar VMM03P0 +proviniendo provenir VMG0000 +provoca provocar VMM02S0 +provocad provocar VMM02P0 +provocando provocar VMG0000 +provocar provocar VMN0000 +provoque provocar VMM03S0 +provoquemos provocar VMM01P0 +provoquen provocar VMM03P0 +proyecta proyectar VMM02S0 +proyectad proyectar VMM02P0 +proyectando proyectar VMG0000 +proyectar proyectar VMN0000 +proyecte proyectar VMM03S0 +proyectemos proyectar VMM01P0 +proyecten proyectar VMM03P0 +prueba probar VMM02S0 +pruebe probar VMM03S0 +prueben probar VMM03P0 +publica publicar VMM02S0 +publicad publicar VMM02P0 +publicando publicar VMG0000 +publicar publicar VMN0000 +publicita publicitar VMM02S0 +publicitad publicitar VMM02P0 +publicitando publicitar VMG0000 +publicitar publicitar VMN0000 +publicite publicitar VMM03S0 +publicitemos publicitar VMM01P0 +publiciten publicitar VMM03P0 +publique publicar VMM03S0 +publiquemos publicar VMM01P0 +publiquen publicar VMM03P0 +pudela pudelar VMM02S0 +pudelad pudelar VMM02P0 +pudelando pudelar VMG0000 +pudelar pudelar VMN0000 +pudele pudelar VMM03S0 +pudelemos pudelar VMM01P0 +pudelen pudelar VMM03P0 +pudiendo poder VMG0000 +pudra pudrir VMM03S0 +pudramos pudrir VMM01P0 +pudran pudrir VMM03P0 +pudre pudrir VMM02S0 +pudrid pudrir VMM02P0 +pudriendo pudrir VMG0000 +pudrir pudrir VMN0000 +podrir pudrir VMN0000 +puebla poblar VMM02S0 +pueble poblar VMM03S0 +pueblen poblar VMM03P0 +pueda poder VMM03S0 +puedan poder VMM03P0 +puede poder VMM02S0 +pugna pugnar VMM02S0 +pugnad pugnar VMM02P0 +pugnando pugnar VMG0000 +pugnar pugnar VMN0000 +pugne pugnar VMM03S0 +pugnemos pugnar VMM01P0 +pugnen pugnar VMM03P0 +puja pujar VMM02S0 +pujad pujar VMM02P0 +pujando pujar VMG0000 +pujar pujar VMN0000 +puje pujar VMM03S0 +pujemos pujar VMM01P0 +pujen pujar VMM03P0 +pula pulir VMM03S0 +pulamos pulir VMM01P0 +pulan pulir VMM03P0 +pule pulir VMM02S0 +pulid pulir VMM02P0 +puliendo pulir VMG0000 +pulimenta pulimentar VMM02S0 +pulimentad pulimentar VMM02P0 +pulimentando pulimentar VMG0000 +pulimentar pulimentar VMN0000 +pulimente pulimentar VMM03S0 +pulimentemos pulimentar VMM01P0 +pulimenten pulimentar VMM03P0 +pulir pulir VMN0000 +pulsa pulsar VMM02S0 +pulsad pulsar VMM02P0 +pulsando pulsar VMG0000 +pulsar pulsar VMN0000 +pulse pulsar VMM03S0 +pulsea pulsear VMM02S0 +pulsead pulsear VMM02P0 +pulseando pulsear VMG0000 +pulsear pulsear VMN0000 +pulsee pulsear VMM03S0 +pulseemos pulsear VMM01P0 +pulseen pulsear VMM03P0 +pulsemos pulsar VMM01P0 +pulsen pulsar VMM03P0 +pulula pulular VMM02S0 +pululad pulular VMM02P0 +pululando pulular VMG0000 +pulular pulular VMN0000 +pulule pulular VMM03S0 +pululemos pulular VMM01P0 +pululen pulular VMM03P0 +pulverice pulverizar VMM03S0 +pulvericemos pulverizar VMM01P0 +pulvericen pulverizar VMM03P0 +pulveriza pulverizar VMM02S0 +pulverizad pulverizar VMM02P0 +pulverizando pulverizar VMG0000 +pulverizar pulverizar VMN0000 +puna punir VMM03S0 +punamos punir VMM01P0 +punan punir VMM03P0 +punce punzar VMM03S0 +puncemos punzar VMM01P0 +puncen punzar VMM03P0 +punciona puncionar VMM02S0 +puncionad puncionar VMM02P0 +puncionando puncionar VMG0000 +puncionar puncionar VMN0000 +puncione puncionar VMM03S0 +puncionemos puncionar VMM01P0 +puncionen puncionar VMM03P0 +pune punir VMM02S0 +punge pungir VMM02S0 +pungid pungir VMM02P0 +pungiendo pungir VMG0000 +pungir pungir VMN0000 +punid punir VMM02P0 +puniendo punir VMG0000 +punir punir VMN0000 +punja pungir VMM03S0 +punjamos pungir VMM01P0 +punjan pungir VMM03P0 +puntea puntear VMM02S0 +puntead puntear VMM02P0 +punteando puntear VMG0000 +puntear puntear VMN0000 +puntee puntear VMM03S0 +punteemos puntear VMM01P0 +punteen puntear VMM03P0 +puntuad puntuar VMM02P0 +puntualice puntualizar VMM03S0 +puntualicemos puntualizar VMM01P0 +puntualicen puntualizar VMM03P0 +puntualiza puntualizar VMM02S0 +puntualizad puntualizar VMM02P0 +puntualizando puntualizar VMG0000 +puntualizar puntualizar VMN0000 +puntuando puntuar VMG0000 +puntuar puntuar VMN0000 +puntuemos puntuar VMM01P0 +puntúa puntuar VMM02S0 +puntúe puntuar VMM03S0 +puntúen puntuar VMM03P0 +punza punzar VMM02S0 +punzad punzar VMM02P0 +punzando punzar VMG0000 +punzar punzar VMN0000 +punzona punzonar VMM02S0 +punzonad punzonar VMM02P0 +punzonando punzonar VMG0000 +punzonar punzonar VMN0000 +punzone punzonar VMM03S0 +punzonemos punzonar VMM01P0 +punzonen punzonar VMM03P0 +purga purgar VMM02S0 +purgad purgar VMM02P0 +purgando purgar VMG0000 +purgar purgar VMN0000 +purgue purgar VMM03S0 +purguemos purgar VMM01P0 +purguen purgar VMM03P0 +purifica purificar VMM02S0 +purificad purificar VMM02P0 +purificando purificar VMG0000 +purificar purificar VMN0000 +purifique purificar VMM03S0 +purifiquemos purificar VMM01P0 +purifiquen purificar VMM03P0 +purpura purpurar VMM02S0 +purpurad purpurar VMM02P0 +purpurando purpurar VMG0000 +purpurar purpurar VMN0000 +purpure purpurar VMM03S0 +purpurea purpurear VMM02S0 +purpuread purpurear VMM02P0 +purpureando purpurear VMG0000 +purpurear purpurear VMN0000 +purpuree purpurear VMM03S0 +purpureemos purpurear VMM01P0 +purpureen purpurear VMM03P0 +purpuremos purpurar VMM01P0 +purpuren purpurar VMM03P0 +putañea putañear VMM02S0 +putañead putañear VMM02P0 +putañeando putañear VMG0000 +putañear putañear VMN0000 +putañee putañear VMM03S0 +putañeemos putañear VMM01P0 +putañeen putañear VMM03P0 +putea putear VMM02S0 +putead putear VMM02P0 +puteando putear VMG0000 +putear putear VMN0000 +putee putear VMM03S0 +puteemos putear VMM01P0 +puteen putear VMM03P0 +pía piar VMM02S0 +píe piar VMM03S0 +píen piar VMM03P0 +quebrad quebrar VMM02P0 +quebraja quebrajar VMM02S0 +quebrajad quebrajar VMM02P0 +quebrajando quebrajar VMG0000 +quebrajar quebrajar VMN0000 +quebraje quebrajar VMM03S0 +quebrajemos quebrajar VMM01P0 +quebrajen quebrajar VMM03P0 +quebrando quebrar VMG0000 +quebranta quebrantar VMM02S0 +quebrantad quebrantar VMM02P0 +quebrantando quebrantar VMG0000 +quebrantar quebrantar VMN0000 +quebrante quebrantar VMM03S0 +quebrantemos quebrantar VMM01P0 +quebranten quebrantar VMM03P0 +quebrar quebrar VMN0000 +quebremos quebrar VMM01P0 +queda quedar VMM02S0 +quedad quedar VMM02P0 +quedando quedar VMG0000 +quedar quedar VMN0000 +quede quedar VMM03S0 +quedemos quedar VMM01P0 +queden quedar VMM03P0 +queja quejar VMM02S0 +quejad quejar VMM02P0 +quejando quejar VMG0000 +quejar quejar VMN0000 +queje quejar VMM03S0 +quejemos quejar VMM01P0 +quejen quejar VMM03P0 +quema quemar VMM02S0 +quemad quemar VMM02P0 +quemando quemar VMG0000 +quemar quemar VMN0000 +queme quemar VMM03S0 +quememos quemar VMM01P0 +quemen quemar VMM03P0 +quepa caber VMM03S0 +quepamos caber VMM01P0 +quepan caber VMM03P0 +queramos querer VMM01P0 +quered querer VMM02P0 +querella querellar VMM02S0 +querellad querellar VMM02P0 +querellando querellar VMG0000 +querellar querellar VMN0000 +querelle querellar VMM03S0 +querellemos querellar VMM01P0 +querellen querellar VMM03P0 +querer querer VMN0000 +queriendo querer VMG0000 +querocha querochar VMM02S0 +querochad querochar VMM02P0 +querochando querochar VMG0000 +querochar querochar VMN0000 +queroche querochar VMM03S0 +querochemos querochar VMM01P0 +querochen querochar VMM03P0 +quiebra quebrar VMM02S0 +quiebre quebrar VMM03S0 +quiebren quebrar VMM03P0 +quiera querer VMM03S0 +quieran querer VMM03P0 +quiere querer VMM02S0 +quilata quilatar VMM02S0 +quilatad quilatar VMM02P0 +quilatando quilatar VMG0000 +quilatar quilatar VMN0000 +quilate quilatar VMM03S0 +quilatemos quilatar VMM01P0 +quilaten quilatar VMM03P0 +quilifica quilificar VMM02S0 +quilificad quilificar VMM02P0 +quilificando quilificar VMG0000 +quilificar quilificar VMN0000 +quilifique quilificar VMM03S0 +quilifiquemos quilificar VMM01P0 +quilifiquen quilificar VMM03P0 +quimerice quimerizar VMM03S0 +quimericemos quimerizar VMM01P0 +quimericen quimerizar VMM03P0 +quimeriza quimerizar VMM02S0 +quimerizad quimerizar VMM02P0 +quimerizando quimerizar VMG0000 +quimerizar quimerizar VMN0000 +quimifica quimificar VMM02S0 +quimificad quimificar VMM02P0 +quimificando quimificar VMG0000 +quimificar quimificar VMN0000 +quimifique quimificar VMM03S0 +quimifiquemos quimificar VMM01P0 +quimifiquen quimificar VMM03P0 +quinta quintar VMM02S0 +quintad quintar VMM02P0 +quintaesencia quintaesenciar VMM02S0 +quintaesenciad quintaesenciar VMM02P0 +quintaesenciando quintaesenciar VMG0000 +quintaesenciar quintaesenciar VMN0000 +quintaesencie quintaesenciar VMM03S0 +quintaesenciemos quintaesenciar VMM01P0 +quintaesencien quintaesenciar VMM03P0 +quintando quintar VMG0000 +quintar quintar VMN0000 +quinte quintar VMM03S0 +quintemos quintar VMM01P0 +quinten quintar VMM03P0 +quintuplica quintuplicar VMM02S0 +quintuplicad quintuplicar VMM02P0 +quintuplicando quintuplicar VMG0000 +quintuplicar quintuplicar VMN0000 +quintuplique quintuplicar VMM03S0 +quintupliquemos quintuplicar VMM01P0 +quintupliquen quintuplicar VMM03P0 +quita quitar VMM02S0 +quitad quitar VMM02P0 +quitando quitar VMG0000 +quitar quitar VMN0000 +quite quitar VMM03S0 +quitemos quitar VMM01P0 +quiten quitar VMM03P0 +rabea rabear VMM02S0 +rabead rabear VMM02P0 +rabeando rabear VMG0000 +rabear rabear VMN0000 +rabee rabear VMM03S0 +rabeemos rabear VMM01P0 +rabeen rabear VMM03P0 +rabia rabiar VMM02S0 +rabiad rabiar VMM02P0 +rabiando rabiar VMG0000 +rabiar rabiar VMN0000 +rabiata rabiatar VMM02S0 +rabiatad rabiatar VMM02P0 +rabiatando rabiatar VMG0000 +rabiatar rabiatar VMN0000 +rabiate rabiatar VMM03S0 +rabiatemos rabiatar VMM01P0 +rabiaten rabiatar VMM03P0 +rabie rabiar VMM03S0 +rabiemos rabiar VMM01P0 +rabien rabiar VMM03P0 +rabosea rabosear VMM02S0 +rabosead rabosear VMM02P0 +raboseando rabosear VMG0000 +rabosear rabosear VMN0000 +rabosee rabosear VMM03S0 +raboseemos rabosear VMM01P0 +raboseen rabosear VMM03P0 +rabotea rabotear VMM02S0 +rabotead rabotear VMM02P0 +raboteando rabotear VMG0000 +rabotear rabotear VMN0000 +rabotee rabotear VMM03S0 +raboteemos rabotear VMM01P0 +raboteen rabotear VMM03P0 +racima racimar VMM02S0 +racimad racimar VMM02P0 +racimando racimar VMG0000 +racimar racimar VMN0000 +racime racimar VMM03S0 +racimemos racimar VMM01P0 +racimen racimar VMM03P0 +raciocina raciocinar VMM02S0 +raciocinad raciocinar VMM02P0 +raciocinando raciocinar VMG0000 +raciocinar raciocinar VMN0000 +raciocine raciocinar VMM03S0 +raciocinemos raciocinar VMM01P0 +raciocinen raciocinar VMM03P0 +raciona racionar VMM02S0 +racionad racionar VMM02P0 +racionalice racionalizar VMM03S0 +racionalicemos racionalizar VMM01P0 +racionalicen racionalizar VMM03P0 +racionaliza racionalizar VMM02S0 +racionalizad racionalizar VMM02P0 +racionalizando racionalizar VMG0000 +racionalizar racionalizar VMN0000 +racionando racionar VMG0000 +racionar racionar VMN0000 +racione racionar VMM03S0 +racionemos racionar VMM01P0 +racionen racionar VMM03P0 +radia radiar VMM02S0 +radiad radiar VMM02P0 +radiando radiar VMG0000 +radiar radiar VMN0000 +radica radicar VMM02S0 +radicad radicar VMM02P0 +radicalice radicalizar VMM03S0 +radicalicemos radicalizar VMM01P0 +radicalicen radicalizar VMM03P0 +radicaliza radicalizar VMM02S0 +radicalizad radicalizar VMM02P0 +radicalizando radicalizar VMG0000 +radicalizar radicalizar VMN0000 +radicando radicar VMG0000 +radicar radicar VMN0000 +radie radiar VMM03S0 +radiemos radiar VMM01P0 +radien radiar VMM03P0 +radiografiad radiografiar VMM02P0 +radiografiando radiografiar VMG0000 +radiografiar radiografiar VMN0000 +radiografiemos radiografiar VMM01P0 +radiografía radiografiar VMM02S0 +radiografíe radiografiar VMM03S0 +radiografíen radiografiar VMM03P0 +radiotelegrafiad radiotelegrafiar VMM02P0 +radiotelegrafiando radiotelegrafiar VMG0000 +radiotelegrafiar radiotelegrafiar VMN0000 +radiotelegrafiemos radiotelegrafiar VMM01P0 +radiotelegrafía radiotelegrafiar VMM02S0 +radiotelegrafíe radiotelegrafiar VMM03S0 +radiotelegrafíen radiotelegrafiar VMM03P0 +radique radicar VMM03S0 +radiquemos radicar VMM01P0 +radiquen radicar VMM03P0 +rae raer VMM02S0 +raed raer VMM02P0 +raer raer VMN0000 +raiga raer VMM03S0 +raigamos raer VMM01P0 +raigan raer VMM03P0 +raja rajar VMM02S0 +rajad rajar VMM02P0 +rajando rajar VMG0000 +rajar rajar VMN0000 +raje rajar VMM03S0 +rajemos rajar VMM01P0 +rajen rajar VMM03P0 +ralea ralear VMM02S0 +ralead ralear VMM02P0 +raleando ralear VMG0000 +ralear ralear VMN0000 +ralee ralear VMM03S0 +raleemos ralear VMM01P0 +raleen ralear VMM03P0 +ralentice ralentizar VMM03S0 +ralenticemos ralentizar VMM01P0 +ralenticen ralentizar VMM03P0 +ralentiza ralentizar VMM02S0 +ralentizad ralentizar VMM02P0 +ralentizando ralentizar VMG0000 +ralentizar ralentizar VMN0000 +ralla rallar VMM02S0 +rallad rallar VMM02P0 +rallando rallar VMG0000 +rallar rallar VMN0000 +ralle rallar VMM03S0 +rallemos rallar VMM01P0 +rallen rallar VMM03P0 +ramifica ramificar VMM02S0 +ramificad ramificar VMM02P0 +ramificando ramificar VMG0000 +ramificar ramificar VMN0000 +ramifique ramificar VMM03S0 +ramifiquemos ramificar VMM01P0 +ramifiquen ramificar VMM03P0 +ramonea ramonear VMM02S0 +ramonead ramonear VMM02P0 +ramoneando ramonear VMG0000 +ramonear ramonear VMN0000 +ramonee ramonear VMM03S0 +ramoneemos ramonear VMM01P0 +ramoneen ramonear VMM03P0 +ranchea ranchear VMM02S0 +ranchead ranchear VMM02P0 +rancheando ranchear VMG0000 +ranchear ranchear VMN0000 +ranchee ranchear VMM03S0 +rancheemos ranchear VMM01P0 +rancheen ranchear VMM03P0 +rancia ranciar VMM02S0 +ranciad ranciar VMM02P0 +ranciando ranciar VMG0000 +ranciar ranciar VMN0000 +rancie ranciar VMM03S0 +ranciemos ranciar VMM01P0 +rancien ranciar VMM03P0 +ranura ranurar VMM02S0 +ranurad ranurar VMM02P0 +ranurando ranurar VMG0000 +ranurar ranurar VMN0000 +ranure ranurar VMM03S0 +ranuremos ranurar VMM01P0 +ranuren ranurar VMM03P0 +rapa rapar VMM02S0 +rapad rapar VMM02P0 +rapando rapar VMG0000 +rapar rapar VMN0000 +rape rapar VMM03S0 +rapemos rapar VMM01P0 +rapen rapar VMM03P0 +rapiña rapiñar VMM02S0 +rapiñad rapiñar VMM02P0 +rapiñando rapiñar VMG0000 +rapiñar rapiñar VMN0000 +rapiñe rapiñar VMM03S0 +rapiñemos rapiñar VMM01P0 +rapiñen rapiñar VMM03P0 +raposea raposear VMM02S0 +raposead raposear VMM02P0 +raposeando raposear VMG0000 +raposear raposear VMN0000 +raposee raposear VMM03S0 +raposeemos raposear VMM01P0 +raposeen raposear VMM03P0 +rapta raptar VMM02S0 +raptad raptar VMM02P0 +raptando raptar VMG0000 +raptar raptar VMN0000 +rapte raptar VMM03S0 +raptemos raptar VMM01P0 +rapten raptar VMM03P0 +raquea raquear VMM02S0 +raquead raquear VMM02P0 +raqueando raquear VMG0000 +raquear raquear VMN0000 +raquee raquear VMM03S0 +raqueemos raquear VMM01P0 +raqueen raquear VMM03P0 +rareface rarefacer VMM02S0 +rarefaced rarefacer VMM02P0 +rarefacer rarefacer VMN0000 +rarefaciendo rarefacer VMG0000 +rarefaga rarefacer VMM03S0 +rarefagamos rarefacer VMM01P0 +rarefagan rarefacer VMM03P0 +rarefaz rarefacer VMM02S0 +rarifica rarificar VMM02S0 +rarificad rarificar VMM02P0 +rarificando rarificar VMG0000 +rarificar rarificar VMN0000 +rarifique rarificar VMM03S0 +rarifiquemos rarificar VMM01P0 +rarifiquen rarificar VMM03P0 +rasa rasar VMM02S0 +rasad rasar VMM02P0 +rasando rasar VMG0000 +rasar rasar VMN0000 +rasca rascar VMM02S0 +rascad rascar VMM02P0 +rascando rascar VMG0000 +rascar rascar VMN0000 +rase rasar VMM03S0 +rasea rasear VMM02S0 +rasead rasear VMM02P0 +raseando rasear VMG0000 +rasear rasear VMN0000 +rasee rasear VMM03S0 +raseemos rasear VMM01P0 +raseen rasear VMM03P0 +rasemos rasar VMM01P0 +rasen rasar VMM03P0 +rasga rasgar VMM02S0 +rasgad rasgar VMM02P0 +rasgando rasgar VMG0000 +rasgar rasgar VMN0000 +rasgue rasgar VMM03S0 +rasguea rasguear VMM02S0 +rasguead rasguear VMM02P0 +rasgueando rasguear VMG0000 +rasguear rasguear VMN0000 +rasguee rasguear VMM03S0 +rasgueemos rasguear VMM01P0 +rasgueen rasguear VMM03P0 +rasguemos rasgar VMM01P0 +rasguen rasgar VMM03P0 +rasguña rasguñar VMM02S0 +rasguñad rasguñar VMM02P0 +rasguñando rasguñar VMG0000 +rasguñar rasguñar VMN0000 +rasguñe rasguñar VMM03S0 +rasguñemos rasguñar VMM01P0 +rasguñen rasguñar VMM03P0 +raspa raspar VMM02S0 +raspad raspar VMM02P0 +raspando raspar VMG0000 +raspar raspar VMN0000 +raspe raspar VMM03S0 +raspea raspear VMM02S0 +raspead raspear VMM02P0 +raspeando raspear VMG0000 +raspear raspear VMN0000 +raspee raspear VMM03S0 +raspeemos raspear VMM01P0 +raspeen raspear VMM03P0 +raspemos raspar VMM01P0 +raspen raspar VMM03P0 +rasque rascar VMM03S0 +rasquemos rascar VMM01P0 +rasquen rascar VMM03P0 +rasquetea rasquetear VMM02S0 +rasquetead rasquetear VMM02P0 +rasqueteando rasquetear VMG0000 +rasquetear rasquetear VMN0000 +rasquetee rasquetear VMM03S0 +rasqueteemos rasquetear VMM01P0 +rasqueteen rasquetear VMM03P0 +rastralla rastrallar VMM02S0 +rastrallad rastrallar VMM02P0 +rastrallando rastrallar VMG0000 +rastrallar rastrallar VMN0000 +rastralle rastrallar VMM03S0 +rastrallemos rastrallar VMM01P0 +rastrallen rastrallar VMM03P0 +rastrea rastrear VMM02S0 +rastread rastrear VMM02P0 +rastreando rastrear VMG0000 +rastrear rastrear VMN0000 +rastree rastrear VMM03S0 +rastreemos rastrear VMM01P0 +rastreen rastrear VMM03P0 +rastrilla rastrillar VMM02S0 +rastrillad rastrillar VMM02P0 +rastrillando rastrillar VMG0000 +rastrillar rastrillar VMN0000 +rastrille rastrillar VMM03S0 +rastrillemos rastrillar VMM01P0 +rastrillen rastrillar VMM03P0 +rastroja rastrojar VMM02S0 +rastrojad rastrojar VMM02P0 +rastrojando rastrojar VMG0000 +rastrojar rastrojar VMN0000 +rastroje rastrojar VMM03S0 +rastrojemos rastrojar VMM01P0 +rastrojen rastrojar VMM03P0 +rasura rasurar VMM02S0 +rasurad rasurar VMM02P0 +rasurando rasurar VMG0000 +rasurar rasurar VMN0000 +rasure rasurar VMM03S0 +rasuremos rasurar VMM01P0 +rasuren rasurar VMM03P0 +ratea ratear VMM02S0 +ratead ratear VMM02P0 +rateando ratear VMG0000 +ratear ratear VMN0000 +ratee ratear VMM03S0 +rateemos ratear VMM01P0 +rateen ratear VMM03P0 +ratifica ratificar VMM02S0 +ratificad ratificar VMM02P0 +ratificando ratificar VMG0000 +ratificar ratificar VMN0000 +ratifique ratificar VMM03S0 +ratifiquemos ratificar VMM01P0 +ratifiquen ratificar VMM03P0 +raya raer VMM03S0 +raya rayar VMM02S0 +rayad rayar VMM02P0 +rayamos raer VMM01P0 +rayan raer VMM03P0 +rayando rayar VMG0000 +rayar rayar VMN0000 +raye rayar VMM03S0 +rayemos rayar VMM01P0 +rayen rayar VMM03P0 +rayendo raer VMG0000 +razona razonar VMM02S0 +razonad razonar VMM02P0 +razonando razonar VMG0000 +razonar razonar VMN0000 +razone razonar VMM03S0 +razonemos razonar VMM01P0 +razonen razonar VMM03P0 +reabra reabrir VMM03S0 +reabramos reabrir VMM01P0 +reabran reabrir VMM03P0 +reabre reabrir VMM02S0 +reabrid reabrir VMM02P0 +reabriendo reabrir VMG0000 +reabrir reabrir VMN0000 +reabsorba reabsorber VMM03S0 +reabsorbamos reabsorber VMM01P0 +reabsorban reabsorber VMM03P0 +reabsorbe reabsorber VMM02S0 +reabsorbed reabsorber VMM02P0 +reabsorber reabsorber VMN0000 +reabsorbiendo reabsorber VMG0000 +reacciona reaccionar VMM02S0 +reaccionad reaccionar VMM02P0 +reaccionando reaccionar VMG0000 +reaccionar reaccionar VMN0000 +reaccione reaccionar VMM03S0 +reaccionemos reaccionar VMM01P0 +reaccionen reaccionar VMM03P0 +reactiva reactivar VMM02S0 +reactivad reactivar VMM02P0 +reactivando reactivar VMG0000 +reactivar reactivar VMN0000 +reactive reactivar VMM03S0 +reactivemos reactivar VMM01P0 +reactiven reactivar VMM03P0 +reacuña reacuñar VMM02S0 +reacuñad reacuñar VMM02P0 +reacuñando reacuñar VMG0000 +reacuñar reacuñar VMN0000 +reacuñe reacuñar VMM03S0 +reacuñemos reacuñar VMM01P0 +reacuñen reacuñar VMM03P0 +readapta readaptar VMM02S0 +readaptad readaptar VMM02P0 +readaptando readaptar VMG0000 +readaptar readaptar VMN0000 +readapte readaptar VMM03S0 +readaptemos readaptar VMM01P0 +readapten readaptar VMM03P0 +readmita readmitir VMM03S0 +readmitamos readmitir VMM01P0 +readmitan readmitir VMM03P0 +readmite readmitir VMM02S0 +readmitid readmitir VMM02P0 +readmitiendo readmitir VMG0000 +readmitir readmitir VMN0000 +readopta readoptar VMM02S0 +readoptad readoptar VMM02P0 +readoptando readoptar VMG0000 +readoptar readoptar VMN0000 +readquiera readquirir VMM03S0 +readquieran readquirir VMM03P0 +readquiere readquirir VMM02S0 +readquiramos readquirir VMM01P0 +readquirid readquirir VMM02P0 +readquiriendo readquirir VMG0000 +readquirir readquirir VMN0000 +reafirma reafirmar VMM02S0 +reafirmad reafirmar VMM02P0 +reafirmando reafirmar VMG0000 +reafirmar reafirmar VMN0000 +reafirme reafirmar VMM03S0 +reafirmemos reafirmar VMM01P0 +reafirmen reafirmar VMM03P0 +reagrupa reagrupar VMM02S0 +reagrupad reagrupar VMM02P0 +reagrupando reagrupar VMG0000 +reagrupar reagrupar VMN0000 +reagrupe reagrupar VMM03S0 +reagrupemos reagrupar VMM01P0 +reagrupen reagrupar VMM03P0 +reajusta reajustar VMM02S0 +reajustad reajustar VMM02P0 +reajustando reajustar VMG0000 +reajustar reajustar VMN0000 +reajuste reajustar VMM03S0 +reajustemos reajustar VMM01P0 +reajusten reajustar VMM03P0 +realce realzar VMM03S0 +realcemos realzar VMM01P0 +realcen realzar VMM03P0 +realice realizar VMM03S0 +realicemos realizar VMM01P0 +realicen realizar VMM03P0 +realiza realizar VMM02S0 +realizad realizar VMM02P0 +realizando realizar VMG0000 +realizar realizar VMN0000 +realoja realojar VMM02S0 +realojad realojar VMM02P0 +realojando realojar VMG0000 +realojar realojar VMN0000 +realoje realojar VMM03S0 +realojemos realojar VMM01P0 +realojen realojar VMM03P0 +realquila realquilar VMM02S0 +realquilad realquilar VMM02P0 +realquilando realquilar VMG0000 +realquilar realquilar VMN0000 +realquile realquilar VMM03S0 +realquilemos realquilar VMM01P0 +realquilen realquilar VMM03P0 +realza realzar VMM02S0 +realzad realzar VMM02P0 +realzando realzar VMG0000 +realzar realzar VMN0000 +reanima reanimar VMM02S0 +reanimad reanimar VMM02P0 +reanimando reanimar VMG0000 +reanimar reanimar VMN0000 +reanime reanimar VMM03S0 +reanimemos reanimar VMM01P0 +reanimen reanimar VMM03P0 +reanuda reanudar VMM02S0 +reanudad reanudar VMM02P0 +reanudando reanudar VMG0000 +reanudar reanudar VMN0000 +reanude reanudar VMM03S0 +reanudemos reanudar VMM01P0 +reanuden reanudar VMM03P0 +reaparece reaparecer VMM02S0 +reapareced reaparecer VMM02P0 +reaparecer reaparecer VMN0000 +reapareciendo reaparecer VMG0000 +reaparezca reaparecer VMM03S0 +reaparezcamos reaparecer VMM01P0 +reaparezcan reaparecer VMM03P0 +rearguya reargüir VMM03S0 +rearguyamos reargüir VMM01P0 +rearguyan reargüir VMM03P0 +rearguye reargüir VMM02S0 +rearguyendo reargüir VMG0000 +reargüid reargüir VMM02P0 +reargüir reargüir VMN0000 +rearma rearmar VMM02S0 +rearmad rearmar VMM02P0 +rearmando rearmar VMG0000 +rearmar rearmar VMN0000 +rearme rearmar VMM03S0 +rearmemos rearmar VMM01P0 +rearmen rearmar VMM03P0 +reasegura reasegurar VMM02S0 +reasegurad reasegurar VMM02P0 +reasegurando reasegurar VMG0000 +reasegurar reasegurar VMN0000 +reasegure reasegurar VMM03S0 +reaseguremos reasegurar VMM01P0 +reaseguren reasegurar VMM03P0 +reasentad reasentar VMM02P0 +reasentando reasentar VMG0000 +reasentar reasentar VMN0000 +reasienta reasentar VMM02S0 +reasigna reasignar VMM02S0 +reasignad reasignar VMM02P0 +reasignando reasignar VMG0000 +reasignar reasignar VMN0000 +reasigne reasignar VMM03S0 +reasignemos reasignar VMM01P0 +reasignen reasignar VMM03P0 +reasuma reasumir VMM03S0 +reasumamos reasumir VMM01P0 +reasuman reasumir VMM03P0 +reasume reasumir VMM02S0 +reasumid reasumir VMM02P0 +reasumiendo reasumir VMG0000 +reasumir reasumir VMN0000 +reata reatar VMM02S0 +reatad reatar VMM02P0 +reatando reatar VMG0000 +reatar reatar VMN0000 +reate reatar VMM03S0 +reatemos reatar VMM01P0 +reaten reatar VMM03P0 +reaviva reavivar VMM02S0 +reavivad reavivar VMM02P0 +reavivando reavivar VMG0000 +reavivar reavivar VMN0000 +reavive reavivar VMM03S0 +reavivemos reavivar VMM01P0 +reaviven reavivar VMM03P0 +rebaja rebajar VMM02S0 +rebajad rebajar VMM02P0 +rebajando rebajar VMG0000 +rebajar rebajar VMN0000 +rebaje rebajar VMM03S0 +rebajemos rebajar VMM01P0 +rebajen rebajar VMM03P0 +rebalsa rebalsar VMM02S0 +rebalsad rebalsar VMM02P0 +rebalsando rebalsar VMG0000 +rebalsar rebalsar VMN0000 +rebalse rebalsar VMM03S0 +rebalsemos rebalsar VMM01P0 +rebalsen rebalsar VMM03P0 +rebana rebanar VMM02S0 +rebanad rebanar VMM02P0 +rebanando rebanar VMG0000 +rebanar rebanar VMN0000 +rebane rebanar VMM03S0 +rebanemos rebanar VMM01P0 +rebanen rebanar VMM03P0 +rebasa rebasar VMM02S0 +rebasad rebasar VMM02P0 +rebasando rebasar VMG0000 +rebasar rebasar VMN0000 +rebase rebasar VMM03S0 +rebasemos rebasar VMM01P0 +rebasen rebasar VMM03P0 +rebata rebatir VMM03S0 +rebatamos rebatir VMM01P0 +rebatan rebatir VMM03P0 +rebate rebatir VMM02S0 +rebatid rebatir VMM02P0 +rebatiendo rebatir VMG0000 +rebatir rebatir VMN0000 +rebautice rebautizar VMM03S0 +rebauticemos rebautizar VMM01P0 +rebauticen rebautizar VMM03P0 +rebautiza rebautizar VMM02S0 +rebautizad rebautizar VMM02P0 +rebautizando rebautizar VMG0000 +rebautizar rebautizar VMN0000 +rebaña rebañar VMM02S0 +rebañad rebañar VMM02P0 +rebañando rebañar VMG0000 +rebañar rebañar VMN0000 +rebañe rebañar VMM03S0 +rebañemos rebañar VMM01P0 +rebañen rebañar VMM03P0 +rebela rebelar VMM02S0 +rebelad rebelar VMM02P0 +rebelando rebelar VMG0000 +rebelar rebelar VMN0000 +rebele rebelar VMM03S0 +rebelemos rebelar VMM01P0 +rebelen rebelar VMM03P0 +rebina rebinar VMM02S0 +rebinad rebinar VMM02P0 +rebinando rebinar VMG0000 +rebinar rebinar VMN0000 +rebine rebinar VMM03S0 +rebinemos rebinar VMM01P0 +rebinen rebinar VMM03P0 +reblandece reblandecer VMM02S0 +reblandeced reblandecer VMM02P0 +reblandecer reblandecer VMN0000 +reblandeciendo reblandecer VMG0000 +reblandezca reblandecer VMM03S0 +reblandezcamos reblandecer VMM01P0 +reblandezcan reblandecer VMM03P0 +rebobina rebobinar VMM02S0 +rebobinad rebobinar VMM02P0 +rebobinando rebobinar VMG0000 +rebobinar rebobinar VMN0000 +rebobine rebobinar VMM03S0 +rebobinemos rebobinar VMM01P0 +rebobinen rebobinar VMM03P0 +reboce rebozar VMM03S0 +rebocemos rebozar VMM01P0 +rebocen rebozar VMM03P0 +rebordea rebordear VMM02S0 +rebordead rebordear VMM02P0 +rebordeando rebordear VMG0000 +rebordear rebordear VMN0000 +rebordee rebordear VMM03S0 +rebordeemos rebordear VMM01P0 +rebordeen rebordear VMM03P0 +rebosa rebosar VMM02S0 +rebosad rebosar VMM02P0 +rebosando rebosar VMG0000 +rebosar rebosar VMN0000 +rebose rebosar VMM03S0 +rebosemos rebosar VMM01P0 +rebosen rebosar VMM03P0 +rebota rebotar VMM02S0 +rebotad rebotar VMM02P0 +rebotando rebotar VMG0000 +rebotar rebotar VMN0000 +rebote rebotar VMM03S0 +rebotea rebotear VMM02S0 +rebotead rebotear VMM02P0 +reboteando rebotear VMG0000 +rebotear rebotear VMN0000 +rebotee rebotear VMM03S0 +reboteemos rebotear VMM01P0 +reboteen rebotear VMM03P0 +rebotemos rebotar VMM01P0 +reboten rebotar VMM03P0 +reboza rebozar VMM02S0 +rebozad rebozar VMM02P0 +rebozando rebozar VMG0000 +rebozar rebozar VMN0000 +rebrama rebramar VMM02S0 +rebramad rebramar VMM02P0 +rebramando rebramar VMG0000 +rebramar rebramar VMN0000 +rebrame rebramar VMM03S0 +rebramemos rebramar VMM01P0 +rebramen rebramar VMM03P0 +rebrinca rebrincar VMM02S0 +rebrincad rebrincar VMM02P0 +rebrincando rebrincar VMG0000 +rebrincar rebrincar VMN0000 +rebrinque rebrincar VMM03S0 +rebrinquemos rebrincar VMM01P0 +rebrinquen rebrincar VMM03P0 +rebrota rebrotar VMM02S0 +rebrotad rebrotar VMM02P0 +rebrotando rebrotar VMG0000 +rebrotar rebrotar VMN0000 +rebrote rebrotar VMM03S0 +rebrotemos rebrotar VMM01P0 +rebroten rebrotar VMM03P0 +rebudia rebudiar VMM02S0 +rebudiad rebudiar VMM02P0 +rebudiando rebudiar VMG0000 +rebudiar rebudiar VMN0000 +rebudie rebudiar VMM03S0 +rebudiemos rebudiar VMM01P0 +rebudien rebudiar VMM03P0 +rebufa rebufar VMM02S0 +rebufad rebufar VMM02P0 +rebufando rebufar VMG0000 +rebufar rebufar VMN0000 +rebufe rebufar VMM03S0 +rebufemos rebufar VMM01P0 +rebufen rebufar VMM03P0 +rebuja rebujar VMM02S0 +rebujad rebujar VMM02P0 +rebujando rebujar VMG0000 +rebujar rebujar VMN0000 +rebuje rebujar VMM03S0 +rebujemos rebujar VMM01P0 +rebujen rebujar VMM03P0 +rebulla rebullir VMM03S0 +rebullamos rebullir VMM01P0 +rebullan rebullir VMM03P0 +rebulle rebullir VMM02S0 +rebullendo rebullir VMG0000 +rebullid rebullir VMM02P0 +rebullir rebullir VMN0000 +reburuja reburujar VMM02S0 +reburujad reburujar VMM02P0 +reburujando reburujar VMG0000 +reburujar reburujar VMN0000 +reburuje reburujar VMM03S0 +reburujemos reburujar VMM01P0 +reburujen reburujar VMM03P0 +rebusca rebuscar VMM02S0 +rebuscad rebuscar VMM02P0 +rebuscando rebuscar VMG0000 +rebuscar rebuscar VMN0000 +rebusque rebuscar VMM03S0 +rebusquemos rebuscar VMM01P0 +rebusquen rebuscar VMM03P0 +rebuzna rebuznar VMM02S0 +rebuznad rebuznar VMM02P0 +rebuznando rebuznar VMG0000 +rebuznar rebuznar VMN0000 +rebuzne rebuznar VMM03S0 +rebuznemos rebuznar VMM01P0 +rebuznen rebuznar VMM03P0 +recaba recabar VMM02S0 +recabad recabar VMM02P0 +recabando recabar VMG0000 +recabar recabar VMN0000 +recabe recabar VMM03S0 +recabemos recabar VMM01P0 +recaben recabar VMM03P0 +recae recaer VMM02S0 +recaed recaer VMM02P0 +recaer recaer VMN0000 +recaiga recaer VMM03S0 +recaigamos recaer VMM01P0 +recaigan recaer VMM03P0 +recala recalar VMM02S0 +recalad recalar VMM02P0 +recalando recalar VMG0000 +recalar recalar VMN0000 +recalca recalcar VMM02S0 +recalcad recalcar VMM02P0 +recalcando recalcar VMG0000 +recalcar recalcar VMN0000 +recalce recalzar VMM03S0 +recalcemos recalzar VMM01P0 +recalcen recalzar VMM03P0 +recalcitra recalcitrar VMM02S0 +recalcitrad recalcitrar VMM02P0 +recalcitrando recalcitrar VMG0000 +recalcitrar recalcitrar VMN0000 +recalcitre recalcitrar VMM03S0 +recalcitremos recalcitrar VMM01P0 +recalcitren recalcitrar VMM03P0 +recale recalar VMM03S0 +recalemos recalar VMM01P0 +recalen recalar VMM03P0 +recalentad recalentar VMM02P0 +recalentando recalentar VMG0000 +recalentar recalentar VMN0000 +recalentemos recalentar VMM01P0 +recalienta recalentar VMM02S0 +recaliente recalentar VMM03S0 +recalienten recalentar VMM03P0 +recalifica recalificar VMM02S0 +recalificad recalificar VMM02P0 +recalificando recalificar VMG0000 +recalificar recalificar VMN0000 +recalifique recalificar VMM03S0 +recalifiquemos recalificar VMM01P0 +recalifiquen recalificar VMM03P0 +recalque recalcar VMM03S0 +recalquemos recalcar VMM01P0 +recalquen recalcar VMM03P0 +recalza recalzar VMM02S0 +recalzad recalzar VMM02P0 +recalzando recalzar VMG0000 +recalzar recalzar VMN0000 +recama recamar VMM02S0 +recamad recamar VMM02P0 +recamando recamar VMG0000 +recamar recamar VMN0000 +recambia recambiar VMM02S0 +recambiad recambiar VMM02P0 +recambiando recambiar VMG0000 +recambiar recambiar VMN0000 +recambie recambiar VMM03S0 +recambiemos recambiar VMM01P0 +recambien recambiar VMM03P0 +recame recamar VMM03S0 +recamemos recamar VMM01P0 +recamen recamar VMM03P0 +recapacita recapacitar VMM02S0 +recapacitad recapacitar VMM02P0 +recapacitando recapacitar VMG0000 +recapacitar recapacitar VMN0000 +recapacite recapacitar VMM03S0 +recapacitemos recapacitar VMM01P0 +recapaciten recapacitar VMM03P0 +recapitula recapitular VMM02S0 +recapitulad recapitular VMM02P0 +recapitulando recapitular VMG0000 +recapitular recapitular VMN0000 +recapitule recapitular VMM03S0 +recapitulemos recapitular VMM01P0 +recapitulen recapitular VMM03P0 +recarga recargar VMM02S0 +recargad recargar VMM02P0 +recargando recargar VMG0000 +recargar recargar VMN0000 +recargue recargar VMM03S0 +recarguemos recargar VMM01P0 +recarguen recargar VMM03P0 +recata recatar VMM02S0 +recatad recatar VMM02P0 +recatando recatar VMG0000 +recatar recatar VMN0000 +recate recatar VMM03S0 +recatemos recatar VMM01P0 +recaten recatar VMM03P0 +recauchuta recauchutar VMM02S0 +recauchutad recauchutar VMM02P0 +recauchutando recauchutar VMG0000 +recauchutar recauchutar VMN0000 +recauchute recauchutar VMM03S0 +recauchutemos recauchutar VMM01P0 +recauchuten recauchutar VMM03P0 +recauda recaudar VMM02S0 +recaudad recaudar VMM02P0 +recaudando recaudar VMG0000 +recaudar recaudar VMN0000 +recaude recaudar VMM03S0 +recaudemos recaudar VMM01P0 +recauden recaudar VMM03P0 +recava recavar VMM02S0 +recavad recavar VMM02P0 +recavando recavar VMG0000 +recavar recavar VMN0000 +recave recavar VMM03S0 +recavemos recavar VMM01P0 +recaven recavar VMM03P0 +recayendo recaer VMG0000 +rece rezar VMM03S0 +receba recebar VMM02S0 +recebad recebar VMM02P0 +recebando recebar VMG0000 +recebar recebar VMN0000 +recebe recebar VMM03S0 +recebemos recebar VMM01P0 +receben recebar VMM03P0 +recela recelar VMM02S0 +recelad recelar VMM02P0 +recelando recelar VMG0000 +recelar recelar VMN0000 +recele recelar VMM03S0 +recelemos recelar VMM01P0 +recelen recelar VMM03P0 +recemos rezar VMM01P0 +recen rezar VMM03P0 +recentad recentar VMM02P0 +recentando recentar VMG0000 +recentar recentar VMN0000 +recentemos recentar VMM01P0 +recepciona recepcionar VMM02S0 +recepcionad recepcionar VMM02P0 +recepcionando recepcionar VMG0000 +recepcionar recepcionar VMN0000 +recepcione recepcionar VMM03S0 +recepcionemos recepcionar VMM01P0 +recepcionen recepcionar VMM03P0 +recepta receptar VMM02S0 +receptad receptar VMM02P0 +receptando receptar VMG0000 +receptar receptar VMN0000 +recepte receptar VMM03S0 +receptemos receptar VMM01P0 +recepten receptar VMM03P0 +receta recetar VMM02S0 +recetad recetar VMM02P0 +recetando recetar VMG0000 +recetar recetar VMN0000 +recete recetar VMM03S0 +recetemos recetar VMM01P0 +receten recetar VMM03P0 +rechace rechazar VMM03S0 +rechacemos rechazar VMM01P0 +rechacen rechazar VMM03P0 +rechaza rechazar VMM02S0 +rechazad rechazar VMM02P0 +rechazando rechazar VMG0000 +rechazar rechazar VMN0000 +rechifla rechiflar VMM02S0 +rechiflad rechiflar VMM02P0 +rechiflando rechiflar VMG0000 +rechiflar rechiflar VMN0000 +rechifle rechiflar VMM03S0 +rechiflemos rechiflar VMM01P0 +rechiflen rechiflar VMM03P0 +rechina rechinar VMM02S0 +rechinad rechinar VMM02P0 +rechinando rechinar VMG0000 +rechinar rechinar VMN0000 +rechine rechinar VMM03S0 +rechinemos rechinar VMM01P0 +rechinen rechinar VMM03P0 +rechista rechistar VMM02S0 +rechistad rechistar VMM02P0 +rechistando rechistar VMG0000 +rechistar rechistar VMN0000 +rechiste rechistar VMM03S0 +rechistemos rechistar VMM01P0 +rechisten rechistar VMM03P0 +reciba recibir VMM03S0 +recibamos recibir VMM01P0 +reciban recibir VMM03P0 +recibe recibir VMM02S0 +recibid recibir VMM02P0 +recibiendo recibir VMG0000 +recibir recibir VMN0000 +recicla reciclar VMM02S0 +reciclad reciclar VMM02P0 +reciclando reciclar VMG0000 +reciclar reciclar VMN0000 +recicle reciclar VMM03S0 +reciclemos reciclar VMM01P0 +reciclen reciclar VMM03P0 +recidiva recidivar VMM02S0 +recidivad recidivar VMM02P0 +recidivando recidivar VMG0000 +recidivar recidivar VMN0000 +recidive recidivar VMM03S0 +recidivemos recidivar VMM01P0 +recidiven recidivar VMM03P0 +recienta recentar VMM02S0 +reciente recentar VMM03S0 +recienten recentar VMM03P0 +reciproca reciprocar VMM02S0 +reciprocad reciprocar VMM02P0 +reciprocando reciprocar VMG0000 +reciprocar reciprocar VMN0000 +reciproque reciprocar VMM03S0 +reciproquemos reciprocar VMM01P0 +reciproquen reciprocar VMM03P0 +recita recitar VMM02S0 +recitad recitar VMM02P0 +recitando recitar VMG0000 +recitar recitar VMN0000 +recite recitar VMM03S0 +recitemos recitar VMM01P0 +reciten recitar VMM03P0 +reclama reclamar VMM02S0 +reclamad reclamar VMM02P0 +reclamando reclamar VMG0000 +reclamar reclamar VMN0000 +reclame reclamar VMM03S0 +reclamemos reclamar VMM01P0 +reclamen reclamar VMM03P0 +reclina reclinar VMM02S0 +reclinad reclinar VMM02P0 +reclinando reclinar VMG0000 +reclinar reclinar VMN0000 +recline reclinar VMM03S0 +reclinemos reclinar VMM01P0 +reclinen reclinar VMM03P0 +recluid recluir VMM02P0 +recluir recluir VMN0000 +recluta reclutar VMM02S0 +reclutad reclutar VMM02P0 +reclutando reclutar VMG0000 +reclutar reclutar VMN0000 +reclute reclutar VMM03S0 +reclutemos reclutar VMM01P0 +recluten reclutar VMM03P0 +recluya recluir VMM03S0 +recluyamos recluir VMM01P0 +recluyan recluir VMM03P0 +recluye recluir VMM02S0 +recluyendo recluir VMG0000 +recobra recobrar VMM02S0 +recobrad recobrar VMM02P0 +recobrando recobrar VMG0000 +recobrar recobrar VMN0000 +recobre recobrar VMM03S0 +recobremos recobrar VMM01P0 +recobren recobrar VMM03P0 +recoced recocer VMM02P0 +recocer recocer VMN0000 +recochinea recochinear VMM02S0 +recochinead recochinear VMM02P0 +recochineando recochinear VMG0000 +recochinear recochinear VMN0000 +recochinee recochinear VMM03S0 +recochineemos recochinear VMM01P0 +recochineen recochinear VMM03P0 +recociendo recocer VMG0000 +recoda recodar VMM02S0 +recodad recodar VMM02P0 +recodando recodar VMG0000 +recodar recodar VMN0000 +recode recodar VMM03S0 +recodemos recodar VMM01P0 +recoden recodar VMM03P0 +recoge recoger VMM02S0 +recoged recoger VMM02P0 +recoger recoger VMN0000 +recogiendo recoger VMG0000 +recoja recoger VMM03S0 +recojamos recoger VMM01P0 +recojan recoger VMM03P0 +recolad recolar VMM02P0 +recolando recolar VMG0000 +recolar recolar VMN0000 +recolecta recolectar VMM02S0 +recolectad recolectar VMM02P0 +recolectando recolectar VMG0000 +recolectar recolectar VMN0000 +recolecte recolectar VMM03S0 +recolectemos recolectar VMM01P0 +recolecten recolectar VMM03P0 +recolemos recolar VMM01P0 +recoma recomer VMM03S0 +recomamos recomer VMM01P0 +recoman recomer VMM03P0 +recome recomer VMM02S0 +recomed recomer VMM02P0 +recomencemos recomenzar VMM01P0 +recomendad recomendar VMM02P0 +recomendando recomendar VMG0000 +recomendar recomendar VMN0000 +recomendemos recomendar VMM01P0 +recomenzad recomenzar VMM02P0 +recomenzando recomenzar VMG0000 +recomenzar recomenzar VMN0000 +recomer recomer VMN0000 +recomience recomenzar VMM03S0 +recomiencen recomenzar VMM03P0 +recomienda recomendar VMM02S0 +recomiende recomendar VMM03S0 +recomienden recomendar VMM03P0 +recomiendo recomer VMG0000 +recomienza recomenzar VMM02S0 +recompensa recompensar VMM02S0 +recompensad recompensar VMM02P0 +recompensando recompensar VMG0000 +recompensar recompensar VMN0000 +recompense recompensar VMM03S0 +recompensemos recompensar VMM01P0 +recompensen recompensar VMM03P0 +recompila recompilar VMM02S0 +recompilad recompilar VMM02P0 +recompilando recompilar VMG0000 +recompilar recompilar VMN0000 +recomponed recomponer VMM02P0 +recomponer recomponer VMN0000 +recomponga recomponer VMM03S0 +recompongamos recomponer VMM01P0 +recompongan recomponer VMM03P0 +recomponiendo recomponer VMG0000 +recompón recomponer VMM02S0 +reconcentra reconcentrar VMM02S0 +reconcentrad reconcentrar VMM02P0 +reconcentrando reconcentrar VMG0000 +reconcentrar reconcentrar VMN0000 +reconcentre reconcentrar VMM03S0 +reconcentremos reconcentrar VMM01P0 +reconcentren reconcentrar VMM03P0 +reconcilia reconciliar VMM02S0 +reconciliad reconciliar VMM02P0 +reconciliando reconciliar VMG0000 +reconciliar reconciliar VMN0000 +reconcilie reconciliar VMM03S0 +reconciliemos reconciliar VMM01P0 +reconcilien reconciliar VMM03P0 +reconcoma reconcomer VMM03S0 +reconcomamos reconcomer VMM01P0 +reconcoman reconcomer VMM03P0 +reconcome reconcomer VMM02S0 +reconcomed reconcomer VMM02P0 +reconcomer reconcomer VMN0000 +reconcomiendo reconcomer VMG0000 +recondena recondenar VMM02S0 +recondenad recondenar VMM02P0 +recondenando recondenar VMG0000 +recondenar recondenar VMN0000 +recondene recondenar VMM03S0 +recondenemos recondenar VMM01P0 +recondenen recondenar VMM03P0 +reconduce reconducir VMM02S0 +reconducid reconducir VMM02P0 +reconduciendo reconducir VMG0000 +reconducir reconducir VMN0000 +reconduzca reconducir VMM03S0 +reconduzcamos reconducir VMM01P0 +reconduzcan reconducir VMM03P0 +reconforta reconfortar VMM02S0 +reconfortad reconfortar VMM02P0 +reconfortando reconfortar VMG0000 +reconfortar reconfortar VMN0000 +reconforte reconfortar VMM03S0 +reconfortemos reconfortar VMM01P0 +reconforten reconfortar VMM03P0 +reconoce reconocer VMM02S0 +reconoced reconocer VMM02P0 +reconocer reconocer VMN0000 +reconociendo reconocer VMG0000 +reconozca reconocer VMM03S0 +reconozcamos reconocer VMM01P0 +reconozcan reconocer VMM03P0 +reconquista reconquistar VMM02S0 +reconquistad reconquistar VMM02P0 +reconquistando reconquistar VMG0000 +reconquistar reconquistar VMN0000 +reconquiste reconquistar VMM03S0 +reconquistemos reconquistar VMM01P0 +reconquisten reconquistar VMM03P0 +reconsidera reconsiderar VMM02S0 +reconsiderad reconsiderar VMM02P0 +reconsiderando reconsiderar VMG0000 +reconsiderar reconsiderar VMN0000 +reconsidere reconsiderar VMM03S0 +reconsideremos reconsiderar VMM01P0 +reconsideren reconsiderar VMM03P0 +reconstituid reconstituir VMM02P0 +reconstituir reconstituir VMN0000 +reconstituya reconstituir VMM03S0 +reconstituyamos reconstituir VMM01P0 +reconstituyan reconstituir VMM03P0 +reconstituye reconstituir VMM02S0 +reconstituyendo reconstituir VMG0000 +reconstruid reconstruir VMM02P0 +reconstruir reconstruir VMN0000 +reconstruya reconstruir VMM03S0 +reconstruyamos reconstruir VMM01P0 +reconstruyan reconstruir VMM03P0 +reconstruye reconstruir VMM02S0 +reconstruyendo reconstruir VMG0000 +recontad recontar VMM02P0 +recontando recontar VMG0000 +recontar recontar VMN0000 +recontemos recontar VMM01P0 +reconvalece reconvalecer VMM02S0 +reconvaleced reconvalecer VMM02P0 +reconvalecer reconvalecer VMN0000 +reconvaleciendo reconvalecer VMG0000 +reconvalezca reconvalecer VMM03S0 +reconvalezcamos reconvalecer VMM01P0 +reconvalezcan reconvalecer VMM03P0 +reconven reconvenir VMM02S0 +reconvenga reconvenir VMM03S0 +reconvengamos reconvenir VMM01P0 +reconvengan reconvenir VMM03P0 +reconvenid reconvenir VMM02P0 +reconvenir reconvenir VMN0000 +reconvertid reconvertir VMM02P0 +reconvertir reconvertir VMN0000 +reconvierta reconvertir VMM03S0 +reconviertan reconvertir VMM03P0 +reconvierte reconvertir VMM02S0 +reconviniendo reconvenir VMG0000 +reconvirtamos reconvertir VMM01P0 +reconvirtiendo reconvertir VMG0000 +recopila recopilar VMM02S0 +recopilad recopilar VMM02P0 +recopilando recopilar VMG0000 +recopilar recopilar VMN0000 +recopile recopilar VMM03S0 +recopilemos recopilar VMM01P0 +recopilen recopilar VMM03P0 +recordad recordar VMM02P0 +recordando recordar VMG0000 +recordar recordar VMN0000 +recordemos recordar VMM01P0 +recorra recorrer VMM03S0 +recorramos recorrer VMM01P0 +recorran recorrer VMM03P0 +recorre recorrer VMM02S0 +recorred recorrer VMM02P0 +recorrer recorrer VMN0000 +recorriendo recorrer VMG0000 +recorta recortar VMM02S0 +recortad recortar VMM02P0 +recortando recortar VMG0000 +recortar recortar VMN0000 +recorte recortar VMM03S0 +recortemos recortar VMM01P0 +recorten recortar VMM03P0 +recorva recorvar VMM02S0 +recorvad recorvar VMM02P0 +recorvando recorvar VMG0000 +recorvar recorvar VMN0000 +recorve recorvar VMM03S0 +recorvemos recorvar VMM01P0 +recorven recorvar VMM03P0 +recosa recoser VMM03S0 +recosamos recoser VMM01P0 +recosan recoser VMM03P0 +recose recoser VMM02S0 +recosed recoser VMM02P0 +recoser recoser VMN0000 +recosiendo recoser VMG0000 +recostad recostar VMM02P0 +recostando recostar VMG0000 +recostar recostar VMN0000 +recostemos recostar VMM01P0 +recova recovar VMM02S0 +recovad recovar VMM02P0 +recovando recovar VMG0000 +recovar recovar VMN0000 +recove recovar VMM03S0 +recovemos recovar VMM01P0 +recoven recovar VMM03P0 +recozamos recocer VMM01P0 +recrea recrear VMM02S0 +recread recrear VMM02P0 +recreando recrear VMG0000 +recrear recrear VMN0000 +recrece recrecer VMM02S0 +recreced recrecer VMM02P0 +recrecer recrecer VMN0000 +recreciendo recrecer VMG0000 +recree recrear VMM03S0 +recreemos recrear VMM01P0 +recreen recrear VMM03P0 +recrezca recrecer VMM03S0 +recrezcamos recrecer VMM01P0 +recrezcan recrecer VMM03P0 +recriad recriar VMM02P0 +recriando recriar VMG0000 +recriar recriar VMN0000 +recriemos recriar VMM01P0 +recrimina recriminar VMM02S0 +recriminad recriminar VMM02P0 +recriminando recriminar VMG0000 +recriminar recriminar VMN0000 +recrimine recriminar VMM03S0 +recriminemos recriminar VMM01P0 +recriminen recriminar VMM03P0 +recristalice recristalizar VMM03S0 +recristalicemos recristalizar VMM01P0 +recristalicen recristalizar VMM03P0 +recristaliza recristalizar VMM02S0 +recristalizad recristalizar VMM02P0 +recristalizando recristalizar VMG0000 +recristalizar recristalizar VMN0000 +recrudece recrudecer VMM02S0 +recrudeced recrudecer VMM02P0 +recrudecer recrudecer VMN0000 +recrudeciendo recrudecer VMG0000 +recrudezca recrudecer VMM03S0 +recrudezcamos recrudecer VMM01P0 +recrudezcan recrudecer VMM03P0 +recría recriar VMM02S0 +recríe recriar VMM03S0 +recríen recriar VMM03P0 +rectifica rectificar VMM02S0 +rectificad rectificar VMM02P0 +rectificando rectificar VMG0000 +rectificar rectificar VMN0000 +rectifique rectificar VMM03S0 +rectifiquemos rectificar VMM01P0 +rectifiquen rectificar VMM03P0 +recuadra recuadrar VMM02S0 +recuadrad recuadrar VMM02P0 +recuadrando recuadrar VMG0000 +recuadrar recuadrar VMN0000 +recuadre recuadrar VMM03S0 +recuadremos recuadrar VMM01P0 +recuadren recuadrar VMM03P0 +recubra recubrir VMM03S0 +recubramos recubrir VMM01P0 +recubran recubrir VMM03P0 +recubre recubrir VMM02S0 +recubrid recubrir VMM02P0 +recubriendo recubrir VMG0000 +recubrir recubrir VMN0000 +recuece recocer VMM02S0 +recuela recolar VMM02S0 +recuele recolar VMM03S0 +recuelen recolar VMM03P0 +recuenta recontar VMM02S0 +recuente recontar VMM03S0 +recuenten recontar VMM03P0 +recuerda recordar VMM02S0 +recuerde recordar VMM03S0 +recuerden recordar VMM03P0 +recuesta recostar VMM02S0 +recuesta recuestar VMM02S0 +recuestad recuestar VMM02P0 +recuestando recuestar VMG0000 +recuestar recuestar VMN0000 +recueste recostar VMM03S0 +recueste recuestar VMM03S0 +recuestemos recuestar VMM01P0 +recuesten recostar VMM03P0 +recuesten recuestar VMM03P0 +recueza recocer VMM03S0 +recuezan recocer VMM03P0 +recula recular VMM02S0 +reculad recular VMM02P0 +reculando recular VMG0000 +recular recular VMN0000 +recule recular VMM03S0 +reculemos recular VMM01P0 +reculen recular VMM03P0 +recupera recuperar VMM02S0 +recuperad recuperar VMM02P0 +recuperando recuperar VMG0000 +recuperar recuperar VMN0000 +recupere recuperar VMM03S0 +recuperemos recuperar VMM01P0 +recuperen recuperar VMM03P0 +recurra recurrir VMM03S0 +recurramos recurrir VMM01P0 +recurran recurrir VMM03P0 +recurre recurrir VMM02S0 +recurrid recurrir VMM02P0 +recurriendo recurrir VMG0000 +recurrir recurrir VMN0000 +recusa recusar VMM02S0 +recusad recusar VMM02P0 +recusando recusar VMG0000 +recusar recusar VMN0000 +recuse recusar VMM03S0 +recusemos recusar VMM01P0 +recusen recusar VMM03P0 +recuña recuñar VMM02S0 +recuñad recuñar VMM02P0 +recuñando recuñar VMG0000 +recuñar recuñar VMN0000 +recuñe recuñar VMM03S0 +recuñemos recuñar VMM01P0 +recuñen recuñar VMM03P0 +reda redar VMM02S0 +redacta redactar VMM02S0 +redactad redactar VMM02P0 +redactando redactar VMG0000 +redactar redactar VMN0000 +redacte redactar VMM03S0 +redactemos redactar VMM01P0 +redacten redactar VMM03P0 +redad redar VMM02P0 +redando redar VMG0000 +redar redar VMN0000 +redarguya redargüir VMM03S0 +redarguyamos redargüir VMM01P0 +redarguyan redargüir VMM03P0 +redarguye redargüir VMM02S0 +redarguyendo redargüir VMG0000 +redargüid redargüir VMM02P0 +redargüir redargüir VMN0000 +rede redar VMM03S0 +redecid redecir VMM02P0 +redecir redecir VMN0000 +redefina redefinir VMM03S0 +redefinamos redefinir VMM01P0 +redefinan redefinir VMM03P0 +redefine redefinir VMM02S0 +redefinid redefinir VMM02P0 +redefiniendo redefinir VMG0000 +redefinir redefinir VMN0000 +redemos redar VMM01P0 +reden redar VMM03P0 +redescubra redescubrir VMM03S0 +redescubramos redescubrir VMM01P0 +redescubran redescubrir VMM03P0 +redescubre redescubrir VMM02S0 +redescubrid redescubrir VMM02P0 +redescubriendo redescubrir VMG0000 +redescubrir redescubrir VMN0000 +redhiba redhibir VMM03S0 +redhibamos redhibir VMM01P0 +redhiban redhibir VMM03P0 +redhibe redhibir VMM02S0 +redhibid redhibir VMM02P0 +redhibiendo redhibir VMG0000 +redhibir redhibir VMN0000 +redice redecir VMM02S0 +rediciendo redecir VMG0000 +rediezma rediezmar VMM02S0 +rediezmad rediezmar VMM02P0 +rediezmando rediezmar VMG0000 +rediezmar rediezmar VMN0000 +rediezme rediezmar VMM03S0 +rediezmemos rediezmar VMM01P0 +rediezmen rediezmar VMM03P0 +rediga redecir VMM03S0 +redigamos redecir VMM01P0 +redigan redecir VMM03P0 +redila redilar VMM02S0 +redilad redilar VMM02P0 +redilando redilar VMG0000 +redilar redilar VMN0000 +redile redilar VMM03S0 +redilea redilear VMM02S0 +redilead redilear VMM02P0 +redileando redilear VMG0000 +redilear redilear VMN0000 +redilee redilear VMM03S0 +redileemos redilear VMM01P0 +redileen redilear VMM03P0 +redilemos redilar VMM01P0 +redilen redilar VMM03P0 +redima redimir VMM03S0 +redimamos redimir VMM01P0 +rediman redimir VMM03P0 +redime redimir VMM02S0 +redimid redimir VMM02P0 +redimiendo redimir VMG0000 +redimir redimir VMN0000 +rediseña rediseñar VMM02S0 +rediseñad rediseñar VMM02P0 +rediseñando rediseñar VMG0000 +rediseñar rediseñar VMN0000 +redistribuid redistribuir VMM02P0 +redistribuir redistribuir VMN0000 +redistribuya redistribuir VMM03S0 +redistribuyamos redistribuir VMM01P0 +redistribuyan redistribuir VMM03P0 +redistribuye redistribuir VMM02S0 +redistribuyendo redistribuir VMG0000 +redituad redituar VMM02P0 +redituando redituar VMG0000 +redituar redituar VMN0000 +redituemos redituar VMM01P0 +reditúa redituar VMM02S0 +reditúe redituar VMM03S0 +reditúen redituar VMM03P0 +redobla redoblar VMM02S0 +redoblad redoblar VMM02P0 +redoblando redoblar VMG0000 +redoblar redoblar VMN0000 +redoble redoblar VMM03S0 +redoblemos redoblar VMM01P0 +redoblen redoblar VMM03P0 +redondea redondear VMM02S0 +redondead redondear VMM02P0 +redondeando redondear VMG0000 +redondear redondear VMN0000 +redondee redondear VMM03S0 +redondeemos redondear VMM01P0 +redondeen redondear VMM03P0 +redora redorar VMM02S0 +redorad redorar VMM02P0 +redorando redorar VMG0000 +redorar redorar VMN0000 +redore redorar VMM03S0 +redoremos redorar VMM01P0 +redoren redorar VMM03P0 +redra redrar VMM02S0 +redrad redrar VMM02P0 +redrando redrar VMG0000 +redrar redrar VMN0000 +reduce reducir VMM02S0 +reducid reducir VMM02P0 +reduciendo reducir VMG0000 +reducir reducir VMN0000 +redunda redundar VMM02S0 +redundad redundar VMM02P0 +redundando redundar VMG0000 +redundar redundar VMN0000 +redunde redundar VMM03S0 +redundemos redundar VMM01P0 +redunden redundar VMM03P0 +reduplica reduplicar VMM02S0 +reduplicad reduplicar VMM02P0 +reduplicando reduplicar VMG0000 +reduplicar reduplicar VMN0000 +reduplique reduplicar VMM03S0 +redupliquemos reduplicar VMM01P0 +redupliquen reduplicar VMM03P0 +reduzca reducir VMM03S0 +reduzcamos reducir VMM01P0 +reduzcan reducir VMM03P0 +reedifica reedificar VMM02S0 +reedificad reedificar VMM02P0 +reedificando reedificar VMG0000 +reedificar reedificar VMN0000 +reedifique reedificar VMM03S0 +reedifiquemos reedificar VMM01P0 +reedifiquen reedificar VMM03P0 +reedita reeditar VMM02S0 +reeditad reeditar VMM02P0 +reeditando reeditar VMG0000 +reeditar reeditar VMN0000 +reedite reeditar VMM03S0 +reeditemos reeditar VMM01P0 +reediten reeditar VMM03P0 +reeduca reeducar VMM02S0 +reeducad reeducar VMM02P0 +reeducando reeducar VMG0000 +reeducar reeducar VMN0000 +reeduque reeducar VMM03S0 +reeduquemos reeducar VMM01P0 +reeduquen reeducar VMM03P0 +reelegid reelegir VMM02P0 +reelegir reelegir VMN0000 +reelige reelegir VMM02S0 +reeligiendo reelegir VMG0000 +reelija reelegir VMM03S0 +reelijamos reelegir VMM01P0 +reelijan reelegir VMM03P0 +reembarca reembarcar VMM02S0 +reembarcad reembarcar VMM02P0 +reembarcando reembarcar VMG0000 +reembarcar reembarcar VMN0000 +reembarque reembarcar VMM03S0 +reembarquemos reembarcar VMM01P0 +reembarquen reembarcar VMM03P0 +reembolsa reembolsar VMM02S0 +reembolsad reembolsar VMM02P0 +reembolsando reembolsar VMG0000 +reembolsar reembolsar VMN0000 +reembolse reembolsar VMM03S0 +reembolsemos reembolsar VMM01P0 +reembolsen reembolsar VMM03P0 +reemplace reemplazar VMM03S0 +reemplacemos reemplazar VMM01P0 +reemplacen reemplazar VMM03P0 +reemplaza reemplazar VMM02S0 +reemplazad reemplazar VMM02P0 +reemplazando reemplazar VMG0000 +reemplazar reemplazar VMN0000 +reemprenda reemprender VMM03S0 +reemprendamos reemprender VMM01P0 +reemprendan reemprender VMM03P0 +reemprende reemprender VMM02S0 +reemprended reemprender VMM02P0 +reemprender reemprender VMN0000 +reemprendiendo reemprender VMG0000 +reencarna reencarnar VMM02S0 +reencarnad reencarnar VMM02P0 +reencarnando reencarnar VMG0000 +reencarnar reencarnar VMN0000 +reencarne reencarnar VMM03S0 +reencarnemos reencarnar VMM01P0 +reencarnen reencarnar VMM03P0 +reencontrad reencontrar VMM02P0 +reencontrando reencontrar VMG0000 +reencontrar reencontrar VMN0000 +reencontremos reencontrar VMM01P0 +reencuaderna reencuadernar VMM02S0 +reencuadernad reencuadernar VMM02P0 +reencuadernando reencuadernar VMG0000 +reencuadernar reencuadernar VMN0000 +reencuaderne reencuadernar VMM03S0 +reencuadernemos reencuadernar VMM01P0 +reencuadernen reencuadernar VMM03P0 +reencuentra reencontrar VMM02S0 +reencuentre reencontrar VMM03S0 +reencuentren reencontrar VMM03P0 +reengancha reenganchar VMM02S0 +reenganchad reenganchar VMM02P0 +reenganchando reenganchar VMG0000 +reenganchar reenganchar VMN0000 +reenganche reenganchar VMM03S0 +reenganchemos reenganchar VMM01P0 +reenganchen reenganchar VMM03P0 +reengendra reengendrar VMM02S0 +reengendrad reengendrar VMM02P0 +reengendrando reengendrar VMG0000 +reengendrar reengendrar VMN0000 +reengendre reengendrar VMM03S0 +reengendremos reengendrar VMM01P0 +reengendren reengendrar VMM03P0 +reensaya reensayar VMM02S0 +reensayad reensayar VMM02P0 +reensayando reensayar VMG0000 +reensayar reensayar VMN0000 +reensaye reensayar VMM03S0 +reensayemos reensayar VMM01P0 +reensayen reensayar VMM03P0 +reenviad reenviar VMM02P0 +reenviando reenviar VMG0000 +reenviar reenviar VMN0000 +reenvida reenvidar VMM02S0 +reenvidad reenvidar VMM02P0 +reenvidando reenvidar VMG0000 +reenvidar reenvidar VMN0000 +reenvide reenvidar VMM03S0 +reenvidemos reenvidar VMM01P0 +reenviden reenvidar VMM03P0 +reenviemos reenviar VMM01P0 +reenvía reenviar VMM02S0 +reenvíe reenviar VMM03S0 +reenvíen reenviar VMM03P0 +reequilibra reequilibrar VMM02S0 +reequilibrad reequilibrar VMM02P0 +reequilibrando reequilibrar VMG0000 +reequilibrar reequilibrar VMN0000 +reescriba reescribir VMM03S0 +reescribamos reescribir VMM01P0 +reescriban reescribir VMM03P0 +reescribe reescribir VMM02S0 +reescribid reescribir VMM02P0 +reescribiendo reescribir VMG0000 +reescribir reescribir VMN0000 +reestablece reestablecer VMM02S0 +reestableced reestablecer VMM02P0 +reestablecer reestablecer VMN0000 +reestableciendo reestablecer VMG0000 +reestablezca reestablecer VMM03S0 +reestablezcamos reestablecer VMM01P0 +reestablezcan reestablecer VMM03P0 +reestrena reestrenar VMM02S0 +reestrenad reestrenar VMM02P0 +reestrenando reestrenar VMG0000 +reestrenar reestrenar VMN0000 +reestrene reestrenar VMM03S0 +reestrenemos reestrenar VMM01P0 +reestrenen reestrenar VMM03P0 +reestructura reestructurar VMM02S0 +reestructurad reestructurar VMM02P0 +reestructurando reestructurar VMG0000 +reestructurar reestructurar VMN0000 +reestructure reestructurar VMM03S0 +reestructuremos reestructurar VMM01P0 +reestructuren reestructurar VMM03P0 +reexamina reexaminar VMM02S0 +reexaminad reexaminar VMM02P0 +reexaminando reexaminar VMG0000 +reexaminar reexaminar VMN0000 +reexamine reexaminar VMM03S0 +reexaminemos reexaminar VMM01P0 +reexaminen reexaminar VMM03P0 +reexpedid reexpedir VMM02P0 +reexpedir reexpedir VMN0000 +reexpida reexpedir VMM03S0 +reexpidamos reexpedir VMM01P0 +reexpidan reexpedir VMM03P0 +reexpide reexpedir VMM02S0 +reexpidiendo reexpedir VMG0000 +reexporta reexportar VMM02S0 +reexportad reexportar VMM02P0 +reexportando reexportar VMG0000 +reexportar reexportar VMN0000 +reexporte reexportar VMM03S0 +reexportemos reexportar VMM01P0 +reexporten reexportar VMM03P0 +referencia referenciar VMM02S0 +referenciad referenciar VMM02P0 +referenciando referenciar VMG0000 +referenciar referenciar VMN0000 +referencie referenciar VMM03S0 +referenciemos referenciar VMM01P0 +referencien referenciar VMM03P0 +referid referir VMM02P0 +referir referir VMN0000 +refiera referir VMM03S0 +refieran referir VMM03P0 +refiere referir VMM02S0 +refina refinar VMM02S0 +refinad refinar VMM02P0 +refinancia refinanciar VMM02S0 +refinanciad refinanciar VMM02P0 +refinanciando refinanciar VMG0000 +refinanciar refinanciar VMN0000 +refinando refinar VMG0000 +refinar refinar VMN0000 +refine refinar VMM03S0 +refinemos refinar VMM01P0 +refinen refinar VMM03P0 +refiramos referir VMM01P0 +refiriendo referir VMG0000 +reflecta reflectar VMM02S0 +reflectad reflectar VMM02P0 +reflectando reflectar VMG0000 +reflectar reflectar VMN0000 +reflecte reflectar VMM03S0 +reflectemos reflectar VMM01P0 +reflecten reflectar VMM03P0 +refleja reflejar VMM02S0 +reflejad reflejar VMM02P0 +reflejando reflejar VMG0000 +reflejar reflejar VMN0000 +refleje reflejar VMM03S0 +reflejemos reflejar VMM01P0 +reflejen reflejar VMM03P0 +reflexiona reflexionar VMM02S0 +reflexionad reflexionar VMM02P0 +reflexionando reflexionar VMG0000 +reflexionar reflexionar VMN0000 +reflexione reflexionar VMM03S0 +reflexionemos reflexionar VMM01P0 +reflexionen reflexionar VMM03P0 +reflorece reflorecer VMM02S0 +refloreced reflorecer VMM02P0 +reflorecer reflorecer VMN0000 +refloreciendo reflorecer VMG0000 +reflorezca reflorecer VMM03S0 +reflorezcamos reflorecer VMM01P0 +reflorezcan reflorecer VMM03P0 +reflota reflotar VMM02S0 +reflotad reflotar VMM02P0 +reflotando reflotar VMG0000 +reflotar reflotar VMN0000 +reflote reflotar VMM03S0 +reflotemos reflotar VMM01P0 +refloten reflotar VMM03P0 +refluid refluir VMM02P0 +refluir refluir VMN0000 +refluya refluir VMM03S0 +refluyamos refluir VMM01P0 +refluyan refluir VMM03P0 +refluye refluir VMM02S0 +refluyendo refluir VMG0000 +refocila refocilar VMM02S0 +refocilad refocilar VMM02P0 +refocilando refocilar VMG0000 +refocilar refocilar VMN0000 +refocile refocilar VMM03S0 +refocilemos refocilar VMM01P0 +refocilen refocilar VMM03P0 +reforcemos reforzar VMM01P0 +reforma reformar VMM02S0 +reformad reformar VMM02P0 +reformando reformar VMG0000 +reformar reformar VMN0000 +reformatea reformatear VMM02S0 +reformatead reformatear VMM02P0 +reformateando reformatear VMG0000 +reformatear reformatear VMN0000 +reformatee reformatear VMM03S0 +reformateemos reformatear VMM01P0 +reformateen reformatear VMM03P0 +reforme reformar VMM03S0 +reformemos reformar VMM01P0 +reformen reformar VMM03P0 +reforzad reforzar VMM02P0 +reforzando reforzar VMG0000 +reforzar reforzar VMN0000 +refracta refractar VMM02S0 +refractad refractar VMM02P0 +refractando refractar VMG0000 +refractar refractar VMN0000 +refracte refractar VMM03S0 +refractemos refractar VMM01P0 +refracten refractar VMM03P0 +refregad refregar VMM02P0 +refregando refregar VMG0000 +refregar refregar VMN0000 +refreguemos refregar VMM01P0 +refrena refrenar VMM02S0 +refrenad refrenar VMM02P0 +refrenando refrenar VMG0000 +refrenar refrenar VMN0000 +refrenda refrendar VMM02S0 +refrendad refrendar VMM02P0 +refrendando refrendar VMG0000 +refrendar refrendar VMN0000 +refrende refrendar VMM03S0 +refrendemos refrendar VMM01P0 +refrenden refrendar VMM03P0 +refrene refrenar VMM03S0 +refrenemos refrenar VMM01P0 +refrenen refrenar VMM03P0 +refresca refrescar VMM02S0 +refrescad refrescar VMM02P0 +refrescando refrescar VMG0000 +refrescar refrescar VMN0000 +refresque refrescar VMM03S0 +refresquemos refrescar VMM01P0 +refresquen refrescar VMM03P0 +refreíd refreír VMM02P0 +refreír refreír VMN0000 +refriamos refreír VMM01P0 +refriega refregar VMM02S0 +refriegue refregar VMM03S0 +refrieguen refregar VMM03P0 +refriendo refreír VMG0000 +refrigera refrigerar VMM02S0 +refrigerad refrigerar VMM02P0 +refrigerando refrigerar VMG0000 +refrigerar refrigerar VMN0000 +refrigere refrigerar VMM03S0 +refrigeremos refrigerar VMM01P0 +refrigeren refrigerar VMM03P0 +refringe refringir VMM02S0 +refringid refringir VMM02P0 +refringiendo refringir VMG0000 +refringir refringir VMN0000 +refrinja refringir VMM03S0 +refrinjamos refringir VMM01P0 +refrinjan refringir VMM03P0 +refría refreír VMM03S0 +refrían refreír VMM03P0 +refríe refreír VMM02S0 +refuerce reforzar VMM03S0 +refuercen reforzar VMM03P0 +refuerza reforzar VMM02S0 +refugia refugiar VMM02S0 +refugiad refugiar VMM02P0 +refugiando refugiar VMG0000 +refugiar refugiar VMN0000 +refugie refugiar VMM03S0 +refugiemos refugiar VMM01P0 +refugien refugiar VMM03P0 +refulge refulgir VMM02S0 +refulgid refulgir VMM02P0 +refulgiendo refulgir VMG0000 +refulgir refulgir VMN0000 +refulja refulgir VMM03S0 +refuljamos refulgir VMM01P0 +refuljan refulgir VMM03P0 +refunda refundar VMM02S0 +refunda refundir VMM03S0 +refundad refundar VMM02P0 +refundamos refundir VMM01P0 +refundan refundir VMM03P0 +refundando refundar VMG0000 +refundar refundar VMN0000 +refunde refundar VMM03S0 +refunde refundir VMM02S0 +refundemos refundar VMM01P0 +refunden refundar VMM03P0 +refundid refundir VMM02P0 +refundiendo refundir VMG0000 +refundir refundir VMN0000 +refunfuña refunfuñar VMM02S0 +refunfuñad refunfuñar VMM02P0 +refunfuñando refunfuñar VMG0000 +refunfuñar refunfuñar VMN0000 +refunfuñe refunfuñar VMM03S0 +refunfuñemos refunfuñar VMM01P0 +refunfuñen refunfuñar VMM03P0 +refuta refutar VMM02S0 +refutad refutar VMM02P0 +refutando refutar VMG0000 +refutar refutar VMN0000 +refute refutar VMM03S0 +refutemos refutar VMM01P0 +refuten refutar VMM03P0 +regad regar VMM02P0 +regala regalar VMM02S0 +regalad regalar VMM02P0 +regalando regalar VMG0000 +regalar regalar VMN0000 +regale regalar VMM03S0 +regalemos regalar VMM01P0 +regalen regalar VMM03P0 +regando regar VMG0000 +regar regar VMN0000 +regatea regatear VMM02S0 +regatead regatear VMM02P0 +regateando regatear VMG0000 +regatear regatear VMN0000 +regatee regatear VMM03S0 +regateemos regatear VMM01P0 +regateen regatear VMM03P0 +regaña regañar VMM02S0 +regañad regañar VMM02P0 +regañando regañar VMG0000 +regañar regañar VMN0000 +regañe regañar VMM03S0 +regañemos regañar VMM01P0 +regañen regañar VMM03P0 +regenera regenerar VMM02S0 +regenerad regenerar VMM02P0 +regenerando regenerar VMG0000 +regenerar regenerar VMN0000 +regenere regenerar VMM03S0 +regeneremos regenerar VMM01P0 +regeneren regenerar VMM03P0 +regenta regentar VMM02S0 +regentad regentar VMM02P0 +regentando regentar VMG0000 +regentar regentar VMN0000 +regente regentar VMM03S0 +regentea regentear VMM02S0 +regentead regentear VMM02P0 +regenteando regentear VMG0000 +regentear regentear VMN0000 +regentee regentear VMM03S0 +regenteemos regentear VMM01P0 +regenteen regentear VMM03P0 +regentemos regentar VMM01P0 +regenten regentar VMM03P0 +regid regir VMM02P0 +regimentad regimentar VMM02P0 +regimentando regimentar VMG0000 +regimentar regimentar VMN0000 +regimentemos regimentar VMM01P0 +regimienta regimentar VMM02S0 +regimiente regimentar VMM03S0 +regimienten regimentar VMM03P0 +regionalice regionalizar VMM03S0 +regionalicemos regionalizar VMM01P0 +regionalicen regionalizar VMM03P0 +regionaliza regionalizar VMM02S0 +regionalizad regionalizar VMM02P0 +regionalizando regionalizar VMG0000 +regionalizar regionalizar VMN0000 +regir regir VMN0000 +registra registrar VMM02S0 +registrad registrar VMM02P0 +registrando registrar VMG0000 +registrar registrar VMN0000 +registre registrar VMM03S0 +registremos registrar VMM01P0 +registren registrar VMM03P0 +regla reglar VMM02S0 +reglad reglar VMM02P0 +reglamenta reglamentar VMM02S0 +reglamentad reglamentar VMM02P0 +reglamentando reglamentar VMG0000 +reglamentar reglamentar VMN0000 +reglamente reglamentar VMM03S0 +reglamentemos reglamentar VMM01P0 +reglamenten reglamentar VMM03P0 +reglando reglar VMG0000 +reglar reglar VMN0000 +regle reglar VMM03S0 +reglemos reglar VMM01P0 +reglen reglar VMM03P0 +regletea regletear VMM02S0 +regletead regletear VMM02P0 +regleteando regletear VMG0000 +regletear regletear VMN0000 +regletee regletear VMM03S0 +regleteemos regletear VMM01P0 +regleteen regletear VMM03P0 +regocija regocijar VMM02S0 +regocijad regocijar VMM02P0 +regocijando regocijar VMG0000 +regocijar regocijar VMN0000 +regocije regocijar VMM03S0 +regocijemos regocijar VMM01P0 +regocijen regocijar VMM03P0 +regodea regodear VMM02S0 +regodead regodear VMM02P0 +regodeando regodear VMG0000 +regodear regodear VMN0000 +regodee regodear VMM03S0 +regodeemos regodear VMM01P0 +regodeen regodear VMM03P0 +regoldad regoldar VMM02P0 +regoldando regoldar VMG0000 +regoldar regoldar VMN0000 +regoldemos regoldar VMM01P0 +regresa regresar VMM02S0 +regresad regresar VMM02P0 +regresando regresar VMG0000 +regresar regresar VMN0000 +regrese regresar VMM03S0 +regresemos regresar VMM01P0 +regresen regresar VMM03P0 +regruña regruñir VMM03S0 +regruñamos regruñir VMM01P0 +regruñan regruñir VMM03P0 +regruñe regruñir VMM02S0 +regruñendo regruñir VMG0000 +regruñid regruñir VMM02P0 +regruñir regruñir VMN0000 +reguelda regoldar VMM02S0 +reguelde regoldar VMM03S0 +reguelden regoldar VMM03P0 +reguemos regar VMM01P0 +regula regular VMM02S0 +regulad regular VMM02P0 +regulando regular VMG0000 +regular regular VMN0000 +regularice regularizar VMM03S0 +regularicemos regularizar VMM01P0 +regularicen regularizar VMM03P0 +regulariza regularizar VMM02S0 +regularizad regularizar VMM02P0 +regularizando regularizar VMG0000 +regularizar regularizar VMN0000 +regule regular VMM03S0 +regulemos regular VMM01P0 +regulen regular VMM03P0 +regurgita regurgitar VMM02S0 +regurgitad regurgitar VMM02P0 +regurgitando regurgitar VMG0000 +regurgitar regurgitar VMN0000 +regurgite regurgitar VMM03S0 +regurgitemos regurgitar VMM01P0 +regurgiten regurgitar VMM03P0 +rehabilita rehabilitar VMM02S0 +rehabilitad rehabilitar VMM02P0 +rehabilitando rehabilitar VMG0000 +rehabilitar rehabilitar VMN0000 +rehabilite rehabilitar VMM03S0 +rehabilitemos rehabilitar VMM01P0 +rehabiliten rehabilitar VMM03P0 +rehaced rehacer VMM02P0 +rehacer rehacer VMN0000 +rehaciendo rehacer VMG0000 +rehaga rehacer VMM03S0 +rehagamos rehacer VMM01P0 +rehagan rehacer VMM03P0 +rehaz rehacer VMM02S0 +rehenchid rehenchir VMM02P0 +rehenchir rehenchir VMN0000 +rehervid rehervir VMM02P0 +rehervir rehervir VMN0000 +rehierva rehervir VMM03S0 +rehiervan rehervir VMM03P0 +rehierve rehervir VMM02S0 +rehilad rehilar VMM02P0 +rehilando rehilar VMG0000 +rehilar rehilar VMN0000 +rehilemos rehilar VMM01P0 +rehincha rehenchir VMM03S0 +rehinchamos rehenchir VMM01P0 +rehinchan rehenchir VMM03P0 +rehinche rehenchir VMM02S0 +rehinchiendo rehenchir VMG0000 +rehirvamos rehervir VMM01P0 +rehirviendo rehervir VMG0000 +rehoga rehogar VMM02S0 +rehogad rehogar VMM02P0 +rehogando rehogar VMG0000 +rehogar rehogar VMN0000 +rehogue rehogar VMM03S0 +rehoguemos rehogar VMM01P0 +rehoguen rehogar VMM03P0 +rehollad rehollar VMM02P0 +rehollando rehollar VMG0000 +rehollar rehollar VMN0000 +rehollemos rehollar VMM01P0 +rehuella rehollar VMM02S0 +rehuelle rehollar VMM03S0 +rehuellen rehollar VMM03P0 +rehuid rehuir VMM02P0 +rehuir rehuir VMN0000 +rehumedece rehumedecer VMM02S0 +rehumedeced rehumedecer VMM02P0 +rehumedecer rehumedecer VMN0000 +rehumedeciendo rehumedecer VMG0000 +rehumedezca rehumedecer VMM03S0 +rehumedezcamos rehumedecer VMM01P0 +rehumedezcan rehumedecer VMM03P0 +rehunda rehundir VMM03S0 +rehundamos rehundir VMM01P0 +rehundan rehundir VMM03P0 +rehunde rehundir VMM02S0 +rehundid rehundir VMM02P0 +rehundiendo rehundir VMG0000 +rehundir rehundir VMN0000 +rehusad rehusar VMM02P0 +rehusando rehusar VMG0000 +rehusar rehusar VMN0000 +rehusemos rehusar VMM01P0 +rehuya rehuir VMM03S0 +rehuyamos rehuir VMM01P0 +rehuyan rehuir VMM03P0 +rehuye rehuir VMM02S0 +rehuyendo rehuir VMG0000 +rehíla rehilar VMM02S0 +rehíle rehilar VMM03S0 +rehílen rehilar VMM03P0 +rehúsa rehusar VMM02S0 +rehúse rehusar VMM03S0 +rehúsen rehusar VMM03P0 +reimporta reimportar VMM02S0 +reimportad reimportar VMM02P0 +reimportando reimportar VMG0000 +reimportar reimportar VMN0000 +reimporte reimportar VMM03S0 +reimportemos reimportar VMM01P0 +reimporten reimportar VMM03P0 +reimprima reimprimir VMM03S0 +reimprimamos reimprimir VMM01P0 +reimpriman reimprimir VMM03P0 +reimprime reimprimir VMM02S0 +reimprimid reimprimir VMM02P0 +reimprimiendo reimprimir VMG0000 +reimprimir reimprimir VMN0000 +reina reinar VMM02S0 +reinad reinar VMM02P0 +reinando reinar VMG0000 +reinar reinar VMN0000 +reincida reincidir VMM03S0 +reincidamos reincidir VMM01P0 +reincidan reincidir VMM03P0 +reincide reincidir VMM02S0 +reincidid reincidir VMM02P0 +reincidiendo reincidir VMG0000 +reincidir reincidir VMN0000 +reincorpora reincorporar VMM02S0 +reincorporad reincorporar VMM02P0 +reincorporando reincorporar VMG0000 +reincorporar reincorporar VMN0000 +reincorpore reincorporar VMM03S0 +reincorporemos reincorporar VMM01P0 +reincorporen reincorporar VMM03P0 +reine reinar VMM03S0 +reinemos reinar VMM01P0 +reinen reinar VMM03P0 +reingresa reingresar VMM02S0 +reingresad reingresar VMM02P0 +reingresando reingresar VMG0000 +reingresar reingresar VMN0000 +reingrese reingresar VMM03S0 +reingresemos reingresar VMM01P0 +reingresen reingresar VMM03P0 +reinserta reinsertar VMM02S0 +reinsertad reinsertar VMM02P0 +reinsertando reinsertar VMG0000 +reinsertar reinsertar VMN0000 +reinserte reinsertar VMM03S0 +reinsertemos reinsertar VMM01P0 +reinserten reinsertar VMM03P0 +reinstala reinstalar VMM02S0 +reinstalad reinstalar VMM02P0 +reinstalando reinstalar VMG0000 +reinstalar reinstalar VMN0000 +reinstale reinstalar VMM03S0 +reinstalemos reinstalar VMM01P0 +reinstalen reinstalar VMM03P0 +reinstaura reinstaurar VMM02S0 +reinstaurad reinstaurar VMM02P0 +reinstaurando reinstaurar VMG0000 +reinstaurar reinstaurar VMN0000 +reinstaure reinstaurar VMM03S0 +reinstauremos reinstaurar VMM01P0 +reinstauren reinstaurar VMM03P0 +reintegra reintegrar VMM02S0 +reintegrad reintegrar VMM02P0 +reintegrando reintegrar VMG0000 +reintegrar reintegrar VMN0000 +reintegre reintegrar VMM03S0 +reintegremos reintegrar VMM01P0 +reintegren reintegrar VMM03P0 +reinventa reinventar VMM02S0 +reinventad reinventar VMM02P0 +reinventando reinventar VMG0000 +reinventar reinventar VMN0000 +reinvente reinventar VMM03S0 +reinventemos reinventar VMM01P0 +reinventen reinventar VMM03P0 +reitera reiterar VMM02S0 +reiterad reiterar VMM02P0 +reiterando reiterar VMG0000 +reiterar reiterar VMN0000 +reitere reiterar VMM03S0 +reiteremos reiterar VMM01P0 +reiteren reiterar VMM03P0 +reivindica reivindicar VMM02S0 +reivindicad reivindicar VMM02P0 +reivindicando reivindicar VMG0000 +reivindicar reivindicar VMN0000 +reivindique reivindicar VMM03S0 +reivindiquemos reivindicar VMM01P0 +reivindiquen reivindicar VMM03P0 +rejaca rejacar VMM02S0 +rejacad rejacar VMM02P0 +rejacando rejacar VMG0000 +rejacar rejacar VMN0000 +rejaque rejacar VMM03S0 +rejaquemos rejacar VMM01P0 +rejaquen rejacar VMM03P0 +rejonea rejonear VMM02S0 +rejonead rejonear VMM02P0 +rejoneando rejonear VMG0000 +rejonear rejonear VMN0000 +rejonee rejonear VMM03S0 +rejoneemos rejonear VMM01P0 +rejoneen rejonear VMM03P0 +rejunta rejuntar VMM02S0 +rejuntad rejuntar VMM02P0 +rejuntando rejuntar VMG0000 +rejuntar rejuntar VMN0000 +rejunte rejuntar VMM03S0 +rejuntemos rejuntar VMM01P0 +rejunten rejuntar VMM03P0 +rejuvenece rejuvenecer VMM02S0 +rejuveneced rejuvenecer VMM02P0 +rejuvenecer rejuvenecer VMN0000 +rejuveneciendo rejuvenecer VMG0000 +rejuvenezca rejuvenecer VMM03S0 +rejuvenezcamos rejuvenecer VMM01P0 +rejuvenezcan rejuvenecer VMM03P0 +relaciona relacionar VMM02S0 +relacionad relacionar VMM02P0 +relacionando relacionar VMG0000 +relacionar relacionar VMN0000 +relacione relacionar VMM03S0 +relacionemos relacionar VMM01P0 +relacionen relacionar VMM03P0 +relaja relajar VMM02S0 +relajad relajar VMM02P0 +relajando relajar VMG0000 +relajar relajar VMN0000 +relaje relajar VMM03S0 +relajemos relajar VMM01P0 +relajen relajar VMM03P0 +relama relamer VMM03S0 +relamamos relamer VMM01P0 +relaman relamer VMM03P0 +relame relamer VMM02S0 +relamed relamer VMM02P0 +relamer relamer VMN0000 +relamiendo relamer VMG0000 +relampaguea relampaguear VMM02S0 +relampaguead relampaguear VMM02P0 +relampagueando relampaguear VMG0000 +relampaguear relampaguear VMN0000 +relampaguee relampaguear VMM03S0 +relampagueemos relampaguear VMM01P0 +relampagueen relampaguear VMM03P0 +relance relanzar VMM03S0 +relancemos relanzar VMM01P0 +relancen relanzar VMM03P0 +relanza relanzar VMM02S0 +relanzad relanzar VMM02P0 +relanzando relanzar VMG0000 +relanzar relanzar VMN0000 +relata relatar VMM02S0 +relatad relatar VMM02P0 +relatando relatar VMG0000 +relatar relatar VMN0000 +relate relatar VMM03S0 +relatemos relatar VMM01P0 +relaten relatar VMM03P0 +relativice relativizar VMM03S0 +relativicemos relativizar VMM01P0 +relativicen relativizar VMM03P0 +relativiza relativizar VMM02S0 +relativizad relativizar VMM02P0 +relativizando relativizar VMG0000 +relativizar relativizar VMN0000 +relea releer VMM03S0 +releamos releer VMM01P0 +relean releer VMM03P0 +relee releer VMM02S0 +releed releer VMM02P0 +releer releer VMN0000 +relega relegar VMM02S0 +relegad relegar VMM02P0 +relegando relegar VMG0000 +relegar relegar VMN0000 +relegue relegar VMM03S0 +releguemos relegar VMM01P0 +releguen relegar VMM03P0 +releva relevar VMM02S0 +relevad relevar VMM02P0 +relevando relevar VMG0000 +relevar relevar VMN0000 +releve relevar VMM03S0 +relevemos relevar VMM01P0 +releven relevar VMM03P0 +releyendo releer VMG0000 +religa religar VMM02S0 +religad religar VMM02P0 +religando religar VMG0000 +religar religar VMN0000 +religue religar VMM03S0 +religuemos religar VMM01P0 +religuen religar VMM03P0 +relincha relinchar VMM02S0 +relinchad relinchar VMM02P0 +relinchando relinchar VMG0000 +relinchar relinchar VMN0000 +relinche relinchar VMM03S0 +relinchemos relinchar VMM01P0 +relinchen relinchar VMM03P0 +relinga relingar VMM02S0 +relingad relingar VMM02P0 +relingando relingar VMG0000 +relingar relingar VMN0000 +relingue relingar VMM03S0 +relinguemos relingar VMM01P0 +relinguen relingar VMM03P0 +rellana rellanar VMM02S0 +rellanad rellanar VMM02P0 +rellanando rellanar VMG0000 +rellanar rellanar VMN0000 +rellane rellanar VMM03S0 +rellanemos rellanar VMM01P0 +rellanen rellanar VMM03P0 +rellena rellenar VMM02S0 +rellenad rellenar VMM02P0 +rellenando rellenar VMG0000 +rellenar rellenar VMN0000 +rellene rellenar VMM03S0 +rellenemos rellenar VMM01P0 +rellenen rellenar VMM03P0 +reluce relucir VMM02S0 +relucid relucir VMM02P0 +reluciendo relucir VMG0000 +relucir relucir VMN0000 +relumbra relumbrar VMM02S0 +relumbrad relumbrar VMM02P0 +relumbrando relumbrar VMG0000 +relumbrar relumbrar VMN0000 +relumbre relumbrar VMM03S0 +relumbremos relumbrar VMM01P0 +relumbren relumbrar VMM03P0 +reluzca relucir VMM03S0 +reluzcamos relucir VMM01P0 +reluzcan relucir VMM03P0 +rema remar VMM02S0 +remacha remachar VMM02S0 +remachad remachar VMM02P0 +remachando remachar VMG0000 +remachar remachar VMN0000 +remache remachar VMM03S0 +remachemos remachar VMM01P0 +remachen remachar VMM03P0 +remad remar VMM02P0 +remalla remallar VMM02S0 +remallad remallar VMM02P0 +remallando remallar VMG0000 +remallar remallar VMN0000 +remalle remallar VMM03S0 +remallemos remallar VMM01P0 +remallen remallar VMM03P0 +remando remar VMG0000 +remanga remangar VMM02S0 +remangad remangar VMM02P0 +remangando remangar VMG0000 +remangar remangar VMN0000 +remangue remangar VMM03S0 +remanguemos remangar VMM01P0 +remanguen remangar VMM03P0 +remansa remansar VMM02S0 +remansad remansar VMM02P0 +remansando remansar VMG0000 +remansar remansar VMN0000 +remanse remansar VMM03S0 +remansemos remansar VMM01P0 +remansen remansar VMM03P0 +remar remar VMN0000 +remarca remarcar VMM02S0 +remarcad remarcar VMM02P0 +remarcando remarcar VMG0000 +remarcar remarcar VMN0000 +remarque remarcar VMM03S0 +remarquemos remarcar VMM01P0 +remarquen remarcar VMM03P0 +remata rematar VMM02S0 +rematad rematar VMM02P0 +rematando rematar VMG0000 +rematar rematar VMN0000 +remate rematar VMM03S0 +rematemos rematar VMM01P0 +rematen rematar VMM03P0 +rembolsa rembolsar VMM02S0 +rembolsad rembolsar VMM02P0 +rembolsando rembolsar VMG0000 +rembolsar rembolsar VMN0000 +rembolse rembolsar VMM03S0 +rembolsemos rembolsar VMM01P0 +rembolsen rembolsar VMM03P0 +reme remar VMM03S0 +remece remecer VMM02S0 +remeced remecer VMM02P0 +remecer remecer VMN0000 +remeciendo remecer VMG0000 +remeda remedar VMM02S0 +remedad remedar VMM02P0 +remedando remedar VMG0000 +remedar remedar VMN0000 +remede remedar VMM03S0 +remedemos remedar VMM01P0 +remeden remedar VMM03P0 +remedia remediar VMM02S0 +remediad remediar VMM02P0 +remediando remediar VMG0000 +remediar remediar VMN0000 +remedid remedir VMM02P0 +remedie remediar VMM03S0 +remediemos remediar VMM01P0 +remedien remediar VMM03P0 +remedir remedir VMN0000 +remella remellar VMM02S0 +remellad remellar VMM02P0 +remellando remellar VMG0000 +remellar remellar VMN0000 +remelle remellar VMM03S0 +remellemos remellar VMM01P0 +remellen remellar VMM03P0 +rememora rememorar VMM02S0 +rememorad rememorar VMM02P0 +rememorando rememorar VMG0000 +rememorar rememorar VMN0000 +rememore rememorar VMM03S0 +rememoremos rememorar VMM01P0 +rememoren rememorar VMM03P0 +rememos remar VMM01P0 +remen remar VMM03P0 +remendad remendar VMM02P0 +remendando remendar VMG0000 +remendar remendar VMN0000 +remendemos remendar VMM01P0 +remesa remesar VMM02S0 +remesad remesar VMM02P0 +remesando remesar VMG0000 +remesar remesar VMN0000 +remese remesar VMM03S0 +remesemos remesar VMM01P0 +remesen remesar VMM03P0 +remeta remeter VMM03S0 +remetamos remeter VMM01P0 +remetan remeter VMM03P0 +remete remeter VMM02S0 +remeted remeter VMM02P0 +remeter remeter VMN0000 +remetiendo remeter VMG0000 +remeza remecer VMM03S0 +remezamos remecer VMM01P0 +remezan remecer VMM03P0 +remida remedir VMM03S0 +remidamos remedir VMM01P0 +remidan remedir VMM03P0 +remide remedir VMM02S0 +remidiendo remedir VMG0000 +remienda remendar VMM02S0 +remiende remendar VMM03S0 +remienden remendar VMM03P0 +remilga remilgar VMM02S0 +remilgad remilgar VMM02P0 +remilgando remilgar VMG0000 +remilgar remilgar VMN0000 +remilgue remilgar VMM03S0 +remilguemos remilgar VMM01P0 +remilguen remilgar VMM03P0 +remira remirar VMM02S0 +remirad remirar VMM02P0 +remirando remirar VMG0000 +remirar remirar VMN0000 +remire remirar VMM03S0 +remiremos remirar VMM01P0 +remiren remirar VMM03P0 +remita remitir VMM03S0 +remitamos remitir VMM01P0 +remitan remitir VMM03P0 +remite remitir VMM02S0 +remitid remitir VMM02P0 +remitiendo remitir VMG0000 +remitir remitir VMN0000 +remoce remozar VMM03S0 +remocemos remozar VMM01P0 +remocen remozar VMM03P0 +remodela remodelar VMM02S0 +remodelad remodelar VMM02P0 +remodelando remodelar VMG0000 +remodelar remodelar VMN0000 +remodele remodelar VMM03S0 +remodelemos remodelar VMM01P0 +remodelen remodelar VMM03P0 +remoja remojar VMM02S0 +remojad remojar VMM02P0 +remojando remojar VMG0000 +remojar remojar VMN0000 +remoje remojar VMM03S0 +remojemos remojar VMM01P0 +remojen remojar VMM03P0 +remolamos remoler VMM01P0 +remolca remolcar VMM02S0 +remolcad remolcar VMM02P0 +remolcando remolcar VMG0000 +remolcar remolcar VMN0000 +remoled remoler VMM02P0 +remoler remoler VMN0000 +remoliendo remoler VMG0000 +remolina remolinar VMM02S0 +remolinad remolinar VMM02P0 +remolinando remolinar VMG0000 +remolinar remolinar VMN0000 +remoline remolinar VMM03S0 +remolinea remolinear VMM02S0 +remolinead remolinear VMM02P0 +remolineando remolinear VMG0000 +remolinear remolinear VMN0000 +remolinee remolinear VMM03S0 +remolineemos remolinear VMM01P0 +remolineen remolinear VMM03P0 +remolinemos remolinar VMM01P0 +remolinen remolinar VMM03P0 +remolonea remolonear VMM02S0 +remolonead remolonear VMM02P0 +remoloneando remolonear VMG0000 +remolonear remolonear VMN0000 +remolonee remolonear VMM03S0 +remoloneemos remolonear VMM01P0 +remoloneen remolonear VMM03P0 +remolque remolcar VMM03S0 +remolquemos remolcar VMM01P0 +remolquen remolcar VMM03P0 +remonta remontar VMM02S0 +remontad remontar VMM02P0 +remontando remontar VMG0000 +remontar remontar VMN0000 +remonte remontar VMM03S0 +remontemos remontar VMM01P0 +remonten remontar VMM03P0 +remordamos remorder VMM01P0 +remorded remorder VMM02P0 +remorder remorder VMN0000 +remordiendo remorder VMG0000 +remosquea remosquear VMM02S0 +remosquead remosquear VMM02P0 +remosqueando remosquear VMG0000 +remosquear remosquear VMN0000 +remosquee remosquear VMM03S0 +remosqueemos remosquear VMM01P0 +remosqueen remosquear VMM03P0 +remosta remostar VMM02S0 +remostad remostar VMM02P0 +remostando remostar VMG0000 +remostar remostar VMN0000 +remoste remostar VMM03S0 +remostemos remostar VMM01P0 +remosten remostar VMM03P0 +removamos remover VMM01P0 +removed remover VMM02P0 +remover remover VMN0000 +removiendo remover VMG0000 +remoza remozar VMM02S0 +remozad remozar VMM02P0 +remozando remozar VMG0000 +remozar remozar VMN0000 +remplace remplazar VMM03S0 +remplacemos remplazar VMM01P0 +remplacen remplazar VMM03P0 +remplaza remplazar VMM02S0 +remplazad remplazar VMM02P0 +remplazando remplazar VMG0000 +remplazar remplazar VMN0000 +rempuja rempujar VMM02S0 +rempujad rempujar VMM02P0 +rempujando rempujar VMG0000 +rempujar rempujar VMN0000 +rempuje rempujar VMM03S0 +rempujemos rempujar VMM01P0 +rempujen rempujar VMM03P0 +remuda remudar VMM02S0 +remudad remudar VMM02P0 +remudando remudar VMG0000 +remudar remudar VMN0000 +remude remudar VMM03S0 +remudemos remudar VMM01P0 +remuden remudar VMM03P0 +remuela remoler VMM03S0 +remuelan remoler VMM03P0 +remuele remoler VMM02S0 +remuerda remorder VMM03S0 +remuerdan remorder VMM03P0 +remuerde remorder VMM02S0 +remueva remover VMM03S0 +remuevan remover VMM03P0 +remueve remover VMM02S0 +remulla remullir VMM03S0 +remullamos remullir VMM01P0 +remullan remullir VMM03P0 +remulle remullir VMM02S0 +remullendo remullir VMG0000 +remullid remullir VMM02P0 +remullir remullir VMN0000 +remunera remunerar VMM02S0 +remunerad remunerar VMM02P0 +remunerando remunerar VMG0000 +remunerar remunerar VMN0000 +remunere remunerar VMM03S0 +remuneremos remunerar VMM01P0 +remuneren remunerar VMM03P0 +remusga remusgar VMM02S0 +remusgad remusgar VMM02P0 +remusgando remusgar VMG0000 +remusgar remusgar VMN0000 +remusgue remusgar VMM03S0 +remusguemos remusgar VMM01P0 +remusguen remusgar VMM03P0 +renace renacer VMM02S0 +renaced renacer VMM02P0 +renacer renacer VMN0000 +renaciendo renacer VMG0000 +renazca renacer VMM03S0 +renazcamos renacer VMM01P0 +renazcan renacer VMM03P0 +rendid rendir VMM02P0 +rendir rendir VMN0000 +renegad renegar VMM02P0 +renegando renegar VMG0000 +renegar renegar VMN0000 +renegocia renegociar VMM02S0 +renegociad renegociar VMM02P0 +renegociando renegociar VMG0000 +renegociar renegociar VMN0000 +renegocie renegociar VMM03S0 +renegociemos renegociar VMM01P0 +renegocien renegociar VMM03P0 +reneguemos renegar VMM01P0 +renguea renguear VMM02S0 +renguead renguear VMM02P0 +rengueando renguear VMG0000 +renguear renguear VMN0000 +renguee renguear VMM03S0 +rengueemos renguear VMM01P0 +rengueen renguear VMM03P0 +reniega renegar VMM02S0 +reniegue renegar VMM03S0 +renieguen renegar VMM03P0 +renovad renovar VMM02P0 +renovando renovar VMG0000 +renovar renovar VMN0000 +renovemos renovar VMM01P0 +renquea renquear VMM02S0 +renquead renquear VMM02P0 +renqueando renquear VMG0000 +renquear renquear VMN0000 +renquee renquear VMM03S0 +renqueemos renquear VMM01P0 +renqueen renquear VMM03P0 +renta rentar VMM02S0 +rentabilice rentabilizar VMM03S0 +rentabilicemos rentabilizar VMM01P0 +rentabilicen rentabilizar VMM03P0 +rentabiliza rentabilizar VMM02S0 +rentabilizad rentabilizar VMM02P0 +rentabilizando rentabilizar VMG0000 +rentabilizar rentabilizar VMN0000 +rentad rentar VMM02P0 +rentando rentar VMG0000 +rentar rentar VMN0000 +rente rentar VMM03S0 +rentemos rentar VMM01P0 +renten rentar VMM03P0 +renueva renovar VMM02S0 +renueve renovar VMM03S0 +renueven renovar VMM03P0 +renuncia renunciar VMM02S0 +renunciad renunciar VMM02P0 +renunciando renunciar VMG0000 +renunciar renunciar VMN0000 +renuncie renunciar VMM03S0 +renunciemos renunciar VMM01P0 +renuncien renunciar VMM03P0 +renvalsa renvalsar VMM02S0 +renvalsad renvalsar VMM02P0 +renvalsando renvalsar VMG0000 +renvalsar renvalsar VMN0000 +renvalse renvalsar VMM03S0 +renvalsemos renvalsar VMM01P0 +renvalsen renvalsar VMM03P0 +reordena reordenar VMM02S0 +reordenad reordenar VMM02P0 +reordenando reordenar VMG0000 +reordenar reordenar VMN0000 +reordene reordenar VMM03S0 +reordenemos reordenar VMM01P0 +reordenen reordenar VMM03P0 +reorganice reorganizar VMM03S0 +reorganicemos reorganizar VMM01P0 +reorganicen reorganizar VMM03P0 +reorganiza reorganizar VMM02S0 +reorganizad reorganizar VMM02P0 +reorganizando reorganizar VMG0000 +reorganizar reorganizar VMN0000 +reorienta reorientar VMM02S0 +reorientad reorientar VMM02P0 +reorientando reorientar VMG0000 +reorientar reorientar VMN0000 +reoriente reorientar VMM03S0 +reorientemos reorientar VMM01P0 +reorienten reorientar VMM03P0 +repanchiga repanchigar VMM02S0 +repanchigad repanchigar VMM02P0 +repanchigando repanchigar VMG0000 +repanchigar repanchigar VMN0000 +repanchigue repanchigar VMM03S0 +repanchiguemos repanchigar VMM01P0 +repanchiguen repanchigar VMM03P0 +repantiga repantigar VMM02S0 +repantigad repantigar VMM02P0 +repantigando repantigar VMG0000 +repantigar repantigar VMN0000 +repantigue repantigar VMM03S0 +repantiguemos repantigar VMM01P0 +repantiguen repantigar VMM03P0 +repara reparar VMM02S0 +reparad reparar VMM02P0 +reparando reparar VMG0000 +reparar reparar VMN0000 +repare reparar VMM03S0 +reparemos reparar VMM01P0 +reparen reparar VMM03P0 +reparta repartir VMM03S0 +repartamos repartir VMM01P0 +repartan repartir VMM03P0 +reparte repartir VMM02S0 +repartid repartir VMM02P0 +repartiendo repartir VMG0000 +repartir repartir VMN0000 +repasa repasar VMM02S0 +repasad repasar VMM02P0 +repasando repasar VMG0000 +repasar repasar VMN0000 +repase repasar VMM03S0 +repasemos repasar VMM01P0 +repasen repasar VMM03P0 +repasta repastar VMM02S0 +repastad repastar VMM02P0 +repastando repastar VMG0000 +repastar repastar VMN0000 +repaste repastar VMM03S0 +repastemos repastar VMM01P0 +repasten repastar VMM03P0 +repatriad repatriar VMM02P0 +repatriando repatriar VMG0000 +repatriar repatriar VMN0000 +repatriemos repatriar VMM01P0 +repatría repatriar VMM02S0 +repatríe repatriar VMM03S0 +repatríen repatriar VMM03P0 +repecha repechar VMM02S0 +repechad repechar VMM02P0 +repechando repechar VMG0000 +repechar repechar VMN0000 +repeche repechar VMM03S0 +repechemos repechar VMM01P0 +repechen repechar VMM03P0 +repeina repeinar VMM02S0 +repeinad repeinar VMM02P0 +repeinando repeinar VMG0000 +repeinar repeinar VMN0000 +repeine repeinar VMM03S0 +repeinemos repeinar VMM01P0 +repeinen repeinar VMM03P0 +repela repelar VMM02S0 +repela repeler VMM03S0 +repelad repelar VMM02P0 +repelamos repeler VMM01P0 +repelan repeler VMM03P0 +repelando repelar VMG0000 +repelar repelar VMN0000 +repele repelar VMM03S0 +repele repeler VMM02S0 +repeled repeler VMM02P0 +repelemos repelar VMM01P0 +repelen repelar VMM03P0 +repeler repeler VMN0000 +repeliendo repeler VMG0000 +repella repellar VMM02S0 +repellad repellar VMM02P0 +repellando repellar VMG0000 +repellar repellar VMN0000 +repelle repellar VMM03S0 +repellemos repellar VMM01P0 +repellen repellar VMM03P0 +repensad repensar VMM02P0 +repensando repensar VMG0000 +repensar repensar VMN0000 +repensemos repensar VMM01P0 +repentice repentizar VMM03S0 +repenticemos repentizar VMM01P0 +repenticen repentizar VMM03P0 +repentiza repentizar VMM02S0 +repentizad repentizar VMM02P0 +repentizando repentizar VMG0000 +repentizar repentizar VMN0000 +repercuta repercutir VMM03S0 +repercutamos repercutir VMM01P0 +repercutan repercutir VMM03P0 +repercute repercutir VMM02S0 +repercutid repercutir VMM02P0 +repercutiendo repercutir VMG0000 +repercutir repercutir VMN0000 +repesa repesar VMM02S0 +repesad repesar VMM02P0 +repesando repesar VMG0000 +repesar repesar VMN0000 +repesca repescar VMM02S0 +repescad repescar VMM02P0 +repescando repescar VMG0000 +repescar repescar VMN0000 +repese repesar VMM03S0 +repesemos repesar VMM01P0 +repesen repesar VMM03P0 +repesque repescar VMM03S0 +repesquemos repescar VMM01P0 +repesquen repescar VMM03P0 +repetid repetir VMM02P0 +repetir repetir VMN0000 +repica repicar VMM02S0 +repicad repicar VMM02P0 +repicando repicar VMG0000 +repicar repicar VMN0000 +repiensa repensar VMM02S0 +repiense repensar VMM03S0 +repiensen repensar VMM03P0 +repinta repintar VMM02S0 +repintad repintar VMM02P0 +repintando repintar VMG0000 +repintar repintar VMN0000 +repinte repintar VMM03S0 +repintemos repintar VMM01P0 +repinten repintar VMM03P0 +repique repicar VMM03S0 +repiquemos repicar VMM01P0 +repiquen repicar VMM03P0 +repiquetea repiquetear VMM02S0 +repiquetead repiquetear VMM02P0 +repiqueteando repiquetear VMG0000 +repiquetear repiquetear VMN0000 +repiquetee repiquetear VMM03S0 +repiqueteemos repiquetear VMM01P0 +repiqueteen repiquetear VMM03P0 +repita repetir VMM03S0 +repitamos repetir VMM01P0 +repitan repetir VMM03P0 +repite repetir VMM02S0 +repitiendo repetir VMG0000 +replanta replantar VMM02S0 +replantad replantar VMM02P0 +replantando replantar VMG0000 +replantar replantar VMN0000 +replante replantar VMM03S0 +replantea replantear VMM02S0 +replantead replantear VMM02P0 +replanteando replantear VMG0000 +replantear replantear VMN0000 +replantee replantear VMM03S0 +replanteemos replantear VMM01P0 +replanteen replantear VMM03P0 +replantemos replantar VMM01P0 +replanten replantar VMM03P0 +replegad replegar VMM02P0 +replegando replegar VMG0000 +replegar replegar VMN0000 +repleguemos replegar VMM01P0 +replica replicar VMM02S0 +replicad replicar VMM02P0 +replicando replicar VMG0000 +replicar replicar VMN0000 +repliega replegar VMM02S0 +repliegue replegar VMM03S0 +replieguen replegar VMM03P0 +replique replicar VMM03S0 +repliquemos replicar VMM01P0 +repliquen replicar VMM03P0 +repoblad repoblar VMM02P0 +repoblando repoblar VMG0000 +repoblar repoblar VMN0000 +repoblemos repoblar VMM01P0 +repoda repodar VMM02S0 +repodad repodar VMM02P0 +repodando repodar VMG0000 +repodar repodar VMN0000 +repode repodar VMM03S0 +repodemos repodar VMM01P0 +repoden repodar VMM03P0 +repolla repollar VMM02S0 +repollad repollar VMM02P0 +repollando repollar VMG0000 +repollar repollar VMN0000 +repolle repollar VMM03S0 +repollemos repollar VMM01P0 +repollen repollar VMM03P0 +reponed reponer VMM02P0 +reponer reponer VMN0000 +reponga reponer VMM03S0 +repongamos reponer VMM01P0 +repongan reponer VMM03P0 +reponiendo reponer VMG0000 +reporta reportar VMM02S0 +reportad reportar VMM02P0 +reportando reportar VMG0000 +reportar reportar VMN0000 +reporte reportar VMM03S0 +reportemos reportar VMM01P0 +reporten reportar VMM03P0 +reposa reposar VMM02S0 +reposad reposar VMM02P0 +reposando reposar VMG0000 +reposar reposar VMN0000 +repose reposar VMM03S0 +reposemos reposar VMM01P0 +reposen reposar VMM03P0 +reposta repostar VMM02S0 +repostad repostar VMM02P0 +repostando repostar VMG0000 +repostar repostar VMN0000 +reposte repostar VMM03S0 +repostemos repostar VMM01P0 +reposten repostar VMM03P0 +reprenda reprender VMM03S0 +reprendamos reprender VMM01P0 +reprendan reprender VMM03P0 +reprende reprender VMM02S0 +reprended reprender VMM02P0 +reprender reprender VMN0000 +reprendiendo reprender VMG0000 +represa represar VMM02S0 +represad represar VMM02P0 +represando represar VMG0000 +represar represar VMN0000 +represe represar VMM03S0 +represemos represar VMM01P0 +represen represar VMM03P0 +representa representar VMM02S0 +representad representar VMM02P0 +representando representar VMG0000 +representar representar VMN0000 +represente representar VMM03S0 +representemos representar VMM01P0 +representen representar VMM03P0 +reprima reprimir VMM03S0 +reprimamos reprimir VMM01P0 +repriman reprimir VMM03P0 +reprime reprimir VMM02S0 +reprimid reprimir VMM02P0 +reprimiendo reprimir VMG0000 +reprimir reprimir VMN0000 +reprobad reprobar VMM02P0 +reprobando reprobar VMG0000 +reprobar reprobar VMN0000 +reprobemos reprobar VMM01P0 +reprocha reprochar VMM02S0 +reprochad reprochar VMM02P0 +reprochando reprochar VMG0000 +reprochar reprochar VMN0000 +reproche reprochar VMM03S0 +reprochemos reprochar VMM01P0 +reprochen reprochar VMM03P0 +reproduce reproducir VMM02S0 +reproducid reproducir VMM02P0 +reproduciendo reproducir VMG0000 +reproducir reproducir VMN0000 +reproduzca reproducir VMM03S0 +reproduzcamos reproducir VMM01P0 +reproduzcan reproducir VMM03P0 +reprueba reprobar VMM02S0 +repruebe reprobar VMM03S0 +reprueben reprobar VMM03P0 +repta reptar VMM02S0 +reptad reptar VMM02P0 +reptando reptar VMG0000 +reptar reptar VMN0000 +repte reptar VMM03S0 +reptemos reptar VMM01P0 +repten reptar VMM03P0 +repudia repudiar VMM02S0 +repudiad repudiar VMM02P0 +repudiando repudiar VMG0000 +repudiar repudiar VMN0000 +repudie repudiar VMM03S0 +repudiemos repudiar VMM01P0 +repudien repudiar VMM03P0 +repudra repudrir VMM03S0 +repudramos repudrir VMM01P0 +repudran repudrir VMM03P0 +repudre repudrir VMM02S0 +repudrid repudrir VMM02P0 +repudriendo repudrir VMG0000 +repudrir repudrir VMN0000 +repodrir repudrir VMN0000 +repuebla repoblar VMM02S0 +repueble repoblar VMM03S0 +repueblen repoblar VMM03P0 +repugna repugnar VMM02S0 +repugnad repugnar VMM02P0 +repugnando repugnar VMG0000 +repugnar repugnar VMN0000 +repugne repugnar VMM03S0 +repugnemos repugnar VMM01P0 +repugnen repugnar VMM03P0 +repuja repujar VMM02S0 +repujad repujar VMM02P0 +repujando repujar VMG0000 +repujar repujar VMN0000 +repuje repujar VMM03S0 +repujemos repujar VMM01P0 +repujen repujar VMM03P0 +repula repulir VMM03S0 +repulamos repulir VMM01P0 +repulan repulir VMM03P0 +repule repulir VMM02S0 +repulga repulgar VMM02S0 +repulgad repulgar VMM02P0 +repulgando repulgar VMG0000 +repulgar repulgar VMN0000 +repulgue repulgar VMM03S0 +repulguemos repulgar VMM01P0 +repulguen repulgar VMM03P0 +repulid repulir VMM02P0 +repuliendo repulir VMG0000 +repulir repulir VMN0000 +repulsa repulsar VMM02S0 +repulsad repulsar VMM02P0 +repulsando repulsar VMG0000 +repulsar repulsar VMN0000 +repulse repulsar VMM03S0 +repulsemos repulsar VMM01P0 +repulsen repulsar VMM03P0 +repunta repuntar VMM02S0 +repuntad repuntar VMM02P0 +repuntando repuntar VMG0000 +repuntar repuntar VMN0000 +repunte repuntar VMM03S0 +repuntemos repuntar VMM01P0 +repunten repuntar VMM03P0 +repurga repurgar VMM02S0 +repurgad repurgar VMM02P0 +repurgando repurgar VMG0000 +repurgar repurgar VMN0000 +repurgue repurgar VMM03S0 +repurguemos repurgar VMM01P0 +repurguen repurgar VMM03P0 +reputa reputar VMM02S0 +reputad reputar VMM02P0 +reputando reputar VMG0000 +reputar reputar VMN0000 +repute reputar VMM03S0 +reputemos reputar VMM01P0 +reputen reputar VMM03P0 +repón reponer VMM02S0 +requebrad requebrar VMM02P0 +requebrando requebrar VMG0000 +requebrar requebrar VMN0000 +requebremos requebrar VMM01P0 +requema requemar VMM02S0 +requemad requemar VMM02P0 +requemando requemar VMG0000 +requemar requemar VMN0000 +requeme requemar VMM03S0 +requememos requemar VMM01P0 +requemen requemar VMM03P0 +requerid requerir VMM02P0 +requerir requerir VMN0000 +requiebra requebrar VMM02S0 +requiebre requebrar VMM03S0 +requiebren requebrar VMM03P0 +requiera requerir VMM03S0 +requieran requerir VMM03P0 +requiere requerir VMM02S0 +requinta requintar VMM02S0 +requintad requintar VMM02P0 +requintando requintar VMG0000 +requintar requintar VMN0000 +requinte requintar VMM03S0 +requintemos requintar VMM01P0 +requinten requintar VMM03P0 +requiramos requerir VMM01P0 +requiriendo requerir VMG0000 +requisa requisar VMM02S0 +requisad requisar VMM02P0 +requisando requisar VMG0000 +requisar requisar VMN0000 +requise requisar VMM03S0 +requisemos requisar VMM01P0 +requisen requisar VMM03P0 +resabia resabiar VMM02S0 +resabiad resabiar VMM02P0 +resabiando resabiar VMG0000 +resabiar resabiar VMN0000 +resabie resabiar VMM03S0 +resabiemos resabiar VMM01P0 +resabien resabiar VMM03P0 +resaca resacar VMM02S0 +resacad resacar VMM02P0 +resacando resacar VMG0000 +resacar resacar VMN0000 +resal resalir VMM02S0 +resalga resalir VMM03S0 +resalgamos resalir VMM01P0 +resalgan resalir VMM03P0 +resalid resalir VMM02P0 +resaliendo resalir VMG0000 +resalir resalir VMN0000 +resalla resallar VMM02S0 +resallad resallar VMM02P0 +resallando resallar VMG0000 +resallar resallar VMN0000 +resalle resallar VMM03S0 +resallemos resallar VMM01P0 +resallen resallar VMM03P0 +resalta resaltar VMM02S0 +resaltad resaltar VMM02P0 +resaltando resaltar VMG0000 +resaltar resaltar VMN0000 +resalte resaltar VMM03S0 +resaltemos resaltar VMM01P0 +resalten resaltar VMM03P0 +resana resanar VMM02S0 +resanad resanar VMM02P0 +resanando resanar VMG0000 +resanar resanar VMN0000 +resane resanar VMM03S0 +resanemos resanar VMM01P0 +resanen resanar VMM03P0 +resaque resacar VMM03S0 +resaquemos resacar VMM01P0 +resaquen resacar VMM03P0 +resarce resarcir VMM02S0 +resarcid resarcir VMM02P0 +resarciendo resarcir VMG0000 +resarcir resarcir VMN0000 +resarza resarcir VMM03S0 +resarzamos resarcir VMM01P0 +resarzan resarcir VMM03P0 +resbala resbalar VMM02S0 +resbalad resbalar VMM02P0 +resbalando resbalar VMG0000 +resbalar resbalar VMN0000 +resbale resbalar VMM03S0 +resbalemos resbalar VMM01P0 +resbalen resbalar VMM03P0 +rescalda rescaldar VMM02S0 +rescaldad rescaldar VMM02P0 +rescaldando rescaldar VMG0000 +rescaldar rescaldar VMN0000 +rescalde rescaldar VMM03S0 +rescaldemos rescaldar VMM01P0 +rescalden rescaldar VMM03P0 +rescata rescatar VMM02S0 +rescatad rescatar VMM02P0 +rescatando rescatar VMG0000 +rescatar rescatar VMN0000 +rescate rescatar VMM03S0 +rescatemos rescatar VMM01P0 +rescaten rescatar VMM03P0 +rescinda rescindir VMM03S0 +rescindamos rescindir VMM01P0 +rescindan rescindir VMM03P0 +rescinde rescindir VMM02S0 +rescindid rescindir VMM02P0 +rescindiendo rescindir VMG0000 +rescindir rescindir VMN0000 +rescriba rescribir VMM03S0 +rescribamos rescribir VMM01P0 +rescriban rescribir VMM03P0 +rescribe rescribir VMM02S0 +rescribid rescribir VMM02P0 +rescribiendo rescribir VMG0000 +rescribir rescribir VMN0000 +reseca resecar VMM02S0 +resecad resecar VMM02P0 +resecando resecar VMG0000 +resecar resecar VMN0000 +resegad resegar VMM02P0 +resegando resegar VMG0000 +resegar resegar VMN0000 +reseguemos resegar VMM01P0 +reseguid reseguir VMM02P0 +reseguir reseguir VMN0000 +resella resellar VMM02S0 +resellad resellar VMM02P0 +resellando resellar VMG0000 +resellar resellar VMN0000 +reselle resellar VMM03S0 +resellemos resellar VMM01P0 +resellen resellar VMM03P0 +resembrad resembrar VMM02P0 +resembrando resembrar VMG0000 +resembrar resembrar VMN0000 +resembremos resembrar VMM01P0 +resentid resentir VMM02P0 +resentir resentir VMN0000 +reseque resecar VMM03S0 +resequemos resecar VMM01P0 +resequen resecar VMM03P0 +reserva reservar VMM02S0 +reservad reservar VMM02P0 +reservando reservar VMG0000 +reservar reservar VMN0000 +reserve reservar VMM03S0 +reservemos reservar VMM01P0 +reserven reservar VMM03P0 +reseña reseñar VMM02S0 +reseñad reseñar VMM02P0 +reseñando reseñar VMG0000 +reseñar reseñar VMN0000 +reseñe reseñar VMM03S0 +reseñemos reseñar VMM01P0 +reseñen reseñar VMM03P0 +resfriad resfriar VMM02P0 +resfriando resfriar VMG0000 +resfriar resfriar VMN0000 +resfriemos resfriar VMM01P0 +resfría resfriar VMM02S0 +resfríe resfriar VMM03S0 +resfríen resfriar VMM03P0 +resguarda resguardar VMM02S0 +resguardad resguardar VMM02P0 +resguardando resguardar VMG0000 +resguardar resguardar VMN0000 +resguarde resguardar VMM03S0 +resguardemos resguardar VMM01P0 +resguarden resguardar VMM03P0 +resida residir VMM03S0 +residamos residir VMM01P0 +residan residir VMM03P0 +reside residir VMM02S0 +residencia residenciar VMM02S0 +residenciad residenciar VMM02P0 +residenciando residenciar VMG0000 +residenciar residenciar VMN0000 +residencie residenciar VMM03S0 +residenciemos residenciar VMM01P0 +residencien residenciar VMM03P0 +residid residir VMM02P0 +residiendo residir VMG0000 +residir residir VMN0000 +resiega resegar VMM02S0 +resiegue resegar VMM03S0 +resieguen resegar VMM03P0 +resiembra resembrar VMM02S0 +resiembre resembrar VMM03S0 +resiembren resembrar VMM03P0 +resienta resentir VMM03S0 +resientan resentir VMM03P0 +resiente resentir VMM02S0 +resiga reseguir VMM03S0 +resigamos reseguir VMM01P0 +resigan reseguir VMM03P0 +resigna resignar VMM02S0 +resignad resignar VMM02P0 +resignando resignar VMG0000 +resignar resignar VMN0000 +resigne resignar VMM03S0 +resignemos resignar VMM01P0 +resignen resignar VMM03P0 +resigue reseguir VMM02S0 +resiguiendo reseguir VMG0000 +resina resinar VMM02S0 +resinad resinar VMM02P0 +resinando resinar VMG0000 +resinar resinar VMN0000 +resine resinar VMM03S0 +resinemos resinar VMM01P0 +resinen resinar VMM03P0 +resinifica resinificar VMM02S0 +resinificad resinificar VMM02P0 +resinificando resinificar VMG0000 +resinificar resinificar VMN0000 +resinifique resinificar VMM03S0 +resinifiquemos resinificar VMM01P0 +resinifiquen resinificar VMM03P0 +resintamos resentir VMM01P0 +resintiendo resentir VMG0000 +resista resistir VMM03S0 +resistamos resistir VMM01P0 +resistan resistir VMM03P0 +resiste resistir VMM02S0 +resistid resistir VMM02P0 +resistiendo resistir VMG0000 +resistir resistir VMN0000 +resollad resollar VMM02P0 +resollando resollar VMG0000 +resollar resollar VMN0000 +resollemos resollar VMM01P0 +resolvamos resolver VMM01P0 +resolved resolver VMM02P0 +resolver resolver VMN0000 +resolviendo resolver VMG0000 +resonad resonar VMM02P0 +resonando resonar VMG0000 +resonar resonar VMN0000 +resonemos resonar VMM01P0 +resopla resoplar VMM02S0 +resoplad resoplar VMM02P0 +resoplando resoplar VMG0000 +resoplar resoplar VMN0000 +resople resoplar VMM03S0 +resoplemos resoplar VMM01P0 +resoplen resoplar VMM03P0 +respalda respaldar VMM02S0 +respaldad respaldar VMM02P0 +respaldando respaldar VMG0000 +respaldar respaldar VMN0000 +respalde respaldar VMM03S0 +respaldemos respaldar VMM01P0 +respalden respaldar VMM03P0 +respecta respectar VMM02S0 +respectad respectar VMM02P0 +respectando respectar VMG0000 +respectar respectar VMN0000 +respecte respectar VMM03S0 +respectemos respectar VMM01P0 +respecten respectar VMM03P0 +respeta respetar VMM02S0 +respetad respetar VMM02P0 +respetando respetar VMG0000 +respetar respetar VMN0000 +respete respetar VMM03S0 +respetemos respetar VMM01P0 +respeten respetar VMM03P0 +respiga respigar VMM02S0 +respigad respigar VMM02P0 +respigando respigar VMG0000 +respigar respigar VMN0000 +respigue respigar VMM03S0 +respiguemos respigar VMM01P0 +respiguen respigar VMM03P0 +respinga respingar VMM02S0 +respingad respingar VMM02P0 +respingando respingar VMG0000 +respingar respingar VMN0000 +respingue respingar VMM03S0 +respinguemos respingar VMM01P0 +respinguen respingar VMM03P0 +respira respirar VMM02S0 +respirad respirar VMM02P0 +respirando respirar VMG0000 +respirar respirar VMN0000 +respire respirar VMM03S0 +respiremos respirar VMM01P0 +respiren respirar VMM03P0 +resplandece resplandecer VMM02S0 +resplandeced resplandecer VMM02P0 +resplandecer resplandecer VMN0000 +resplandeciendo resplandecer VMG0000 +resplandezca resplandecer VMM03S0 +resplandezcamos resplandecer VMM01P0 +resplandezcan resplandecer VMM03P0 +responda responder VMM03S0 +respondamos responder VMM01P0 +respondan responder VMM03P0 +responde responder VMM02S0 +responded responder VMM02P0 +responder responder VMN0000 +respondiendo responder VMG0000 +responsa responsar VMM02S0 +responsabilice responsabilizar VMM03S0 +responsabilicemos responsabilizar VMM01P0 +responsabilicen responsabilizar VMM03P0 +responsabiliza responsabilizar VMM02S0 +responsabilizad responsabilizar VMM02P0 +responsabilizando responsabilizar VMG0000 +responsabilizar responsabilizar VMN0000 +responsad responsar VMM02P0 +responsando responsar VMG0000 +responsar responsar VMN0000 +response responsar VMM03S0 +responsea responsear VMM02S0 +responsead responsear VMM02P0 +responseando responsear VMG0000 +responsear responsear VMN0000 +responsee responsear VMM03S0 +responseemos responsear VMM01P0 +responseen responsear VMM03P0 +responsemos responsar VMM01P0 +responsen responsar VMM03P0 +resquebrad resquebrar VMM02P0 +resquebraja resquebrajar VMM02S0 +resquebrajad resquebrajar VMM02P0 +resquebrajando resquebrajar VMG0000 +resquebrajar resquebrajar VMN0000 +resquebraje resquebrajar VMM03S0 +resquebrajemos resquebrajar VMM01P0 +resquebrajen resquebrajar VMM03P0 +resquebrando resquebrar VMG0000 +resquebrar resquebrar VMN0000 +resquebremos resquebrar VMM01P0 +resquema resquemar VMM02S0 +resquemad resquemar VMM02P0 +resquemando resquemar VMG0000 +resquemar resquemar VMN0000 +resqueme resquemar VMM03S0 +resquememos resquemar VMM01P0 +resquemen resquemar VMM03P0 +resquiebra resquebrar VMM02S0 +resquiebre resquebrar VMM03S0 +resquiebren resquebrar VMM03P0 +resta restar VMM02S0 +restablece restablecer VMM02S0 +restableced restablecer VMM02P0 +restablecer restablecer VMN0000 +restableciendo restablecer VMG0000 +restablezca restablecer VMM03S0 +restablezcamos restablecer VMM01P0 +restablezcan restablecer VMM03P0 +restad restar VMM02P0 +restalla restallar VMM02S0 +restallad restallar VMM02P0 +restallando restallar VMG0000 +restallar restallar VMN0000 +restalle restallar VMM03S0 +restallemos restallar VMM01P0 +restallen restallar VMM03P0 +restando restar VMG0000 +restar restar VMN0000 +restaura restaurar VMM02S0 +restaurad restaurar VMM02P0 +restaurando restaurar VMG0000 +restaurar restaurar VMN0000 +restaure restaurar VMM03S0 +restauremos restaurar VMM01P0 +restauren restaurar VMM03P0 +restaña restañar VMM02S0 +restañad restañar VMM02P0 +restañando restañar VMG0000 +restañar restañar VMN0000 +restañe restañar VMM03S0 +restañemos restañar VMM01P0 +restañen restañar VMM03P0 +reste restar VMM03S0 +restemos restar VMM01P0 +resten restar VMM03P0 +restituid restituir VMM02P0 +restituir restituir VMN0000 +restituya restituir VMM03S0 +restituyamos restituir VMM01P0 +restituyan restituir VMM03P0 +restituye restituir VMM02S0 +restituyendo restituir VMG0000 +restregad restregar VMM02P0 +restregando restregar VMG0000 +restregar restregar VMN0000 +restreguemos restregar VMM01P0 +restriega restregar VMM02S0 +restriegue restregar VMM03S0 +restrieguen restregar VMM03P0 +restringe restringir VMM02S0 +restringid restringir VMM02P0 +restringiendo restringir VMG0000 +restringir restringir VMN0000 +restrinja restringir VMM03S0 +restrinjamos restringir VMM01P0 +restrinjan restringir VMM03P0 +restriña restriñir VMM03S0 +restriñamos restriñir VMM01P0 +restriñan restriñir VMM03P0 +restriñe restriñir VMM02S0 +restriñendo restriñir VMG0000 +restriñid restriñir VMM02P0 +restriñir restriñir VMN0000 +resucita resucitar VMM02S0 +resucitad resucitar VMM02P0 +resucitando resucitar VMG0000 +resucitar resucitar VMN0000 +resucite resucitar VMM03S0 +resucitemos resucitar VMM01P0 +resuciten resucitar VMM03P0 +resuda resudar VMM02S0 +resudad resudar VMM02P0 +resudando resudar VMG0000 +resudar resudar VMN0000 +resude resudar VMM03S0 +resudemos resudar VMM01P0 +resuden resudar VMM03P0 +resuella resollar VMM02S0 +resuelle resollar VMM03S0 +resuellen resollar VMM03P0 +resuelva resolver VMM03S0 +resuelvan resolver VMM03P0 +resuelve resolver VMM02S0 +resuena resonar VMM02S0 +resuene resonar VMM03S0 +resuenen resonar VMM03P0 +resulta resultar VMM02S0 +resultad resultar VMM02P0 +resultando resultar VMG0000 +resultar resultar VMN0000 +resulte resultar VMM03S0 +resultemos resultar VMM01P0 +resulten resultar VMM03P0 +resuma resumir VMM03S0 +resumamos resumir VMM01P0 +resuman resumir VMM03P0 +resume resumir VMM02S0 +resumid resumir VMM02P0 +resumiendo resumir VMG0000 +resumir resumir VMN0000 +resurge resurgir VMM02S0 +resurgid resurgir VMM02P0 +resurgiendo resurgir VMG0000 +resurgir resurgir VMN0000 +resurja resurgir VMM03S0 +resurjamos resurgir VMM01P0 +resurjan resurgir VMM03P0 +reta retar VMM02S0 +retaca retacar VMM02S0 +retacad retacar VMM02P0 +retacando retacar VMG0000 +retacar retacar VMN0000 +retace retazar VMM03S0 +retacemos retazar VMM01P0 +retacen retazar VMM03P0 +retad retar VMM02P0 +retaja retajar VMM02S0 +retajad retajar VMM02P0 +retajando retajar VMG0000 +retajar retajar VMN0000 +retaje retajar VMM03S0 +retajemos retajar VMM01P0 +retajen retajar VMM03P0 +retalla retallar VMM02S0 +retallad retallar VMM02P0 +retallando retallar VMG0000 +retallar retallar VMN0000 +retalle retallar VMM03S0 +retallece retallecer VMM02S0 +retalleced retallecer VMM02P0 +retallecer retallecer VMN0000 +retalleciendo retallecer VMG0000 +retallemos retallar VMM01P0 +retallen retallar VMM03P0 +retallezca retallecer VMM03S0 +retallezcamos retallecer VMM01P0 +retallezcan retallecer VMM03P0 +retando retar VMG0000 +retaque retacar VMM03S0 +retaquemos retacar VMM01P0 +retaquen retacar VMM03P0 +retar retar VMN0000 +retarda retardar VMM02S0 +retardad retardar VMM02P0 +retardando retardar VMG0000 +retardar retardar VMN0000 +retarde retardar VMM03S0 +retardemos retardar VMM01P0 +retarden retardar VMM03P0 +retasa retasar VMM02S0 +retasad retasar VMM02P0 +retasando retasar VMG0000 +retasar retasar VMN0000 +retase retasar VMM03S0 +retasemos retasar VMM01P0 +retasen retasar VMM03P0 +retaza retazar VMM02S0 +retazad retazar VMM02P0 +retazando retazar VMG0000 +retazar retazar VMN0000 +rete retar VMM03S0 +reteja retejar VMM02S0 +reteja retejer VMM03S0 +retejad retejar VMM02P0 +retejamos retejer VMM01P0 +retejan retejer VMM03P0 +retejando retejar VMG0000 +retejar retejar VMN0000 +reteje retejar VMM03S0 +reteje retejer VMM02S0 +retejed retejer VMM02P0 +retejemos retejar VMM01P0 +retejen retejar VMM03P0 +retejer retejer VMN0000 +retejiendo retejer VMG0000 +retemblad retemblar VMM02P0 +retemblando retemblar VMG0000 +retemblar retemblar VMN0000 +retemblemos retemblar VMM01P0 +retemos retar VMM01P0 +reten retar VMM03P0 +retened retener VMM02P0 +retener retener VMN0000 +retenga retener VMM03S0 +retengamos retener VMM01P0 +retengan retener VMM03P0 +reteniendo retener VMG0000 +retesa retesar VMM02S0 +retesad retesar VMM02P0 +retesando retesar VMG0000 +retesar retesar VMN0000 +retese retesar VMM03S0 +retesemos retesar VMM01P0 +retesen retesar VMM03P0 +reteñid reteñir VMM02P0 +reteñir reteñir VMN0000 +retiembla retemblar VMM02S0 +retiemble retemblar VMM03S0 +retiemblen retemblar VMM03P0 +retira retirar VMM02S0 +retirad retirar VMM02P0 +retirando retirar VMG0000 +retirar retirar VMN0000 +retire retirar VMM03S0 +retiremos retirar VMM01P0 +retiren retirar VMM03P0 +retiña reteñir VMM03S0 +retiña retiñir VMM03S0 +retiñamos reteñir VMM01P0 +retiñamos retiñir VMM01P0 +retiñan reteñir VMM03P0 +retiñan retiñir VMM03P0 +retiñe reteñir VMM02S0 +retiñe retiñir VMM02S0 +retiñendo reteñir VMG0000 +retiñendo retiñir VMG0000 +retiñid retiñir VMM02P0 +retiñir retiñir VMN0000 +retoba retobar VMM02S0 +retobad retobar VMM02P0 +retobando retobar VMG0000 +retobar retobar VMN0000 +retobe retobar VMM03S0 +retobemos retobar VMM01P0 +retoben retobar VMM03P0 +retoca retocar VMM02S0 +retocad retocar VMM02P0 +retocando retocar VMG0000 +retocar retocar VMN0000 +retoce retozar VMM03S0 +retocemos retozar VMM01P0 +retocen retozar VMM03P0 +retoma retomar VMM02S0 +retomad retomar VMM02P0 +retomando retomar VMG0000 +retomar retomar VMN0000 +retome retomar VMM03S0 +retomemos retomar VMM01P0 +retomen retomar VMM03P0 +retoque retocar VMM03S0 +retoquemos retocar VMM01P0 +retoquen retocar VMM03P0 +retorced retorcer VMM02P0 +retorcer retorcer VMN0000 +retorciendo retorcer VMG0000 +retorna retornar VMM02S0 +retornad retornar VMM02P0 +retornando retornar VMG0000 +retornar retornar VMN0000 +retorne retornar VMM03S0 +retornemos retornar VMM01P0 +retornen retornar VMM03P0 +retorzamos retorcer VMM01P0 +retostad retostar VMM02P0 +retostando retostar VMG0000 +retostar retostar VMN0000 +retostemos retostar VMM01P0 +retoza retozar VMM02S0 +retozad retozar VMM02P0 +retozando retozar VMG0000 +retozar retozar VMN0000 +retoña retoñar VMM02S0 +retoñad retoñar VMM02P0 +retoñando retoñar VMG0000 +retoñar retoñar VMN0000 +retoñe retoñar VMM03S0 +retoñece retoñecer VMM02S0 +retoñeced retoñecer VMM02P0 +retoñecer retoñecer VMN0000 +retoñeciendo retoñecer VMG0000 +retoñemos retoñar VMM01P0 +retoñen retoñar VMM03P0 +retoñezca retoñecer VMM03S0 +retoñezcamos retoñecer VMM01P0 +retoñezcan retoñecer VMM03P0 +retracta retractar VMM02S0 +retractad retractar VMM02P0 +retractando retractar VMG0000 +retractar retractar VMN0000 +retracte retractar VMM03S0 +retractemos retractar VMM01P0 +retracten retractar VMM03P0 +retrae retraer VMM02S0 +retraed retraer VMM02P0 +retraer retraer VMN0000 +retraiga retraer VMM03S0 +retraigamos retraer VMM01P0 +retraigan retraer VMM03P0 +retranquea retranquear VMM02S0 +retranquead retranquear VMM02P0 +retranqueando retranquear VMG0000 +retranquear retranquear VMN0000 +retranquee retranquear VMM03S0 +retranqueemos retranquear VMM01P0 +retranqueen retranquear VMM03P0 +retransmita retransmitir VMM03S0 +retransmitamos retransmitir VMM01P0 +retransmitan retransmitir VMM03P0 +retransmite retransmitir VMM02S0 +retransmitid retransmitir VMM02P0 +retransmitiendo retransmitir VMG0000 +retransmitir retransmitir VMN0000 +retrasa retrasar VMM02S0 +retrasad retrasar VMM02P0 +retrasando retrasar VMG0000 +retrasar retrasar VMN0000 +retrase retrasar VMM03S0 +retrasemos retrasar VMM01P0 +retrasen retrasar VMM03P0 +retrata retratar VMM02S0 +retratad retratar VMM02P0 +retratando retratar VMG0000 +retratar retratar VMN0000 +retrate retratar VMM03S0 +retratemos retratar VMM01P0 +retraten retratar VMM03P0 +retrayendo retraer VMG0000 +retrecha retrechar VMM02S0 +retrechad retrechar VMM02P0 +retrechando retrechar VMG0000 +retrechar retrechar VMN0000 +retreche retrechar VMM03S0 +retrechemos retrechar VMM01P0 +retrechen retrechar VMM03P0 +retrepa retrepar VMM02S0 +retrepad retrepar VMM02P0 +retrepando retrepar VMG0000 +retrepar retrepar VMN0000 +retrepe retrepar VMM03S0 +retrepemos retrepar VMM01P0 +retrepen retrepar VMM03P0 +retribuid retribuir VMM02P0 +retribuir retribuir VMN0000 +retribuya retribuir VMM03S0 +retribuyamos retribuir VMM01P0 +retribuyan retribuir VMM03P0 +retribuye retribuir VMM02S0 +retribuyendo retribuir VMG0000 +retrilla retrillar VMM02S0 +retrillad retrillar VMM02P0 +retrillando retrillar VMG0000 +retrillar retrillar VMN0000 +retrille retrillar VMM03S0 +retrillemos retrillar VMM01P0 +retrillen retrillar VMM03P0 +retroceda retroceder VMM03S0 +retrocedamos retroceder VMM01P0 +retrocedan retroceder VMM03P0 +retrocede retroceder VMM02S0 +retroceded retroceder VMM02P0 +retroceder retroceder VMN0000 +retrocediendo retroceder VMG0000 +retrograda retrogradar VMM02S0 +retrogradad retrogradar VMM02P0 +retrogradando retrogradar VMG0000 +retrogradar retrogradar VMN0000 +retrograde retrogradar VMM03S0 +retrogrademos retrogradar VMM01P0 +retrograden retrogradar VMM03P0 +retrotrae retrotraer VMM02S0 +retrotraed retrotraer VMM02P0 +retrotraer retrotraer VMN0000 +retrotraiga retrotraer VMM03S0 +retrotraigamos retrotraer VMM01P0 +retrotraigan retrotraer VMM03P0 +retrotrayendo retrotraer VMG0000 +retrovenda retrovender VMM03S0 +retrovendamos retrovender VMM01P0 +retrovendan retrovender VMM03P0 +retrovende retrovender VMM02S0 +retrovended retrovender VMM02P0 +retrovender retrovender VMN0000 +retrovendiendo retrovender VMG0000 +retruca retrucar VMM02S0 +retrucad retrucar VMM02P0 +retrucando retrucar VMG0000 +retrucar retrucar VMN0000 +retruque retrucar VMM03S0 +retruquemos retrucar VMM01P0 +retruquen retrucar VMM03P0 +retuerce retorcer VMM02S0 +retuerza retorcer VMM03S0 +retuerzan retorcer VMM03P0 +retuesta retostar VMM02S0 +retueste retostar VMM03S0 +retuesten retostar VMM03P0 +retumba retumbar VMM02S0 +retumbad retumbar VMM02P0 +retumbando retumbar VMG0000 +retumbar retumbar VMN0000 +retumbe retumbar VMM03S0 +retumbemos retumbar VMM01P0 +retumben retumbar VMM03P0 +retén retener VMM02S0 +reubica reubicar VMM02S0 +reubicad reubicar VMM02P0 +reubicando reubicar VMG0000 +reubicar reubicar VMN0000 +reubique reubicar VMM03S0 +reubiquemos reubicar VMM01P0 +reubiquen reubicar VMM03P0 +reunamos reunir VMM01P0 +reunid reunir VMM02P0 +reuniendo reunir VMG0000 +reunir reunir VMN0000 +reutilice reutilizar VMM03S0 +reutilicemos reutilizar VMM01P0 +reutilicen reutilizar VMM03P0 +reutiliza reutilizar VMM02S0 +reutilizad reutilizar VMM02P0 +reutilizando reutilizar VMG0000 +reutilizar reutilizar VMN0000 +revacuna revacunar VMM02S0 +revacunad revacunar VMM02P0 +revacunando revacunar VMG0000 +revacunar revacunar VMN0000 +revacune revacunar VMM03S0 +revacunemos revacunar VMM01P0 +revacunen revacunar VMM03P0 +revalida revalidar VMM02S0 +revalidad revalidar VMM02P0 +revalidando revalidar VMG0000 +revalidar revalidar VMN0000 +revalide revalidar VMM03S0 +revalidemos revalidar VMM01P0 +revaliden revalidar VMM03P0 +revalora revalorar VMM02S0 +revalorad revalorar VMM02P0 +revalorando revalorar VMG0000 +revalorar revalorar VMN0000 +revalorice revalorizar VMM03S0 +revaloricemos revalorizar VMM01P0 +revaloricen revalorizar VMM03P0 +revaloriza revalorizar VMM02S0 +revalorizad revalorizar VMM02P0 +revalorizando revalorizar VMG0000 +revalorizar revalorizar VMN0000 +revaluad revaluar VMM02P0 +revaluando revaluar VMG0000 +revaluar revaluar VMN0000 +revaluemos revaluar VMM01P0 +revalúa revaluar VMM02S0 +revalúe revaluar VMM03S0 +revalúen revaluar VMM03P0 +revea rever VMM03S0 +reveamos rever VMM01P0 +revean rever VMM03P0 +reved rever VMM02P0 +revejece revejecer VMM02S0 +revejeced revejecer VMM02P0 +revejecer revejecer VMN0000 +revejeciendo revejecer VMG0000 +revejezca revejecer VMM03S0 +revejezcamos revejecer VMM01P0 +revejezcan revejecer VMM03P0 +revela revelar VMM02S0 +revelad revelar VMM02P0 +revelando revelar VMG0000 +revelar revelar VMN0000 +revele revelar VMM03S0 +revelemos revelar VMM01P0 +revelen revelar VMM03P0 +reven revenir VMM02S0 +revena revenar VMM02S0 +revenad revenar VMM02P0 +revenando revenar VMG0000 +revenar revenar VMN0000 +revenda revender VMM03S0 +revendamos revender VMM01P0 +revendan revender VMM03P0 +revende revender VMM02S0 +revended revender VMM02P0 +revender revender VMN0000 +revendiendo revender VMG0000 +revene revenar VMM03S0 +revenemos revenar VMM01P0 +revenen revenar VMM03P0 +revenga revenir VMM03S0 +revengamos revenir VMM01P0 +revengan revenir VMM03P0 +revenid revenir VMM02P0 +revenir revenir VMN0000 +reventad reventar VMM02P0 +reventando reventar VMG0000 +reventar reventar VMN0000 +reventemos reventar VMM01P0 +rever rever VMN0000 +reverbera reverberar VMM02S0 +reverberad reverberar VMM02P0 +reverberando reverberar VMG0000 +reverberar reverberar VMN0000 +reverbere reverberar VMM03S0 +reverberemos reverberar VMM01P0 +reverberen reverberar VMM03P0 +reverdece reverdecer VMM02S0 +reverdeced reverdecer VMM02P0 +reverdecer reverdecer VMN0000 +reverdeciendo reverdecer VMG0000 +reverdezca reverdecer VMM03S0 +reverdezcamos reverdecer VMM01P0 +reverdezcan reverdecer VMM03P0 +reverencia reverenciar VMM02S0 +reverenciad reverenciar VMM02P0 +reverenciando reverenciar VMG0000 +reverenciar reverenciar VMN0000 +reverencie reverenciar VMM03S0 +reverenciemos reverenciar VMM01P0 +reverencien reverenciar VMM03P0 +revertid revertir VMM02P0 +revertir revertir VMN0000 +revestid revestir VMM02P0 +revestir revestir VMN0000 +reviendo rever VMG0000 +revienta reventar VMM02S0 +reviente reventar VMM03S0 +revienten reventar VMM03P0 +revierta revertir VMM03S0 +reviertan revertir VMM03P0 +revierte revertir VMM02S0 +revigorice revigorizar VMM03S0 +revigoricemos revigorizar VMM01P0 +revigoricen revigorizar VMM03P0 +revigoriza revigorizar VMM02S0 +revigorizad revigorizar VMM02P0 +revigorizando revigorizar VMG0000 +revigorizar revigorizar VMN0000 +reviniendo revenir VMG0000 +revirtamos revertir VMM01P0 +revirtiendo revertir VMG0000 +revisa revisar VMM02S0 +revisad revisar VMM02P0 +revisando revisar VMG0000 +revisar revisar VMN0000 +revise revisar VMM03S0 +revisemos revisar VMM01P0 +revisen revisar VMM03P0 +revista revestir VMM03S0 +revista revistar VMM02S0 +revistad revistar VMM02P0 +revistamos revestir VMM01P0 +revistan revestir VMM03P0 +revistando revistar VMG0000 +revistar revistar VMN0000 +reviste revestir VMM02S0 +reviste revistar VMM03S0 +revistemos revistar VMM01P0 +revisten revistar VMM03P0 +revistiendo revestir VMG0000 +revitalice revitalizar VMM03S0 +revitalicemos revitalizar VMM01P0 +revitalicen revitalizar VMM03P0 +revitaliza revitalizar VMM02S0 +revitalizad revitalizar VMM02P0 +revitalizando revitalizar VMG0000 +revitalizar revitalizar VMN0000 +reviva revivir VMM03S0 +revivamos revivir VMM01P0 +revivan revivir VMM03P0 +revive revivir VMM02S0 +revivid revivir VMM02P0 +reviviendo revivir VMG0000 +revivifica revivificar VMM02S0 +revivificad revivificar VMM02P0 +revivificando revivificar VMG0000 +revivificar revivificar VMN0000 +revivifique revivificar VMM03S0 +revivifiquemos revivificar VMM01P0 +revivifiquen revivificar VMM03P0 +revivir revivir VMN0000 +revoca revocar VMM02S0 +revocad revocar VMM02P0 +revocando revocar VMG0000 +revocar revocar VMN0000 +revolcad revolcar VMM02P0 +revolcando revolcar VMG0000 +revolcar revolcar VMN0000 +revolea revolear VMM02S0 +revolead revolear VMM02P0 +revoleando revolear VMG0000 +revolear revolear VMN0000 +revolee revolear VMM03S0 +revoleemos revolear VMM01P0 +revoleen revolear VMM03P0 +revolotea revolotear VMM02S0 +revolotead revolotear VMM02P0 +revoloteando revolotear VMG0000 +revolotear revolotear VMN0000 +revolotee revolotear VMM03S0 +revoloteemos revolotear VMM01P0 +revoloteen revolotear VMM03P0 +revolquemos revolcar VMM01P0 +revoluciona revolucionar VMM02S0 +revolucionad revolucionar VMM02P0 +revolucionando revolucionar VMG0000 +revolucionar revolucionar VMN0000 +revolucione revolucionar VMM03S0 +revolucionemos revolucionar VMM01P0 +revolucionen revolucionar VMM03P0 +revolvamos revolver VMM01P0 +revolved revolver VMM02P0 +revolver revolver VMN0000 +revolviendo revolver VMG0000 +revoque revocar VMM03S0 +revoquemos revocar VMM01P0 +revoquen revocar VMM03P0 +revuelca revolcar VMM02S0 +revuelque revolcar VMM03S0 +revuelquen revolcar VMM03P0 +revuelva revolver VMM03S0 +revuelvan revolver VMM03P0 +revuelve revolver VMM02S0 +revé rever VMM02S0 +reza rezar VMM02S0 +rezad rezar VMM02P0 +rezaga rezagar VMM02S0 +rezagad rezagar VMM02P0 +rezagando rezagar VMG0000 +rezagar rezagar VMN0000 +rezague rezagar VMM03S0 +rezaguemos rezagar VMM01P0 +rezaguen rezagar VMM03P0 +rezando rezar VMG0000 +rezar rezar VMN0000 +rezonga rezongar VMM02S0 +rezongad rezongar VMM02P0 +rezongando rezongar VMG0000 +rezongar rezongar VMN0000 +rezongue rezongar VMM03S0 +rezonguemos rezongar VMM01P0 +rezonguen rezongar VMM03P0 +rezuma rezumar VMM02S0 +rezumad rezumar VMM02P0 +rezumando rezumar VMG0000 +rezumar rezumar VMN0000 +rezume rezumar VMM03S0 +rezumemos rezumar VMM01P0 +rezumen rezumar VMM03P0 +reíd reír VMM02P0 +reír reír VMN0000 +reñid reñir VMM02P0 +reñir reñir VMN0000 +reúna reunir VMM03S0 +reúnan reunir VMM03P0 +reúne reunir VMM02S0 +riamos reír VMM01P0 +ribetea ribetear VMM02S0 +ribetead ribetear VMM02P0 +ribeteando ribetear VMG0000 +ribetear ribetear VMN0000 +ribetee ribetear VMM03S0 +ribeteemos ribetear VMM01P0 +ribeteen ribetear VMM03P0 +rice rizar VMM03S0 +ricemos rizar VMM01P0 +ricen rizar VMM03P0 +ridiculice ridiculizar VMM03S0 +ridiculicemos ridiculizar VMM01P0 +ridiculicen ridiculizar VMM03P0 +ridiculiza ridiculizar VMM02S0 +ridiculizad ridiculizar VMM02P0 +ridiculizando ridiculizar VMG0000 +ridiculizar ridiculizar VMN0000 +riega regar VMM02S0 +riegue regar VMM03S0 +rieguen regar VMM03P0 +riela rielar VMM02S0 +rielad rielar VMM02P0 +rielando rielar VMG0000 +rielar rielar VMN0000 +riele rielar VMM03S0 +rielemos rielar VMM01P0 +rielen rielar VMM03P0 +riendo reír VMG0000 +rifa rifar VMM02S0 +rifad rifar VMM02P0 +rifando rifar VMG0000 +rifar rifar VMN0000 +rife rifar VMM03S0 +rifemos rifar VMM01P0 +rifen rifar VMM03P0 +rige regir VMM02S0 +rigiendo regir VMG0000 +rija regir VMM03S0 +rijamos regir VMM01P0 +rijan regir VMM03P0 +rila rilar VMM02S0 +rilad rilar VMM02P0 +rilando rilar VMG0000 +rilar rilar VMN0000 +rile rilar VMM03S0 +rilemos rilar VMM01P0 +rilen rilar VMM03P0 +rima rimar VMM02S0 +rimad rimar VMM02P0 +rimando rimar VMG0000 +rimar rimar VMN0000 +rime rimar VMM03S0 +rimemos rimar VMM01P0 +rimen rimar VMM03P0 +rinda rendir VMM03S0 +rindamos rendir VMM01P0 +rindan rendir VMM03P0 +rinde rendir VMM02S0 +rindiendo rendir VMG0000 +ripia ripiar VMM02S0 +ripiad ripiar VMM02P0 +ripiando ripiar VMG0000 +ripiar ripiar VMN0000 +ripie ripiar VMM03S0 +ripiemos ripiar VMM01P0 +ripien ripiar VMM03P0 +ritma ritmar VMM02S0 +ritmad ritmar VMM02P0 +ritmando ritmar VMG0000 +ritmar ritmar VMN0000 +ritme ritmar VMM03S0 +ritmemos ritmar VMM01P0 +ritmen ritmar VMM03P0 +rivalice rivalizar VMM03S0 +rivalicemos rivalizar VMM01P0 +rivalicen rivalizar VMM03P0 +rivaliza rivalizar VMM02S0 +rivalizad rivalizar VMM02P0 +rivalizando rivalizar VMG0000 +rivalizar rivalizar VMN0000 +riza rizar VMM02S0 +rizad rizar VMM02P0 +rizando rizar VMG0000 +rizar rizar VMN0000 +riña reñir VMM03S0 +riñamos reñir VMM01P0 +riñan reñir VMM03P0 +riñe reñir VMM02S0 +riñendo reñir VMG0000 +roa roer VMM03S0 +roamos roer VMM01P0 +roan roer VMM03P0 +roba robar VMM02S0 +robad robar VMM02P0 +robando robar VMG0000 +robar robar VMN0000 +robe robar VMM03S0 +robemos robar VMM01P0 +roben robar VMM03P0 +robla roblar VMM02S0 +roblad roblar VMM02P0 +roblando roblar VMG0000 +roblar roblar VMN0000 +roble roblar VMM03S0 +roblemos roblar VMM01P0 +roblen roblar VMM03P0 +roblona roblonar VMM02S0 +roblonad roblonar VMM02P0 +roblonando roblonar VMG0000 +roblonar roblonar VMN0000 +roblone roblonar VMM03S0 +roblonemos roblonar VMM01P0 +roblonen roblonar VMM03P0 +robora roborar VMM02S0 +roborad roborar VMM02P0 +roborando roborar VMG0000 +roborar roborar VMN0000 +robore roborar VMM03S0 +roboremos roborar VMM01P0 +roboren roborar VMM03P0 +robustece robustecer VMM02S0 +robusteced robustecer VMM02P0 +robustecer robustecer VMN0000 +robusteciendo robustecer VMG0000 +robustezca robustecer VMM03S0 +robustezcamos robustecer VMM01P0 +robustezcan robustecer VMM03P0 +roce rozar VMM03S0 +rocemos rozar VMM01P0 +rocen rozar VMM03P0 +rociad rociar VMM02P0 +rociando rociar VMG0000 +rociar rociar VMN0000 +rociemos rociar VMM01P0 +rocía rociar VMM02S0 +rocíe rociar VMM03S0 +rocíen rociar VMM03P0 +rodad rodar VMM02P0 +rodando rodar VMG0000 +rodar rodar VMN0000 +rodea rodear VMM02S0 +rodead rodear VMM02P0 +rodeando rodear VMG0000 +rodear rodear VMN0000 +rodee rodear VMM03S0 +rodeemos rodear VMM01P0 +rodeen rodear VMM03P0 +rodemos rodar VMM01P0 +rodriga rodrigar VMM02S0 +rodrigad rodrigar VMM02P0 +rodrigando rodrigar VMG0000 +rodrigar rodrigar VMN0000 +rodrigue rodrigar VMM03S0 +rodriguemos rodrigar VMM01P0 +rodriguen rodrigar VMM03P0 +roe roer VMM02S0 +roed roer VMM02P0 +roer roer VMN0000 +rogad rogar VMM02P0 +rogando rogar VMG0000 +rogar rogar VMN0000 +roguemos rogar VMM01P0 +roiga roer VMM03S0 +roigamos roer VMM01P0 +roigan roer VMM03P0 +rojea rojear VMM02S0 +rojead rojear VMM02P0 +rojeando rojear VMG0000 +rojear rojear VMN0000 +rojee rojear VMM03S0 +rojeemos rojear VMM01P0 +rojeen rojear VMM03P0 +rola rolar VMM02S0 +rolad rolar VMM02P0 +rolando rolar VMG0000 +rolar rolar VMN0000 +role rolar VMM03S0 +rolemos rolar VMM01P0 +rolen rolar VMM03P0 +romanice romanizar VMM03S0 +romanicemos romanizar VMM01P0 +romanicen romanizar VMM03P0 +romaniza romanizar VMM02S0 +romanizad romanizar VMM02P0 +romanizando romanizar VMG0000 +romanizar romanizar VMN0000 +rompa romper VMM03S0 +rompamos romper VMM01P0 +rompan romper VMM03P0 +rompe romper VMM02S0 +romped romper VMM02P0 +romper romper VMN0000 +rompiendo romper VMG0000 +ronca roncar VMM02S0 +roncad roncar VMM02P0 +roncando roncar VMG0000 +roncar roncar VMN0000 +ronce ronzar VMM03S0 +roncea roncear VMM02S0 +roncead roncear VMM02P0 +ronceando roncear VMG0000 +roncear roncear VMN0000 +roncee roncear VMM03S0 +ronceemos roncear VMM01P0 +ronceen roncear VMM03P0 +roncemos ronzar VMM01P0 +roncen ronzar VMM03P0 +ronda rondar VMM02S0 +rondad rondar VMM02P0 +rondando rondar VMG0000 +rondar rondar VMN0000 +ronde rondar VMM03S0 +rondemos rondar VMM01P0 +ronden rondar VMM03P0 +ronque roncar VMM03S0 +ronquea ronquear VMM02S0 +ronquead ronquear VMM02P0 +ronqueando ronquear VMG0000 +ronquear ronquear VMN0000 +ronquee ronquear VMM03S0 +ronqueemos ronquear VMM01P0 +ronqueen ronquear VMM03P0 +ronquemos roncar VMM01P0 +ronquen roncar VMM03P0 +ronronea ronronear VMM02S0 +ronronead ronronear VMM02P0 +ronroneando ronronear VMG0000 +ronronear ronronear VMN0000 +ronronee ronronear VMM03S0 +ronroneemos ronronear VMM01P0 +ronroneen ronronear VMM03P0 +ronza ronzar VMM02S0 +ronzad ronzar VMM02P0 +ronzando ronzar VMG0000 +ronzar ronzar VMN0000 +rosca roscar VMM02S0 +roscad roscar VMM02P0 +roscando roscar VMG0000 +roscar roscar VMN0000 +rosque roscar VMM03S0 +rosquemos roscar VMM01P0 +rosquen roscar VMM03P0 +rota rotar VMM02S0 +rotad rotar VMM02P0 +rotando rotar VMG0000 +rotar rotar VMN0000 +rote rotar VMM03S0 +rotemos rotar VMM01P0 +roten rotar VMM03P0 +rotula rotular VMM02S0 +rotulad rotular VMM02P0 +rotulando rotular VMG0000 +rotular rotular VMN0000 +rotule rotular VMM03S0 +rotulemos rotular VMM01P0 +rotulen rotular VMM03P0 +rotura roturar VMM02S0 +roturad roturar VMM02P0 +roturando roturar VMG0000 +roturar roturar VMN0000 +roture roturar VMM03S0 +roturemos roturar VMM01P0 +roturen roturar VMM03P0 +roya roer VMM03S0 +royamos roer VMM01P0 +royan roer VMM03P0 +royendo roer VMG0000 +roza rozar VMM02S0 +rozad rozar VMM02P0 +rozando rozar VMG0000 +rozar rozar VMN0000 +rubifica rubificar VMM02S0 +rubificad rubificar VMM02P0 +rubificando rubificar VMG0000 +rubificar rubificar VMN0000 +rubifique rubificar VMM03S0 +rubifiquemos rubificar VMM01P0 +rubifiquen rubificar VMM03P0 +ruborice ruborizar VMM03S0 +ruboricemos ruborizar VMM01P0 +ruboricen ruborizar VMM03P0 +ruboriza ruborizar VMM02S0 +ruborizad ruborizar VMM02P0 +ruborizando ruborizar VMG0000 +ruborizar ruborizar VMN0000 +rubrica rubricar VMM02S0 +rubricad rubricar VMM02P0 +rubricando rubricar VMG0000 +rubricar rubricar VMN0000 +rubrique rubricar VMM03S0 +rubriquemos rubricar VMM01P0 +rubriquen rubricar VMM03P0 +rueda rodar VMM02S0 +ruede rodar VMM03S0 +rueden rodar VMM03P0 +ruega rogar VMM02S0 +ruegue rogar VMM03S0 +rueguen rogar VMM03P0 +rufianea rufianear VMM02S0 +rufianead rufianear VMM02P0 +rufianeando rufianear VMG0000 +rufianear rufianear VMN0000 +rufianee rufianear VMM03S0 +rufianeemos rufianear VMM01P0 +rufianeen rufianear VMM03P0 +ruge rugir VMM02S0 +rugid rugir VMM02P0 +rugiendo rugir VMG0000 +rugir rugir VMN0000 +ruja rugir VMM03S0 +rujamos rugir VMM01P0 +rujan rugir VMM03P0 +rumbea rumbear VMM02S0 +rumbead rumbear VMM02P0 +rumbeando rumbear VMG0000 +rumbear rumbear VMN0000 +rumbee rumbear VMM03S0 +rumbeemos rumbear VMM01P0 +rumbeen rumbear VMM03P0 +rumia rumiar VMM02S0 +rumiad rumiar VMM02P0 +rumiando rumiar VMG0000 +rumiar rumiar VMN0000 +rumie rumiar VMM03S0 +rumiemos rumiar VMM01P0 +rumien rumiar VMM03P0 +rumora rumorar VMM02S0 +rumorad rumorar VMM02P0 +rumorando rumorar VMG0000 +rumorar rumorar VMN0000 +rumore rumorar VMM03S0 +rumorea rumorear VMM02S0 +rumoread rumorear VMM02P0 +rumoreando rumorear VMG0000 +rumorear rumorear VMN0000 +rumoree rumorear VMM03S0 +rumoreemos rumorear VMM01P0 +rumoreen rumorear VMM03P0 +rumoremos rumorar VMM01P0 +rumoren rumorar VMM03P0 +runrunea runrunear VMM02S0 +runrunead runrunear VMM02P0 +runruneando runrunear VMG0000 +runrunear runrunear VMN0000 +runrunee runrunear VMM03S0 +runruneemos runrunear VMM01P0 +runruneen runrunear VMM03P0 +rusifica rusificar VMM02S0 +rusificad rusificar VMM02P0 +rusificando rusificar VMG0000 +rusificar rusificar VMN0000 +rusifique rusificar VMM03S0 +rusifiquemos rusificar VMM01P0 +rusifiquen rusificar VMM03P0 +rutila rutilar VMM02S0 +rutilad rutilar VMM02P0 +rutilando rutilar VMG0000 +rutilar rutilar VMN0000 +rutile rutilar VMM03S0 +rutilemos rutilar VMM01P0 +rutilen rutilar VMM03P0 +ruña ruñar VMM02S0 +ruñad ruñar VMM02P0 +ruñando ruñar VMG0000 +ruñar ruñar VMN0000 +ruñe ruñar VMM03S0 +ruñemos ruñar VMM01P0 +ruñen ruñar VMM03P0 +ría reír VMM03S0 +rían reír VMM03P0 +ríe reír VMM02S0 +sabanea sabanear VMM02S0 +sabanead sabanear VMM02P0 +sabaneando sabanear VMG0000 +sabanear sabanear VMN0000 +sabanee sabanear VMM03S0 +sabaneemos sabanear VMM01P0 +sabaneen sabanear VMM03P0 +sabe saber VMM02S0 +sabed saber VMM02P0 +saber saber VMN0000 +sabiendo saber VMG0000 +sablea sablear VMM02S0 +sablead sablear VMM02P0 +sableando sablear VMG0000 +sablear sablear VMN0000 +sablee sablear VMM03S0 +sableemos sablear VMM01P0 +sableen sablear VMM03P0 +saborea saborear VMM02S0 +saboread saborear VMM02P0 +saboreando saborear VMG0000 +saborear saborear VMN0000 +saboree saborear VMM03S0 +saboreemos saborear VMM01P0 +saboreen saborear VMM03P0 +sabotea sabotear VMM02S0 +sabotead sabotear VMM02P0 +saboteando sabotear VMG0000 +sabotear sabotear VMN0000 +sabotee sabotear VMM03S0 +saboteemos sabotear VMM01P0 +saboteen sabotear VMM03P0 +saca sacar VMM02S0 +sacad sacar VMM02P0 +sacando sacar VMG0000 +sacar sacar VMN0000 +sacarifica sacarificar VMM02S0 +sacarificad sacarificar VMM02P0 +sacarificando sacarificar VMG0000 +sacarificar sacarificar VMN0000 +sacarifique sacarificar VMM03S0 +sacarifiquemos sacarificar VMM01P0 +sacarifiquen sacarificar VMM03P0 +sacha sachar VMM02S0 +sachad sachar VMM02P0 +sachando sachar VMG0000 +sachar sachar VMN0000 +sache sachar VMM03S0 +sachemos sachar VMM01P0 +sachen sachar VMM03P0 +sacia saciar VMM02S0 +saciad saciar VMM02P0 +saciando saciar VMG0000 +saciar saciar VMN0000 +sacie saciar VMM03S0 +saciemos saciar VMM01P0 +sacien saciar VMM03P0 +sacralice sacralizar VMM03S0 +sacralicemos sacralizar VMM01P0 +sacralicen sacralizar VMM03P0 +sacraliza sacralizar VMM02S0 +sacralizad sacralizar VMM02P0 +sacralizando sacralizar VMG0000 +sacralizar sacralizar VMN0000 +sacramenta sacramentar VMM02S0 +sacramentad sacramentar VMM02P0 +sacramentando sacramentar VMG0000 +sacramentar sacramentar VMN0000 +sacramente sacramentar VMM03S0 +sacramentemos sacramentar VMM01P0 +sacramenten sacramentar VMM03P0 +sacrifica sacrificar VMM02S0 +sacrificad sacrificar VMM02P0 +sacrificando sacrificar VMG0000 +sacrificar sacrificar VMN0000 +sacrifique sacrificar VMM03S0 +sacrifiquemos sacrificar VMM01P0 +sacrifiquen sacrificar VMM03P0 +sacuda sacudir VMM03S0 +sacudamos sacudir VMM01P0 +sacudan sacudir VMM03P0 +sacude sacudir VMM02S0 +sacudid sacudir VMM02P0 +sacudiendo sacudir VMG0000 +sacudir sacudir VMN0000 +saetea saetear VMM02S0 +saetead saetear VMM02P0 +saeteando saetear VMG0000 +saetear saetear VMN0000 +saetee saetear VMM03S0 +saeteemos saetear VMM01P0 +saeteen saetear VMM03P0 +sahorna sahornar VMM02S0 +sahornad sahornar VMM02P0 +sahornando sahornar VMG0000 +sahornar sahornar VMN0000 +sahorne sahornar VMM03S0 +sahornemos sahornar VMM01P0 +sahornen sahornar VMM03P0 +sainad sainar VMM02P0 +sainando sainar VMG0000 +sainar sainar VMN0000 +sainemos sainar VMM01P0 +sainetea sainetear VMM02S0 +sainetead sainetear VMM02P0 +saineteando sainetear VMG0000 +sainetear sainetear VMN0000 +sainetee sainetear VMM03S0 +saineteemos sainetear VMM01P0 +saineteen sainetear VMM03P0 +saja sajar VMM02S0 +sajad sajar VMM02P0 +sajando sajar VMG0000 +sajar sajar VMN0000 +saje sajar VMM03S0 +sajemos sajar VMM01P0 +sajen sajar VMM03P0 +sal salir VMM02S0 +sala salar VMM02S0 +salad salar VMM02P0 +salando salar VMG0000 +salar salar VMN0000 +salaria salariar VMM02S0 +salariad salariar VMM02P0 +salariando salariar VMG0000 +salariar salariar VMN0000 +salarie salariar VMM03S0 +salariemos salariar VMM01P0 +salarien salariar VMM03P0 +salcocha salcochar VMM02S0 +salcochad salcochar VMM02P0 +salcochando salcochar VMG0000 +salcochar salcochar VMN0000 +salcoche salcochar VMM03S0 +salcochemos salcochar VMM01P0 +salcochen salcochar VMM03P0 +salda saldar VMM02S0 +saldad saldar VMM02P0 +saldando saldar VMG0000 +saldar saldar VMN0000 +salde saldar VMM03S0 +saldemos saldar VMM01P0 +salden saldar VMM03P0 +sale salar VMM03S0 +salemos salar VMM01P0 +salen salar VMM03P0 +salga salgar VMM02S0 +salga salir VMM03S0 +salgad salgar VMM02P0 +salgamos salir VMM01P0 +salgan salir VMM03P0 +salgando salgar VMG0000 +salgar salgar VMN0000 +salgue salgar VMM03S0 +salguemos salgar VMM01P0 +salguen salgar VMM03P0 +salid salir VMM02P0 +saliendo salir VMG0000 +salifica salificar VMM02S0 +salificad salificar VMM02P0 +salificando salificar VMG0000 +salificar salificar VMN0000 +salifique salificar VMM03S0 +salifiquemos salificar VMM01P0 +salifiquen salificar VMM03P0 +salir salir VMN0000 +saliva salivar VMM02S0 +salivad salivar VMM02P0 +salivando salivar VMG0000 +salivar salivar VMN0000 +salive salivar VMM03S0 +salivemos salivar VMM01P0 +saliven salivar VMM03P0 +salmea salmear VMM02S0 +salmead salmear VMM02P0 +salmeando salmear VMG0000 +salmear salmear VMN0000 +salmee salmear VMM03S0 +salmeemos salmear VMM01P0 +salmeen salmear VMM03P0 +salmodia salmodiar VMM02S0 +salmodiad salmodiar VMM02P0 +salmodiando salmodiar VMG0000 +salmodiar salmodiar VMN0000 +salmodie salmodiar VMM03S0 +salmodiemos salmodiar VMM01P0 +salmodien salmodiar VMM03P0 +salpica salpicar VMM02S0 +salpicad salpicar VMM02P0 +salpicando salpicar VMG0000 +salpicar salpicar VMN0000 +salpimentad salpimentar VMM02P0 +salpimentando salpimentar VMG0000 +salpimentar salpimentar VMN0000 +salpimentemos salpimentar VMM01P0 +salpimienta salpimentar VMM02S0 +salpimiente salpimentar VMM03S0 +salpimienten salpimentar VMM03P0 +salpique salpicar VMM03S0 +salpiquemos salpicar VMM01P0 +salpiquen salpicar VMM03P0 +salpresa salpresar VMM02S0 +salpresad salpresar VMM02P0 +salpresando salpresar VMG0000 +salpresar salpresar VMN0000 +salprese salpresar VMM03S0 +salpresemos salpresar VMM01P0 +salpresen salpresar VMM03P0 +salta saltar VMM02S0 +saltad saltar VMM02P0 +saltando saltar VMG0000 +saltar saltar VMN0000 +salte saltar VMM03S0 +saltea saltear VMM02S0 +saltead saltear VMM02P0 +salteando saltear VMG0000 +saltear saltear VMN0000 +saltee saltear VMM03S0 +salteemos saltear VMM01P0 +salteen saltear VMM03P0 +saltemos saltar VMM01P0 +salten saltar VMM03P0 +saluda saludar VMM02S0 +saludad saludar VMM02P0 +saludando saludar VMG0000 +saludar saludar VMN0000 +salude saludar VMM03S0 +saludemos saludar VMM01P0 +saluden saludar VMM03P0 +salva salvar VMM02S0 +salvad salvar VMM02P0 +salvaguarda salvaguardar VMM02S0 +salvaguardad salvaguardar VMM02P0 +salvaguardando salvaguardar VMG0000 +salvaguardar salvaguardar VMN0000 +salvaguarde salvaguardar VMM03S0 +salvaguardemos salvaguardar VMM01P0 +salvaguarden salvaguardar VMM03P0 +salvando salvar VMG0000 +salvar salvar VMN0000 +salve salvar VMM03S0 +salvemos salvar VMM01P0 +salven salvar VMM03P0 +sana sanar VMM02S0 +sanad sanar VMM02P0 +sanando sanar VMG0000 +sanar sanar VMN0000 +sanciona sancionar VMM02S0 +sancionad sancionar VMM02P0 +sancionando sancionar VMG0000 +sancionar sancionar VMN0000 +sancione sancionar VMM03S0 +sancionemos sancionar VMM01P0 +sancionen sancionar VMM03P0 +sancocha sancochar VMM02S0 +sancochad sancochar VMM02P0 +sancochando sancochar VMG0000 +sancochar sancochar VMN0000 +sancoche sancochar VMM03S0 +sancochemos sancochar VMM01P0 +sancochen sancochar VMM03P0 +sane sanar VMM03S0 +sanea sanear VMM02S0 +sanead sanear VMM02P0 +saneando sanear VMG0000 +sanear sanear VMN0000 +sanee sanear VMM03S0 +saneemos sanear VMM01P0 +saneen sanear VMM03P0 +sanemos sanar VMM01P0 +sanen sanar VMM03P0 +sangra sangrar VMM02S0 +sangrad sangrar VMM02P0 +sangrando sangrar VMG0000 +sangrar sangrar VMN0000 +sangre sangrar VMM03S0 +sangremos sangrar VMM01P0 +sangren sangrar VMM03P0 +sanguifica sanguificar VMM02S0 +sanguificad sanguificar VMM02P0 +sanguificando sanguificar VMG0000 +sanguificar sanguificar VMN0000 +sanguifique sanguificar VMM03S0 +sanguifiquemos sanguificar VMM01P0 +sanguifiquen sanguificar VMM03P0 +santifica santificar VMM02S0 +santificad santificar VMM02P0 +santificando santificar VMG0000 +santificar santificar VMN0000 +santifique santificar VMM03S0 +santifiquemos santificar VMM01P0 +santifiquen santificar VMM03P0 +santigua santiguar VMM02S0 +santiguad santiguar VMM02P0 +santiguando santiguar VMG0000 +santiguar santiguar VMN0000 +santigüe santiguar VMM03S0 +santigüemos santiguar VMM01P0 +santigüen santiguar VMM03P0 +saponifica saponificar VMM02S0 +saponificad saponificar VMM02P0 +saponificando saponificar VMG0000 +saponificar saponificar VMN0000 +saponifique saponificar VMM03S0 +saponifiquemos saponificar VMM01P0 +saponifiquen saponificar VMM03P0 +saque sacar VMM03S0 +saquea saquear VMM02S0 +saquead saquear VMM02P0 +saqueando saquear VMG0000 +saquear saquear VMN0000 +saquee saquear VMM03S0 +saqueemos saquear VMM01P0 +saqueen saquear VMM03P0 +saquemos sacar VMM01P0 +saquen sacar VMM03P0 +sargentea sargentear VMM02S0 +sargentead sargentear VMM02P0 +sargenteando sargentear VMG0000 +sargentear sargentear VMN0000 +sargentee sargentear VMM03S0 +sargenteemos sargentear VMM01P0 +sargenteen sargentear VMM03P0 +sarmentad sarmentar VMM02P0 +sarmentando sarmentar VMG0000 +sarmentar sarmentar VMN0000 +sarmentemos sarmentar VMM01P0 +sarmienta sarmentar VMM02S0 +sarmiente sarmentar VMM03S0 +sarmienten sarmentar VMM03P0 +satelice satelizar VMM03S0 +satelicemos satelizar VMM01P0 +satelicen satelizar VMM03P0 +sateliza satelizar VMM02S0 +satelizad satelizar VMM02P0 +satelizando satelizar VMG0000 +satelizar satelizar VMN0000 +satina satinar VMM02S0 +satinad satinar VMM02P0 +satinando satinar VMG0000 +satinar satinar VMN0000 +satine satinar VMM03S0 +satinemos satinar VMM01P0 +satinen satinar VMM03P0 +satirice satirizar VMM03S0 +satiricemos satirizar VMM01P0 +satiricen satirizar VMM03P0 +satiriza satirizar VMM02S0 +satirizad satirizar VMM02P0 +satirizando satirizar VMG0000 +satirizar satirizar VMN0000 +satisface satisfacer VMM02S0 +satisfaced satisfacer VMM02P0 +satisfacer satisfacer VMN0000 +satisfaciendo satisfacer VMG0000 +satisfaga satisfacer VMM03S0 +satisfagamos satisfacer VMM01P0 +satisfagan satisfacer VMM03P0 +satisfaz satisfacer VMM02S0 +satura saturar VMM02S0 +saturad saturar VMM02P0 +saturando saturar VMG0000 +saturar saturar VMN0000 +sature saturar VMM03S0 +saturemos saturar VMM01P0 +saturen saturar VMM03P0 +sazona sazonar VMM02S0 +sazonad sazonar VMM02P0 +sazonando sazonar VMG0000 +sazonar sazonar VMN0000 +sazone sazonar VMM03S0 +sazonemos sazonar VMM01P0 +sazonen sazonar VMM03P0 +saína sainar VMM02S0 +saíne sainar VMM03S0 +saínen sainar VMM03P0 +seca secar VMM02S0 +secad secar VMM02P0 +secando secar VMG0000 +secar secar VMN0000 +secciona seccionar VMM02S0 +seccionad seccionar VMM02P0 +seccionando seccionar VMG0000 +seccionar seccionar VMN0000 +seccione seccionar VMM03S0 +seccionemos seccionar VMM01P0 +seccionen seccionar VMM03P0 +secreta secretar VMM02S0 +secretad secretar VMM02P0 +secretando secretar VMG0000 +secretar secretar VMN0000 +secrete secretar VMM03S0 +secretea secretear VMM02S0 +secretead secretear VMM02P0 +secreteando secretear VMG0000 +secretear secretear VMN0000 +secretee secretear VMM03S0 +secreteemos secretear VMM01P0 +secreteen secretear VMM03P0 +secretemos secretar VMM01P0 +secreten secretar VMM03P0 +secuencia secuenciar VMM02S0 +secuenciad secuenciar VMM02P0 +secuenciando secuenciar VMG0000 +secuenciar secuenciar VMN0000 +secuencie secuenciar VMM03S0 +secuenciemos secuenciar VMM01P0 +secuencien secuenciar VMM03P0 +secuestra secuestrar VMM02S0 +secuestrad secuestrar VMM02P0 +secuestrando secuestrar VMG0000 +secuestrar secuestrar VMN0000 +secuestre secuestrar VMM03S0 +secuestremos secuestrar VMM01P0 +secuestren secuestrar VMM03P0 +secularice secularizar VMM03S0 +secularicemos secularizar VMM01P0 +secularicen secularizar VMM03P0 +seculariza secularizar VMM02S0 +secularizad secularizar VMM02P0 +secularizando secularizar VMG0000 +secularizar secularizar VMN0000 +secunda secundar VMM02S0 +secundad secundar VMM02P0 +secundando secundar VMG0000 +secundar secundar VMN0000 +secunde secundar VMM03S0 +secundemos secundar VMM01P0 +secunden secundar VMM03P0 +seda sedar VMM02S0 +sedad sedar VMM02P0 +sedando sedar VMG0000 +sedar sedar VMN0000 +sede sedar VMM03S0 +sedea sedear VMM02S0 +sedead sedear VMM02P0 +sedeando sedear VMG0000 +sedear sedear VMN0000 +sedee sedear VMM03S0 +sedeemos sedear VMM01P0 +sedeen sedear VMM03P0 +sedemos sedar VMM01P0 +seden sedar VMM03P0 +sedimenta sedimentar VMM02S0 +sedimentad sedimentar VMM02P0 +sedimentando sedimentar VMG0000 +sedimentar sedimentar VMN0000 +sedimente sedimentar VMM03S0 +sedimentemos sedimentar VMM01P0 +sedimenten sedimentar VMM03P0 +seduce seducir VMM02S0 +seducid seducir VMM02P0 +seduciendo seducir VMG0000 +seducir seducir VMN0000 +seduzca seducir VMM03S0 +seduzcamos seducir VMM01P0 +seduzcan seducir VMM03P0 +segad segar VMM02P0 +segando segar VMG0000 +segar segar VMN0000 +segmenta segmentar VMM02S0 +segmentad segmentar VMM02P0 +segmentando segmentar VMG0000 +segmentar segmentar VMN0000 +segmente segmentar VMM03S0 +segmentemos segmentar VMM01P0 +segmenten segmentar VMM03P0 +segrega segregar VMM02S0 +segregad segregar VMM02P0 +segregando segregar VMG0000 +segregar segregar VMN0000 +segregue segregar VMM03S0 +segreguemos segregar VMM01P0 +segreguen segregar VMM03P0 +seguemos segar VMM01P0 +seguid seguir VMM02P0 +seguir seguir VMN0000 +segunda segundar VMM02S0 +segundad segundar VMM02P0 +segundando segundar VMG0000 +segundar segundar VMN0000 +segunde segundar VMM03S0 +segundemos segundar VMM01P0 +segunden segundar VMM03P0 +selecciona seleccionar VMM02S0 +seleccionad seleccionar VMM02P0 +seleccionando seleccionar VMG0000 +seleccionar seleccionar VMN0000 +seleccione seleccionar VMM03S0 +seleccionemos seleccionar VMM01P0 +seleccionen seleccionar VMM03P0 +sella sellar VMM02S0 +sellad sellar VMM02P0 +sellando sellar VMG0000 +sellar sellar VMN0000 +selle sellar VMM03S0 +sellemos sellar VMM01P0 +sellen sellar VMM03P0 +sembrad sembrar VMM02P0 +sembrando sembrar VMG0000 +sembrar sembrar VMN0000 +sembremos sembrar VMM01P0 +semeja semejar VMM02S0 +semejad semejar VMM02P0 +semejando semejar VMG0000 +semejar semejar VMN0000 +semeje semejar VMM03S0 +semejemos semejar VMM01P0 +semejen semejar VMM03P0 +semicerrad semicerrar VMM02P0 +semicerrando semicerrar VMG0000 +semicerrar semicerrar VMN0000 +semicierra semicerrar VMM02S0 +senderea senderear VMM02S0 +senderead senderear VMM02P0 +sendereando senderear VMG0000 +senderear senderear VMN0000 +senderee senderear VMM03S0 +sendereemos senderear VMM01P0 +sendereen senderear VMM03P0 +sensibilice sensibilizar VMM03S0 +sensibilicemos sensibilizar VMM01P0 +sensibilicen sensibilizar VMM03P0 +sensibiliza sensibilizar VMM02S0 +sensibilizad sensibilizar VMM02P0 +sensibilizando sensibilizar VMG0000 +sensibilizar sensibilizar VMN0000 +sentad sentar VMM02P0 +sentando sentar VMG0000 +sentar sentar VMN0000 +sentemos sentar VMM01P0 +sentencia sentenciar VMM02S0 +sentenciad sentenciar VMM02P0 +sentenciando sentenciar VMG0000 +sentenciar sentenciar VMN0000 +sentencie sentenciar VMM03S0 +sentenciemos sentenciar VMM01P0 +sentencien sentenciar VMM03P0 +sentid sentir VMM02P0 +sentir sentir VMN0000 +sepa saber VMM03S0 +sepamos saber VMM01P0 +sepan saber VMM03P0 +separa separar VMM02S0 +separad separar VMM02P0 +separando separar VMG0000 +separar separar VMN0000 +separe separar VMM03S0 +separemos separar VMM01P0 +separen separar VMM03P0 +septuplica septuplicar VMM02S0 +septuplicad septuplicar VMM02P0 +septuplicando septuplicar VMG0000 +septuplicar septuplicar VMN0000 +septuplique septuplicar VMM03S0 +septupliquemos septuplicar VMM01P0 +septupliquen septuplicar VMM03P0 +sepulta sepultar VMM02S0 +sepultad sepultar VMM02P0 +sepultando sepultar VMG0000 +sepultar sepultar VMN0000 +sepulte sepultar VMM03S0 +sepultemos sepultar VMM01P0 +sepulten sepultar VMM03P0 +seque secar VMM03S0 +sequemos secar VMM01P0 +sequen secar VMM03P0 +serena serenar VMM02S0 +serenad serenar VMM02P0 +serenando serenar VMG0000 +serenar serenar VMN0000 +serene serenar VMM03S0 +serenemos serenar VMM01P0 +serenen serenar VMM03P0 +seria seriar VMM02S0 +seriad seriar VMM02P0 +seriando seriar VMG0000 +seriar seriar VMN0000 +serie seriar VMM03S0 +seriemos seriar VMM01P0 +serien seriar VMM03P0 +sermonea sermonear VMM02S0 +sermonead sermonear VMM02P0 +sermoneando sermonear VMG0000 +sermonear sermonear VMN0000 +sermonee sermonear VMM03S0 +sermoneemos sermonear VMM01P0 +sermoneen sermonear VMM03P0 +serpentea serpentear VMM02S0 +serpentead serpentear VMM02P0 +serpenteando serpentear VMG0000 +serpentear serpentear VMN0000 +serpentee serpentear VMM03S0 +serpenteemos serpentear VMM01P0 +serpenteen serpentear VMM03P0 +serpolla serpollar VMM02S0 +serpollad serpollar VMM02P0 +serpollando serpollar VMG0000 +serpollar serpollar VMN0000 +serpolle serpollar VMM03S0 +serpollemos serpollar VMM01P0 +serpollen serpollar VMM03P0 +serrad serrar VMM02P0 +serrando serrar VMG0000 +serrar serrar VMN0000 +serremos serrar VMM01P0 +servid servir VMM02P0 +servir servir VMN0000 +sesea sesear VMM02S0 +sesead sesear VMM02P0 +seseando sesear VMG0000 +sesear sesear VMN0000 +sesee sesear VMM03S0 +seseemos sesear VMM01P0 +seseen sesear VMM03P0 +sesga sesgar VMM02S0 +sesgad sesgar VMM02P0 +sesgando sesgar VMG0000 +sesgar sesgar VMN0000 +sesgue sesgar VMM03S0 +sesguemos sesgar VMM01P0 +sesguen sesgar VMM03P0 +sestea sestear VMM02S0 +sestead sestear VMM02P0 +sesteando sestear VMG0000 +sestear sestear VMN0000 +sestee sestear VMM03S0 +sesteemos sestear VMM01P0 +sesteen sestear VMM03P0 +sextava sextavar VMM02S0 +sextavad sextavar VMM02P0 +sextavando sextavar VMG0000 +sextavar sextavar VMN0000 +sextave sextavar VMM03S0 +sextavemos sextavar VMM01P0 +sextaven sextavar VMM03P0 +sextuplica sextuplicar VMM02S0 +sextuplicad sextuplicar VMM02P0 +sextuplicando sextuplicar VMG0000 +sextuplicar sextuplicar VMN0000 +sextuplique sextuplicar VMM03S0 +sextupliquemos sextuplicar VMM01P0 +sextupliquen sextuplicar VMM03P0 +señala señalar VMM02S0 +señalad señalar VMM02P0 +señalando señalar VMG0000 +señalar señalar VMN0000 +señale señalar VMM03S0 +señalemos señalar VMM01P0 +señalen señalar VMM03P0 +señalice señalizar VMM03S0 +señalicemos señalizar VMM01P0 +señalicen señalizar VMM03P0 +señaliza señalizar VMM02S0 +señalizad señalizar VMM02P0 +señalizando señalizar VMG0000 +señalizar señalizar VMN0000 +señorea señorear VMM02S0 +señoread señorear VMM02P0 +señoreando señorear VMG0000 +señorear señorear VMN0000 +señoree señorear VMM03S0 +señoreemos señorear VMM01P0 +señoreen señorear VMM03P0 +siega segar VMM02S0 +siegue segar VMM03S0 +sieguen segar VMM03P0 +siembra sembrar VMM02S0 +siembre sembrar VMM03S0 +siembren sembrar VMM03P0 +sienta sentar VMM02S0 +sienta sentir VMM03S0 +sientan sentir VMM03P0 +siente sentar VMM03S0 +siente sentir VMM02S0 +sienten sentar VMM03P0 +sierra serrar VMM02S0 +sierre serrar VMM03S0 +sierren serrar VMM03P0 +siga seguir VMM03S0 +sigamos seguir VMM01P0 +sigan seguir VMM03P0 +sigila sigilar VMM02S0 +sigilad sigilar VMM02P0 +sigilando sigilar VMG0000 +sigilar sigilar VMN0000 +sigile sigilar VMM03S0 +sigilemos sigilar VMM01P0 +sigilen sigilar VMM03P0 +signa signar VMM02S0 +signad signar VMM02P0 +signando signar VMG0000 +signar signar VMN0000 +signe signar VMM03S0 +signemos signar VMM01P0 +signen signar VMM03P0 +significa significar VMM02S0 +significad significar VMM02P0 +significando significar VMG0000 +significar significar VMN0000 +signifique significar VMM03S0 +signifiquemos significar VMM01P0 +signifiquen significar VMM03P0 +sigue seguir VMM02S0 +siguiendo seguir VMG0000 +silaba silabar VMM02S0 +silabad silabar VMM02P0 +silabando silabar VMG0000 +silabar silabar VMN0000 +silabe silabar VMM03S0 +silabea silabear VMM02S0 +silabead silabear VMM02P0 +silabeando silabear VMG0000 +silabear silabear VMN0000 +silabee silabear VMM03S0 +silabeemos silabear VMM01P0 +silabeen silabear VMM03P0 +silabemos silabar VMM01P0 +silaben silabar VMM03P0 +silba silbar VMM02S0 +silbad silbar VMM02P0 +silbando silbar VMG0000 +silbar silbar VMN0000 +silbe silbar VMM03S0 +silbemos silbar VMM01P0 +silben silbar VMM03P0 +silencia silenciar VMM02S0 +silenciad silenciar VMM02P0 +silenciando silenciar VMG0000 +silenciar silenciar VMN0000 +silencie silenciar VMM03S0 +silenciemos silenciar VMM01P0 +silencien silenciar VMM03P0 +silogice silogizar VMM03S0 +silogicemos silogizar VMM01P0 +silogicen silogizar VMM03P0 +silogiza silogizar VMM02S0 +silogizad silogizar VMM02P0 +silogizando silogizar VMG0000 +silogizar silogizar VMN0000 +simbolice simbolizar VMM03S0 +simbolicemos simbolizar VMM01P0 +simbolicen simbolizar VMM03P0 +simboliza simbolizar VMM02S0 +simbolizad simbolizar VMM02P0 +simbolizando simbolizar VMG0000 +simbolizar simbolizar VMN0000 +simpatice simpatizar VMM03S0 +simpaticemos simpatizar VMM01P0 +simpaticen simpatizar VMM03P0 +simpatiza simpatizar VMM02S0 +simpatizad simpatizar VMM02P0 +simpatizando simpatizar VMG0000 +simpatizar simpatizar VMN0000 +simplifica simplificar VMM02S0 +simplificad simplificar VMM02P0 +simplificando simplificar VMG0000 +simplificar simplificar VMN0000 +simplifique simplificar VMM03S0 +simplifiquemos simplificar VMM01P0 +simplifiquen simplificar VMM03P0 +simula simular VMM02S0 +simulad simular VMM02P0 +simulando simular VMG0000 +simular simular VMN0000 +simule simular VMM03S0 +simulemos simular VMM01P0 +simulen simular VMM03P0 +simultanea simultanear VMM02S0 +simultanead simultanear VMM02P0 +simultaneando simultanear VMG0000 +simultanear simultanear VMN0000 +simultanee simultanear VMM03S0 +simultaneemos simultanear VMM01P0 +simultaneen simultanear VMM03P0 +sincera sincerar VMM02S0 +sincerad sincerar VMM02P0 +sincerando sincerar VMG0000 +sincerar sincerar VMN0000 +sincere sincerar VMM03S0 +sinceremos sincerar VMM01P0 +sinceren sincerar VMM03P0 +sincopa sincopar VMM02S0 +sincopad sincopar VMM02P0 +sincopando sincopar VMG0000 +sincopar sincopar VMN0000 +sincope sincopar VMM03S0 +sincopemos sincopar VMM01P0 +sincopen sincopar VMM03P0 +sincopice sincopizar VMM03S0 +sincopicemos sincopizar VMM01P0 +sincopicen sincopizar VMM03P0 +sincopiza sincopizar VMM02S0 +sincopizad sincopizar VMM02P0 +sincopizando sincopizar VMG0000 +sincopizar sincopizar VMN0000 +sincronice sincronizar VMM03S0 +sincronicemos sincronizar VMM01P0 +sincronicen sincronizar VMM03P0 +sincroniza sincronizar VMM02S0 +sincronizad sincronizar VMM02P0 +sincronizando sincronizar VMG0000 +sincronizar sincronizar VMN0000 +sindica sindicar VMM02S0 +sindicad sindicar VMM02P0 +sindicando sindicar VMG0000 +sindicar sindicar VMN0000 +sindique sindicar VMM03S0 +sindiquemos sindicar VMM01P0 +sindiquen sindicar VMM03P0 +singa singar VMM02S0 +singad singar VMM02P0 +singando singar VMG0000 +singar singar VMN0000 +singla singlar VMM02S0 +singlad singlar VMM02P0 +singlando singlar VMG0000 +singlar singlar VMN0000 +single singlar VMM03S0 +singlemos singlar VMM01P0 +singlen singlar VMM03P0 +singue singar VMM03S0 +singuemos singar VMM01P0 +singuen singar VMM03P0 +singularice singularizar VMM03S0 +singularicemos singularizar VMM01P0 +singularicen singularizar VMM03P0 +singulariza singularizar VMM02S0 +singularizad singularizar VMM02P0 +singularizando singularizar VMG0000 +singularizar singularizar VMN0000 +sintamos sentir VMM01P0 +sinterice sinterizar VMM03S0 +sintericemos sinterizar VMM01P0 +sintericen sinterizar VMM03P0 +sinteriza sinterizar VMM02S0 +sinterizad sinterizar VMM02P0 +sinterizando sinterizar VMG0000 +sinterizar sinterizar VMN0000 +sintetice sintetizar VMM03S0 +sinteticemos sintetizar VMM01P0 +sinteticen sintetizar VMM03P0 +sintetiza sintetizar VMM02S0 +sintetizad sintetizar VMM02P0 +sintetizando sintetizar VMG0000 +sintetizar sintetizar VMN0000 +sintiendo sentir VMG0000 +sintonice sintonizar VMM03S0 +sintonicemos sintonizar VMM01P0 +sintonicen sintonizar VMM03P0 +sintoniza sintonizar VMM02S0 +sintonizad sintonizar VMM02P0 +sintonizando sintonizar VMG0000 +sintonizar sintonizar VMN0000 +sirga sirgar VMM02S0 +sirgad sirgar VMM02P0 +sirgando sirgar VMG0000 +sirgar sirgar VMN0000 +sirgue sirgar VMM03S0 +sirguemos sirgar VMM01P0 +sirguen sirgar VMM03P0 +sirva servir VMM03S0 +sirvamos servir VMM01P0 +sirvan servir VMM03P0 +sirve servir VMM02S0 +sirviendo servir VMG0000 +sisa sisar VMM02S0 +sisad sisar VMM02P0 +sisando sisar VMG0000 +sisar sisar VMN0000 +sise sisar VMM03S0 +sisea sisear VMM02S0 +sisead sisear VMM02P0 +siseando sisear VMG0000 +sisear sisear VMN0000 +sisee sisear VMM03S0 +siseemos sisear VMM01P0 +siseen sisear VMM03P0 +sisemos sisar VMM01P0 +sisen sisar VMM03P0 +sistematice sistematizar VMM03S0 +sistematicemos sistematizar VMM01P0 +sistematicen sistematizar VMM03P0 +sistematiza sistematizar VMM02S0 +sistematizad sistematizar VMM02P0 +sistematizando sistematizar VMG0000 +sistematizar sistematizar VMN0000 +sitia sitiar VMM02S0 +sitiad sitiar VMM02P0 +sitiando sitiar VMG0000 +sitiar sitiar VMN0000 +sitie sitiar VMM03S0 +sitiemos sitiar VMM01P0 +sitien sitiar VMM03P0 +situad situar VMM02P0 +situando situar VMG0000 +situar situar VMN0000 +situemos situar VMM01P0 +sitúa situar VMM02S0 +sitúe situar VMM03S0 +sitúen situar VMM03P0 +soasa soasar VMM02S0 +soasad soasar VMM02P0 +soasando soasar VMG0000 +soasar soasar VMN0000 +soase soasar VMM03S0 +soasemos soasar VMM01P0 +soasen soasar VMM03P0 +soba sobar VMM02S0 +sobad sobar VMM02P0 +sobaja sobajar VMM02S0 +sobajad sobajar VMM02P0 +sobajando sobajar VMG0000 +sobajar sobajar VMN0000 +sobaje sobajar VMM03S0 +sobajea sobajear VMM02S0 +sobajead sobajear VMM02P0 +sobajeando sobajear VMG0000 +sobajear sobajear VMN0000 +sobajee sobajear VMM03S0 +sobajeemos sobajear VMM01P0 +sobajeen sobajear VMM03P0 +sobajemos sobajar VMM01P0 +sobajen sobajar VMM03P0 +sobando sobar VMG0000 +sobar sobar VMN0000 +sobe sobar VMM03S0 +sobemos sobar VMM01P0 +soben sobar VMM03P0 +soberanea soberanear VMM02S0 +soberanead soberanear VMM02P0 +soberaneando soberanear VMG0000 +soberanear soberanear VMN0000 +soberanee soberanear VMM03S0 +soberaneemos soberanear VMM01P0 +soberaneen soberanear VMM03P0 +soborna sobornar VMM02S0 +sobornad sobornar VMM02P0 +sobornando sobornar VMG0000 +sobornar sobornar VMN0000 +soborne sobornar VMM03S0 +sobornemos sobornar VMM01P0 +sobornen sobornar VMM03P0 +sobra sobrar VMM02S0 +sobrad sobrar VMM02P0 +sobrando sobrar VMG0000 +sobrar sobrar VMN0000 +sobrasa sobrasar VMM02S0 +sobrasad sobrasar VMM02P0 +sobrasando sobrasar VMG0000 +sobrasar sobrasar VMN0000 +sobrase sobrasar VMM03S0 +sobrasemos sobrasar VMM01P0 +sobrasen sobrasar VMM03P0 +sobre sobrar VMM03S0 +sobreabunda sobreabundar VMM02S0 +sobreabundad sobreabundar VMM02P0 +sobreabundando sobreabundar VMG0000 +sobreabundar sobreabundar VMN0000 +sobreabunde sobreabundar VMM03S0 +sobreabundemos sobreabundar VMM01P0 +sobreabunden sobreabundar VMM03P0 +sobrealce sobrealzar VMM03S0 +sobrealcemos sobrealzar VMM01P0 +sobrealcen sobrealzar VMM03P0 +sobrealimenta sobrealimentar VMM02S0 +sobrealimentad sobrealimentar VMM02P0 +sobrealimentando sobrealimentar VMG0000 +sobrealimentar sobrealimentar VMN0000 +sobrealimente sobrealimentar VMM03S0 +sobrealimentemos sobrealimentar VMM01P0 +sobrealimenten sobrealimentar VMM03P0 +sobrealza sobrealzar VMM02S0 +sobrealzad sobrealzar VMM02P0 +sobrealzando sobrealzar VMG0000 +sobrealzar sobrealzar VMN0000 +sobreara sobrearar VMM02S0 +sobrearad sobrearar VMM02P0 +sobrearando sobrearar VMG0000 +sobrearar sobrearar VMN0000 +sobreare sobrearar VMM03S0 +sobrearemos sobrearar VMM01P0 +sobrearen sobrearar VMM03P0 +sobreañada sobreañadir VMM03S0 +sobreañadamos sobreañadir VMM01P0 +sobreañadan sobreañadir VMM03P0 +sobreañade sobreañadir VMM02S0 +sobreañadid sobreañadir VMM02P0 +sobreañadiendo sobreañadir VMG0000 +sobreañadir sobreañadir VMN0000 +sobrebarra sobrebarrer VMM03S0 +sobrebarramos sobrebarrer VMM01P0 +sobrebarran sobrebarrer VMM03P0 +sobrebarre sobrebarrer VMM02S0 +sobrebarred sobrebarrer VMM02P0 +sobrebarrer sobrebarrer VMN0000 +sobrebarriendo sobrebarrer VMG0000 +sobrebeba sobrebeber VMM03S0 +sobrebebamos sobrebeber VMM01P0 +sobrebeban sobrebeber VMM03P0 +sobrebebe sobrebeber VMM02S0 +sobrebebed sobrebeber VMM02P0 +sobrebeber sobrebeber VMN0000 +sobrebebiendo sobrebeber VMG0000 +sobrecalentad sobrecalentar VMM02P0 +sobrecalentando sobrecalentar VMG0000 +sobrecalentar sobrecalentar VMN0000 +sobrecalentemos sobrecalentar VMM01P0 +sobrecalienta sobrecalentar VMM02S0 +sobrecaliente sobrecalentar VMM03S0 +sobrecalienten sobrecalentar VMM03P0 +sobrecarga sobrecargar VMM02S0 +sobrecargad sobrecargar VMM02P0 +sobrecargando sobrecargar VMG0000 +sobrecargar sobrecargar VMN0000 +sobrecargue sobrecargar VMM03S0 +sobrecarguemos sobrecargar VMM01P0 +sobrecarguen sobrecargar VMM03P0 +sobrecarta sobrecartar VMM02S0 +sobrecartad sobrecartar VMM02P0 +sobrecartando sobrecartar VMG0000 +sobrecartar sobrecartar VMN0000 +sobrecarte sobrecartar VMM03S0 +sobrecartemos sobrecartar VMM01P0 +sobrecarten sobrecartar VMM03P0 +sobrecena sobrecenar VMM02S0 +sobrecenad sobrecenar VMM02P0 +sobrecenando sobrecenar VMG0000 +sobrecenar sobrecenar VMN0000 +sobrecene sobrecenar VMM03S0 +sobrecenemos sobrecenar VMM01P0 +sobrecenen sobrecenar VMM03P0 +sobrecoge sobrecoger VMM02S0 +sobrecoged sobrecoger VMM02P0 +sobrecoger sobrecoger VMN0000 +sobrecogiendo sobrecoger VMG0000 +sobrecoja sobrecoger VMM03S0 +sobrecojamos sobrecoger VMM01P0 +sobrecojan sobrecoger VMM03P0 +sobrecrece sobrecrecer VMM02S0 +sobrecreced sobrecrecer VMM02P0 +sobrecrecer sobrecrecer VMN0000 +sobrecreciendo sobrecrecer VMG0000 +sobrecrezca sobrecrecer VMM03S0 +sobrecrezcamos sobrecrecer VMM01P0 +sobrecrezcan sobrecrecer VMM03P0 +sobredimensiona sobredimensionar VMM02S0 +sobredimensionad sobredimensionar VMM02P0 +sobredimensionando sobredimensionar VMG0000 +sobredimensionar sobredimensionar VMN0000 +sobredimensione sobredimensionar VMM03S0 +sobredimensionemos sobredimensionar VMM01P0 +sobredimensionen sobredimensionar VMM03P0 +sobredora sobredorar VMM02S0 +sobredorad sobredorar VMM02P0 +sobredorando sobredorar VMG0000 +sobredorar sobredorar VMN0000 +sobredore sobredorar VMM03S0 +sobredoremos sobredorar VMM01P0 +sobredoren sobredorar VMM03P0 +sobreedifica sobreedificar VMM02S0 +sobreedificad sobreedificar VMM02P0 +sobreedificando sobreedificar VMG0000 +sobreedificar sobreedificar VMN0000 +sobreedifique sobreedificar VMM03S0 +sobreedifiquemos sobreedificar VMM01P0 +sobreedifiquen sobreedificar VMM03P0 +sobreentendamos sobreentender VMM01P0 +sobreentended sobreentender VMM02P0 +sobreentender sobreentender VMN0000 +sobreentendiendo sobreentender VMG0000 +sobreentienda sobreentender VMM03S0 +sobreentiendan sobreentender VMM03P0 +sobreentiende sobreentender VMM02S0 +sobreescriba sobreescribir VMM03S0 +sobreescribamos sobreescribir VMM01P0 +sobreescriban sobreescribir VMM03P0 +sobreescribe sobreescribir VMM02S0 +sobreescribid sobreescribir VMM02P0 +sobreescribiendo sobreescribir VMG0000 +sobreescribir sobreescribir VMN0000 +sobreestima sobreestimar VMM02S0 +sobreestimad sobreestimar VMM02P0 +sobreestimando sobreestimar VMG0000 +sobreestimar sobreestimar VMN0000 +sobreestime sobreestimar VMM03S0 +sobreestimemos sobreestimar VMM01P0 +sobreestimen sobreestimar VMM03P0 +sobreexceda sobreexceder VMM03S0 +sobreexcedamos sobreexceder VMM01P0 +sobreexcedan sobreexceder VMM03P0 +sobreexcede sobreexceder VMM02S0 +sobreexceded sobreexceder VMM02P0 +sobreexceder sobreexceder VMN0000 +sobreexcediendo sobreexceder VMG0000 +sobreexcita sobreexcitar VMM02S0 +sobreexcitad sobreexcitar VMM02P0 +sobreexcitando sobreexcitar VMG0000 +sobreexcitar sobreexcitar VMN0000 +sobreexcite sobreexcitar VMM03S0 +sobreexcitemos sobreexcitar VMM01P0 +sobreexciten sobreexcitar VMM03P0 +sobreexponed sobreexponer VMM02P0 +sobreexponer sobreexponer VMN0000 +sobreexponga sobreexponer VMM03S0 +sobreexpongamos sobreexponer VMM01P0 +sobreexpongan sobreexponer VMM03P0 +sobreexponiendo sobreexponer VMG0000 +sobreexpón sobreexponer VMM02S0 +sobrehilad sobrehilar VMM02P0 +sobrehilando sobrehilar VMG0000 +sobrehilar sobrehilar VMN0000 +sobrehilemos sobrehilar VMM01P0 +sobrehíla sobrehilar VMM02S0 +sobrehíle sobrehilar VMM03S0 +sobrehílen sobrehilar VMM03P0 +sobrellena sobrellenar VMM02S0 +sobrellenad sobrellenar VMM02P0 +sobrellenando sobrellenar VMG0000 +sobrellenar sobrellenar VMN0000 +sobrellene sobrellenar VMM03S0 +sobrellenemos sobrellenar VMM01P0 +sobrellenen sobrellenar VMM03P0 +sobrelleva sobrellevar VMM02S0 +sobrellevad sobrellevar VMM02P0 +sobrellevando sobrellevar VMG0000 +sobrellevar sobrellevar VMN0000 +sobrelleve sobrellevar VMM03S0 +sobrellevemos sobrellevar VMM01P0 +sobrelleven sobrellevar VMM03P0 +sobremos sobrar VMM01P0 +sobren sobrar VMM03P0 +sobrenada sobrenadar VMM02S0 +sobrenadad sobrenadar VMM02P0 +sobrenadando sobrenadar VMG0000 +sobrenadar sobrenadar VMN0000 +sobrenade sobrenadar VMM03S0 +sobrenademos sobrenadar VMM01P0 +sobrenaden sobrenadar VMM03P0 +sobrentendamos sobrentender VMM01P0 +sobrentended sobrentender VMM02P0 +sobrentender sobrentender VMN0000 +sobrentendiendo sobrentender VMG0000 +sobrentienda sobrentender VMM03S0 +sobrentiendan sobrentender VMM03P0 +sobrentiende sobrentender VMM02S0 +sobrepasa sobrepasar VMM02S0 +sobrepasad sobrepasar VMM02P0 +sobrepasando sobrepasar VMG0000 +sobrepasar sobrepasar VMN0000 +sobrepase sobrepasar VMM03S0 +sobrepasemos sobrepasar VMM01P0 +sobrepasen sobrepasar VMM03P0 +sobrepinta sobrepintar VMM02S0 +sobrepintad sobrepintar VMM02P0 +sobrepintando sobrepintar VMG0000 +sobrepintar sobrepintar VMN0000 +sobrepinte sobrepintar VMM03S0 +sobrepintemos sobrepintar VMM01P0 +sobrepinten sobrepintar VMM03P0 +sobreponed sobreponer VMM02P0 +sobreponer sobreponer VMN0000 +sobreponga sobreponer VMM03S0 +sobrepongamos sobreponer VMM01P0 +sobrepongan sobreponer VMM03P0 +sobreponiendo sobreponer VMG0000 +sobrepuja sobrepujar VMM02S0 +sobrepujad sobrepujar VMM02P0 +sobrepujando sobrepujar VMG0000 +sobrepujar sobrepujar VMN0000 +sobrepuje sobrepujar VMM03S0 +sobrepujemos sobrepujar VMM01P0 +sobrepujen sobrepujar VMM03P0 +sobrepón sobreponer VMM02S0 +sobresal sobresalir VMM02S0 +sobresalga sobresalir VMM03S0 +sobresalgamos sobresalir VMM01P0 +sobresalgan sobresalir VMM03P0 +sobresalid sobresalir VMM02P0 +sobresaliendo sobresalir VMG0000 +sobresalir sobresalir VMN0000 +sobresalta sobresaltar VMM02S0 +sobresaltad sobresaltar VMM02P0 +sobresaltando sobresaltar VMG0000 +sobresaltar sobresaltar VMN0000 +sobresalte sobresaltar VMM03S0 +sobresaltemos sobresaltar VMM01P0 +sobresalten sobresaltar VMM03P0 +sobresatura sobresaturar VMM02S0 +sobresaturad sobresaturar VMM02P0 +sobresaturando sobresaturar VMG0000 +sobresaturar sobresaturar VMN0000 +sobresature sobresaturar VMM03S0 +sobresaturemos sobresaturar VMM01P0 +sobresaturen sobresaturar VMM03P0 +sobresea sobreseer VMM03S0 +sobreseamos sobreseer VMM01P0 +sobresean sobreseer VMM03P0 +sobresee sobreseer VMM02S0 +sobreseed sobreseer VMM02P0 +sobreseer sobreseer VMN0000 +sobresembrad sobresembrar VMM02P0 +sobresembrando sobresembrar VMG0000 +sobresembrar sobresembrar VMN0000 +sobresembremos sobresembrar VMM01P0 +sobreseyendo sobreseer VMG0000 +sobresiembra sobresembrar VMM02S0 +sobresiembre sobresembrar VMM03S0 +sobresiembren sobresembrar VMM03P0 +sobrestima sobrestimar VMM02S0 +sobrestimad sobrestimar VMM02P0 +sobrestimando sobrestimar VMG0000 +sobrestimar sobrestimar VMN0000 +sobrestime sobrestimar VMM03S0 +sobrestimemos sobrestimar VMM01P0 +sobrestimen sobrestimar VMM03P0 +sobrevalora sobrevalorar VMM02S0 +sobrevalorad sobrevalorar VMM02P0 +sobrevalorando sobrevalorar VMG0000 +sobrevalorar sobrevalorar VMN0000 +sobrevalore sobrevalorar VMM03S0 +sobrevaloremos sobrevalorar VMM01P0 +sobrevaloren sobrevalorar VMM03P0 +sobreven sobrevenir VMM02S0 +sobrevenga sobrevenir VMM03S0 +sobrevengamos sobrevenir VMM01P0 +sobrevengan sobrevenir VMM03P0 +sobrevenid sobrevenir VMM02P0 +sobrevenir sobrevenir VMN0000 +sobreviniendo sobrevenir VMG0000 +sobreviva sobrevivir VMM03S0 +sobrevivamos sobrevivir VMM01P0 +sobrevivan sobrevivir VMM03P0 +sobrevive sobrevivir VMM02S0 +sobrevivid sobrevivir VMM02P0 +sobreviviendo sobrevivir VMG0000 +sobrevivir sobrevivir VMN0000 +sobrevolad sobrevolar VMM02P0 +sobrevolando sobrevolar VMG0000 +sobrevolar sobrevolar VMN0000 +sobrevolemos sobrevolar VMM01P0 +sobrevuela sobrevolar VMM02S0 +sobrevuele sobrevolar VMM03S0 +sobrevuelen sobrevolar VMM03P0 +sobrexceda sobrexceder VMM03S0 +sobrexcedamos sobrexceder VMM01P0 +sobrexcedan sobrexceder VMM03P0 +sobrexcede sobrexceder VMM02S0 +sobrexceded sobrexceder VMM02P0 +sobrexceder sobrexceder VMN0000 +sobrexcediendo sobrexceder VMG0000 +sobrexcita sobrexcitar VMM02S0 +sobrexcitad sobrexcitar VMM02P0 +sobrexcitando sobrexcitar VMG0000 +sobrexcitar sobrexcitar VMN0000 +sobrexcite sobrexcitar VMM03S0 +sobrexcitemos sobrexcitar VMM01P0 +sobrexciten sobrexcitar VMM03P0 +socalce socalzar VMM03S0 +socalcemos socalzar VMM01P0 +socalcen socalzar VMM03P0 +socaliña socaliñar VMM02S0 +socaliñad socaliñar VMM02P0 +socaliñando socaliñar VMG0000 +socaliñar socaliñar VMN0000 +socaliñe socaliñar VMM03S0 +socaliñemos socaliñar VMM01P0 +socaliñen socaliñar VMM03P0 +socalza socalzar VMM02S0 +socalzad socalzar VMM02P0 +socalzando socalzar VMG0000 +socalzar socalzar VMN0000 +socapa socapar VMM02S0 +socapad socapar VMM02P0 +socapando socapar VMG0000 +socapar socapar VMN0000 +socape socapar VMM03S0 +socapemos socapar VMM01P0 +socapen socapar VMM03P0 +socarra socarrar VMM02S0 +socarrad socarrar VMM02P0 +socarrando socarrar VMG0000 +socarrar socarrar VMN0000 +socarre socarrar VMM03S0 +socarremos socarrar VMM01P0 +socarren socarrar VMM03P0 +socava socavar VMM02S0 +socavad socavar VMM02P0 +socavando socavar VMG0000 +socavar socavar VMN0000 +socave socavar VMM03S0 +socavemos socavar VMM01P0 +socaven socavar VMM03P0 +socialice socializar VMM03S0 +socialicemos socializar VMM01P0 +socialicen socializar VMM03P0 +socializa socializar VMM02S0 +socializad socializar VMM02P0 +socializando socializar VMG0000 +socializar socializar VMN0000 +socorra socorrer VMM03S0 +socorramos socorrer VMM01P0 +socorran socorrer VMM03P0 +socorre socorrer VMM02S0 +socorred socorrer VMM02P0 +socorrer socorrer VMN0000 +socorriendo socorrer VMG0000 +sofalda sofaldar VMM02S0 +sofaldad sofaldar VMM02P0 +sofaldando sofaldar VMG0000 +sofaldar sofaldar VMN0000 +sofalde sofaldar VMM03S0 +sofaldemos sofaldar VMM01P0 +sofalden sofaldar VMM03P0 +sofistica sofisticar VMM02S0 +sofisticad sofisticar VMM02P0 +sofisticando sofisticar VMG0000 +sofisticar sofisticar VMN0000 +sofistique sofisticar VMM03S0 +sofistiquemos sofisticar VMM01P0 +sofistiquen sofisticar VMM03P0 +soflama soflamar VMM02S0 +soflamad soflamar VMM02P0 +soflamando soflamar VMG0000 +soflamar soflamar VMN0000 +soflame soflamar VMM03S0 +soflamemos soflamar VMM01P0 +soflamen soflamar VMM03P0 +sofoca sofocar VMM02S0 +sofocad sofocar VMM02P0 +sofocando sofocar VMG0000 +sofocar sofocar VMN0000 +sofoque sofocar VMM03S0 +sofoquemos sofocar VMM01P0 +sofoquen sofocar VMM03P0 +sofrena sofrenar VMM02S0 +sofrenad sofrenar VMM02P0 +sofrenando sofrenar VMG0000 +sofrenar sofrenar VMN0000 +sofrene sofrenar VMM03S0 +sofrenemos sofrenar VMM01P0 +sofrenen sofrenar VMM03P0 +sofreíd sofreír VMM02P0 +sofreír sofreír VMN0000 +sofriamos sofreír VMM01P0 +sofriendo sofreír VMG0000 +sofría sofreír VMM03S0 +sofrían sofreír VMM03P0 +sofríe sofreír VMM02S0 +sojuzga sojuzgar VMM02S0 +sojuzgad sojuzgar VMM02P0 +sojuzgando sojuzgar VMG0000 +sojuzgar sojuzgar VMN0000 +sojuzgue sojuzgar VMM03S0 +sojuzguemos sojuzgar VMM01P0 +sojuzguen sojuzgar VMM03P0 +solace solazar VMM03S0 +solacemos solazar VMM01P0 +solacen solazar VMM03P0 +solad solar VMM02P0 +solando solar VMG0000 +solapa solapar VMM02S0 +solapad solapar VMM02P0 +solapando solapar VMG0000 +solapar solapar VMN0000 +solape solapar VMM03S0 +solapemos solapar VMM01P0 +solapen solapar VMM03P0 +solar solar VMN0000 +solaza solazar VMM02S0 +solazad solazar VMM02P0 +solazando solazar VMG0000 +solazar solazar VMN0000 +soldad soldar VMM02P0 +soldando soldar VMG0000 +soldar soldar VMN0000 +soldemos soldar VMM01P0 +solea solear VMM02S0 +solead solear VMM02P0 +soleando solear VMG0000 +solear solear VMN0000 +solee solear VMM03S0 +soleemos solear VMM01P0 +soleen solear VMM03P0 +solemnice solemnizar VMM03S0 +solemnicemos solemnizar VMM01P0 +solemnicen solemnizar VMM03P0 +solemniza solemnizar VMM02S0 +solemnizad solemnizar VMM02P0 +solemnizando solemnizar VMG0000 +solemnizar solemnizar VMN0000 +solemos solar VMM01P0 +soler soler VMN0000 +soleva solevar VMM02S0 +solevad solevar VMM02P0 +solevando solevar VMG0000 +solevanta solevantar VMM02S0 +solevantad solevantar VMM02P0 +solevantando solevantar VMG0000 +solevantar solevantar VMN0000 +solevante solevantar VMM03S0 +solevantemos solevantar VMM01P0 +solevanten solevantar VMM03P0 +solevar solevar VMN0000 +soleve solevar VMM03S0 +solevemos solevar VMM01P0 +soleven solevar VMM03P0 +solfea solfear VMM02S0 +solfead solfear VMM02P0 +solfeando solfear VMG0000 +solfear solfear VMN0000 +solfee solfear VMM03S0 +solfeemos solfear VMM01P0 +solfeen solfear VMM03P0 +solicita solicitar VMM02S0 +solicitad solicitar VMM02P0 +solicitando solicitar VMG0000 +solicitar solicitar VMN0000 +solicite solicitar VMM03S0 +solicitemos solicitar VMM01P0 +soliciten solicitar VMM03P0 +solida solidar VMM02S0 +solidad solidar VMM02P0 +solidando solidar VMG0000 +solidar solidar VMN0000 +solidarice solidarizar VMM03S0 +solidaricemos solidarizar VMM01P0 +solidaricen solidarizar VMM03P0 +solidariza solidarizar VMM02S0 +solidarizad solidarizar VMM02P0 +solidarizando solidarizar VMG0000 +solidarizar solidarizar VMN0000 +solide solidar VMM03S0 +solidemos solidar VMM01P0 +soliden solidar VMM03P0 +solidifica solidificar VMM02S0 +solidificad solidificar VMM02P0 +solidificando solidificar VMG0000 +solidificar solidificar VMN0000 +solidifique solidificar VMM03S0 +solidifiquemos solidificar VMM01P0 +solidifiquen solidificar VMM03P0 +soliloquia soliloquiar VMM02S0 +soliloquiad soliloquiar VMM02P0 +soliloquiando soliloquiar VMG0000 +soliloquiar soliloquiar VMN0000 +soliloquie soliloquiar VMM03S0 +soliloquiemos soliloquiar VMM01P0 +soliloquien soliloquiar VMM03P0 +solivia soliviar VMM02S0 +soliviad soliviar VMM02P0 +soliviando soliviar VMG0000 +solivianta soliviantar VMM02S0 +soliviantad soliviantar VMM02P0 +soliviantando soliviantar VMG0000 +soliviantar soliviantar VMN0000 +soliviante soliviantar VMM03S0 +soliviantemos soliviantar VMM01P0 +solivianten soliviantar VMM03P0 +soliviar soliviar VMN0000 +solivie soliviar VMM03S0 +soliviemos soliviar VMM01P0 +solivien soliviar VMM03P0 +sollama sollamar VMM02S0 +sollamad sollamar VMM02P0 +sollamando sollamar VMG0000 +sollamar sollamar VMN0000 +sollame sollamar VMM03S0 +sollamemos sollamar VMM01P0 +sollamen sollamar VMM03P0 +solloce sollozar VMM03S0 +sollocemos sollozar VMM01P0 +sollocen sollozar VMM03P0 +solloza sollozar VMM02S0 +sollozad sollozar VMM02P0 +sollozando sollozar VMG0000 +sollozar sollozar VMN0000 +soltad soltar VMM02P0 +soltando soltar VMG0000 +soltar soltar VMN0000 +soltemos soltar VMM01P0 +solubilice solubilizar VMM03S0 +solubilicemos solubilizar VMM01P0 +solubilicen solubilizar VMM03P0 +solubiliza solubilizar VMM02S0 +solubilizad solubilizar VMM02P0 +solubilizando solubilizar VMG0000 +solubilizar solubilizar VMN0000 +soluciona solucionar VMM02S0 +solucionad solucionar VMM02P0 +solucionando solucionar VMG0000 +solucionar solucionar VMN0000 +solucione solucionar VMM03S0 +solucionemos solucionar VMM01P0 +solucionen solucionar VMM03P0 +solventa solventar VMM02S0 +solventad solventar VMM02P0 +solventando solventar VMG0000 +solventar solventar VMN0000 +solvente solventar VMM03S0 +solventemos solventar VMM01P0 +solventen solventar VMM03P0 +sombra sombrar VMM02S0 +sombrad sombrar VMM02P0 +sombrando sombrar VMG0000 +sombrar sombrar VMN0000 +sombre sombrar VMM03S0 +sombrea sombrear VMM02S0 +sombread sombrear VMM02P0 +sombreando sombrear VMG0000 +sombrear sombrear VMN0000 +sombree sombrear VMM03S0 +sombreemos sombrear VMM01P0 +sombreen sombrear VMM03P0 +sombremos sombrar VMM01P0 +sombren sombrar VMM03P0 +someta someter VMM03S0 +sometamos someter VMM01P0 +sometan someter VMM03P0 +somete someter VMM02S0 +someted someter VMM02P0 +someter someter VMN0000 +sometiendo someter VMG0000 +somorguja somorgujar VMM02S0 +somorgujad somorgujar VMM02P0 +somorgujando somorgujar VMG0000 +somorgujar somorgujar VMN0000 +somorguje somorgujar VMM03S0 +somorgujemos somorgujar VMM01P0 +somorgujen somorgujar VMM03P0 +somormuja somormujar VMM02S0 +somormujad somormujar VMM02P0 +somormujando somormujar VMG0000 +somormujar somormujar VMN0000 +somormuje somormujar VMM03S0 +somormujemos somormujar VMM01P0 +somormujen somormujar VMM03P0 +sonad sonar VMM02P0 +sonando sonar VMG0000 +sonar sonar VMN0000 +sonda sondar VMM02S0 +sondad sondar VMM02P0 +sondando sondar VMG0000 +sondar sondar VMN0000 +sonde sondar VMM03S0 +sondea sondear VMM02S0 +sondead sondear VMM02P0 +sondeando sondear VMG0000 +sondear sondear VMN0000 +sondee sondear VMM03S0 +sondeemos sondear VMM01P0 +sondeen sondear VMM03P0 +sondemos sondar VMM01P0 +sonden sondar VMM03P0 +sonemos sonar VMM01P0 +sonorice sonorizar VMM03S0 +sonoricemos sonorizar VMM01P0 +sonoricen sonorizar VMM03P0 +sonoriza sonorizar VMM02S0 +sonorizad sonorizar VMM02P0 +sonorizando sonorizar VMG0000 +sonorizar sonorizar VMN0000 +sonreíd sonreír VMM02P0 +sonreír sonreír VMN0000 +sonriamos sonreír VMM01P0 +sonriendo sonreír VMG0000 +sonroja sonrojar VMM02S0 +sonrojad sonrojar VMM02P0 +sonrojando sonrojar VMG0000 +sonrojar sonrojar VMN0000 +sonroje sonrojar VMM03S0 +sonrojemos sonrojar VMM01P0 +sonrojen sonrojar VMM03P0 +sonrosa sonrosar VMM02S0 +sonrosad sonrosar VMM02P0 +sonrosando sonrosar VMG0000 +sonrosar sonrosar VMN0000 +sonrose sonrosar VMM03S0 +sonrosea sonrosear VMM02S0 +sonrosead sonrosear VMM02P0 +sonroseando sonrosear VMG0000 +sonrosear sonrosear VMN0000 +sonrosee sonrosear VMM03S0 +sonroseemos sonrosear VMM01P0 +sonroseen sonrosear VMM03P0 +sonrosemos sonrosar VMM01P0 +sonrosen sonrosar VMM03P0 +sonría sonreír VMM03S0 +sonrían sonreír VMM03P0 +sonríe sonreír VMM02S0 +sonsaca sonsacar VMM02S0 +sonsacad sonsacar VMM02P0 +sonsacando sonsacar VMG0000 +sonsacar sonsacar VMN0000 +sonsaque sonsacar VMM03S0 +sonsaquemos sonsacar VMM01P0 +sonsaquen sonsacar VMM03P0 +sopa sopar VMM02S0 +sopad sopar VMM02P0 +sopando sopar VMG0000 +sopapea sopapear VMM02S0 +sopapead sopapear VMM02P0 +sopapeando sopapear VMG0000 +sopapear sopapear VMN0000 +sopapee sopapear VMM03S0 +sopapeemos sopapear VMM01P0 +sopapeen sopapear VMM03P0 +sopar sopar VMN0000 +sope sopar VMM03S0 +sopemos sopar VMM01P0 +sopen sopar VMM03P0 +sopesa sopesar VMM02S0 +sopesad sopesar VMM02P0 +sopesando sopesar VMG0000 +sopesar sopesar VMN0000 +sopese sopesar VMM03S0 +sopesemos sopesar VMM01P0 +sopesen sopesar VMM03P0 +sopetea sopetear VMM02S0 +sopetead sopetear VMM02P0 +sopeteando sopetear VMG0000 +sopetear sopetear VMN0000 +sopetee sopetear VMM03S0 +sopeteemos sopetear VMM01P0 +sopeteen sopetear VMM03P0 +sopla soplar VMM02S0 +soplad soplar VMM02P0 +soplando soplar VMG0000 +soplar soplar VMN0000 +sople soplar VMM03S0 +soplemos soplar VMM01P0 +soplen soplar VMM03P0 +soplonea soplonear VMM02S0 +soplonead soplonear VMM02P0 +soploneando soplonear VMG0000 +soplonear soplonear VMN0000 +soplonee soplonear VMM03S0 +soploneemos soplonear VMM01P0 +soploneen soplonear VMM03P0 +soporta soportar VMM02S0 +soportad soportar VMM02P0 +soportando soportar VMG0000 +soportar soportar VMN0000 +soporte soportar VMM03S0 +soportemos soportar VMM01P0 +soporten soportar VMM03P0 +sorba sorber VMM03S0 +sorbamos sorber VMM01P0 +sorban sorber VMM03P0 +sorbe sorber VMM02S0 +sorbed sorber VMM02P0 +sorber sorber VMN0000 +sorbiendo sorber VMG0000 +sorprenda sorprender VMM03S0 +sorprendamos sorprender VMM01P0 +sorprendan sorprender VMM03P0 +sorprende sorprender VMM02S0 +sorprended sorprender VMM02P0 +sorprender sorprender VMN0000 +sorprendiendo sorprender VMG0000 +sorregad sorregar VMM02P0 +sorregando sorregar VMG0000 +sorregar sorregar VMN0000 +sorreguemos sorregar VMM01P0 +sorriega sorregar VMM02S0 +sorriegue sorregar VMM03S0 +sorrieguen sorregar VMM03P0 +sortea sortear VMM02S0 +sortead sortear VMM02P0 +sorteando sortear VMG0000 +sortear sortear VMN0000 +sortee sortear VMM03S0 +sorteemos sortear VMM01P0 +sorteen sortear VMM03P0 +sosegad sosegar VMM02P0 +sosegando sosegar VMG0000 +sosegar sosegar VMN0000 +soseguemos sosegar VMM01P0 +sosiega sosegar VMM02S0 +sosiegue sosegar VMM03S0 +sosieguen sosegar VMM03P0 +soslaya soslayar VMM02S0 +soslayad soslayar VMM02P0 +soslayando soslayar VMG0000 +soslayar soslayar VMN0000 +soslaye soslayar VMM03S0 +soslayemos soslayar VMM01P0 +soslayen soslayar VMM03P0 +sospecha sospechar VMM02S0 +sospechad sospechar VMM02P0 +sospechando sospechar VMG0000 +sospechar sospechar VMN0000 +sospeche sospechar VMM03S0 +sospechemos sospechar VMM01P0 +sospechen sospechar VMM03P0 +sostened sostener VMM02P0 +sostener sostener VMN0000 +sostenga sostener VMM03S0 +sostengamos sostener VMM01P0 +sostengan sostener VMM03P0 +sosteniendo sostener VMG0000 +sostén sostener VMM02S0 +sotanea sotanear VMM02S0 +sotanead sotanear VMM02P0 +sotaneando sotanear VMG0000 +sotanear sotanear VMN0000 +sotanee sotanear VMM03S0 +sotaneemos sotanear VMM01P0 +sotaneen sotanear VMM03P0 +sotaventa sotaventar VMM02S0 +sotaventad sotaventar VMM02P0 +sotaventando sotaventar VMG0000 +sotaventar sotaventar VMN0000 +sotavente sotaventar VMM03S0 +sotaventemos sotaventar VMM01P0 +sotaventen sotaventar VMM03P0 +soterra soterrar VMM02S0 +soterrad soterrar VMM02P0 +soterrando soterrar VMG0000 +soterrar soterrar VMN0000 +soterre soterrar VMM03S0 +soterremos soterrar VMM01P0 +soterren soterrar VMM03P0 +sovietice sovietizar VMM03S0 +sovieticemos sovietizar VMM01P0 +sovieticen sovietizar VMM03P0 +sovietiza sovietizar VMM02S0 +sovietizad sovietizar VMM02P0 +sovietizando sovietizar VMG0000 +sovietizar sovietizar VMN0000 +soñad soñar VMM02P0 +soñando soñar VMG0000 +soñar soñar VMN0000 +soñemos soñar VMM01P0 +suavice suavizar VMM03S0 +suavicemos suavizar VMM01P0 +suavicen suavizar VMM03P0 +suaviza suavizar VMM02S0 +suavizad suavizar VMM02P0 +suavizando suavizar VMG0000 +suavizar suavizar VMN0000 +suba subir VMM03S0 +subamos subir VMM01P0 +suban subir VMM03P0 +subarrendad subarrendar VMM02P0 +subarrendando subarrendar VMG0000 +subarrendar subarrendar VMN0000 +subarrendemos subarrendar VMM01P0 +subarrienda subarrendar VMM02S0 +subarriende subarrendar VMM03S0 +subarrienden subarrendar VMM03P0 +subasta subastar VMM02S0 +subastad subastar VMM02P0 +subastando subastar VMG0000 +subastar subastar VMN0000 +subaste subastar VMM03S0 +subastemos subastar VMM01P0 +subasten subastar VMM03P0 +subcontrata subcontratar VMM02S0 +subcontratad subcontratar VMM02P0 +subcontratando subcontratar VMG0000 +subcontratar subcontratar VMN0000 +subcontrate subcontratar VMM03S0 +subcontratemos subcontratar VMM01P0 +subcontraten subcontratar VMM03P0 +subdelega subdelegar VMM02S0 +subdelegad subdelegar VMM02P0 +subdelegando subdelegar VMG0000 +subdelegar subdelegar VMN0000 +subdelegue subdelegar VMM03S0 +subdeleguemos subdelegar VMM01P0 +subdeleguen subdelegar VMM03P0 +subdivida subdividir VMM03S0 +subdividamos subdividir VMM01P0 +subdividan subdividir VMM03P0 +subdivide subdividir VMM02S0 +subdividid subdividir VMM02P0 +subdividiendo subdividir VMG0000 +subdividir subdividir VMN0000 +sube subir VMM02S0 +subestima subestimar VMM02S0 +subestimad subestimar VMM02P0 +subestimando subestimar VMG0000 +subestimar subestimar VMN0000 +subestime subestimar VMM03S0 +subestimemos subestimar VMM01P0 +subestimen subestimar VMM03P0 +subid subir VMM02P0 +subiendo subir VMG0000 +subintra subintrar VMM02S0 +subintrad subintrar VMM02P0 +subintrando subintrar VMG0000 +subintrar subintrar VMN0000 +subintre subintrar VMM03S0 +subintremos subintrar VMM01P0 +subintren subintrar VMM03P0 +subir subir VMN0000 +subleva sublevar VMM02S0 +sublevad sublevar VMM02P0 +sublevando sublevar VMG0000 +sublevar sublevar VMN0000 +subleve sublevar VMM03S0 +sublevemos sublevar VMM01P0 +subleven sublevar VMM03P0 +sublima sublimar VMM02S0 +sublimad sublimar VMM02P0 +sublimando sublimar VMG0000 +sublimar sublimar VMN0000 +sublime sublimar VMM03S0 +sublimemos sublimar VMM01P0 +sublimen sublimar VMM03P0 +subordina subordinar VMM02S0 +subordinad subordinar VMM02P0 +subordinando subordinar VMG0000 +subordinar subordinar VMN0000 +subordine subordinar VMM03S0 +subordinemos subordinar VMM01P0 +subordinen subordinar VMM03P0 +subraya subrayar VMM02S0 +subrayad subrayar VMM02P0 +subrayando subrayar VMG0000 +subrayar subrayar VMN0000 +subraye subrayar VMM03S0 +subrayemos subrayar VMM01P0 +subrayen subrayar VMM03P0 +subroga subrogar VMM02S0 +subrogad subrogar VMM02P0 +subrogando subrogar VMG0000 +subrogar subrogar VMN0000 +subrogue subrogar VMM03S0 +subroguemos subrogar VMM01P0 +subroguen subrogar VMM03P0 +subsana subsanar VMM02S0 +subsanad subsanar VMM02P0 +subsanando subsanar VMG0000 +subsanar subsanar VMN0000 +subsane subsanar VMM03S0 +subsanemos subsanar VMM01P0 +subsanen subsanar VMM03P0 +subscriba subscribir VMM03S0 +subscribamos subscribir VMM01P0 +subscriban subscribir VMM03P0 +subscribe subscribir VMM02S0 +subscribid subscribir VMM02P0 +subscribiendo subscribir VMG0000 +subscribir subscribir VMN0000 +subseguid subseguir VMM02P0 +subseguir subseguir VMN0000 +subsidia subsidiar VMM02S0 +subsidiad subsidiar VMM02P0 +subsidiando subsidiar VMG0000 +subsidiar subsidiar VMN0000 +subsidie subsidiar VMM03S0 +subsidiemos subsidiar VMM01P0 +subsidien subsidiar VMM03P0 +subsiga subseguir VMM03S0 +subsigamos subseguir VMM01P0 +subsigan subseguir VMM03P0 +subsigue subseguir VMM02S0 +subsiguiendo subseguir VMG0000 +subsista subsistir VMM03S0 +subsistamos subsistir VMM01P0 +subsistan subsistir VMM03P0 +subsiste subsistir VMM02S0 +subsistid subsistir VMM02P0 +subsistiendo subsistir VMG0000 +subsistir subsistir VMN0000 +substancia substanciar VMM02S0 +substanciad substanciar VMM02P0 +substanciando substanciar VMG0000 +substanciar substanciar VMN0000 +substancie substanciar VMM03S0 +substanciemos substanciar VMM01P0 +substancien substanciar VMM03P0 +substantiva substantivar VMM02S0 +substantivad substantivar VMM02P0 +substantivando substantivar VMG0000 +substantivar substantivar VMN0000 +substantive substantivar VMM03S0 +substantivemos substantivar VMM01P0 +substantiven substantivar VMM03P0 +substituid substituir VMM02P0 +substituir substituir VMN0000 +substituya substituir VMM03S0 +substituyamos substituir VMM01P0 +substituyan substituir VMM03P0 +substituye substituir VMM02S0 +substituyendo substituir VMG0000 +substrae substraer VMM02S0 +substraed substraer VMM02P0 +substraer substraer VMN0000 +substraiga substraer VMM03S0 +substraigamos substraer VMM01P0 +substraigan substraer VMM03P0 +substrayendo substraer VMG0000 +subtendamos subtender VMM01P0 +subtended subtender VMM02P0 +subtender subtender VMN0000 +subtendiendo subtender VMG0000 +subtienda subtender VMM03S0 +subtiendan subtender VMM03P0 +subtiende subtender VMM02S0 +subtitula subtitular VMM02S0 +subtitulad subtitular VMM02P0 +subtitulando subtitular VMG0000 +subtitular subtitular VMN0000 +subtitule subtitular VMM03S0 +subtitulemos subtitular VMM01P0 +subtitulen subtitular VMM03P0 +subvalora subvalorar VMM02S0 +subvalorad subvalorar VMM02P0 +subvalorando subvalorar VMG0000 +subvalorar subvalorar VMN0000 +subvalore subvalorar VMM03S0 +subvaloremos subvalorar VMM01P0 +subvaloren subvalorar VMM03P0 +subven subvenir VMM02S0 +subvenciona subvencionar VMM02S0 +subvencionad subvencionar VMM02P0 +subvencionando subvencionar VMG0000 +subvencionar subvencionar VMN0000 +subvencione subvencionar VMM03S0 +subvencionemos subvencionar VMM01P0 +subvencionen subvencionar VMM03P0 +subvenga subvenir VMM03S0 +subvengamos subvenir VMM01P0 +subvengan subvenir VMM03P0 +subvenid subvenir VMM02P0 +subvenir subvenir VMN0000 +subvertid subvertir VMM02P0 +subvertir subvertir VMN0000 +subvierta subvertir VMM03S0 +subviertan subvertir VMM03P0 +subvierte subvertir VMM02S0 +subviniendo subvenir VMG0000 +subvirtamos subvertir VMM01P0 +subvirtiendo subvertir VMG0000 +subyace subyacer VMM02S0 +subyaced subyacer VMM02P0 +subyacer subyacer VMN0000 +subyaciendo subyacer VMG0000 +subyaga subyacer VMM03S0 +subyagamos subyacer VMM01P0 +subyagan subyacer VMM03P0 +subyaz subyacer VMM02S0 +subyazca subyacer VMM03S0 +subyazcamos subyacer VMM01P0 +subyazcan subyacer VMM03P0 +subyazga subyacer VMM03S0 +subyazgamos subyacer VMM01P0 +subyazgan subyacer VMM03P0 +subyuga subyugar VMM02S0 +subyugad subyugar VMM02P0 +subyugando subyugar VMG0000 +subyugar subyugar VMN0000 +subyugue subyugar VMM03S0 +subyuguemos subyugar VMM01P0 +subyuguen subyugar VMM03P0 +suceda suceder VMM03S0 +sucedamos suceder VMM01P0 +sucedan suceder VMM03P0 +sucede suceder VMM02S0 +suceded suceder VMM02P0 +suceder suceder VMN0000 +sucediendo suceder VMG0000 +sucumba sucumbir VMM03S0 +sucumbamos sucumbir VMM01P0 +sucumban sucumbir VMM03P0 +sucumbe sucumbir VMM02S0 +sucumbid sucumbir VMM02P0 +sucumbiendo sucumbir VMG0000 +sucumbir sucumbir VMN0000 +suda sudar VMM02S0 +sudad sudar VMM02P0 +sudando sudar VMG0000 +sudar sudar VMN0000 +sude sudar VMM03S0 +sudemos sudar VMM01P0 +suden sudar VMM03P0 +suela solar VMM02S0 +suelda soldar VMM02S0 +suelde soldar VMM03S0 +suelden soldar VMM03P0 +suele solar VMM03S0 +suelen solar VMM03P0 +suelta soltar VMM02S0 +suelte soltar VMM03S0 +suelten soltar VMM03P0 +suena sonar VMM02S0 +suene sonar VMM03S0 +suenen sonar VMM03P0 +sueña soñar VMM02S0 +sueñe soñar VMM03S0 +sueñen soñar VMM03P0 +sufija sufijar VMM02S0 +sufijad sufijar VMM02P0 +sufijando sufijar VMG0000 +sufijar sufijar VMN0000 +sufije sufijar VMM03S0 +sufijemos sufijar VMM01P0 +sufijen sufijar VMM03P0 +sufra sufrir VMM03S0 +sufraga sufragar VMM02S0 +sufragad sufragar VMM02P0 +sufragando sufragar VMG0000 +sufragar sufragar VMN0000 +sufrague sufragar VMM03S0 +sufraguemos sufragar VMM01P0 +sufraguen sufragar VMM03P0 +suframos sufrir VMM01P0 +sufran sufrir VMM03P0 +sufre sufrir VMM02S0 +sufrid sufrir VMM02P0 +sufriendo sufrir VMG0000 +sufrir sufrir VMN0000 +sugerid sugerir VMM02P0 +sugerir sugerir VMN0000 +sugestiona sugestionar VMM02S0 +sugestionad sugestionar VMM02P0 +sugestionando sugestionar VMG0000 +sugestionar sugestionar VMN0000 +sugestione sugestionar VMM03S0 +sugestionemos sugestionar VMM01P0 +sugestionen sugestionar VMM03P0 +sugiera sugerir VMM03S0 +sugieran sugerir VMM03P0 +sugiere sugerir VMM02S0 +sugiramos sugerir VMM01P0 +sugiriendo sugerir VMG0000 +suicida suicidar VMM02S0 +suicidad suicidar VMM02P0 +suicidando suicidar VMG0000 +suicidar suicidar VMN0000 +suicide suicidar VMM03S0 +suicidemos suicidar VMM01P0 +suiciden suicidar VMM03P0 +sujeta sujetar VMM02S0 +sujetad sujetar VMM02P0 +sujetando sujetar VMG0000 +sujetar sujetar VMN0000 +sujete sujetar VMM03S0 +sujetemos sujetar VMM01P0 +sujeten sujetar VMM03P0 +sulfata sulfatar VMM02S0 +sulfatad sulfatar VMM02P0 +sulfatando sulfatar VMG0000 +sulfatar sulfatar VMN0000 +sulfate sulfatar VMM03S0 +sulfatemos sulfatar VMM01P0 +sulfaten sulfatar VMM03P0 +sulfura sulfurar VMM02S0 +sulfurad sulfurar VMM02P0 +sulfurando sulfurar VMG0000 +sulfurar sulfurar VMN0000 +sulfure sulfurar VMM03S0 +sulfuremos sulfurar VMM01P0 +sulfuren sulfurar VMM03P0 +suma sumar VMM02S0 +suma sumir VMM03S0 +sumad sumar VMM02P0 +sumamos sumir VMM01P0 +suman sumir VMM03P0 +sumando sumar VMG0000 +sumar sumar VMN0000 +sumaria sumariar VMM02S0 +sumariad sumariar VMM02P0 +sumariando sumariar VMG0000 +sumariar sumariar VMN0000 +sumarie sumariar VMM03S0 +sumariemos sumariar VMM01P0 +sumarien sumariar VMM03P0 +sume sumar VMM03S0 +sume sumir VMM02S0 +sumemos sumar VMM01P0 +sumen sumar VMM03P0 +sumerge sumergir VMM02S0 +sumergid sumergir VMM02P0 +sumergiendo sumergir VMG0000 +sumergir sumergir VMN0000 +sumerja sumergir VMM03S0 +sumerjamos sumergir VMM01P0 +sumerjan sumergir VMM03P0 +sumid sumir VMM02P0 +sumiendo sumir VMG0000 +suministra suministrar VMM02S0 +suministrad suministrar VMM02P0 +suministrando suministrar VMG0000 +suministrar suministrar VMN0000 +suministre suministrar VMM03S0 +suministremos suministrar VMM01P0 +suministren suministrar VMM03P0 +sumir sumir VMN0000 +supedita supeditar VMM02S0 +supeditad supeditar VMM02P0 +supeditando supeditar VMG0000 +supeditar supeditar VMN0000 +supedite supeditar VMM03S0 +supeditemos supeditar VMM01P0 +supediten supeditar VMM03P0 +supera superar VMM02S0 +superabunda superabundar VMM02S0 +superabundad superabundar VMM02P0 +superabundando superabundar VMG0000 +superabundar superabundar VMN0000 +superabunde superabundar VMM03S0 +superabundemos superabundar VMM01P0 +superabunden superabundar VMM03P0 +superad superar VMM02P0 +superalimenta superalimentar VMM02S0 +superalimentad superalimentar VMM02P0 +superalimentando superalimentar VMG0000 +superalimentar superalimentar VMN0000 +superalimente superalimentar VMM03S0 +superalimentemos superalimentar VMM01P0 +superalimenten superalimentar VMM03P0 +superando superar VMG0000 +superar superar VMN0000 +supere superar VMM03S0 +superemos superar VMM01P0 +superen superar VMM03P0 +supermarca supermarcar VMM02S0 +supermarcad supermarcar VMM02P0 +supermarcando supermarcar VMG0000 +supermarcar supermarcar VMN0000 +superpoblad superpoblar VMM02P0 +superpoblando superpoblar VMG0000 +superpoblar superpoblar VMN0000 +superpoblemos superpoblar VMM01P0 +superponed superponer VMM02P0 +superponer superponer VMN0000 +superponga superponer VMM03S0 +superpongamos superponer VMM01P0 +superpongan superponer VMM03P0 +superponiendo superponer VMG0000 +superpuebla superpoblar VMM02S0 +superpueble superpoblar VMM03S0 +superpueblen superpoblar VMM03P0 +superpón superponer VMM02S0 +supersatura supersaturar VMM02S0 +supersaturad supersaturar VMM02P0 +supersaturando supersaturar VMG0000 +supersaturar supersaturar VMN0000 +supersature supersaturar VMM03S0 +supersaturemos supersaturar VMM01P0 +supersaturen supersaturar VMM03P0 +supervalora supervalorar VMM02S0 +supervalorad supervalorar VMM02P0 +supervalorando supervalorar VMG0000 +supervalorar supervalorar VMN0000 +supervalore supervalorar VMM03S0 +supervaloremos supervalorar VMM01P0 +supervaloren supervalorar VMM03P0 +superven supervenir VMM02S0 +supervenga supervenir VMM03S0 +supervengamos supervenir VMM01P0 +supervengan supervenir VMM03P0 +supervenid supervenir VMM02P0 +supervenir supervenir VMN0000 +superviniendo supervenir VMG0000 +supervisa supervisar VMM02S0 +supervisad supervisar VMM02P0 +supervisando supervisar VMG0000 +supervisar supervisar VMN0000 +supervise supervisar VMM03S0 +supervisemos supervisar VMM01P0 +supervisen supervisar VMM03P0 +superviva supervivir VMM03S0 +supervivamos supervivir VMM01P0 +supervivan supervivir VMM03P0 +supervive supervivir VMM02S0 +supervivid supervivir VMM02P0 +superviviendo supervivir VMG0000 +supervivir supervivir VMN0000 +supla suplir VMM03S0 +suplamos suplir VMM01P0 +suplan suplir VMM03P0 +suplanta suplantar VMM02S0 +suplantad suplantar VMM02P0 +suplantando suplantar VMG0000 +suplantar suplantar VMN0000 +suplante suplantar VMM03S0 +suplantemos suplantar VMM01P0 +suplanten suplantar VMM03P0 +suple suplir VMM02S0 +suplementa suplementar VMM02S0 +suplementad suplementar VMM02P0 +suplementando suplementar VMG0000 +suplementar suplementar VMN0000 +suplica suplicar VMM02S0 +suplicad suplicar VMM02P0 +suplicando suplicar VMG0000 +suplicar suplicar VMN0000 +suplid suplir VMM02P0 +supliendo suplir VMG0000 +suplique suplicar VMM03S0 +supliquemos suplicar VMM01P0 +supliquen suplicar VMM03P0 +suplir suplir VMN0000 +suponed suponer VMM02P0 +suponer suponer VMN0000 +suponga suponer VMM03S0 +supongamos suponer VMM01P0 +supongan suponer VMM03P0 +suponiendo suponer VMG0000 +suprima suprimir VMM03S0 +suprimamos suprimir VMM01P0 +supriman suprimir VMM03P0 +suprime suprimir VMM02S0 +suprimid suprimir VMM02P0 +suprimiendo suprimir VMG0000 +suprimir suprimir VMN0000 +supura supurar VMM02S0 +supurad supurar VMM02P0 +supurando supurar VMG0000 +supurar supurar VMN0000 +supure supurar VMM03S0 +supuremos supurar VMM01P0 +supuren supurar VMM03P0 +suputa suputar VMM02S0 +suputad suputar VMM02P0 +suputando suputar VMG0000 +suputar suputar VMN0000 +supute suputar VMM03S0 +suputemos suputar VMM01P0 +suputen suputar VMM03P0 +supón suponer VMM02S0 +surca surcar VMM02S0 +surcad surcar VMM02P0 +surcando surcar VMG0000 +surcar surcar VMN0000 +surge surgir VMM02S0 +surgid surgir VMM02P0 +surgiendo surgir VMG0000 +surgir surgir VMN0000 +surja surgir VMM03S0 +surjamos surgir VMM01P0 +surjan surgir VMM03P0 +surque surcar VMM03S0 +surquemos surcar VMM01P0 +surquen surcar VMM03P0 +surta surtir VMM03S0 +surtamos surtir VMM01P0 +surtan surtir VMM03P0 +surte surtir VMM02S0 +surtid surtir VMM02P0 +surtiendo surtir VMG0000 +surtir surtir VMN0000 +suscita suscitar VMM02S0 +suscitad suscitar VMM02P0 +suscitando suscitar VMG0000 +suscitar suscitar VMN0000 +suscite suscitar VMM03S0 +suscitemos suscitar VMM01P0 +susciten suscitar VMM03P0 +suscriba suscribir VMM03S0 +suscribamos suscribir VMM01P0 +suscriban suscribir VMM03P0 +suscribe suscribir VMM02S0 +suscribid suscribir VMM02P0 +suscribiendo suscribir VMG0000 +suscribir suscribir VMN0000 +suspenda suspender VMM03S0 +suspendamos suspender VMM01P0 +suspendan suspender VMM03P0 +suspende suspender VMM02S0 +suspended suspender VMM02P0 +suspender suspender VMN0000 +suspendiendo suspender VMG0000 +suspira suspirar VMM02S0 +suspirad suspirar VMM02P0 +suspirando suspirar VMG0000 +suspirar suspirar VMN0000 +suspire suspirar VMM03S0 +suspiremos suspirar VMM01P0 +suspiren suspirar VMM03P0 +sustancia sustanciar VMM02S0 +sustanciad sustanciar VMM02P0 +sustanciando sustanciar VMG0000 +sustanciar sustanciar VMN0000 +sustancie sustanciar VMM03S0 +sustanciemos sustanciar VMM01P0 +sustancien sustanciar VMM03P0 +sustantiva sustantivar VMM02S0 +sustantivad sustantivar VMM02P0 +sustantivando sustantivar VMG0000 +sustantivar sustantivar VMN0000 +sustantive sustantivar VMM03S0 +sustantivemos sustantivar VMM01P0 +sustantiven sustantivar VMM03P0 +sustenta sustentar VMM02S0 +sustentad sustentar VMM02P0 +sustentando sustentar VMG0000 +sustentar sustentar VMN0000 +sustente sustentar VMM03S0 +sustentemos sustentar VMM01P0 +sustenten sustentar VMM03P0 +sustituid sustituir VMM02P0 +sustituir sustituir VMN0000 +sustituya sustituir VMM03S0 +sustituyamos sustituir VMM01P0 +sustituyan sustituir VMM03P0 +sustituye sustituir VMM02S0 +sustituyendo sustituir VMG0000 +sustrae sustraer VMM02S0 +sustraed sustraer VMM02P0 +sustraer sustraer VMN0000 +sustraiga sustraer VMM03S0 +sustraigamos sustraer VMM01P0 +sustraigan sustraer VMM03P0 +sustrayendo sustraer VMG0000 +susurra susurrar VMM02S0 +susurrad susurrar VMM02P0 +susurrando susurrar VMG0000 +susurrar susurrar VMN0000 +susurre susurrar VMM03S0 +susurremos susurrar VMM01P0 +susurren susurrar VMM03P0 +sutilice sutilizar VMM03S0 +sutilicemos sutilizar VMM01P0 +sutilicen sutilizar VMM03P0 +sutiliza sutilizar VMM02S0 +sutilizad sutilizar VMM02P0 +sutilizando sutilizar VMG0000 +sutilizar sutilizar VMN0000 +sutura suturar VMM02S0 +suturad suturar VMM02P0 +suturando suturar VMG0000 +suturar suturar VMN0000 +suture suturar VMM03S0 +suturemos suturar VMM01P0 +suturen suturar VMM03P0 +tabalea tabalear VMM02S0 +tabalead tabalear VMM02P0 +tabaleando tabalear VMG0000 +tabalear tabalear VMN0000 +tabalee tabalear VMM03S0 +tabaleemos tabalear VMM01P0 +tabaleen tabalear VMM03P0 +tabella tabellar VMM02S0 +tabellad tabellar VMM02P0 +tabellando tabellar VMG0000 +tabellar tabellar VMN0000 +tabelle tabellar VMM03S0 +tabellemos tabellar VMM01P0 +tabellen tabellar VMM03P0 +tabica tabicar VMM02S0 +tabicad tabicar VMM02P0 +tabicando tabicar VMG0000 +tabicar tabicar VMN0000 +tabique tabicar VMM03S0 +tabiquemos tabicar VMM01P0 +tabiquen tabicar VMM03P0 +tablea tablear VMM02S0 +tablead tablear VMM02P0 +tableando tablear VMG0000 +tablear tablear VMN0000 +tablee tablear VMM03S0 +tableemos tablear VMM01P0 +tableen tablear VMM03P0 +tabletea tabletear VMM02S0 +tabletead tabletear VMM02P0 +tableteando tabletear VMG0000 +tabletear tabletear VMN0000 +tabletee tabletear VMM03S0 +tableteemos tabletear VMM01P0 +tableteen tabletear VMM03P0 +tabula tabular VMM02S0 +tabulad tabular VMM02P0 +tabulando tabular VMG0000 +tabular tabular VMN0000 +tabule tabular VMM03S0 +tabulemos tabular VMM01P0 +tabulen tabular VMM03P0 +tacañea tacañear VMM02S0 +tacañead tacañear VMM02P0 +tacañeando tacañear VMG0000 +tacañear tacañear VMN0000 +tacañee tacañear VMM03S0 +tacañeemos tacañear VMM01P0 +tacañeen tacañear VMM03P0 +tacha tachar VMM02S0 +tachad tachar VMM02P0 +tachando tachar VMG0000 +tachar tachar VMN0000 +tache tachar VMM03S0 +tachemos tachar VMM01P0 +tachen tachar VMM03P0 +tachona tachonar VMM02S0 +tachonad tachonar VMM02P0 +tachonando tachonar VMG0000 +tachonar tachonar VMN0000 +tachone tachonar VMM03S0 +tachonemos tachonar VMM01P0 +tachonen tachonar VMM03P0 +taconea taconear VMM02S0 +taconead taconear VMM02P0 +taconeando taconear VMG0000 +taconear taconear VMN0000 +taconee taconear VMM03S0 +taconeemos taconear VMM01P0 +taconeen taconear VMM03P0 +tafiletea tafiletear VMM02S0 +tafiletead tafiletear VMM02P0 +tafileteando tafiletear VMG0000 +tafiletear tafiletear VMN0000 +tafiletee tafiletear VMM03S0 +tafileteemos tafiletear VMM01P0 +tafileteen tafiletear VMM03P0 +taimad taimar VMM02P0 +taimando taimar VMG0000 +taimar taimar VMN0000 +taimemos taimar VMM01P0 +taja tajar VMM02S0 +tajad tajar VMM02P0 +tajando tajar VMG0000 +tajar tajar VMN0000 +taje tajar VMM03S0 +tajemos tajar VMM01P0 +tajen tajar VMM03P0 +tala talar VMM02S0 +talad talar VMM02P0 +taladra taladrar VMM02S0 +taladrad taladrar VMM02P0 +taladrando taladrar VMG0000 +taladrar taladrar VMN0000 +taladre taladrar VMM03S0 +taladremos taladrar VMM01P0 +taladren taladrar VMM03P0 +talando talar VMG0000 +talar talar VMN0000 +tale talar VMM03S0 +talemos talar VMM01P0 +talen talar VMM03P0 +talla tallar VMM02S0 +tallad tallar VMM02P0 +tallando tallar VMG0000 +tallar tallar VMN0000 +talle tallar VMM03S0 +tallece tallecer VMM02S0 +talleced tallecer VMM02P0 +tallecer tallecer VMN0000 +talleciendo tallecer VMG0000 +tallemos tallar VMM01P0 +tallen tallar VMM03P0 +tallezca tallecer VMM03S0 +tallezcamos tallecer VMM01P0 +tallezcan tallecer VMM03P0 +talonea talonear VMM02S0 +talonead talonear VMM02P0 +taloneando talonear VMG0000 +talonear talonear VMN0000 +talonee talonear VMM03S0 +taloneemos talonear VMM01P0 +taloneen talonear VMM03P0 +tambalea tambalear VMM02S0 +tambalead tambalear VMM02P0 +tambaleando tambalear VMG0000 +tambalear tambalear VMN0000 +tambalee tambalear VMM03S0 +tambaleemos tambalear VMM01P0 +tambaleen tambalear VMM03P0 +tamborea tamborear VMM02S0 +tamboread tamborear VMM02P0 +tamboreando tamborear VMG0000 +tamborear tamborear VMN0000 +tamboree tamborear VMM03S0 +tamboreemos tamborear VMM01P0 +tamboreen tamborear VMM03P0 +tamborilea tamborilear VMM02S0 +tamborilead tamborilear VMM02P0 +tamborileando tamborilear VMG0000 +tamborilear tamborilear VMN0000 +tamborilee tamborilear VMM03S0 +tamborileemos tamborilear VMM01P0 +tamborileen tamborilear VMM03P0 +tamice tamizar VMM03S0 +tamicemos tamizar VMM01P0 +tamicen tamizar VMM03P0 +tamiza tamizar VMM02S0 +tamizad tamizar VMM02P0 +tamizando tamizar VMG0000 +tamizar tamizar VMN0000 +tantea tantear VMM02S0 +tantead tantear VMM02P0 +tanteando tantear VMG0000 +tantear tantear VMN0000 +tantee tantear VMM03S0 +tanteemos tantear VMM01P0 +tanteen tantear VMM03P0 +tapa tapar VMM02S0 +tapad tapar VMM02P0 +tapando tapar VMG0000 +tapar tapar VMN0000 +tape tapar VMM03S0 +tapemos tapar VMM01P0 +tapen tapar VMM03P0 +tapia tapiar VMM02S0 +tapiad tapiar VMM02P0 +tapiando tapiar VMG0000 +tapiar tapiar VMN0000 +tapice tapizar VMM03S0 +tapicemos tapizar VMM01P0 +tapicen tapizar VMM03P0 +tapie tapiar VMM03S0 +tapiemos tapiar VMM01P0 +tapien tapiar VMM03P0 +tapiza tapizar VMM02S0 +tapizad tapizar VMM02P0 +tapizando tapizar VMG0000 +tapizar tapizar VMN0000 +tapona taponar VMM02S0 +taponad taponar VMM02P0 +taponando taponar VMG0000 +taponar taponar VMN0000 +tapone taponar VMM03S0 +taponemos taponar VMM01P0 +taponen taponar VMM03P0 +taquigrafiad taquigrafiar VMM02P0 +taquigrafiando taquigrafiar VMG0000 +taquigrafiar taquigrafiar VMN0000 +taquigrafiemos taquigrafiar VMM01P0 +taquigrafía taquigrafiar VMM02S0 +taquigrafíe taquigrafiar VMM03S0 +taquigrafíen taquigrafiar VMM03P0 +tara tarar VMM02S0 +taracea taracear VMM02S0 +taracead taracear VMM02P0 +taraceando taracear VMG0000 +taracear taracear VMN0000 +taracee taracear VMM03S0 +taraceemos taracear VMM01P0 +taraceen taracear VMM03P0 +tarad tarar VMM02P0 +tarando tarar VMG0000 +tarar tarar VMN0000 +tararea tararear VMM02S0 +tararead tararear VMM02P0 +tarareando tararear VMG0000 +tararear tararear VMN0000 +tararee tararear VMM03S0 +tarareemos tararear VMM01P0 +tarareen tararear VMM03P0 +tarasca tarascar VMM02S0 +tarascad tarascar VMM02P0 +tarascando tarascar VMG0000 +tarascar tarascar VMN0000 +tarasque tarascar VMM03S0 +tarasquemos tarascar VMM01P0 +tarasquen tarascar VMM03P0 +tarda tardar VMM02S0 +tardad tardar VMM02P0 +tardando tardar VMG0000 +tardar tardar VMN0000 +tarde tardar VMM03S0 +tardece tardecer VMM02S0 +tardeced tardecer VMM02P0 +tardecer tardecer VMN0000 +tardeciendo tardecer VMG0000 +tardemos tardar VMM01P0 +tarden tardar VMM03P0 +tardezca tardecer VMM03S0 +tardezcamos tardecer VMM01P0 +tardezcan tardecer VMM03P0 +tare tarar VMM03S0 +taremos tarar VMM01P0 +taren tarar VMM03P0 +tarifa tarifar VMM02S0 +tarifad tarifar VMM02P0 +tarifando tarifar VMG0000 +tarifar tarifar VMN0000 +tarife tarifar VMM03S0 +tarifemos tarifar VMM01P0 +tarifen tarifar VMM03P0 +tarja tarjar VMM02S0 +tarjad tarjar VMM02P0 +tarjando tarjar VMG0000 +tarjar tarjar VMN0000 +tarje tarjar VMM03S0 +tarjemos tarjar VMM01P0 +tarjen tarjar VMM03P0 +tartajea tartajear VMM02S0 +tartajead tartajear VMM02P0 +tartajeando tartajear VMG0000 +tartajear tartajear VMN0000 +tartajee tartajear VMM03S0 +tartajeemos tartajear VMM01P0 +tartajeen tartajear VMM03P0 +tartamudea tartamudear VMM02S0 +tartamudead tartamudear VMM02P0 +tartamudeando tartamudear VMG0000 +tartamudear tartamudear VMN0000 +tartamudee tartamudear VMM03S0 +tartamudeemos tartamudear VMM01P0 +tartamudeen tartamudear VMM03P0 +tartarice tartarizar VMM03S0 +tartaricemos tartarizar VMM01P0 +tartaricen tartarizar VMM03P0 +tartariza tartarizar VMM02S0 +tartarizad tartarizar VMM02P0 +tartarizando tartarizar VMG0000 +tartarizar tartarizar VMN0000 +tasa tasar VMM02S0 +tasad tasar VMM02P0 +tasando tasar VMG0000 +tasar tasar VMN0000 +tasca tascar VMM02S0 +tascad tascar VMM02P0 +tascando tascar VMG0000 +tascar tascar VMN0000 +tase tasar VMM03S0 +tasemos tasar VMM01P0 +tasen tasar VMM03P0 +tasque tascar VMM03S0 +tasquemos tascar VMM01P0 +tasquen tascar VMM03P0 +tatuad tatuar VMM02P0 +tatuando tatuar VMG0000 +tatuar tatuar VMN0000 +tatuemos tatuar VMM01P0 +tatúa tatuar VMM02S0 +tatúe tatuar VMM03S0 +tatúen tatuar VMM03P0 +taíma taimar VMM02S0 +taíme taimar VMM03S0 +taímen taimar VMM03P0 +taña tañer VMM03S0 +tañamos tañer VMM01P0 +tañan tañer VMM03P0 +tañe tañer VMM02S0 +tañed tañer VMM02P0 +tañendo tañer VMG0000 +tañer tañer VMN0000 +techa techar VMM02S0 +techad techar VMM02P0 +techando techar VMG0000 +techar techar VMN0000 +teche techar VMM03S0 +techemos techar VMM01P0 +techen techar VMM03P0 +teclea teclear VMM02S0 +teclead teclear VMM02P0 +tecleando teclear VMG0000 +teclear teclear VMN0000 +teclee teclear VMM03S0 +tecleemos teclear VMM01P0 +tecleen teclear VMM03P0 +tedia tediar VMM02S0 +tediad tediar VMM02P0 +tediando tediar VMG0000 +tediar tediar VMN0000 +tedie tediar VMM03S0 +tediemos tediar VMM01P0 +tedien tediar VMM03P0 +teja tejar VMM02S0 +teja tejer VMM03S0 +tejad tejar VMM02P0 +tejamos tejer VMM01P0 +tejan tejer VMM03P0 +tejando tejar VMG0000 +tejar tejar VMN0000 +teje tejar VMM03S0 +teje tejer VMM02S0 +tejed tejer VMM02P0 +tejemos tejar VMM01P0 +tejen tejar VMM03P0 +tejer tejer VMN0000 +tejiendo tejer VMG0000 +teledirige teledirigir VMM02S0 +teledirigid teledirigir VMM02P0 +teledirigiendo teledirigir VMG0000 +teledirigir teledirigir VMN0000 +teledirija teledirigir VMM03S0 +teledirijamos teledirigir VMM01P0 +teledirijan teledirigir VMM03P0 +telefonea telefonear VMM02S0 +telefonead telefonear VMM02P0 +telefoneando telefonear VMG0000 +telefonear telefonear VMN0000 +telefonee telefonear VMM03S0 +telefoneemos telefonear VMM01P0 +telefoneen telefonear VMM03P0 +telegrafiad telegrafiar VMM02P0 +telegrafiando telegrafiar VMG0000 +telegrafiar telegrafiar VMN0000 +telegrafiemos telegrafiar VMM01P0 +telegrafía telegrafiar VMM02S0 +telegrafíe telegrafiar VMM03S0 +telegrafíen telegrafiar VMM03P0 +televisa televisar VMM02S0 +televisad televisar VMM02P0 +televisando televisar VMG0000 +televisar televisar VMN0000 +televise televisar VMM03S0 +televisemos televisar VMM01P0 +televisen televisar VMM03P0 +tema temer VMM03S0 +temamos temer VMM01P0 +teman temer VMM03P0 +temblad temblar VMM02P0 +temblando temblar VMG0000 +temblar temblar VMN0000 +temblemos temblar VMM01P0 +temblequea temblequear VMM02S0 +temblequead temblequear VMM02P0 +temblequeando temblequear VMG0000 +temblequear temblequear VMN0000 +temblequee temblequear VMM03S0 +temblequeemos temblequear VMM01P0 +temblequeen temblequear VMM03P0 +tembletea tembletear VMM02S0 +tembletead tembletear VMM02P0 +tembleteando tembletear VMG0000 +tembletear tembletear VMN0000 +tembletee tembletear VMM03S0 +tembleteemos tembletear VMM01P0 +tembleteen tembletear VMM03P0 +teme temer VMM02S0 +temed temer VMM02P0 +temer temer VMN0000 +temiendo temer VMG0000 +tempana tempanar VMM02S0 +tempanad tempanar VMM02P0 +tempanando tempanar VMG0000 +tempanar tempanar VMN0000 +tempane tempanar VMM03S0 +tempanemos tempanar VMM01P0 +tempanen tempanar VMM03P0 +tempera temperar VMM02S0 +temperad temperar VMM02P0 +temperando temperar VMG0000 +temperar temperar VMN0000 +tempere temperar VMM03S0 +temperemos temperar VMM01P0 +temperen temperar VMM03P0 +tempestea tempestear VMM02S0 +tempestead tempestear VMM02P0 +tempesteando tempestear VMG0000 +tempestear tempestear VMN0000 +tempestee tempestear VMM03S0 +tempesteemos tempestear VMM01P0 +tempesteen tempestear VMM03P0 +templa templar VMM02S0 +templad templar VMM02P0 +templando templar VMG0000 +templar templar VMN0000 +temple templar VMM03S0 +templemos templar VMM01P0 +templen templar VMM03P0 +temporalice temporalizar VMM03S0 +temporalicemos temporalizar VMM01P0 +temporalicen temporalizar VMM03P0 +temporaliza temporalizar VMM02S0 +temporalizad temporalizar VMM02P0 +temporalizando temporalizar VMG0000 +temporalizar temporalizar VMN0000 +temporice temporizar VMM03S0 +temporicemos temporizar VMM01P0 +temporicen temporizar VMM03P0 +temporiza temporizar VMM02S0 +temporizad temporizar VMM02P0 +temporizando temporizar VMG0000 +temporizar temporizar VMN0000 +ten tener VMM02S0 +tenacea tenacear VMM02S0 +tenacead tenacear VMM02P0 +tenaceando tenacear VMG0000 +tenacear tenacear VMN0000 +tenacee tenacear VMM03S0 +tenaceemos tenacear VMM01P0 +tenaceen tenacear VMM03P0 +tendamos tender VMM01P0 +tended tender VMM02P0 +tender tender VMN0000 +tendiendo tender VMG0000 +tened tener VMM02P0 +tener tener VMN0000 +tenga tener VMM03S0 +tengamos tener VMM01P0 +tengan tener VMM03P0 +teniendo tener VMG0000 +tensa tensar VMM02S0 +tensad tensar VMM02P0 +tensando tensar VMG0000 +tensar tensar VMN0000 +tense tensar VMM03S0 +tensemos tensar VMM01P0 +tensen tensar VMM03P0 +tentad tentar VMM02P0 +tentalea tentalear VMM02S0 +tentalead tentalear VMM02P0 +tentaleando tentalear VMG0000 +tentalear tentalear VMN0000 +tentalee tentalear VMM03S0 +tentaleemos tentalear VMM01P0 +tentaleen tentalear VMM03P0 +tentando tentar VMG0000 +tentar tentar VMN0000 +tentemos tentar VMM01P0 +teologice teologizar VMM03S0 +teologicemos teologizar VMM01P0 +teologicen teologizar VMM03P0 +teologiza teologizar VMM02S0 +teologizad teologizar VMM02P0 +teologizando teologizar VMG0000 +teologizar teologizar VMN0000 +teorice teorizar VMM03S0 +teoricemos teorizar VMM01P0 +teoricen teorizar VMM03P0 +teoriza teorizar VMM02S0 +teorizad teorizar VMM02P0 +teorizando teorizar VMG0000 +teorizar teorizar VMN0000 +tercia terciar VMM02S0 +terciad terciar VMM02P0 +terciando terciar VMG0000 +terciar terciar VMN0000 +tercie terciar VMM03S0 +terciemos terciar VMM01P0 +tercien terciar VMM03P0 +tergiversa tergiversar VMM02S0 +tergiversad tergiversar VMM02P0 +tergiversando tergiversar VMG0000 +tergiversar tergiversar VMN0000 +tergiverse tergiversar VMM03S0 +tergiversemos tergiversar VMM01P0 +tergiversen tergiversar VMM03P0 +termina terminar VMM02S0 +terminad terminar VMM02P0 +terminando terminar VMG0000 +terminar terminar VMN0000 +termine terminar VMM03S0 +terminemos terminar VMM01P0 +terminen terminar VMM03P0 +terquea terquear VMM02S0 +terquead terquear VMM02P0 +terqueando terquear VMG0000 +terquear terquear VMN0000 +terquee terquear VMM03S0 +terqueemos terquear VMM01P0 +terqueen terquear VMM03P0 +terraplena terraplenar VMM02S0 +terraplenad terraplenar VMM02P0 +terraplenando terraplenar VMG0000 +terraplenar terraplenar VMN0000 +terraplene terraplenar VMM03S0 +terraplenemos terraplenar VMM01P0 +terraplenen terraplenar VMM03P0 +terrea terrear VMM02S0 +terread terrear VMM02P0 +terreando terrear VMG0000 +terrear terrear VMN0000 +terree terrear VMM03S0 +terreemos terrear VMM01P0 +terreen terrear VMM03P0 +tersa tersar VMM02S0 +tersad tersar VMM02P0 +tersando tersar VMG0000 +tersar tersar VMN0000 +terse tersar VMM03S0 +tersemos tersar VMM01P0 +tersen tersar VMM03P0 +tertulia tertuliar VMM02S0 +tertuliad tertuliar VMM02P0 +tertuliando tertuliar VMG0000 +tertuliar tertuliar VMN0000 +tertulie tertuliar VMM03S0 +tertuliemos tertuliar VMM01P0 +tertulien tertuliar VMM03P0 +tesa tesar VMM02S0 +tesad tesar VMM02P0 +tesando tesar VMG0000 +tesar tesar VMN0000 +tese tesar VMM03S0 +tesemos tesar VMM01P0 +tesen tesar VMM03P0 +testa testar VMM02S0 +testad testar VMM02P0 +testando testar VMG0000 +testar testar VMN0000 +teste testar VMM03S0 +testemos testar VMM01P0 +testen testar VMM03P0 +testifica testificar VMM02S0 +testificad testificar VMM02P0 +testificando testificar VMG0000 +testificar testificar VMN0000 +testifique testificar VMM03S0 +testifiquemos testificar VMM01P0 +testifiquen testificar VMM03P0 +testimonia testimoniar VMM02S0 +testimoniad testimoniar VMM02P0 +testimoniando testimoniar VMG0000 +testimoniar testimoniar VMN0000 +testimonie testimoniar VMM03S0 +testimoniemos testimoniar VMM01P0 +testimonien testimoniar VMM03P0 +teñid teñir VMM02P0 +teñir teñir VMN0000 +tiembla temblar VMM02S0 +tiemble temblar VMM03S0 +tiemblen temblar VMM03P0 +tienda tender VMM03S0 +tiendan tender VMM03P0 +tiende tender VMM02S0 +tienta tentar VMM02S0 +tiente tentar VMM03S0 +tienten tentar VMM03P0 +tijeretea tijeretear VMM02S0 +tijeretead tijeretear VMM02P0 +tijereteando tijeretear VMG0000 +tijeretear tijeretear VMN0000 +tijeretee tijeretear VMM03S0 +tijereteemos tijeretear VMM01P0 +tijereteen tijeretear VMM03P0 +tilda tildar VMM02S0 +tildad tildar VMM02P0 +tildando tildar VMG0000 +tildar tildar VMN0000 +tilde tildar VMM03S0 +tildemos tildar VMM01P0 +tilden tildar VMM03P0 +tilla tillar VMM02S0 +tillad tillar VMM02P0 +tillando tillar VMG0000 +tillar tillar VMN0000 +tille tillar VMM03S0 +tillemos tillar VMM01P0 +tillen tillar VMM03P0 +tima timar VMM02S0 +timad timar VMM02P0 +timando timar VMG0000 +timar timar VMN0000 +timbra timbrar VMM02S0 +timbrad timbrar VMM02P0 +timbrando timbrar VMG0000 +timbrar timbrar VMN0000 +timbre timbrar VMM03S0 +timbremos timbrar VMM01P0 +timbren timbrar VMM03P0 +time timar VMM03S0 +timemos timar VMM01P0 +timen timar VMM03P0 +timonea timonear VMM02S0 +timonead timonear VMM02P0 +timoneando timonear VMG0000 +timonear timonear VMN0000 +timonee timonear VMM03S0 +timoneemos timonear VMM01P0 +timoneen timonear VMM03P0 +timpanice timpanizar VMM03S0 +timpanicemos timpanizar VMM01P0 +timpanicen timpanizar VMM03P0 +timpaniza timpanizar VMM02S0 +timpanizad timpanizar VMM02P0 +timpanizando timpanizar VMG0000 +timpanizar timpanizar VMN0000 +tinta tintar VMM02S0 +tintad tintar VMM02P0 +tintando tintar VMG0000 +tintar tintar VMN0000 +tinte tintar VMM03S0 +tintemos tintar VMM01P0 +tinten tintar VMM03P0 +tinterilla tinterillar VMM02S0 +tinterillad tinterillar VMM02P0 +tinterillando tinterillar VMG0000 +tinterillar tinterillar VMN0000 +tinterille tinterillar VMM03S0 +tinterillemos tinterillar VMM01P0 +tinterillen tinterillar VMM03P0 +tintinea tintinear VMM02S0 +tintinead tintinear VMM02P0 +tintineando tintinear VMG0000 +tintinear tintinear VMN0000 +tintinee tintinear VMM03S0 +tintineemos tintinear VMM01P0 +tintineen tintinear VMM03P0 +tipifica tipificar VMM02S0 +tipificad tipificar VMM02P0 +tipificando tipificar VMG0000 +tipificar tipificar VMN0000 +tipifique tipificar VMM03S0 +tipifiquemos tipificar VMM01P0 +tipifiquen tipificar VMM03P0 +tira tirar VMM02S0 +tirad tirar VMM02P0 +tiramolla tiramollar VMM02S0 +tiramollad tiramollar VMM02P0 +tiramollando tiramollar VMG0000 +tiramollar tiramollar VMN0000 +tiramolle tiramollar VMM03S0 +tiramollemos tiramollar VMM01P0 +tiramollen tiramollar VMM03P0 +tirando tirar VMG0000 +tiranice tiranizar VMM03S0 +tiranicemos tiranizar VMM01P0 +tiranicen tiranizar VMM03P0 +tiraniza tiranizar VMM02S0 +tiranizad tiranizar VMM02P0 +tiranizando tiranizar VMG0000 +tiranizar tiranizar VMN0000 +tirar tirar VMN0000 +tire tirar VMM03S0 +tiremos tirar VMM01P0 +tiren tirar VMM03P0 +tirita tiritar VMM02S0 +tiritad tiritar VMM02P0 +tiritando tiritar VMG0000 +tiritar tiritar VMN0000 +tirite tiritar VMM03S0 +tiritemos tiritar VMM01P0 +tiriten tiritar VMM03P0 +tirotea tirotear VMM02S0 +tirotead tirotear VMM02P0 +tiroteando tirotear VMG0000 +tirotear tirotear VMN0000 +tirotee tirotear VMM03S0 +tiroteemos tirotear VMM01P0 +tiroteen tirotear VMM03P0 +titea titear VMM02S0 +titead titear VMM02P0 +titeando titear VMG0000 +titear titear VMN0000 +titee titear VMM03S0 +titeemos titear VMM01P0 +titeen titear VMM03P0 +titila titilar VMM02S0 +titilad titilar VMM02P0 +titilando titilar VMG0000 +titilar titilar VMN0000 +titile titilar VMM03S0 +titilemos titilar VMM01P0 +titilen titilar VMM03P0 +titirita titiritar VMM02S0 +titiritad titiritar VMM02P0 +titiritando titiritar VMG0000 +titiritar titiritar VMN0000 +titirite titiritar VMM03S0 +titiritemos titiritar VMM01P0 +titiriten titiritar VMM03P0 +titubea titubear VMM02S0 +titubead titubear VMM02P0 +titubeando titubear VMG0000 +titubear titubear VMN0000 +titubee titubear VMM03S0 +titubeemos titubear VMM01P0 +titubeen titubear VMM03P0 +titula titular VMM02S0 +titulad titular VMM02P0 +titulando titular VMG0000 +titular titular VMN0000 +titule titular VMM03S0 +titulemos titular VMM01P0 +titulen titular VMM03P0 +tizna tiznar VMM02S0 +tiznad tiznar VMM02P0 +tiznando tiznar VMG0000 +tiznar tiznar VMN0000 +tizne tiznar VMM03S0 +tiznemos tiznar VMM01P0 +tiznen tiznar VMM03P0 +tizonea tizonear VMM02S0 +tizonead tizonear VMM02P0 +tizoneando tizonear VMG0000 +tizonear tizonear VMN0000 +tizonee tizonear VMM03S0 +tizoneemos tizonear VMM01P0 +tizoneen tizonear VMM03P0 +tiña teñir VMM03S0 +tiñamos teñir VMM01P0 +tiñan teñir VMM03P0 +tiñe teñir VMM02S0 +tiñendo teñir VMG0000 +toa toar VMM02S0 +toad toar VMM02P0 +toando toar VMG0000 +toar toar VMN0000 +toca tocar VMM02S0 +tocad tocar VMM02P0 +tocando tocar VMG0000 +tocar tocar VMN0000 +toe toar VMM03S0 +toemos toar VMM01P0 +toen toar VMM03P0 +tolda toldar VMM02S0 +toldad toldar VMM02P0 +toldando toldar VMG0000 +toldar toldar VMN0000 +tolde toldar VMM03S0 +toldemos toldar VMM01P0 +tolden toldar VMM03P0 +tolera tolerar VMM02S0 +tolerad tolerar VMM02P0 +tolerando tolerar VMG0000 +tolerar tolerar VMN0000 +tolere tolerar VMM03S0 +toleremos tolerar VMM01P0 +toleren tolerar VMM03P0 +toma tomar VMM02S0 +tomad tomar VMM02P0 +tomando tomar VMG0000 +tomar tomar VMN0000 +tome tomar VMM03S0 +tomemos tomar VMM01P0 +tomen tomar VMM03P0 +tonad tonar VMM02P0 +tonando tonar VMG0000 +tonar tonar VMN0000 +tonemos tonar VMM01P0 +tonifica tonificar VMM02S0 +tonificad tonificar VMM02P0 +tonificando tonificar VMG0000 +tonificar tonificar VMN0000 +tonifique tonificar VMM03S0 +tonifiquemos tonificar VMM01P0 +tonifiquen tonificar VMM03P0 +tonsura tonsurar VMM02S0 +tonsurad tonsurar VMM02P0 +tonsurando tonsurar VMG0000 +tonsurar tonsurar VMN0000 +tonsure tonsurar VMM03S0 +tonsuremos tonsurar VMM01P0 +tonsuren tonsurar VMM03P0 +tontea tontear VMM02S0 +tontead tontear VMM02P0 +tonteando tontear VMG0000 +tontear tontear VMN0000 +tontee tontear VMM03S0 +tonteemos tontear VMM01P0 +tonteen tontear VMM03P0 +topa topar VMM02S0 +topad topar VMM02P0 +topando topar VMG0000 +topar topar VMN0000 +tope topar VMM03S0 +topemos topar VMM01P0 +topen topar VMM03P0 +topeta topetar VMM02S0 +topetad topetar VMM02P0 +topetando topetar VMG0000 +topetar topetar VMN0000 +topete topetar VMM03S0 +topetemos topetar VMM01P0 +topeten topetar VMM03P0 +toque tocar VMM03S0 +toquemos tocar VMM01P0 +toquen tocar VMM03P0 +toquetea toquetear VMM02S0 +toquetead toquetear VMM02P0 +toqueteando toquetear VMG0000 +toquetear toquetear VMN0000 +toquetee toquetear VMM03S0 +toqueteemos toquetear VMM01P0 +toqueteen toquetear VMM03P0 +torced torcer VMM02P0 +torcer torcer VMN0000 +torciendo torcer VMG0000 +torea torear VMM02S0 +toread torear VMM02P0 +toreando torear VMG0000 +torear torear VMN0000 +toree torear VMM03S0 +toreemos torear VMM01P0 +toreen torear VMM03P0 +torna tornar VMM02S0 +tornad tornar VMM02P0 +tornando tornar VMG0000 +tornar tornar VMN0000 +tornasola tornasolar VMM02S0 +tornasolad tornasolar VMM02P0 +tornasolando tornasolar VMG0000 +tornasolar tornasolar VMN0000 +tornasole tornasolar VMM03S0 +tornasolemos tornasolar VMM01P0 +tornasolen tornasolar VMM03P0 +torne tornar VMM03S0 +tornea tornear VMM02S0 +tornead tornear VMM02P0 +torneando tornear VMG0000 +tornear tornear VMN0000 +tornee tornear VMM03S0 +torneemos tornear VMM01P0 +torneen tornear VMM03P0 +tornemos tornar VMM01P0 +tornen tornar VMM03P0 +torpedea torpedear VMM02S0 +torpedead torpedear VMM02P0 +torpedeando torpedear VMG0000 +torpedear torpedear VMN0000 +torpedee torpedear VMM03S0 +torpedeemos torpedear VMM01P0 +torpedeen torpedear VMM03P0 +torra torrar VMM02S0 +torrad torrar VMM02P0 +torrando torrar VMG0000 +torrar torrar VMN0000 +torre torrar VMM03S0 +torrea torrear VMM02S0 +torread torrear VMM02P0 +torreando torrear VMG0000 +torrear torrear VMN0000 +torree torrear VMM03S0 +torreemos torrear VMM01P0 +torreen torrear VMM03P0 +torremos torrar VMM01P0 +torren torrar VMM03P0 +tortura torturar VMM02S0 +torturad torturar VMM02P0 +torturando torturar VMG0000 +torturar torturar VMN0000 +torture torturar VMM03S0 +torturemos torturar VMM01P0 +torturen torturar VMM03P0 +torzamos torcer VMM01P0 +tosa toser VMM03S0 +tosamos toser VMM01P0 +tosan toser VMM03P0 +tose toser VMM02S0 +tosed toser VMM02P0 +toser toser VMN0000 +tosiendo toser VMG0000 +tostad tostar VMM02P0 +tostando tostar VMG0000 +tostar tostar VMN0000 +tostemos tostar VMM01P0 +totalice totalizar VMM03S0 +totalicemos totalizar VMM01P0 +totalicen totalizar VMM03P0 +totaliza totalizar VMM02S0 +totalizad totalizar VMM02P0 +totalizando totalizar VMG0000 +totalizar totalizar VMN0000 +traba trabar VMM02S0 +trabad trabar VMM02P0 +trabaja trabajar VMM02S0 +trabajad trabajar VMM02P0 +trabajando trabajar VMG0000 +trabajar trabajar VMN0000 +trabaje trabajar VMM03S0 +trabajemos trabajar VMM01P0 +trabajen trabajar VMM03P0 +trabando trabar VMG0000 +trabar trabar VMN0000 +trabe trabar VMM03S0 +trabemos trabar VMM01P0 +traben trabar VMM03P0 +trabuca trabucar VMM02S0 +trabucad trabucar VMM02P0 +trabucando trabucar VMG0000 +trabucar trabucar VMN0000 +trabuque trabucar VMM03S0 +trabuquemos trabucar VMM01P0 +trabuquen trabucar VMM03P0 +trace trazar VMM03S0 +tracemos trazar VMM01P0 +tracen trazar VMM03P0 +traduce traducir VMM02S0 +traducid traducir VMM02P0 +traduciendo traducir VMG0000 +traducir traducir VMN0000 +traduzca traducir VMM03S0 +traduzcamos traducir VMM01P0 +traduzcan traducir VMM03P0 +trae traer VMM02S0 +traed traer VMM02P0 +traer traer VMN0000 +trafaga trafagar VMM02S0 +trafagad trafagar VMM02P0 +trafagando trafagar VMG0000 +trafagar trafagar VMN0000 +trafague trafagar VMM03S0 +trafaguemos trafagar VMM01P0 +trafaguen trafagar VMM03P0 +trafica traficar VMM02S0 +traficad traficar VMM02P0 +traficando traficar VMG0000 +traficar traficar VMN0000 +trafique traficar VMM03S0 +trafiquemos traficar VMM01P0 +trafiquen traficar VMM03P0 +traga tragar VMM02S0 +tragad tragar VMM02P0 +tragando tragar VMG0000 +tragar tragar VMN0000 +tragonea tragonear VMM02S0 +tragonead tragonear VMM02P0 +tragoneando tragonear VMG0000 +tragonear tragonear VMN0000 +tragonee tragonear VMM03S0 +tragoneemos tragonear VMM01P0 +tragoneen tragonear VMM03P0 +trague tragar VMM03S0 +traguemos tragar VMM01P0 +traguen tragar VMM03P0 +traiciona traicionar VMM02S0 +traicionad traicionar VMM02P0 +traicionando traicionar VMG0000 +traicionar traicionar VMN0000 +traicione traicionar VMM03S0 +traicionemos traicionar VMM01P0 +traicionen traicionar VMM03P0 +traiga traer VMM03S0 +traigamos traer VMM01P0 +traigan traer VMM03P0 +traillad traillar VMM02P0 +traillando traillar VMG0000 +traillar traillar VMN0000 +traillemos traillar VMM01P0 +trajea trajear VMM02S0 +trajead trajear VMM02P0 +trajeando trajear VMG0000 +trajear trajear VMN0000 +trajee trajear VMM03S0 +trajeemos trajear VMM01P0 +trajeen trajear VMM03P0 +trajina trajinar VMM02S0 +trajinad trajinar VMM02P0 +trajinando trajinar VMG0000 +trajinar trajinar VMN0000 +trajine trajinar VMM03S0 +trajinemos trajinar VMM01P0 +trajinen trajinar VMM03P0 +trama tramar VMM02S0 +tramad tramar VMM02P0 +tramando tramar VMG0000 +tramar tramar VMN0000 +trame tramar VMM03S0 +tramemos tramar VMM01P0 +tramen tramar VMM03P0 +tramita tramitar VMM02S0 +tramitad tramitar VMM02P0 +tramitando tramitar VMG0000 +tramitar tramitar VMN0000 +tramite tramitar VMM03S0 +tramitemos tramitar VMM01P0 +tramiten tramitar VMM03P0 +tramonta tramontar VMM02S0 +tramontad tramontar VMM02P0 +tramontando tramontar VMG0000 +tramontar tramontar VMN0000 +tramonte tramontar VMM03S0 +tramontemos tramontar VMM01P0 +tramonten tramontar VMM03P0 +trampea trampear VMM02S0 +trampead trampear VMM02P0 +trampeando trampear VMG0000 +trampear trampear VMN0000 +trampee trampear VMM03S0 +trampeemos trampear VMM01P0 +trampeen trampear VMM03P0 +tranca trancar VMM02S0 +trancad trancar VMM02P0 +trancando trancar VMG0000 +trancar trancar VMN0000 +trance tranzar VMM03S0 +trancemos tranzar VMM01P0 +trancen tranzar VMM03P0 +tranque trancar VMM03S0 +tranquemos trancar VMM01P0 +tranquen trancar VMM03P0 +tranquilice tranquilizar VMM03S0 +tranquilicemos tranquilizar VMM01P0 +tranquilicen tranquilizar VMM03P0 +tranquiliza tranquilizar VMM02S0 +tranquilizad tranquilizar VMM02P0 +tranquilizando tranquilizar VMG0000 +tranquilizar tranquilizar VMN0000 +transacciona transaccionar VMM02S0 +transaccionad transaccionar VMM02P0 +transaccionando transaccionar VMG0000 +transaccionar transaccionar VMN0000 +transamina transaminar VMM02S0 +transaminad transaminar VMM02P0 +transaminando transaminar VMG0000 +transaminar transaminar VMN0000 +transborda transbordar VMM02S0 +transbordad transbordar VMM02P0 +transbordando transbordar VMG0000 +transbordar transbordar VMN0000 +transborde transbordar VMM03S0 +transbordemos transbordar VMM01P0 +transborden transbordar VMM03P0 +transcendamos transcender VMM01P0 +transcended transcender VMM02P0 +transcender transcender VMN0000 +transcendiendo transcender VMG0000 +transcienda transcender VMM03S0 +transciendan transcender VMM03P0 +transciende transcender VMM02S0 +transcriba transcribir VMM03S0 +transcribamos transcribir VMM01P0 +transcriban transcribir VMM03P0 +transcribe transcribir VMM02S0 +transcribid transcribir VMM02P0 +transcribiendo transcribir VMG0000 +transcribir transcribir VMN0000 +transcurra transcurrir VMM03S0 +transcurramos transcurrir VMM01P0 +transcurran transcurrir VMM03P0 +transcurre transcurrir VMM02S0 +transcurrid transcurrir VMM02P0 +transcurriendo transcurrir VMG0000 +transcurrir transcurrir VMN0000 +transferid transferir VMM02P0 +transferir transferir VMN0000 +transfiera transferir VMM03S0 +transfieran transferir VMM03P0 +transfiere transferir VMM02S0 +transfigura transfigurar VMM02S0 +transfigurad transfigurar VMM02P0 +transfigurando transfigurar VMG0000 +transfigurar transfigurar VMN0000 +transfigure transfigurar VMM03S0 +transfiguremos transfigurar VMM01P0 +transfiguren transfigurar VMM03P0 +transfiramos transferir VMM01P0 +transfiriendo transferir VMG0000 +transforma transformar VMM02S0 +transformad transformar VMM02P0 +transformando transformar VMG0000 +transformar transformar VMN0000 +transforme transformar VMM03S0 +transformemos transformar VMM01P0 +transformen transformar VMM03P0 +transfunda transfundir VMM03S0 +transfundamos transfundir VMM01P0 +transfundan transfundir VMM03P0 +transfunde transfundir VMM02S0 +transfundid transfundir VMM02P0 +transfundiendo transfundir VMG0000 +transfundir transfundir VMN0000 +transgreda transgredir VMM03S0 +transgredamos transgredir VMM01P0 +transgredan transgredir VMM03P0 +transgrede transgredir VMM02S0 +transgredid transgredir VMM02P0 +transgrediendo transgredir VMG0000 +transgredir transgredir VMN0000 +transige transigir VMM02S0 +transigid transigir VMM02P0 +transigiendo transigir VMG0000 +transigir transigir VMN0000 +transija transigir VMM03S0 +transijamos transigir VMM01P0 +transijan transigir VMM03P0 +transistorice transistorizar VMM03S0 +transistoricemos transistorizar VMM01P0 +transistoricen transistorizar VMM03P0 +transistoriza transistorizar VMM02S0 +transistorizad transistorizar VMM02P0 +transistorizando transistorizar VMG0000 +transistorizar transistorizar VMN0000 +transita transitar VMM02S0 +transitad transitar VMM02P0 +transitando transitar VMG0000 +transitar transitar VMN0000 +transite transitar VMM03S0 +transitemos transitar VMM01P0 +transiten transitar VMM03P0 +translimita translimitar VMM02S0 +translimitad translimitar VMM02P0 +translimitando translimitar VMG0000 +translimitar translimitar VMN0000 +translimite translimitar VMM03S0 +translimitemos translimitar VMM01P0 +translimiten translimitar VMM03P0 +translitera transliterar VMM02S0 +transliterad transliterar VMM02P0 +transliterando transliterar VMG0000 +transliterar transliterar VMN0000 +translitere transliterar VMM03S0 +transliteremos transliterar VMM01P0 +transliteren transliterar VMM03P0 +transluce translucir VMM02S0 +translucid translucir VMM02P0 +transluciendo translucir VMG0000 +translucir translucir VMN0000 +transluzca translucir VMM03S0 +transluzcamos translucir VMM01P0 +transluzcan translucir VMM03P0 +transmigra transmigrar VMM02S0 +transmigrad transmigrar VMM02P0 +transmigrando transmigrar VMG0000 +transmigrar transmigrar VMN0000 +transmigre transmigrar VMM03S0 +transmigremos transmigrar VMM01P0 +transmigren transmigrar VMM03P0 +transmita transmitir VMM03S0 +transmitamos transmitir VMM01P0 +transmitan transmitir VMM03P0 +transmite transmitir VMM02S0 +transmitid transmitir VMM02P0 +transmitiendo transmitir VMG0000 +transmitir transmitir VMN0000 +transmuda transmudar VMM02S0 +transmudad transmudar VMM02P0 +transmudando transmudar VMG0000 +transmudar transmudar VMN0000 +transmude transmudar VMM03S0 +transmudemos transmudar VMM01P0 +transmuden transmudar VMM03P0 +transmuta transmutar VMM02S0 +transmutad transmutar VMM02P0 +transmutando transmutar VMG0000 +transmutar transmutar VMN0000 +transmute transmutar VMM03S0 +transmutemos transmutar VMM01P0 +transmuten transmutar VMM03P0 +transparenta transparentar VMM02S0 +transparentad transparentar VMM02P0 +transparentando transparentar VMG0000 +transparentar transparentar VMN0000 +transparente transparentar VMM03S0 +transparentemos transparentar VMM01P0 +transparenten transparentar VMM03P0 +transpira transpirar VMM02S0 +transpirad transpirar VMM02P0 +transpirando transpirar VMG0000 +transpirar transpirar VMN0000 +transpire transpirar VMM03S0 +transpiremos transpirar VMM01P0 +transpiren transpirar VMM03P0 +transponed transponer VMM02P0 +transponer transponer VMN0000 +transponga transponer VMM03S0 +transpongamos transponer VMM01P0 +transpongan transponer VMM03P0 +transponiendo transponer VMG0000 +transporta transportar VMM02S0 +transportad transportar VMM02P0 +transportando transportar VMG0000 +transportar transportar VMN0000 +transporte transportar VMM03S0 +transportemos transportar VMM01P0 +transporten transportar VMM03P0 +transpón transponer VMM02S0 +transtermina transterminar VMM02S0 +transterminad transterminar VMM02P0 +transterminando transterminar VMG0000 +transterminar transterminar VMN0000 +transtermine transterminar VMM03S0 +transterminemos transterminar VMM01P0 +transterminen transterminar VMM03P0 +transubstancia transubstanciar VMM02S0 +transubstanciad transubstanciar VMM02P0 +transubstanciando transubstanciar VMG0000 +transubstanciar transubstanciar VMN0000 +transubstancie transubstanciar VMM03S0 +transubstanciemos transubstanciar VMM01P0 +transubstancien transubstanciar VMM03P0 +transvasa transvasar VMM02S0 +transvasad transvasar VMM02P0 +transvasando transvasar VMG0000 +transvasar transvasar VMN0000 +transvase transvasar VMM03S0 +transvasemos transvasar VMM01P0 +transvasen transvasar VMM03P0 +tranza tranzar VMM02S0 +tranzad tranzar VMM02P0 +tranzando tranzar VMG0000 +tranzar tranzar VMN0000 +trapacea trapacear VMM02S0 +trapacead trapacear VMM02P0 +trapaceando trapacear VMG0000 +trapacear trapacear VMN0000 +trapacee trapacear VMM03S0 +trapaceemos trapacear VMM01P0 +trapaceen trapacear VMM03P0 +trapalea trapalear VMM02S0 +trapalead trapalear VMM02P0 +trapaleando trapalear VMG0000 +trapalear trapalear VMN0000 +trapalee trapalear VMM03S0 +trapaleemos trapalear VMM01P0 +trapaleen trapalear VMM03P0 +trapichea trapichear VMM02S0 +trapichead trapichear VMM02P0 +trapicheando trapichear VMG0000 +trapichear trapichear VMN0000 +trapichee trapichear VMM03S0 +trapicheemos trapichear VMM01P0 +trapicheen trapichear VMM03P0 +trapisondea trapisondear VMM02S0 +trapisondead trapisondear VMM02P0 +trapisondeando trapisondear VMG0000 +trapisondear trapisondear VMN0000 +trapisondee trapisondear VMM03S0 +trapisondeemos trapisondear VMM01P0 +trapisondeen trapisondear VMM03P0 +traquea traquear VMM02S0 +traquead traquear VMM02P0 +traqueando traquear VMG0000 +traquear traquear VMN0000 +traquee traquear VMM03S0 +traqueemos traquear VMM01P0 +traqueen traquear VMM03P0 +traquetea traquetear VMM02S0 +traquetead traquetear VMM02P0 +traqueteando traquetear VMG0000 +traquetear traquetear VMN0000 +traquetee traquetear VMM03S0 +traqueteemos traquetear VMM01P0 +traqueteen traquetear VMM03P0 +trasboca trasbocar VMM02S0 +trasbocad trasbocar VMM02P0 +trasbocando trasbocar VMG0000 +trasbocar trasbocar VMN0000 +trasboque trasbocar VMM03S0 +trasboquemos trasbocar VMM01P0 +trasboquen trasbocar VMM03P0 +trasborda trasbordar VMM02S0 +trasbordad trasbordar VMM02P0 +trasbordando trasbordar VMG0000 +trasbordar trasbordar VMN0000 +trasborde trasbordar VMM03S0 +trasbordemos trasbordar VMM01P0 +trasborden trasbordar VMM03P0 +trascendamos trascender VMM01P0 +trascended trascender VMM02P0 +trascender trascender VMN0000 +trascendiendo trascender VMG0000 +trascienda trascender VMM03S0 +trasciendan trascender VMM03P0 +trasciende trascender VMM02S0 +trascolad trascolar VMM02P0 +trascolando trascolar VMG0000 +trascolar trascolar VMN0000 +trascolemos trascolar VMM01P0 +trasconeja trasconejar VMM02S0 +trasconejad trasconejar VMM02P0 +trasconejando trasconejar VMG0000 +trasconejar trasconejar VMN0000 +trasconeje trasconejar VMM03S0 +trasconejemos trasconejar VMM01P0 +trasconejen trasconejar VMM03P0 +trascordad trascordar VMM02P0 +trascordando trascordar VMG0000 +trascordar trascordar VMN0000 +trascordemos trascordar VMM01P0 +trascriba trascribir VMM03S0 +trascribamos trascribir VMM01P0 +trascriban trascribir VMM03P0 +trascribe trascribir VMM02S0 +trascribid trascribir VMM02P0 +trascribiendo trascribir VMG0000 +trascribir trascribir VMN0000 +trascuela trascolar VMM02S0 +trascuele trascolar VMM03S0 +trascuelen trascolar VMM03P0 +trascuerda trascordar VMM02S0 +trascuerde trascordar VMM03S0 +trascuerden trascordar VMM03P0 +trascurra trascurrir VMM03S0 +trascurramos trascurrir VMM01P0 +trascurran trascurrir VMM03P0 +trascurre trascurrir VMM02S0 +trascurrid trascurrir VMM02P0 +trascurriendo trascurrir VMG0000 +trascurrir trascurrir VMN0000 +trasdosea trasdosear VMM02S0 +trasdosead trasdosear VMM02P0 +trasdoseando trasdosear VMG0000 +trasdosear trasdosear VMN0000 +trasdosee trasdosear VMM03S0 +trasdoseemos trasdosear VMM01P0 +trasdoseen trasdosear VMM03P0 +trasegad trasegar VMM02P0 +trasegando trasegar VMG0000 +trasegar trasegar VMN0000 +traseguemos trasegar VMM01P0 +trasferid trasferir VMM02P0 +trasferir trasferir VMN0000 +trasfiera trasferir VMM03S0 +trasfieran trasferir VMM03P0 +trasfiere trasferir VMM02S0 +trasfigura trasfigurar VMM02S0 +trasfigurad trasfigurar VMM02P0 +trasfigurando trasfigurar VMG0000 +trasfigurar trasfigurar VMN0000 +trasfigure trasfigurar VMM03S0 +trasfiguremos trasfigurar VMM01P0 +trasfiguren trasfigurar VMM03P0 +trasfiramos trasferir VMM01P0 +trasfiriendo trasferir VMG0000 +trasforma trasformar VMM02S0 +trasformad trasformar VMM02P0 +trasformando trasformar VMG0000 +trasformar trasformar VMN0000 +trasforme trasformar VMM03S0 +trasformemos trasformar VMM01P0 +trasformen trasformar VMM03P0 +trasfunda trasfundir VMM03S0 +trasfundamos trasfundir VMM01P0 +trasfundan trasfundir VMM03P0 +trasfunde trasfundir VMM02S0 +trasfundid trasfundir VMM02P0 +trasfundiendo trasfundir VMG0000 +trasfundir trasfundir VMN0000 +trasgreda trasgredir VMM03S0 +trasgredamos trasgredir VMM01P0 +trasgredan trasgredir VMM03P0 +trasgrede trasgredir VMM02S0 +trasgredid trasgredir VMM02P0 +trasgrediendo trasgredir VMG0000 +trasgredir trasgredir VMN0000 +trasguea trasguear VMM02S0 +trasguead trasguear VMM02P0 +trasgueando trasguear VMG0000 +trasguear trasguear VMN0000 +trasguee trasguear VMM03S0 +trasgueemos trasguear VMM01P0 +trasgueen trasguear VMM03P0 +trashoja trashojar VMM02S0 +trashojad trashojar VMM02P0 +trashojando trashojar VMG0000 +trashojar trashojar VMN0000 +trashoje trashojar VMM03S0 +trashojemos trashojar VMM01P0 +trashojen trashojar VMM03P0 +trashuma trashumar VMM02S0 +trashumad trashumar VMM02P0 +trashumando trashumar VMG0000 +trashumar trashumar VMN0000 +trashume trashumar VMM03S0 +trashumemos trashumar VMM01P0 +trashumen trashumar VMM03P0 +trasiega trasegar VMM02S0 +trasiegue trasegar VMM03S0 +trasieguen trasegar VMM03P0 +traslada trasladar VMM02S0 +trasladad trasladar VMM02P0 +trasladando trasladar VMG0000 +trasladar trasladar VMN0000 +traslade trasladar VMM03S0 +traslademos trasladar VMM01P0 +trasladen trasladar VMM03P0 +traslapa traslapar VMM02S0 +traslapad traslapar VMM02P0 +traslapando traslapar VMG0000 +traslapar traslapar VMN0000 +traslape traslapar VMM03S0 +traslapemos traslapar VMM01P0 +traslapen traslapar VMM03P0 +trasluce traslucir VMM02S0 +traslucid traslucir VMM02P0 +trasluciendo traslucir VMG0000 +traslucir traslucir VMN0000 +traslumbra traslumbrar VMM02S0 +traslumbrad traslumbrar VMM02P0 +traslumbrando traslumbrar VMG0000 +traslumbrar traslumbrar VMN0000 +traslumbre traslumbrar VMM03S0 +traslumbremos traslumbrar VMM01P0 +traslumbren traslumbrar VMM03P0 +trasluzca traslucir VMM03S0 +trasluzcamos traslucir VMM01P0 +trasluzcan traslucir VMM03P0 +trasmigra trasmigrar VMM02S0 +trasmigrad trasmigrar VMM02P0 +trasmigrando trasmigrar VMG0000 +trasmigrar trasmigrar VMN0000 +trasmigre trasmigrar VMM03S0 +trasmigremos trasmigrar VMM01P0 +trasmigren trasmigrar VMM03P0 +trasmina trasminar VMM02S0 +trasminad trasminar VMM02P0 +trasminando trasminar VMG0000 +trasminar trasminar VMN0000 +trasmine trasminar VMM03S0 +trasminemos trasminar VMM01P0 +trasminen trasminar VMM03P0 +trasmita trasmitir VMM03S0 +trasmitamos trasmitir VMM01P0 +trasmitan trasmitir VMM03P0 +trasmite trasmitir VMM02S0 +trasmitid trasmitir VMM02P0 +trasmitiendo trasmitir VMG0000 +trasmitir trasmitir VMN0000 +trasmonta trasmontar VMM02S0 +trasmontad trasmontar VMM02P0 +trasmontando trasmontar VMG0000 +trasmontar trasmontar VMN0000 +trasmonte trasmontar VMM03S0 +trasmontemos trasmontar VMM01P0 +trasmonten trasmontar VMM03P0 +trasmuda trasmudar VMM02S0 +trasmudad trasmudar VMM02P0 +trasmudando trasmudar VMG0000 +trasmudar trasmudar VMN0000 +trasmude trasmudar VMM03S0 +trasmudemos trasmudar VMM01P0 +trasmuden trasmudar VMM03P0 +trasmuta trasmutar VMM02S0 +trasmutad trasmutar VMM02P0 +trasmutando trasmutar VMG0000 +trasmutar trasmutar VMN0000 +trasmute trasmutar VMM03S0 +trasmutemos trasmutar VMM01P0 +trasmuten trasmutar VMM03P0 +trasnocha trasnochar VMM02S0 +trasnochad trasnochar VMM02P0 +trasnochando trasnochar VMG0000 +trasnochar trasnochar VMN0000 +trasnoche trasnochar VMM03S0 +trasnochemos trasnochar VMM01P0 +trasnochen trasnochar VMM03P0 +trasnombra trasnombrar VMM02S0 +trasnombrad trasnombrar VMM02P0 +trasnombrando trasnombrar VMG0000 +trasnombrar trasnombrar VMN0000 +trasnombre trasnombrar VMM03S0 +trasnombremos trasnombrar VMM01P0 +trasnombren trasnombrar VMM03P0 +trasoñad trasoñar VMM02P0 +trasoñando trasoñar VMG0000 +trasoñar trasoñar VMN0000 +trasoñemos trasoñar VMM01P0 +traspala traspalar VMM02S0 +traspalad traspalar VMM02P0 +traspalando traspalar VMG0000 +traspalar traspalar VMN0000 +traspale traspalar VMM03S0 +traspalea traspalear VMM02S0 +traspalead traspalear VMM02P0 +traspaleando traspalear VMG0000 +traspalear traspalear VMN0000 +traspalee traspalear VMM03S0 +traspaleemos traspalear VMM01P0 +traspaleen traspalear VMM03P0 +traspalemos traspalar VMM01P0 +traspalen traspalar VMM03P0 +traspapela traspapelar VMM02S0 +traspapelad traspapelar VMM02P0 +traspapelando traspapelar VMG0000 +traspapelar traspapelar VMN0000 +traspapele traspapelar VMM03S0 +traspapelemos traspapelar VMM01P0 +traspapelen traspapelar VMM03P0 +trasparenta trasparentar VMM02S0 +trasparentad trasparentar VMM02P0 +trasparentando trasparentar VMG0000 +trasparentar trasparentar VMN0000 +trasparente trasparentar VMM03S0 +trasparentemos trasparentar VMM01P0 +trasparenten trasparentar VMM03P0 +traspasa traspasar VMM02S0 +traspasad traspasar VMM02P0 +traspasando traspasar VMG0000 +traspasar traspasar VMN0000 +traspase traspasar VMM03S0 +traspasemos traspasar VMM01P0 +traspasen traspasar VMM03P0 +traspira traspirar VMM02S0 +traspirad traspirar VMM02P0 +traspirando traspirar VMG0000 +traspirar traspirar VMN0000 +traspire traspirar VMM03S0 +traspiremos traspirar VMM01P0 +traspiren traspirar VMM03P0 +trasplanta trasplantar VMM02S0 +trasplantad trasplantar VMM02P0 +trasplantando trasplantar VMG0000 +trasplantar trasplantar VMN0000 +trasplante trasplantar VMM03S0 +trasplantemos trasplantar VMM01P0 +trasplanten trasplantar VMM03P0 +trasponed trasponer VMM02P0 +trasponer trasponer VMN0000 +trasponga trasponer VMM03S0 +traspongamos trasponer VMM01P0 +traspongan trasponer VMM03P0 +trasponiendo trasponer VMG0000 +traspón trasponer VMM02S0 +trasquila trasquilar VMM02S0 +trasquilad trasquilar VMM02P0 +trasquilando trasquilar VMG0000 +trasquilar trasquilar VMN0000 +trasquile trasquilar VMM03S0 +trasquilemos trasquilar VMM01P0 +trasquilen trasquilar VMM03P0 +trastabilla trastabillar VMM02S0 +trastabillad trastabillar VMM02P0 +trastabillando trastabillar VMG0000 +trastabillar trastabillar VMN0000 +trastabille trastabillar VMM03S0 +trastabillemos trastabillar VMM01P0 +trastabillen trastabillar VMM03P0 +trastea trastear VMM02S0 +trastead trastear VMM02P0 +trasteando trastear VMG0000 +trastear trastear VMN0000 +trastee trastear VMM03S0 +trasteemos trastear VMM01P0 +trasteen trastear VMM03P0 +trasteja trastejar VMM02S0 +trastejad trastejar VMM02P0 +trastejando trastejar VMG0000 +trastejar trastejar VMN0000 +trasteje trastejar VMM03S0 +trastejemos trastejar VMM01P0 +trastejen trastejar VMM03P0 +trastoca trastocar VMM02S0 +trastocad trastocar VMM02P0 +trastocando trastocar VMG0000 +trastocar trastocar VMN0000 +trastoque trastocar VMM03S0 +trastoquemos trastocar VMM01P0 +trastoquen trastocar VMM03P0 +trastorna trastornar VMM02S0 +trastornad trastornar VMM02P0 +trastornando trastornar VMG0000 +trastornar trastornar VMN0000 +trastorne trastornar VMM03S0 +trastornemos trastornar VMM01P0 +trastornen trastornar VMM03P0 +trastrabilla trastrabillar VMM02S0 +trastrabillad trastrabillar VMM02P0 +trastrabillando trastrabillar VMG0000 +trastrabillar trastrabillar VMN0000 +trastrabille trastrabillar VMM03S0 +trastrabillemos trastrabillar VMM01P0 +trastrabillen trastrabillar VMM03P0 +trastrocad trastrocar VMM02P0 +trastrocando trastrocar VMG0000 +trastrocar trastrocar VMN0000 +trastroquemos trastrocar VMM01P0 +trastrueca trastrocar VMM02S0 +trastrueque trastrocar VMM03S0 +trastruequen trastrocar VMM03P0 +trasuda trasudar VMM02S0 +trasudad trasudar VMM02P0 +trasudando trasudar VMG0000 +trasudar trasudar VMN0000 +trasude trasudar VMM03S0 +trasudemos trasudar VMM01P0 +trasuden trasudar VMM03P0 +trasueña trasoñar VMM02S0 +trasueñe trasoñar VMM03S0 +trasueñen trasoñar VMM03P0 +trasunta trasuntar VMM02S0 +trasuntad trasuntar VMM02P0 +trasuntando trasuntar VMG0000 +trasuntar trasuntar VMN0000 +trasunte trasuntar VMM03S0 +trasuntemos trasuntar VMM01P0 +trasunten trasuntar VMM03P0 +trasvasa trasvasar VMM02S0 +trasvasad trasvasar VMM02P0 +trasvasando trasvasar VMG0000 +trasvasar trasvasar VMN0000 +trasvase trasvasar VMM03S0 +trasvasemos trasvasar VMM01P0 +trasvasen trasvasar VMM03P0 +trasvea trasver VMM03S0 +trasveamos trasver VMM01P0 +trasvean trasver VMM03P0 +trasved trasver VMM02P0 +trasvena trasvenar VMM02S0 +trasvenad trasvenar VMM02P0 +trasvenando trasvenar VMG0000 +trasvenar trasvenar VMN0000 +trasvene trasvenar VMM03S0 +trasvenemos trasvenar VMM01P0 +trasvenen trasvenar VMM03P0 +trasver trasver VMN0000 +trasvertamos trasverter VMM01P0 +trasverted trasverter VMM02P0 +trasverter trasverter VMN0000 +trasvertiendo trasverter VMG0000 +trasviendo trasver VMG0000 +trasvierta trasverter VMM03S0 +trasviertan trasverter VMM03P0 +trasvierte trasverter VMM02S0 +trasvina trasvinar VMM02S0 +trasvinad trasvinar VMM02P0 +trasvinando trasvinar VMG0000 +trasvinar trasvinar VMN0000 +trasvine trasvinar VMM03S0 +trasvinemos trasvinar VMM01P0 +trasvinen trasvinar VMM03P0 +trasvé trasver VMM02S0 +trata tratar VMM02S0 +tratad tratar VMM02P0 +tratando tratar VMG0000 +tratar tratar VMN0000 +trate tratar VMM03S0 +tratemos tratar VMM01P0 +traten tratar VMM03P0 +traumatice traumatizar VMM03S0 +traumaticemos traumatizar VMM01P0 +traumaticen traumatizar VMM03P0 +traumatiza traumatizar VMM02S0 +traumatizad traumatizar VMM02P0 +traumatizando traumatizar VMG0000 +traumatizar traumatizar VMN0000 +travesea travesear VMM02S0 +travesead travesear VMM02P0 +traveseando travesear VMG0000 +travesear travesear VMN0000 +travesee travesear VMM03S0 +traveseemos travesear VMM01P0 +traveseen travesear VMM03P0 +travestid travestir VMM02P0 +travestir travestir VMN0000 +travista travestir VMM03S0 +travistamos travestir VMM01P0 +travistan travestir VMM03P0 +traviste travestir VMM02S0 +travistiendo travestir VMG0000 +trayendo traer VMG0000 +traza trazar VMM02S0 +trazad trazar VMM02P0 +trazando trazar VMG0000 +trazar trazar VMN0000 +trazuma trazumar VMM02S0 +trazumad trazumar VMM02P0 +trazumando trazumar VMG0000 +trazumar trazumar VMN0000 +trazume trazumar VMM03S0 +trazumemos trazumar VMM01P0 +trazumen trazumar VMM03P0 +traílla traillar VMM02S0 +traílle traillar VMM03S0 +traíllen traillar VMM03P0 +trefila trefilar VMM02S0 +trefilad trefilar VMM02P0 +trefilando trefilar VMG0000 +trefilar trefilar VMN0000 +trefile trefilar VMM03S0 +trefilemos trefilar VMM01P0 +trefilen trefilar VMM03P0 +tremola tremolar VMM02S0 +tremolad tremolar VMM02P0 +tremolando tremolar VMG0000 +tremolar tremolar VMN0000 +tremole tremolar VMM03S0 +tremolemos tremolar VMM01P0 +tremolen tremolar VMM03P0 +trence trenzar VMM03S0 +trencemos trenzar VMM01P0 +trencen trenzar VMM03P0 +trencilla trencillar VMM02S0 +trencillad trencillar VMM02P0 +trencillando trencillar VMG0000 +trencillar trencillar VMN0000 +trencille trencillar VMM03S0 +trencillemos trencillar VMM01P0 +trencillen trencillar VMM03P0 +trenza trenzar VMM02S0 +trenzad trenzar VMM02P0 +trenzando trenzar VMG0000 +trenzar trenzar VMN0000 +trepa trepar VMM02S0 +trepad trepar VMM02P0 +trepana trepanar VMM02S0 +trepanad trepanar VMM02P0 +trepanando trepanar VMG0000 +trepanar trepanar VMN0000 +trepando trepar VMG0000 +trepane trepanar VMM03S0 +trepanemos trepanar VMM01P0 +trepanen trepanar VMM03P0 +trepar trepar VMN0000 +trepe trepar VMM03S0 +trepemos trepar VMM01P0 +trepen trepar VMM03P0 +trepida trepidar VMM02S0 +trepidad trepidar VMM02P0 +trepidando trepidar VMG0000 +trepidar trepidar VMN0000 +trepide trepidar VMM03S0 +trepidemos trepidar VMM01P0 +trepiden trepidar VMM03P0 +tresdobla tresdoblar VMM02S0 +tresdoblad tresdoblar VMM02P0 +tresdoblando tresdoblar VMG0000 +tresdoblar tresdoblar VMN0000 +tresdoble tresdoblar VMM03S0 +tresdoblemos tresdoblar VMM01P0 +tresdoblen tresdoblar VMM03P0 +triad triar VMM02P0 +triando triar VMG0000 +triangula triangular VMM02S0 +triangulad triangular VMM02P0 +triangulando triangular VMG0000 +triangular triangular VMN0000 +triangule triangular VMM03S0 +triangulemos triangular VMM01P0 +triangulen triangular VMM03P0 +triar triar VMN0000 +tribuid tribuir VMM02P0 +tribuir tribuir VMN0000 +tributa tributar VMM02S0 +tributad tributar VMM02P0 +tributando tributar VMG0000 +tributar tributar VMN0000 +tribute tributar VMM03S0 +tributemos tributar VMM01P0 +tributen tributar VMM03P0 +tribuya tribuir VMM03S0 +tribuyamos tribuir VMM01P0 +tribuyan tribuir VMM03P0 +tribuye tribuir VMM02S0 +tribuyendo tribuir VMG0000 +trice trizar VMM03S0 +tricemos trizar VMM01P0 +tricen trizar VMM03P0 +tricota tricotar VMM02S0 +tricotad tricotar VMM02P0 +tricotando tricotar VMG0000 +tricotar tricotar VMN0000 +tricote tricotar VMM03S0 +tricotemos tricotar VMM01P0 +tricoten tricotar VMM03P0 +triemos triar VMM01P0 +trifurca trifurcar VMM02S0 +trifurcad trifurcar VMM02P0 +trifurcando trifurcar VMG0000 +trifurcar trifurcar VMN0000 +trifurque trifurcar VMM03S0 +trifurquemos trifurcar VMM01P0 +trifurquen trifurcar VMM03P0 +trilla trillar VMM02S0 +trillad trillar VMM02P0 +trillando trillar VMG0000 +trillar trillar VMN0000 +trille trillar VMM03S0 +trillemos trillar VMM01P0 +trillen trillar VMM03P0 +trina trinar VMM02S0 +trinad trinar VMM02P0 +trinando trinar VMG0000 +trinar trinar VMN0000 +trinca trincar VMM02S0 +trincad trincar VMM02P0 +trincando trincar VMG0000 +trincar trincar VMN0000 +trincha trinchar VMM02S0 +trinchad trinchar VMM02P0 +trinchando trinchar VMG0000 +trinchar trinchar VMN0000 +trinche trinchar VMM03S0 +trinchemos trinchar VMM01P0 +trinchen trinchar VMM03P0 +trine trinar VMM03S0 +trinemos trinar VMM01P0 +trinen trinar VMM03P0 +trinque trincar VMM03S0 +trinquemos trincar VMM01P0 +trinquen trincar VMM03P0 +triparta tripartir VMM03S0 +tripartamos tripartir VMM01P0 +tripartan tripartir VMM03P0 +triparte tripartir VMM02S0 +tripartid tripartir VMM02P0 +tripartiendo tripartir VMG0000 +tripartir tripartir VMN0000 +triplica triplicar VMM02S0 +triplicad triplicar VMM02P0 +triplicando triplicar VMG0000 +triplicar triplicar VMN0000 +triplique triplicar VMM03S0 +tripliquemos triplicar VMM01P0 +tripliquen triplicar VMM03P0 +triptonga triptongar VMM02S0 +triptongad triptongar VMM02P0 +triptongando triptongar VMG0000 +triptongar triptongar VMN0000 +triptongue triptongar VMM03S0 +triptonguemos triptongar VMM01P0 +triptonguen triptongar VMM03P0 +tripula tripular VMM02S0 +tripulad tripular VMM02P0 +tripulando tripular VMG0000 +tripular tripular VMN0000 +tripule tripular VMM03S0 +tripulemos tripular VMM01P0 +tripulen tripular VMM03P0 +trisa trisar VMM02S0 +trisad trisar VMM02P0 +trisando trisar VMG0000 +trisar trisar VMN0000 +trisca triscar VMM02S0 +triscad triscar VMM02P0 +triscando triscar VMG0000 +triscar triscar VMN0000 +trise trisar VMM03S0 +triseca trisecar VMM02S0 +trisecad trisecar VMM02P0 +trisecando trisecar VMG0000 +trisecar trisecar VMN0000 +trisemos trisar VMM01P0 +trisen trisar VMM03P0 +triseque trisecar VMM03S0 +trisequemos trisecar VMM01P0 +trisequen trisecar VMM03P0 +trisque triscar VMM03S0 +trisquemos triscar VMM01P0 +trisquen triscar VMM03P0 +tritura triturar VMM02S0 +triturad triturar VMM02P0 +triturando triturar VMG0000 +triturar triturar VMN0000 +triture triturar VMM03S0 +trituremos triturar VMM01P0 +trituren triturar VMM03P0 +triunfa triunfar VMM02S0 +triunfad triunfar VMM02P0 +triunfando triunfar VMG0000 +triunfar triunfar VMN0000 +triunfe triunfar VMM03S0 +triunfemos triunfar VMM01P0 +triunfen triunfar VMM03P0 +triza trizar VMM02S0 +trizad trizar VMM02P0 +trizando trizar VMG0000 +trizar trizar VMN0000 +trocad trocar VMM02P0 +trocando trocar VMG0000 +trocar trocar VMN0000 +troce trozar VMM03S0 +trocea trocear VMM02S0 +trocead trocear VMM02P0 +troceando trocear VMG0000 +trocear trocear VMN0000 +trocee trocear VMM03S0 +troceemos trocear VMM01P0 +troceen trocear VMM03P0 +trocemos trozar VMM01P0 +trocen trozar VMM03P0 +trompea trompear VMM02S0 +trompead trompear VMM02P0 +trompeando trompear VMG0000 +trompear trompear VMN0000 +trompee trompear VMM03S0 +trompeemos trompear VMM01P0 +trompeen trompear VMM03P0 +trompetea trompetear VMM02S0 +trompetead trompetear VMM02P0 +trompeteando trompetear VMG0000 +trompetear trompetear VMN0000 +trompetee trompetear VMM03S0 +trompeteemos trompetear VMM01P0 +trompeteen trompetear VMM03P0 +trompica trompicar VMM02S0 +trompicad trompicar VMM02P0 +trompicando trompicar VMG0000 +trompicar trompicar VMN0000 +trompique trompicar VMM03S0 +trompiquemos trompicar VMM01P0 +trompiquen trompicar VMM03P0 +tronad tronar VMM02P0 +tronando tronar VMG0000 +tronar tronar VMN0000 +tronca troncar VMM02S0 +troncad troncar VMM02P0 +troncando troncar VMG0000 +troncar troncar VMN0000 +tronce tronzar VMM03S0 +troncemos tronzar VMM01P0 +troncen tronzar VMM03P0 +troncha tronchar VMM02S0 +tronchad tronchar VMM02P0 +tronchando tronchar VMG0000 +tronchar tronchar VMN0000 +tronche tronchar VMM03S0 +tronchemos tronchar VMM01P0 +tronchen tronchar VMM03P0 +tronemos tronar VMM01P0 +tronque troncar VMM03S0 +tronquemos troncar VMM01P0 +tronquen troncar VMM03P0 +tronza tronzar VMM02S0 +tronzad tronzar VMM02P0 +tronzando tronzar VMG0000 +tronzar tronzar VMN0000 +tropecemos tropezar VMM01P0 +tropezad tropezar VMM02P0 +tropezando tropezar VMG0000 +tropezar tropezar VMN0000 +tropiece tropezar VMM03S0 +tropiecen tropezar VMM03P0 +tropieza tropezar VMM02S0 +troquela troquelar VMM02S0 +troquelad troquelar VMM02P0 +troquelando troquelar VMG0000 +troquelar troquelar VMN0000 +troquele troquelar VMM03S0 +troquelemos troquelar VMM01P0 +troquelen troquelar VMM03P0 +troquemos trocar VMM01P0 +trota trotar VMM02S0 +trotad trotar VMM02P0 +trotando trotar VMG0000 +trotar trotar VMN0000 +trote trotar VMM03S0 +trotemos trotar VMM01P0 +troten trotar VMM03P0 +trova trovar VMM02S0 +trovad trovar VMM02P0 +trovando trovar VMG0000 +trovar trovar VMN0000 +trove trovar VMM03S0 +trovemos trovar VMM01P0 +troven trovar VMM03P0 +troza trozar VMM02S0 +trozad trozar VMM02P0 +trozando trozar VMG0000 +trozar trozar VMN0000 +truca trucar VMM02S0 +trucad trucar VMM02P0 +trucando trucar VMG0000 +trucar trucar VMN0000 +trucida trucidar VMM02S0 +trucidad trucidar VMM02P0 +trucidando trucidar VMG0000 +trucidar trucidar VMN0000 +trucide trucidar VMM03S0 +trucidemos trucidar VMM01P0 +truciden trucidar VMM03P0 +trueca trocar VMM02S0 +truena tronar VMM02S0 +truene tronar VMM03S0 +truenen tronar VMM03P0 +trueque trocar VMM03S0 +truequen trocar VMM03P0 +trufa trufar VMM02S0 +trufad trufar VMM02P0 +trufando trufar VMG0000 +trufar trufar VMN0000 +trufe trufar VMM03S0 +trufemos trufar VMM01P0 +trufen trufar VMM03P0 +truhanea truhanear VMM02S0 +truhanead truhanear VMM02P0 +truhaneando truhanear VMG0000 +truhanear truhanear VMN0000 +truhanee truhanear VMM03S0 +truhaneemos truhanear VMM01P0 +truhaneen truhanear VMM03P0 +trujamanea trujamanear VMM02S0 +trujamanead trujamanear VMM02P0 +trujamaneando trujamanear VMG0000 +trujamanear trujamanear VMN0000 +trujamanee trujamanear VMM03S0 +trujamaneemos trujamanear VMM01P0 +trujamaneen trujamanear VMM03P0 +trunca truncar VMM02S0 +truncad truncar VMM02P0 +truncando truncar VMG0000 +truncar truncar VMN0000 +trunque truncar VMM03S0 +trunquemos truncar VMM01P0 +trunquen truncar VMM03P0 +truque trucar VMM03S0 +truquemos trucar VMM01P0 +truquen trucar VMM03P0 +tría triar VMM02S0 +tríe triar VMM03S0 +tríen triar VMM03P0 +tuberculice tuberculizar VMM03S0 +tuberculicemos tuberculizar VMM01P0 +tuberculicen tuberculizar VMM03P0 +tuberculiza tuberculizar VMM02S0 +tuberculizad tuberculizar VMM02P0 +tuberculizando tuberculizar VMG0000 +tuberculizar tuberculizar VMN0000 +tuena tonar VMM02S0 +tuene tonar VMM03S0 +tuenen tonar VMM03P0 +tuerce torcer VMM02S0 +tuerza torcer VMM03S0 +tuerzan torcer VMM03P0 +tuesta tostar VMM02S0 +tueste tostar VMM03S0 +tuesten tostar VMM03P0 +tulla tullir VMM03S0 +tullamos tullir VMM01P0 +tullan tullir VMM03P0 +tulle tullir VMM02S0 +tullece tullecer VMM02S0 +tulleced tullecer VMM02P0 +tullecer tullecer VMN0000 +tulleciendo tullecer VMG0000 +tullendo tullir VMG0000 +tullezca tullecer VMM03S0 +tullezcamos tullecer VMM01P0 +tullezcan tullecer VMM03P0 +tullid tullir VMM02P0 +tullir tullir VMN0000 +tumba tumbar VMM02S0 +tumbad tumbar VMM02P0 +tumbando tumbar VMG0000 +tumbar tumbar VMN0000 +tumbe tumbar VMM03S0 +tumbemos tumbar VMM01P0 +tumben tumbar VMM03P0 +tumultuad tumultuar VMM02P0 +tumultuando tumultuar VMG0000 +tumultuar tumultuar VMN0000 +tumultuemos tumultuar VMM01P0 +tumultúa tumultuar VMM02S0 +tumultúe tumultuar VMM03S0 +tumultúen tumultuar VMM03P0 +tuna tunar VMM02S0 +tunad tunar VMM02P0 +tunando tunar VMG0000 +tunantea tunantear VMM02S0 +tunantead tunantear VMM02P0 +tunanteando tunantear VMG0000 +tunantear tunantear VMN0000 +tunantee tunantear VMM03S0 +tunanteemos tunantear VMM01P0 +tunanteen tunantear VMM03P0 +tunar tunar VMN0000 +tunda tundir VMM03S0 +tundamos tundir VMM01P0 +tundan tundir VMM03P0 +tunde tundir VMM02S0 +tundid tundir VMM02P0 +tundiendo tundir VMG0000 +tundir tundir VMN0000 +tune tunar VMM03S0 +tunea tunear VMM02S0 +tunead tunear VMM02P0 +tuneando tunear VMG0000 +tunear tunear VMN0000 +tunee tunear VMM03S0 +tuneemos tunear VMM01P0 +tuneen tunear VMM03P0 +tunemos tunar VMM01P0 +tunen tunar VMM03P0 +tupa tupir VMM03S0 +tupamos tupir VMM01P0 +tupan tupir VMM03P0 +tupe tupir VMM02S0 +tupid tupir VMM02P0 +tupiendo tupir VMG0000 +tupir tupir VMN0000 +turba turbar VMM02S0 +turbad turbar VMM02P0 +turbando turbar VMG0000 +turbar turbar VMN0000 +turbe turbar VMM03S0 +turbemos turbar VMM01P0 +turben turbar VMM03P0 +turbina turbinar VMM02S0 +turbinad turbinar VMM02P0 +turbinando turbinar VMG0000 +turbinar turbinar VMN0000 +turbine turbinar VMM03S0 +turbinemos turbinar VMM01P0 +turbinen turbinar VMM03P0 +turifica turificar VMM02S0 +turificad turificar VMM02P0 +turificando turificar VMG0000 +turificar turificar VMN0000 +turifique turificar VMM03S0 +turifiquemos turificar VMM01P0 +turifiquen turificar VMM03P0 +turna turnar VMM02S0 +turnad turnar VMM02P0 +turnando turnar VMG0000 +turnar turnar VMN0000 +turne turnar VMM03S0 +turnemos turnar VMM01P0 +turnen turnar VMM03P0 +turra turrar VMM02S0 +turrad turrar VMM02P0 +turrando turrar VMG0000 +turrar turrar VMN0000 +turre turrar VMM03S0 +turremos turrar VMM01P0 +turren turrar VMM03P0 +tusa tusar VMM02S0 +tusad tusar VMM02P0 +tusando tusar VMG0000 +tusar tusar VMN0000 +tuse tusar VMM03S0 +tusemos tusar VMM01P0 +tusen tusar VMM03P0 +tutea tutear VMM02S0 +tutead tutear VMM02P0 +tuteando tutear VMG0000 +tutear tutear VMN0000 +tutee tutear VMM03S0 +tuteemos tutear VMM01P0 +tuteen tutear VMM03P0 +tutela tutelar VMM02S0 +tutelad tutelar VMM02P0 +tutelando tutelar VMG0000 +tutelar tutelar VMN0000 +tutele tutelar VMM03S0 +tutelemos tutelar VMM01P0 +tutelen tutelar VMM03P0 +ubica ubicar VMM02S0 +ubicad ubicar VMM02P0 +ubicando ubicar VMG0000 +ubicar ubicar VMN0000 +ubique ubicar VMM03S0 +ubiquemos ubicar VMM01P0 +ubiquen ubicar VMM03P0 +ufana ufanar VMM02S0 +ufanad ufanar VMM02P0 +ufanando ufanar VMG0000 +ufanar ufanar VMN0000 +ufane ufanar VMM03S0 +ufanemos ufanar VMM01P0 +ufanen ufanar VMM03P0 +ulcera ulcerar VMM02S0 +ulcerad ulcerar VMM02P0 +ulcerando ulcerar VMG0000 +ulcerar ulcerar VMN0000 +ulcere ulcerar VMM03S0 +ulceremos ulcerar VMM01P0 +ulceren ulcerar VMM03P0 +ultima ultimar VMM02S0 +ultimad ultimar VMM02P0 +ultimando ultimar VMG0000 +ultimar ultimar VMN0000 +ultime ultimar VMM03S0 +ultimemos ultimar VMM01P0 +ultimen ultimar VMM03P0 +ultraja ultrajar VMM02S0 +ultrajad ultrajar VMM02P0 +ultrajando ultrajar VMG0000 +ultrajar ultrajar VMN0000 +ultraje ultrajar VMM03S0 +ultrajemos ultrajar VMM01P0 +ultrajen ultrajar VMM03P0 +ultrapasa ultrapasar VMM02S0 +ultrapasad ultrapasar VMM02P0 +ultrapasando ultrapasar VMG0000 +ultrapasar ultrapasar VMN0000 +ultrapase ultrapasar VMM03S0 +ultrapasemos ultrapasar VMM01P0 +ultrapasen ultrapasar VMM03P0 +ulula ulular VMM02S0 +ululad ulular VMM02P0 +ululando ulular VMG0000 +ulular ulular VMN0000 +ulule ulular VMM03S0 +ululemos ulular VMM01P0 +ululen ulular VMM03P0 +una unir VMM03S0 +unamos unir VMM01P0 +unan unir VMM03P0 +unce uncir VMM02S0 +uncid uncir VMM02P0 +unciendo uncir VMG0000 +uncir uncir VMN0000 +undula undular VMM02S0 +undulad undular VMM02P0 +undulando undular VMG0000 +undular undular VMN0000 +undule undular VMM03S0 +undulemos undular VMM01P0 +undulen undular VMM03P0 +une unir VMM02S0 +unge ungir VMM02S0 +ungid ungir VMM02P0 +ungiendo ungir VMG0000 +ungir ungir VMN0000 +unid unir VMM02P0 +uniendo unir VMG0000 +unifica unificar VMM02S0 +unificad unificar VMM02P0 +unificando unificar VMG0000 +unificar unificar VMN0000 +unifique unificar VMM03S0 +unifiquemos unificar VMM01P0 +unifiquen unificar VMM03P0 +uniforma uniformar VMM02S0 +uniformad uniformar VMM02P0 +uniformando uniformar VMG0000 +uniformar uniformar VMN0000 +uniforme uniformar VMM03S0 +uniformemos uniformar VMM01P0 +uniformen uniformar VMM03P0 +unir unir VMN0000 +unisonad unisonar VMM02P0 +unisonando unisonar VMG0000 +unisonar unisonar VMN0000 +unisonemos unisonar VMM01P0 +unisuena unisonar VMM02S0 +unisuene unisonar VMM03S0 +unisuenen unisonar VMM03P0 +universalice universalizar VMM03S0 +universalicemos universalizar VMM01P0 +universalicen universalizar VMM03P0 +universaliza universalizar VMM02S0 +universalizad universalizar VMM02P0 +universalizando universalizar VMG0000 +universalizar universalizar VMN0000 +unja ungir VMM03S0 +unjamos ungir VMM01P0 +unjan ungir VMM03P0 +unta untar VMM02S0 +untad untar VMM02P0 +untando untar VMG0000 +untar untar VMN0000 +unte untar VMM03S0 +untemos untar VMM01P0 +unten untar VMM03P0 +unza uncir VMM03S0 +unzamos uncir VMM01P0 +unzan uncir VMM03P0 +upa upar VMM02S0 +upad upar VMM02P0 +upando upar VMG0000 +upar upar VMN0000 +upe upar VMM03S0 +upemos upar VMM01P0 +upen upar VMM03P0 +urbanice urbanizar VMM03S0 +urbanicemos urbanizar VMM01P0 +urbanicen urbanizar VMM03P0 +urbaniza urbanizar VMM02S0 +urbanizad urbanizar VMM02P0 +urbanizando urbanizar VMG0000 +urbanizar urbanizar VMN0000 +urda urdir VMM03S0 +urdamos urdir VMM01P0 +urdan urdir VMM03P0 +urde urdir VMM02S0 +urdid urdir VMM02P0 +urdiendo urdir VMG0000 +urdir urdir VMN0000 +urge urgir VMM02S0 +urgid urgir VMM02P0 +urgiendo urgir VMG0000 +urgir urgir VMN0000 +urja urgir VMM03S0 +urjamos urgir VMM01P0 +urjan urgir VMM03P0 +usa usar VMM02S0 +usad usar VMM02P0 +usando usar VMG0000 +usar usar VMN0000 +use usar VMM03S0 +usemos usar VMM01P0 +usen usar VMM03P0 +usucapa usucapir VMM03S0 +usucapamos usucapir VMM01P0 +usucapan usucapir VMM03P0 +usucape usucapir VMM02S0 +usucapid usucapir VMM02P0 +usucapiendo usucapir VMG0000 +usucapir usucapir VMN0000 +usufructuad usufructuar VMM02P0 +usufructuando usufructuar VMG0000 +usufructuar usufructuar VMN0000 +usufructuemos usufructuar VMM01P0 +usufructúa usufructuar VMM02S0 +usufructúe usufructuar VMM03S0 +usufructúen usufructuar VMM03P0 +usurpa usurpar VMM02S0 +usurpad usurpar VMM02P0 +usurpando usurpar VMG0000 +usurpar usurpar VMN0000 +usurpe usurpar VMM03S0 +usurpemos usurpar VMM01P0 +usurpen usurpar VMM03P0 +utilice utilizar VMM03S0 +utilicemos utilizar VMM01P0 +utilicen utilizar VMM03P0 +utiliza utilizar VMM02S0 +utilizad utilizar VMM02P0 +utilizando utilizar VMG0000 +utilizar utilizar VMN0000 +vaca vacar VMM02S0 +vacad vacar VMM02P0 +vacando vacar VMG0000 +vacar vacar VMN0000 +vaciad vaciar VMM02P0 +vaciando vaciar VMG0000 +vaciar vaciar VMN0000 +vaciemos vaciar VMM01P0 +vacila vacilar VMM02S0 +vacilad vacilar VMM02P0 +vacilando vacilar VMG0000 +vacilar vacilar VMN0000 +vacile vacilar VMM03S0 +vacilemos vacilar VMM01P0 +vacilen vacilar VMM03P0 +vacuna vacunar VMM02S0 +vacunad vacunar VMM02P0 +vacunando vacunar VMG0000 +vacunar vacunar VMN0000 +vacune vacunar VMM03S0 +vacunemos vacunar VMM01P0 +vacunen vacunar VMM03P0 +vacía vaciar VMM02S0 +vacíe vaciar VMM03S0 +vacíen vaciar VMM03P0 +vadea vadear VMM02S0 +vadead vadear VMM02P0 +vadeando vadear VMG0000 +vadear vadear VMN0000 +vadee vadear VMM03S0 +vadeemos vadear VMM01P0 +vadeen vadear VMM03P0 +vaga vagar VMM02S0 +vagabundea vagabundear VMM02S0 +vagabundead vagabundear VMM02P0 +vagabundeando vagabundear VMG0000 +vagabundear vagabundear VMN0000 +vagabundee vagabundear VMM03S0 +vagabundeemos vagabundear VMM01P0 +vagabundeen vagabundear VMM03P0 +vagad vagar VMM02P0 +vagamundea vagamundear VMM02S0 +vagamundead vagamundear VMM02P0 +vagamundeando vagamundear VMG0000 +vagamundear vagamundear VMN0000 +vagamundee vagamundear VMM03S0 +vagamundeemos vagamundear VMM01P0 +vagamundeen vagamundear VMM03P0 +vagando vagar VMG0000 +vagar vagar VMN0000 +vague vagar VMM03S0 +vaguea vaguear VMM02S0 +vaguead vaguear VMM02P0 +vagueando vaguear VMG0000 +vaguear vaguear VMN0000 +vaguee vaguear VMM03S0 +vagueemos vaguear VMM01P0 +vagueen vaguear VMM03P0 +vaguemos vagar VMM01P0 +vaguen vagar VMM03P0 +vahea vahear VMM02S0 +vahead vahear VMM02P0 +vaheando vahear VMG0000 +vahear vahear VMN0000 +vahee vahear VMM03S0 +vaheemos vahear VMM01P0 +vaheen vahear VMM03P0 +vale valer VMM02S0 +valed valer VMM02P0 +valer valer VMN0000 +valga valer VMM03S0 +valgamos valer VMM01P0 +valgan valer VMM03P0 +valida validar VMM02S0 +validad validar VMM02P0 +validando validar VMG0000 +validar validar VMN0000 +valide validar VMM03S0 +validemos validar VMM01P0 +validen validar VMM03P0 +valiendo valer VMG0000 +valla vallar VMM02S0 +vallad vallar VMM02P0 +vallando vallar VMG0000 +vallar vallar VMN0000 +valle vallar VMM03S0 +vallemos vallar VMM01P0 +vallen vallar VMM03P0 +valora valorar VMM02S0 +valorad valorar VMM02P0 +valorando valorar VMG0000 +valorar valorar VMN0000 +valore valorar VMM03S0 +valoremos valorar VMM01P0 +valoren valorar VMM03P0 +valorice valorizar VMM03S0 +valoricemos valorizar VMM01P0 +valoricen valorizar VMM03P0 +valoriza valorizar VMM02S0 +valorizad valorizar VMM02P0 +valorizando valorizar VMG0000 +valorizar valorizar VMN0000 +valsa valsar VMM02S0 +valsad valsar VMM02P0 +valsando valsar VMG0000 +valsar valsar VMN0000 +valse valsar VMM03S0 +valsemos valsar VMM01P0 +valsen valsar VMM03P0 +valuad valuar VMM02P0 +valuando valuar VMG0000 +valuar valuar VMN0000 +valuemos valuar VMM01P0 +valúa valuar VMM02S0 +valúe valuar VMM03S0 +valúen valuar VMM03P0 +vamos ir VMM01P0 +vanagloria vanagloriar VMM02S0 +vanagloriad vanagloriar VMM02P0 +vanagloriando vanagloriar VMG0000 +vanagloriar vanagloriar VMN0000 +vanaglorie vanagloriar VMM03S0 +vanagloriemos vanagloriar VMM01P0 +vanaglorien vanagloriar VMM03P0 +vanea vanear VMM02S0 +vanead vanear VMM02P0 +vaneando vanear VMG0000 +vanear vanear VMN0000 +vanee vanear VMM03S0 +vaneemos vanear VMM01P0 +vaneen vanear VMM03P0 +vapora vaporar VMM02S0 +vaporad vaporar VMM02P0 +vaporando vaporar VMG0000 +vaporar vaporar VMN0000 +vapore vaporar VMM03S0 +vaporemos vaporar VMM01P0 +vaporen vaporar VMM03P0 +vaporice vaporizar VMM03S0 +vaporicemos vaporizar VMM01P0 +vaporicen vaporizar VMM03P0 +vaporiza vaporizar VMM02S0 +vaporizad vaporizar VMM02P0 +vaporizando vaporizar VMG0000 +vaporizar vaporizar VMN0000 +vapulea vapulear VMM02S0 +vapulead vapulear VMM02P0 +vapuleando vapulear VMG0000 +vapulear vapulear VMN0000 +vapulee vapulear VMM03S0 +vapuleemos vapulear VMM01P0 +vapuleen vapulear VMM03P0 +vara varar VMM02S0 +varad varar VMM02P0 +varando varar VMG0000 +varar varar VMN0000 +vare varar VMM03S0 +varea varear VMM02S0 +varead varear VMM02P0 +vareando varear VMG0000 +varear varear VMN0000 +varee varear VMM03S0 +vareemos varear VMM01P0 +vareen varear VMM03P0 +varemos varar VMM01P0 +varen varar VMM03P0 +variad variar VMM02P0 +variando variar VMG0000 +variar variar VMN0000 +variemos variar VMM01P0 +varía variar VMM02S0 +varíe variar VMM03S0 +varíen variar VMM03P0 +vaticina vaticinar VMM02S0 +vaticinad vaticinar VMM02P0 +vaticinando vaticinar VMG0000 +vaticinar vaticinar VMN0000 +vaticine vaticinar VMM03S0 +vaticinemos vaticinar VMM01P0 +vaticinen vaticinar VMM03P0 +vaya ir VMM03S0 +vayamos ir VMM01P0 +vayan ir VMM03P0 +ve ir VMM02S0 +ve ver VMM02S0 +vea ver VMM03S0 +veamos ver VMM01P0 +vean ver VMM03P0 +ved ver VMM02P0 +veda vedar VMM02S0 +vedad vedar VMM02P0 +vedando vedar VMG0000 +vedar vedar VMN0000 +vede vedar VMM03S0 +vedemos vedar VMM01P0 +veden vedar VMM03P0 +vegeta vegetar VMM02S0 +vegetad vegetar VMM02P0 +vegetando vegetar VMG0000 +vegetar vegetar VMN0000 +vegete vegetar VMM03S0 +vegetemos vegetar VMM01P0 +vegeten vegetar VMM03P0 +vehicula vehicular VMM02S0 +vehiculad vehicular VMM02P0 +vehiculando vehicular VMG0000 +vehicular vehicular VMN0000 +vehicule vehicular VMM03S0 +vehiculemos vehicular VMM01P0 +vehiculen vehicular VMM03P0 +vehiculice vehiculizar VMM03S0 +vehiculicemos vehiculizar VMM01P0 +vehiculicen vehiculizar VMM03P0 +vehiculiza vehiculizar VMM02S0 +vehiculizad vehiculizar VMM02P0 +vehiculizando vehiculizar VMG0000 +vehiculizar vehiculizar VMN0000 +veja vejar VMM02S0 +vejad vejar VMM02P0 +vejando vejar VMG0000 +vejar vejar VMN0000 +veje vejar VMM03S0 +vejemos vejar VMM01P0 +vejen vejar VMM03P0 +vela velar VMM02S0 +velad velar VMM02P0 +velando velar VMG0000 +velar velar VMN0000 +vele velar VMM03S0 +velemos velar VMM01P0 +velen velar VMM03P0 +velica velicar VMM02S0 +velicad velicar VMM02P0 +velicando velicar VMG0000 +velicar velicar VMN0000 +velique velicar VMM03S0 +veliquemos velicar VMM01P0 +veliquen velicar VMM03P0 +ven venir VMM02S0 +vence vencer VMM02S0 +venced vencer VMM02P0 +vencer vencer VMN0000 +venciendo vencer VMG0000 +venda vendar VMM02S0 +venda vender VMM03S0 +vendad vendar VMM02P0 +vendamos vender VMM01P0 +vendan vender VMM03P0 +vendando vendar VMG0000 +vendar vendar VMN0000 +vende vendar VMM03S0 +vende vender VMM02S0 +vended vender VMM02P0 +vendemos vendar VMM01P0 +venden vendar VMM03P0 +vender vender VMN0000 +vendiendo vender VMG0000 +vendimia vendimiar VMM02S0 +vendimiad vendimiar VMM02P0 +vendimiando vendimiar VMG0000 +vendimiar vendimiar VMN0000 +vendimie vendimiar VMM03S0 +vendimiemos vendimiar VMM01P0 +vendimien vendimiar VMM03P0 +venera venerar VMM02S0 +venerad venerar VMM02P0 +venerando venerar VMG0000 +venerar venerar VMN0000 +venere venerar VMM03S0 +veneremos venerar VMM01P0 +veneren venerar VMM03P0 +venga vengar VMM02S0 +venga venir VMM03S0 +vengad vengar VMM02P0 +vengamos venir VMM01P0 +vengan venir VMM03P0 +vengando vengar VMG0000 +vengar vengar VMN0000 +vengue vengar VMM03S0 +venguemos vengar VMM01P0 +venguen vengar VMM03P0 +venid venir VMM02P0 +venir venir VMN0000 +ventanea ventanear VMM02S0 +ventanead ventanear VMM02P0 +ventaneando ventanear VMG0000 +ventanear ventanear VMN0000 +ventanee ventanear VMM03S0 +ventaneemos ventanear VMM01P0 +ventaneen ventanear VMM03P0 +ventea ventear VMM02S0 +ventead ventear VMM02P0 +venteando ventear VMG0000 +ventear ventear VMN0000 +ventee ventear VMM03S0 +venteemos ventear VMM01P0 +venteen ventear VMM03P0 +ventila ventilar VMM02S0 +ventilad ventilar VMM02P0 +ventilando ventilar VMG0000 +ventilar ventilar VMN0000 +ventile ventilar VMM03S0 +ventilemos ventilar VMM01P0 +ventilen ventilar VMM03P0 +ventisca ventiscar VMM02S0 +ventiscad ventiscar VMM02P0 +ventiscando ventiscar VMG0000 +ventiscar ventiscar VMN0000 +ventisque ventiscar VMM03S0 +ventisqueando ventisquear VMG0000 +ventisquear ventisquear VMN0000 +ventisquemos ventiscar VMM01P0 +ventisquen ventiscar VMM03P0 +ventosea ventosear VMM02S0 +ventosead ventosear VMM02P0 +ventoseando ventosear VMG0000 +ventosear ventosear VMN0000 +ventosee ventosear VMM03S0 +ventoseemos ventosear VMM01P0 +ventoseen ventosear VMM03P0 +venza vencer VMM03S0 +venzamos vencer VMM01P0 +venzan vencer VMM03P0 +ver ver VMN0000 +veranea veranear VMM02S0 +veranead veranear VMM02P0 +veraneando veranear VMG0000 +veranear veranear VMN0000 +veranee veranear VMM03S0 +veraneemos veranear VMM01P0 +veraneen veranear VMM03P0 +verbalice verbalizar VMM03S0 +verbalicemos verbalizar VMM01P0 +verbalicen verbalizar VMM03P0 +verbaliza verbalizar VMM02S0 +verbalizad verbalizar VMM02P0 +verbalizando verbalizar VMG0000 +verbalizar verbalizar VMN0000 +verdea verdear VMM02S0 +verdead verdear VMM02P0 +verdeando verdear VMG0000 +verdear verdear VMN0000 +verdece verdecer VMM02S0 +verdeced verdecer VMM02P0 +verdecer verdecer VMN0000 +verdeciendo verdecer VMG0000 +verdee verdear VMM03S0 +verdeemos verdear VMM01P0 +verdeen verdear VMM03P0 +verdezca verdecer VMM03S0 +verdezcamos verdecer VMM01P0 +verdezcan verdecer VMM03P0 +verguea verguear VMM02S0 +verguead verguear VMM02P0 +vergueando verguear VMG0000 +verguear verguear VMN0000 +verguee verguear VMM03S0 +vergueemos verguear VMM01P0 +vergueen verguear VMM03P0 +verifica verificar VMM02S0 +verificad verificar VMM02P0 +verificando verificar VMG0000 +verificar verificar VMN0000 +verifique verificar VMM03S0 +verifiquemos verificar VMM01P0 +verifiquen verificar VMM03P0 +verilea verilear VMM02S0 +verilead verilear VMM02P0 +verileando verilear VMG0000 +verilear verilear VMN0000 +verilee verilear VMM03S0 +verileemos verilear VMM01P0 +verileen verilear VMM03P0 +verraquea verraquear VMM02S0 +verraquead verraquear VMM02P0 +verraqueando verraquear VMG0000 +verraquear verraquear VMN0000 +verraquee verraquear VMM03S0 +verraqueemos verraquear VMM01P0 +verraqueen verraquear VMM03P0 +versa versar VMM02S0 +versad versar VMM02P0 +versando versar VMG0000 +versar versar VMN0000 +verse versar VMM03S0 +versemos versar VMM01P0 +versen versar VMM03P0 +versifica versificar VMM02S0 +versificad versificar VMM02P0 +versificando versificar VMG0000 +versificar versificar VMN0000 +versifique versificar VMM03S0 +versifiquemos versificar VMM01P0 +versifiquen versificar VMM03P0 +versiona versionar VMM02S0 +versionad versionar VMM02P0 +versionando versionar VMG0000 +versionar versionar VMN0000 +versione versionar VMM03S0 +versionemos versionar VMM01P0 +versionen versionar VMM03P0 +vertamos verter VMM01P0 +vertebra vertebrar VMM02S0 +vertebrad vertebrar VMM02P0 +vertebrando vertebrar VMG0000 +vertebrar vertebrar VMN0000 +vertebre vertebrar VMM03S0 +vertebremos vertebrar VMM01P0 +vertebren vertebrar VMM03P0 +verted verter VMM02P0 +verter verter VMN0000 +vertiendo verter VMG0000 +vestid vestir VMM02P0 +vestir vestir VMN0000 +veta vetar VMM02S0 +vetad vetar VMM02P0 +vetando vetar VMG0000 +vetar vetar VMN0000 +vete vetar VMM03S0 +vetea vetear VMM02S0 +vetead vetear VMM02P0 +veteando vetear VMG0000 +vetear vetear VMN0000 +vetee vetear VMM03S0 +veteemos vetear VMM01P0 +veteen vetear VMM03P0 +vetemos vetar VMM01P0 +veten vetar VMM03P0 +viabilice viabilizar VMM03S0 +viabilicemos viabilizar VMM01P0 +viabilicen viabilizar VMM03P0 +viabiliza viabilizar VMM02S0 +viabilizad viabilizar VMM02P0 +viabilizando viabilizar VMG0000 +viabilizar viabilizar VMN0000 +viaja viajar VMM02S0 +viajad viajar VMM02P0 +viajando viajar VMG0000 +viajar viajar VMN0000 +viaje viajar VMM03S0 +viajemos viajar VMM01P0 +viajen viajar VMM03P0 +viatica viaticar VMM02S0 +viaticad viaticar VMM02P0 +viaticando viaticar VMG0000 +viaticar viaticar VMN0000 +viatique viaticar VMM03S0 +viatiquemos viaticar VMM01P0 +viatiquen viaticar VMM03P0 +viborea viborear VMM02S0 +viboread viborear VMM02P0 +viboreando viborear VMG0000 +viborear viborear VMN0000 +viboree viborear VMM03S0 +viboreemos viborear VMM01P0 +viboreen viborear VMM03P0 +vibra vibrar VMM02S0 +vibrad vibrar VMM02P0 +vibrando vibrar VMG0000 +vibrar vibrar VMN0000 +vibre vibrar VMM03S0 +vibremos vibrar VMM01P0 +vibren vibrar VMM03P0 +vicha vichar VMM02S0 +vichad vichar VMM02P0 +vichando vichar VMG0000 +vichar vichar VMN0000 +viche vichar VMM03S0 +vichemos vichar VMM01P0 +vichen vichar VMM03P0 +vicia viciar VMM02S0 +viciad viciar VMM02P0 +viciando viciar VMG0000 +viciar viciar VMN0000 +vicie viciar VMM03S0 +viciemos viciar VMM01P0 +vicien viciar VMM03P0 +victima victimar VMM02S0 +victimad victimar VMM02P0 +victimando victimar VMG0000 +victimar victimar VMN0000 +victime victimar VMM03S0 +victimemos victimar VMM01P0 +victimen victimar VMM03P0 +vidria vidriar VMM02S0 +vidriad vidriar VMM02P0 +vidriando vidriar VMG0000 +vidriar vidriar VMN0000 +vidrie vidriar VMM03S0 +vidriemos vidriar VMM01P0 +vidrien vidriar VMM03P0 +viendo ver VMG0000 +vierta verter VMM03S0 +viertan verter VMM03P0 +vierte verter VMM02S0 +vigila vigilar VMM02S0 +vigilad vigilar VMM02P0 +vigilando vigilar VMG0000 +vigilar vigilar VMN0000 +vigile vigilar VMM03S0 +vigilemos vigilar VMM01P0 +vigilen vigilar VMM03P0 +vigora vigorar VMM02S0 +vigorad vigorar VMM02P0 +vigorando vigorar VMG0000 +vigorar vigorar VMN0000 +vigore vigorar VMM03S0 +vigoremos vigorar VMM01P0 +vigoren vigorar VMM03P0 +vigorice vigorizar VMM03S0 +vigoricemos vigorizar VMM01P0 +vigoricen vigorizar VMM03P0 +vigoriza vigorizar VMM02S0 +vigorizad vigorizar VMM02P0 +vigorizando vigorizar VMG0000 +vigorizar vigorizar VMN0000 +vilipendia vilipendiar VMM02S0 +vilipendiad vilipendiar VMM02P0 +vilipendiando vilipendiar VMG0000 +vilipendiar vilipendiar VMN0000 +vilipendie vilipendiar VMM03S0 +vilipendiemos vilipendiar VMM01P0 +vilipendien vilipendiar VMM03P0 +viltrotea viltrotear VMM02S0 +viltrotead viltrotear VMM02P0 +viltroteando viltrotear VMG0000 +viltrotear viltrotear VMN0000 +viltrotee viltrotear VMM03S0 +viltroteemos viltrotear VMM01P0 +viltroteen viltrotear VMM03P0 +vincula vincular VMM02S0 +vinculad vincular VMM02P0 +vinculando vincular VMG0000 +vincular vincular VMN0000 +vincule vincular VMM03S0 +vinculemos vincular VMM01P0 +vinculen vincular VMM03P0 +vindica vindicar VMM02S0 +vindicad vindicar VMM02P0 +vindicando vindicar VMG0000 +vindicar vindicar VMN0000 +vindique vindicar VMM03S0 +vindiquemos vindicar VMM01P0 +vindiquen vindicar VMM03P0 +viniendo venir VMG0000 +viola violar VMM02S0 +violad violar VMM02P0 +violando violar VMG0000 +violar violar VMN0000 +viole violar VMM03S0 +violemos violar VMM01P0 +violen violar VMM03P0 +violenta violentar VMM02S0 +violentad violentar VMM02P0 +violentando violentar VMG0000 +violentar violentar VMN0000 +violente violentar VMM03S0 +violentemos violentar VMM01P0 +violenten violentar VMM03P0 +vira virar VMM02S0 +virad virar VMM02P0 +virando virar VMG0000 +virar virar VMN0000 +vire virar VMM03S0 +viremos virar VMM01P0 +viren virar VMM03P0 +visa visar VMM02S0 +visad visar VMM02P0 +visando visar VMG0000 +visar visar VMN0000 +vise visar VMM03S0 +visemos visar VMM01P0 +visen visar VMM03P0 +visiona visionar VMM02S0 +visionad visionar VMM02P0 +visionando visionar VMG0000 +visionar visionar VMN0000 +visione visionar VMM03S0 +visionemos visionar VMM01P0 +visionen visionar VMM03P0 +visita visitar VMM02S0 +visitad visitar VMM02P0 +visitando visitar VMG0000 +visitar visitar VMN0000 +visite visitar VMM03S0 +visitemos visitar VMM01P0 +visiten visitar VMM03P0 +vislumbra vislumbrar VMM02S0 +vislumbrad vislumbrar VMM02P0 +vislumbrando vislumbrar VMG0000 +vislumbrar vislumbrar VMN0000 +vislumbre vislumbrar VMM03S0 +vislumbremos vislumbrar VMM01P0 +vislumbren vislumbrar VMM03P0 +vista vestir VMM03S0 +vistamos vestir VMM01P0 +vistan vestir VMM03P0 +viste vestir VMM02S0 +vistiendo vestir VMG0000 +visualice visualizar VMM03S0 +visualicemos visualizar VMM01P0 +visualicen visualizar VMM03P0 +visualiza visualizar VMM02S0 +visualizad visualizar VMM02P0 +visualizando visualizar VMG0000 +visualizar visualizar VMN0000 +vitalice vitalizar VMM03S0 +vitalicemos vitalizar VMM01P0 +vitalicen vitalizar VMM03P0 +vitaliza vitalizar VMM02S0 +vitalizad vitalizar VMM02P0 +vitalizando vitalizar VMG0000 +vitalizar vitalizar VMN0000 +vitorea vitorear VMM02S0 +vitoread vitorear VMM02P0 +vitoreando vitorear VMG0000 +vitorear vitorear VMN0000 +vitoree vitorear VMM03S0 +vitoreemos vitorear VMM01P0 +vitoreen vitorear VMM03P0 +vitrifica vitrificar VMM02S0 +vitrificad vitrificar VMM02P0 +vitrificando vitrificar VMG0000 +vitrificar vitrificar VMN0000 +vitrifique vitrificar VMM03S0 +vitrifiquemos vitrificar VMM01P0 +vitrifiquen vitrificar VMM03P0 +vitualla vituallar VMM02S0 +vituallad vituallar VMM02P0 +vituallando vituallar VMG0000 +vituallar vituallar VMN0000 +vitualle vituallar VMM03S0 +vituallemos vituallar VMM01P0 +vituallen vituallar VMM03P0 +vitupera vituperar VMM02S0 +vituperad vituperar VMM02P0 +vituperando vituperar VMG0000 +vituperar vituperar VMN0000 +vitupere vituperar VMM03S0 +vituperemos vituperar VMM01P0 +vituperen vituperar VMM03P0 +viva vivir VMM03S0 +vivamos vivir VMM01P0 +vivan vivir VMM03P0 +vivaquea vivaquear VMM02S0 +vivaquead vivaquear VMM02P0 +vivaqueando vivaquear VMG0000 +vivaquear vivaquear VMN0000 +vivaquee vivaquear VMM03S0 +vivaqueemos vivaquear VMM01P0 +vivaqueen vivaquear VMM03P0 +vive vivir VMM02S0 +vivid vivir VMM02P0 +viviendo vivir VMG0000 +vivifica vivificar VMM02S0 +vivificad vivificar VMM02P0 +vivificando vivificar VMG0000 +vivificar vivificar VMN0000 +vivifique vivificar VMM03S0 +vivifiquemos vivificar VMM01P0 +vivifiquen vivificar VMM03P0 +vivir vivir VMN0000 +vocalice vocalizar VMM03S0 +vocalicemos vocalizar VMM01P0 +vocalicen vocalizar VMM03P0 +vocaliza vocalizar VMM02S0 +vocalizad vocalizar VMM02P0 +vocalizando vocalizar VMG0000 +vocalizar vocalizar VMN0000 +vocea vocear VMM02S0 +vocead vocear VMM02P0 +voceando vocear VMG0000 +vocear vocear VMN0000 +vocee vocear VMM03S0 +voceemos vocear VMM01P0 +voceen vocear VMM03P0 +vocifera vociferar VMM02S0 +vociferad vociferar VMM02P0 +vociferando vociferar VMG0000 +vociferar vociferar VMN0000 +vocifere vociferar VMM03S0 +vociferemos vociferar VMM01P0 +vociferen vociferar VMM03P0 +volad volar VMM02P0 +volando volar VMG0000 +volar volar VMN0000 +volatilice volatilizar VMM03S0 +volatilicemos volatilizar VMM01P0 +volatilicen volatilizar VMM03P0 +volatiliza volatilizar VMM02S0 +volatilizad volatilizar VMM02P0 +volatilizando volatilizar VMG0000 +volatilizar volatilizar VMN0000 +volcad volcar VMM02P0 +volcando volcar VMG0000 +volcar volcar VMN0000 +volea volear VMM02S0 +volead volear VMM02P0 +voleando volear VMG0000 +volear volear VMN0000 +volee volear VMM03S0 +voleemos volear VMM01P0 +voleen volear VMM03P0 +volemos volar VMM01P0 +volita volitar VMM02S0 +volitad volitar VMM02P0 +volitando volitar VMG0000 +volitar volitar VMN0000 +volite volitar VMM03S0 +volitemos volitar VMM01P0 +voliten volitar VMM03P0 +volquemos volcar VMM01P0 +voltea voltear VMM02S0 +voltead voltear VMM02P0 +volteando voltear VMG0000 +voltear voltear VMN0000 +voltee voltear VMM03S0 +volteemos voltear VMM01P0 +volteen voltear VMM03P0 +voltejea voltejear VMM02S0 +voltejead voltejear VMM02P0 +voltejeando voltejear VMG0000 +voltejear voltejear VMN0000 +voltejee voltejear VMM03S0 +voltejeemos voltejear VMM01P0 +voltejeen voltejear VMM03P0 +volvamos volver VMM01P0 +volved volver VMM02P0 +volver volver VMN0000 +volviendo volver VMG0000 +vomita vomitar VMM02S0 +vomitad vomitar VMM02P0 +vomitando vomitar VMG0000 +vomitar vomitar VMN0000 +vomite vomitar VMM03S0 +vomitemos vomitar VMM01P0 +vomiten vomitar VMM03P0 +vosea vosear VMM02S0 +vosead vosear VMM02P0 +voseando vosear VMG0000 +vosear vosear VMN0000 +vosee vosear VMM03S0 +voseemos vosear VMM01P0 +voseen vosear VMM03P0 +vota votar VMM02S0 +votad votar VMM02P0 +votando votar VMG0000 +votar votar VMN0000 +vote votar VMM03S0 +votemos votar VMM01P0 +voten votar VMM03P0 +vuela volar VMM02S0 +vuelca volcar VMM02S0 +vuele volar VMM03S0 +vuelen volar VMM03P0 +vuelque volcar VMM03S0 +vuelquen volcar VMM03P0 +vuelva volver VMM03S0 +vuelvan volver VMM03P0 +vuelve volver VMM02S0 +vulcanice vulcanizar VMM03S0 +vulcanicemos vulcanizar VMM01P0 +vulcanicen vulcanizar VMM03P0 +vulcaniza vulcanizar VMM02S0 +vulcanizad vulcanizar VMM02P0 +vulcanizando vulcanizar VMG0000 +vulcanizar vulcanizar VMN0000 +vulgarice vulgarizar VMM03S0 +vulgaricemos vulgarizar VMM01P0 +vulgaricen vulgarizar VMM03P0 +vulgariza vulgarizar VMM02S0 +vulgarizad vulgarizar VMM02P0 +vulgarizando vulgarizar VMG0000 +vulgarizar vulgarizar VMN0000 +vulnera vulnerar VMM02S0 +vulnerad vulnerar VMM02P0 +vulnerando vulnerar VMG0000 +vulnerar vulnerar VMN0000 +vulnere vulnerar VMM03S0 +vulneremos vulnerar VMM01P0 +vulneren vulnerar VMM03P0 +yace yacer VMM02S0 +yaced yacer VMM02P0 +yacer yacer VMN0000 +yaciendo yacer VMG0000 +yaga yacer VMM03S0 +yagamos yacer VMM01P0 +yagan yacer VMM03P0 +yaz yacer VMM02S0 +yazca yacer VMM03S0 +yazcamos yacer VMM01P0 +yazcan yacer VMM03P0 +yazga yacer VMM03S0 +yazgamos yacer VMM01P0 +yazgan yacer VMM03P0 +yendo ir VMG0000 +yerbea yerbear VMM02S0 +yerbead yerbear VMM02P0 +yerbeando yerbear VMG0000 +yerbear yerbear VMN0000 +yerbee yerbear VMM03S0 +yerbeemos yerbear VMM01P0 +yerbeen yerbear VMM03P0 +yerga erguir VMM03S0 +yergan erguir VMM03P0 +yergue erguir VMM02S0 +yerra errar VMM02S0 +yerre errar VMM03S0 +yerren errar VMM03P0 +yoda yodar VMM02S0 +yodad yodar VMM02P0 +yodando yodar VMG0000 +yodar yodar VMN0000 +yode yodar VMM03S0 +yodemos yodar VMM01P0 +yoden yodar VMM03P0 +yodura yodurar VMM02S0 +yodurad yodurar VMM02P0 +yodurando yodurar VMG0000 +yodurar yodurar VMN0000 +yodure yodurar VMM03S0 +yoduremos yodurar VMM01P0 +yoduren yodurar VMM03P0 +yugula yugular VMM02S0 +yugulad yugular VMM02P0 +yugulando yugular VMG0000 +yugular yugular VMN0000 +yugule yugular VMM03S0 +yugulemos yugular VMM01P0 +yugulen yugular VMM03P0 +yuxtaponed yuxtaponer VMM02P0 +yuxtaponer yuxtaponer VMN0000 +yuxtaponga yuxtaponer VMM03S0 +yuxtapongamos yuxtaponer VMM01P0 +yuxtapongan yuxtaponer VMM03P0 +yuxtaponiendo yuxtaponer VMG0000 +yuxtapón yuxtaponer VMM02S0 +zaborda zabordar VMM02S0 +zabordad zabordar VMM02P0 +zabordando zabordar VMG0000 +zabordar zabordar VMN0000 +zaborde zabordar VMM03S0 +zabordemos zabordar VMM01P0 +zaborden zabordar VMM03P0 +zafa zafar VMM02S0 +zafad zafar VMM02P0 +zafando zafar VMG0000 +zafar zafar VMN0000 +zafe zafar VMM03S0 +zafemos zafar VMM01P0 +zafen zafar VMM03P0 +zaherid zaherir VMM02P0 +zaherir zaherir VMN0000 +zahiera zaherir VMM03S0 +zahieran zaherir VMM03P0 +zahiere zaherir VMM02S0 +zahiramos zaherir VMM01P0 +zahiriendo zaherir VMG0000 +zahonda zahondar VMM02S0 +zahondad zahondar VMM02P0 +zahondando zahondar VMG0000 +zahondar zahondar VMN0000 +zahonde zahondar VMM03S0 +zahondemos zahondar VMM01P0 +zahonden zahondar VMM03P0 +zalea zalear VMM02S0 +zalead zalear VMM02P0 +zaleando zalear VMG0000 +zalear zalear VMN0000 +zalee zalear VMM03S0 +zaleemos zalear VMM01P0 +zaleen zalear VMM03P0 +zamarrea zamarrear VMM02S0 +zamarread zamarrear VMM02P0 +zamarreando zamarrear VMG0000 +zamarrear zamarrear VMN0000 +zamarree zamarrear VMM03S0 +zamarreemos zamarrear VMM01P0 +zamarreen zamarrear VMM03P0 +zambulla zambullir VMM03S0 +zambullamos zambullir VMM01P0 +zambullan zambullir VMM03P0 +zambulle zambullir VMM02S0 +zambullendo zambullir VMG0000 +zambullid zambullir VMM02P0 +zambullir zambullir VMN0000 +zampa zampar VMM02S0 +zampad zampar VMM02P0 +zampando zampar VMG0000 +zampar zampar VMN0000 +zampe zampar VMM03S0 +zampea zampear VMM02S0 +zampead zampear VMM02P0 +zampeando zampear VMG0000 +zampear zampear VMN0000 +zampee zampear VMM03S0 +zampeemos zampear VMM01P0 +zampeen zampear VMM03P0 +zampemos zampar VMM01P0 +zampen zampar VMM03P0 +zancadillea zancadillear VMM02S0 +zancadillead zancadillear VMM02P0 +zancadilleando zancadillear VMG0000 +zancadillear zancadillear VMN0000 +zancadillee zancadillear VMM03S0 +zancadilleemos zancadillear VMM01P0 +zancadilleen zancadillear VMM03P0 +zancajea zancajear VMM02S0 +zancajead zancajear VMM02P0 +zancajeando zancajear VMG0000 +zancajear zancajear VMN0000 +zancajee zancajear VMM03S0 +zancajeemos zancajear VMM01P0 +zancajeen zancajear VMM03P0 +zanganea zanganear VMM02S0 +zanganead zanganear VMM02P0 +zanganeando zanganear VMG0000 +zanganear zanganear VMN0000 +zanganee zanganear VMM03S0 +zanganeemos zanganear VMM01P0 +zanganeen zanganear VMM03P0 +zangarrea zangarrear VMM02S0 +zangarread zangarrear VMM02P0 +zangarreando zangarrear VMG0000 +zangarrear zangarrear VMN0000 +zangarree zangarrear VMM03S0 +zangarreemos zangarrear VMM01P0 +zangarreen zangarrear VMM03P0 +zangolotea zangolotear VMM02S0 +zangolotead zangolotear VMM02P0 +zangoloteando zangolotear VMG0000 +zangolotear zangolotear VMN0000 +zangolotee zangolotear VMM03S0 +zangoloteemos zangolotear VMM01P0 +zangoloteen zangolotear VMM03P0 +zangotea zangotear VMM02S0 +zangotead zangotear VMM02P0 +zangoteando zangotear VMG0000 +zangotear zangotear VMN0000 +zangotee zangotear VMM03S0 +zangoteemos zangotear VMM01P0 +zangoteen zangotear VMM03P0 +zanja zanjar VMM02S0 +zanjad zanjar VMM02P0 +zanjando zanjar VMG0000 +zanjar zanjar VMN0000 +zanje zanjar VMM03S0 +zanjemos zanjar VMM01P0 +zanjen zanjar VMM03P0 +zanquea zanquear VMM02S0 +zanquead zanquear VMM02P0 +zanqueando zanquear VMG0000 +zanquear zanquear VMN0000 +zanquee zanquear VMM03S0 +zanqueemos zanquear VMM01P0 +zanqueen zanquear VMM03P0 +zapa zapar VMM02S0 +zapad zapar VMM02P0 +zapando zapar VMG0000 +zapar zapar VMN0000 +zaparrastra zaparrastrar VMM02S0 +zaparrastrad zaparrastrar VMM02P0 +zaparrastrando zaparrastrar VMG0000 +zaparrastrar zaparrastrar VMN0000 +zaparrastre zaparrastrar VMM03S0 +zaparrastremos zaparrastrar VMM01P0 +zaparrastren zaparrastrar VMM03P0 +zapatea zapatear VMM02S0 +zapatead zapatear VMM02P0 +zapateando zapatear VMG0000 +zapatear zapatear VMN0000 +zapatee zapatear VMM03S0 +zapateemos zapatear VMM01P0 +zapateen zapatear VMM03P0 +zape zapar VMM03S0 +zapea zapear VMM02S0 +zapead zapear VMM02P0 +zapeando zapear VMG0000 +zapear zapear VMN0000 +zapee zapear VMM03S0 +zapeemos zapear VMM01P0 +zapeen zapear VMM03P0 +zapemos zapar VMM01P0 +zapen zapar VMM03P0 +zaquea zaquear VMM02S0 +zaquead zaquear VMM02P0 +zaqueando zaquear VMG0000 +zaquear zaquear VMN0000 +zaquee zaquear VMM03S0 +zaqueemos zaquear VMM01P0 +zaqueen zaquear VMM03P0 +zarandea zarandear VMM02S0 +zarandead zarandear VMM02P0 +zarandeando zarandear VMG0000 +zarandear zarandear VMN0000 +zarandee zarandear VMM03S0 +zarandeemos zarandear VMM01P0 +zarandeen zarandear VMM03P0 +zarcea zarcear VMM02S0 +zarcead zarcear VMM02P0 +zarceando zarcear VMG0000 +zarcear zarcear VMN0000 +zarcee zarcear VMM03S0 +zarceemos zarcear VMM01P0 +zarceen zarcear VMM03P0 +zarpa zarpar VMM02S0 +zarpad zarpar VMM02P0 +zarpando zarpar VMG0000 +zarpar zarpar VMN0000 +zarpe zarpar VMM03S0 +zarpea zarpear VMM02S0 +zarpead zarpear VMM02P0 +zarpeando zarpear VMG0000 +zarpear zarpear VMN0000 +zarpee zarpear VMM03S0 +zarpeemos zarpear VMM01P0 +zarpeen zarpear VMM03P0 +zarpemos zarpar VMM01P0 +zarpen zarpar VMM03P0 +zascandilea zascandilear VMM02S0 +zascandilead zascandilear VMM02P0 +zascandileando zascandilear VMG0000 +zascandilear zascandilear VMN0000 +zascandilee zascandilear VMM03S0 +zascandileemos zascandilear VMM01P0 +zascandileen zascandilear VMM03P0 +zigzaguea zigzaguear VMM02S0 +zigzaguead zigzaguear VMM02P0 +zigzagueando zigzaguear VMG0000 +zigzaguear zigzaguear VMN0000 +zigzaguee zigzaguear VMM03S0 +zigzagueemos zigzaguear VMM01P0 +zigzagueen zigzaguear VMM03P0 +zollipa zollipar VMM02S0 +zollipad zollipar VMM02P0 +zollipando zollipar VMG0000 +zollipar zollipar VMN0000 +zollipe zollipar VMM03S0 +zollipemos zollipar VMM01P0 +zollipen zollipar VMM03P0 +zozobra zozobrar VMM02S0 +zozobrad zozobrar VMM02P0 +zozobrando zozobrar VMG0000 +zozobrar zozobrar VMN0000 +zozobre zozobrar VMM03S0 +zozobremos zozobrar VMM01P0 +zozobren zozobrar VMM03P0 +zulaca zulacar VMM02S0 +zulacad zulacar VMM02P0 +zulacando zulacar VMG0000 +zulacar zulacar VMN0000 +zulaque zulacar VMM03S0 +zulaquemos zulacar VMM01P0 +zulaquen zulacar VMM03P0 +zulla zullar VMM02S0 +zullad zullar VMM02P0 +zullando zullar VMG0000 +zullar zullar VMN0000 +zulle zullar VMM03S0 +zullemos zullar VMM01P0 +zullen zullar VMM03P0 +zumba zumbar VMM02S0 +zumbad zumbar VMM02P0 +zumbando zumbar VMG0000 +zumbar zumbar VMN0000 +zumbe zumbar VMM03S0 +zumbemos zumbar VMM01P0 +zumben zumbar VMM03P0 +zuncha zunchar VMM02S0 +zunchad zunchar VMM02P0 +zunchando zunchar VMG0000 +zunchar zunchar VMN0000 +zunche zunchar VMM03S0 +zunchemos zunchar VMM01P0 +zunchen zunchar VMM03P0 +zurce zurcir VMM02S0 +zurcid zurcir VMM02P0 +zurciendo zurcir VMG0000 +zurcir zurcir VMN0000 +zurea zurear VMM02S0 +zuread zurear VMM02P0 +zureando zurear VMG0000 +zurear zurear VMN0000 +zuree zurear VMM03S0 +zureemos zurear VMM01P0 +zureen zurear VMM03P0 +zurra zurrar VMM02S0 +zurrad zurrar VMM02P0 +zurrando zurrar VMG0000 +zurrar zurrar VMN0000 +zurre zurrar VMM03S0 +zurremos zurrar VMM01P0 +zurren zurrar VMM03P0 +zurriaga zurriagar VMM02S0 +zurriagad zurriagar VMM02P0 +zurriagando zurriagar VMG0000 +zurriagar zurriagar VMN0000 +zurriague zurriagar VMM03S0 +zurriaguemos zurriagar VMM01P0 +zurriaguen zurriagar VMM03P0 +zurza zurcir VMM03S0 +zurzamos zurcir VMM01P0 +zurzan zurcir VMM03P0 diff --git a/CoreNLP/stanford-postagger-full-2020-11-17/models/README-Models.txt b/CoreNLP/stanford-postagger-full-2020-11-17/models/README-Models.txt new file mode 100644 index 0000000000000000000000000000000000000000..77eb207c9f5ede15dc4b25a6f4bf82863f02f7e8 --- /dev/null +++ b/CoreNLP/stanford-postagger-full-2020-11-17/models/README-Models.txt @@ -0,0 +1,68 @@ +Stanford POS Tagger, v4.2.0 - 2020-11-17 +Copyright (c) 2002-2020 The Board of Trustees of +The Leland Stanford Junior University. All Rights Reserved. + +This document contains (some) information about the models included in +this release and that may be downloaded for the POS tagger website at +http://nlp.stanford.edu/software/tagger.html . All of the models mentioned +in this document are in the downloaded package in the same directory as this +readme. All taggers are accompanied by the props files used to create +them; please examine these files for more detailed information about the +creation of the taggers. + +For English, the bidirectional taggers are slightly more accurate, but +tag much more slowly; choose the appropriate tagger based on your +speed/performance needs. + +English taggers +--------------------------- +english-left3words-distsim.tagger +Trained on WSJ sections 0-18 and extra parser training data using the +left3words architecture and includes word shape and distributional +similarity features. Penn tagset. UDv2.0 tokenization standard. + +english-bidirectional-distsim.tagger +Trained on WSJ sections 0-18 using a bidirectional architecture and +including word shape and distributional similarity features. +Penn Treebank tagset. UDv2.0 tokenization standard. + +english-caseless-left3words-distsim.tagger +Trained on WSJ sections 0-18 and extra parser training data using the +left3words architecture and includes word shape and distributional +similarity features. Penn tagset. Ignores case. UDv2.0 tokenization +standard. + + +Chinese tagger +--------------------------- +chinese-nodistsim.tagger +Trained on a combination of CTB7 texts from Chinese and Hong Kong +sources. +LDC Chinese Treebank POS tag set. + +chinese-distsim.tagger +Trained on a combination of CTB7 texts from Chinese and Hong Kong +sources with distributional similarity clusters. +LDC Chinese Treebank POS tag set. + +Arabic tagger +--------------------------- +arabic.tagger +Trained on the *entire* ATB p1-3. +When trained on the train part of the ATB p1-3 split done for the 2005 +JHU Summer Workshop (Diab split), using (augmented) Bies tags, it gets + +French tagger +--------------------------- +french-ud.tagger +Trained on the French GSD (UDv2.2) data set + +German tagger +--------------------------- +german-ud.tagger +Trained on the German GSD (UDv2.2) data set + +Spanish tagger +-------------------------- +spanish-ud.tagger +Trained on the Spanish AnCora (UDv2.0) data set diff --git a/CoreNLP/stanford-postagger-full-2020-11-17/models/arabic-train.tagger b/CoreNLP/stanford-postagger-full-2020-11-17/models/arabic-train.tagger new file mode 100644 index 0000000000000000000000000000000000000000..35bc1a54840a9c5cfb1870395c88c1c5bcc4a7bc --- /dev/null +++ b/CoreNLP/stanford-postagger-full-2020-11-17/models/arabic-train.tagger @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d0ea63d5a2b78cc06565accfaac5abdd64b031a422d0e09e189594098671e5e6 +size 2577597 diff --git a/CoreNLP/stanford-postagger-full-2020-11-17/models/arabic-train.tagger.props b/CoreNLP/stanford-postagger-full-2020-11-17/models/arabic-train.tagger.props new file mode 100644 index 0000000000000000000000000000000000000000..699c64a1fd42ce70919312f7ac225d08233df15b --- /dev/null +++ b/CoreNLP/stanford-postagger-full-2020-11-17/models/arabic-train.tagger.props @@ -0,0 +1,35 @@ +## tagger training invoked at Wed Jan 03 12:02:30 PST 2018 with arguments: + model = arabic-train.tagger + arch = words(-2,2),order(1),prefix(6),suffix(6),unicodeshapes(1) + wordFunction = + trainFile = format=TREES,treeNormalizer=edu.stanford.nlp.trees.international.arabic.ArabicTreeNormalizer,trf=edu.stanford.nlp.trees.international.arabic.ArabicTreeReaderFactory,/u/nlp/data/lexparser/trees/Arabic/2-Unvoc-Train.utf8.txt + closedClassTags = + closedClassTagThreshold = 40 + curWordMinFeatureThresh = 1 + debug = false + debugPrefix = + tagSeparator = / + encoding = UTF-8 + iterations = 100 + lang = arabic + learnClosedClassTags = false + minFeatureThresh = 3 + openClassTags = +rareWordMinFeatureThresh = 3 + rareWordThresh = 5 + search = owlqn + sgml = false + sigmaSquared = 0.0 + regL1 = 0.75 + tagInside = + tokenize = false + tokenizerFactory = edu.stanford.nlp.process.WhitespaceTokenizer + tokenizerOptions = + verbose = false + verboseResults = true + veryCommonWordThresh = 250 + xmlInput = + outputFile = + outputFormat = slashTags + outputFormatOptions = + nthreads = 1 diff --git a/CoreNLP/stanford-postagger-full-2020-11-17/models/arabic.tagger b/CoreNLP/stanford-postagger-full-2020-11-17/models/arabic.tagger new file mode 100644 index 0000000000000000000000000000000000000000..fa4dd75948d96bc76a90c58e5e3fa637cc50ec27 --- /dev/null +++ b/CoreNLP/stanford-postagger-full-2020-11-17/models/arabic.tagger @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d07351166e384349a0e1a5d1a8b2987f88a5dcbad9bfb44e24444028802dbd41 +size 2944508 diff --git a/CoreNLP/stanford-postagger-full-2020-11-17/models/arabic.tagger.props b/CoreNLP/stanford-postagger-full-2020-11-17/models/arabic.tagger.props new file mode 100644 index 0000000000000000000000000000000000000000..54e2c06c088070fc383650e3675e64981499690b --- /dev/null +++ b/CoreNLP/stanford-postagger-full-2020-11-17/models/arabic.tagger.props @@ -0,0 +1,35 @@ +## tagger training invoked at Wed Jan 03 12:24:48 PST 2018 with arguments: + model = arabic.tagger + arch = words(-2,2),order(1),prefix(6),suffix(6),unicodeshapes(1) + wordFunction = + trainFile = format=TREES,treeNormalizer=edu.stanford.nlp.trees.international.arabic.ArabicTreeNormalizer,trf=edu.stanford.nlp.trees.international.arabic.ArabicTreeReaderFactory,/u/nlp/data/lexparser/trees/Arabic/2-Unvoc-Train.utf8.txt;format=TREES,treeNormalizer=edu.stanford.nlp.trees.international.arabic.ArabicTreeNormalizer,trf=edu.stanford.nlp.trees.international.arabic.ArabicTreeReaderFactory,/u/nlp/data/lexparser/trees/Arabic/2-Unvoc-Dev.utf8.txt;format=TREES,treeNormalizer=edu.stanford.nlp.trees.international.arabic.ArabicTreeNormalizer,trf=edu.stanford.nlp.trees.international.arabic.ArabicTreeReaderFactory,/u/nlp/data/lexparser/trees/Arabic/2-Unvoc-Test.utf8.txt + closedClassTags = + closedClassTagThreshold = 40 + curWordMinFeatureThresh = 1 + debug = false + debugPrefix = + tagSeparator = / + encoding = UTF-8 + iterations = 100 + lang = arabic + learnClosedClassTags = false + minFeatureThresh = 3 + openClassTags = +rareWordMinFeatureThresh = 3 + rareWordThresh = 5 + search = owlqn + sgml = false + sigmaSquared = 0.0 + regL1 = 0.75 + tagInside = + tokenize = false + tokenizerFactory = edu.stanford.nlp.process.WhitespaceTokenizer + tokenizerOptions = + verbose = false + verboseResults = true + veryCommonWordThresh = 250 + xmlInput = + outputFile = + outputFormat = slashTags + outputFormatOptions = + nthreads = 1 diff --git a/CoreNLP/stanford-postagger-full-2020-11-17/models/chinese-distsim.tagger b/CoreNLP/stanford-postagger-full-2020-11-17/models/chinese-distsim.tagger new file mode 100644 index 0000000000000000000000000000000000000000..6408d9c010eb38105428f5b3134f68d59e4ebad2 --- /dev/null +++ b/CoreNLP/stanford-postagger-full-2020-11-17/models/chinese-distsim.tagger @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ca40fdab701679ac93e9f075da134e2906f3d1a88b084bc0c018506fa7a68e4b +size 13866197 diff --git a/CoreNLP/stanford-postagger-full-2020-11-17/models/chinese-distsim.tagger.props b/CoreNLP/stanford-postagger-full-2020-11-17/models/chinese-distsim.tagger.props new file mode 100644 index 0000000000000000000000000000000000000000..f1524bd35842d180755cf834faabeaa4d9c74134 --- /dev/null +++ b/CoreNLP/stanford-postagger-full-2020-11-17/models/chinese-distsim.tagger.props @@ -0,0 +1,35 @@ +## tagger training invoked at Fri Feb 14 01:19:49 PST 2014 with arguments: + model = chinese-distsim.tagger + arch = generic,suffix(4),prefix(4),unicodeshapes(-1,1),unicodeshapeconjunction(-1,1),words(-2,-2),words(2,2),distsim(/u/nlp/data/chinese/distsim/xin_cmn_2000-2010.ldc.seg.utf8.1M.random-c1000,-1,1),distsimconjunction(/u/nlp/data/chinese/distsim/xin_cmn_2000-2010.ldc.seg.utf8.1M.random-c1000,-1,1) + wordFunction = edu.stanford.nlp.util.UTF8EquivalenceFunction + trainFile = format=TREES,/u/nlp/data/chinese/ctb7/train.mrg + closedClassTags = + closedClassTagThreshold = 40 + curWordMinFeatureThresh = 1 + debug = false + debugPrefix = + tagSeparator = # + encoding = utf-8 + iterations = 100 + lang = chinese + learnClosedClassTags = false + minFeatureThresh = 3 + openClassTags = +rareWordMinFeatureThresh = 3 + rareWordThresh = 20 + search = owlqn + sgml = false + sigmaSquared = 0.0 + regL1 = 0.75 + tagInside = + tokenize = false + tokenizerFactory = + tokenizerOptions = + verbose = false + verboseResults = true + veryCommonWordThresh = 250 + xmlInput = null + outputFile = + outputFormat = slashTags + outputFormatOptions = + nthreads = 1 diff --git a/CoreNLP/stanford-postagger-full-2020-11-17/models/chinese-nodistsim.tagger b/CoreNLP/stanford-postagger-full-2020-11-17/models/chinese-nodistsim.tagger new file mode 100644 index 0000000000000000000000000000000000000000..84c471e7def1d337f1b19e55fcc24a9aae434888 --- /dev/null +++ b/CoreNLP/stanford-postagger-full-2020-11-17/models/chinese-nodistsim.tagger @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:db4178289b565a439f4bd2f2216d770e37f8ae568dcc34b1278c1489d812a8ca +size 3963731 diff --git a/CoreNLP/stanford-postagger-full-2020-11-17/models/chinese-nodistsim.tagger.props b/CoreNLP/stanford-postagger-full-2020-11-17/models/chinese-nodistsim.tagger.props new file mode 100644 index 0000000000000000000000000000000000000000..74dcb351fa78bfe5d83b62ac8323d5dc626230c9 --- /dev/null +++ b/CoreNLP/stanford-postagger-full-2020-11-17/models/chinese-nodistsim.tagger.props @@ -0,0 +1,35 @@ +## tagger training invoked at Fri Feb 14 02:20:03 PST 2014 with arguments: + model = chinese-nodistsim.tagger + arch = generic,suffix(4),prefix(4),unicodeshapes(-1,1),unicodeshapeconjunction(-1,1),words(-2,-2),words(2,2) + wordFunction = edu.stanford.nlp.util.UTF8EquivalenceFunction + trainFile = format=TREES,/u/nlp/data/chinese/ctb7/train.mrg + closedClassTags = + closedClassTagThreshold = 40 + curWordMinFeatureThresh = 1 + debug = false + debugPrefix = + tagSeparator = # + encoding = utf-8 + iterations = 100 + lang = chinese + learnClosedClassTags = false + minFeatureThresh = 3 + openClassTags = +rareWordMinFeatureThresh = 3 + rareWordThresh = 20 + search = owlqn + sgml = false + sigmaSquared = 0.0 + regL1 = 0.75 + tagInside = + tokenize = false + tokenizerFactory = + tokenizerOptions = + verbose = false + verboseResults = true + veryCommonWordThresh = 250 + xmlInput = null + outputFile = + outputFormat = slashTags + outputFormatOptions = + nthreads = 1 diff --git a/CoreNLP/stanford-postagger-full-2020-11-17/models/english-bidirectional-distsim.tagger b/CoreNLP/stanford-postagger-full-2020-11-17/models/english-bidirectional-distsim.tagger new file mode 100644 index 0000000000000000000000000000000000000000..1db7715912de515c8c863f857df3b2825660b97c --- /dev/null +++ b/CoreNLP/stanford-postagger-full-2020-11-17/models/english-bidirectional-distsim.tagger @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a363a88c67b25e793a9382254485d897e95b0e166cc34af314ec3d53d79899b1 +size 20045086 diff --git a/CoreNLP/stanford-postagger-full-2020-11-17/models/english-bidirectional-distsim.tagger.props b/CoreNLP/stanford-postagger-full-2020-11-17/models/english-bidirectional-distsim.tagger.props new file mode 100644 index 0000000000000000000000000000000000000000..32cbe0b33e0d498872b4282c470ef47b1617b30b --- /dev/null +++ b/CoreNLP/stanford-postagger-full-2020-11-17/models/english-bidirectional-distsim.tagger.props @@ -0,0 +1,35 @@ +model = /u/nlp/data/pos-tagger/models-4.0.0/models/english-bidirectional-distsim-prod1.tagger +arch = bidirectional5words,allwordshapes(-1,1),distsim(/u/nlp/data/pos_tags_are_useless/egw4-reut.512.clusters,-1,1),distsimconjunction(/u/nlp/data/pos_tags_are_useless/egw4-reut.512.clusters,-1,1),rareExtractor(edu.stanford.nlp.tagger.maxent.ExtractorUCase),rareExtractor(edu.stanford.nlp.tagger.maxent.ExtractorCNumber),rareExtractor(edu.stanford.nlp.tagger.maxent.ExtractorDash),rareExtractor(edu.stanford.nlp.tagger.maxent.ExtractorLetterDigitDash),rareExtractor(edu.stanford.nlp.tagger.maxent.CompanyNameDetector),rareExtractor(edu.stanford.nlp.tagger.maxent.ExtractorAllCapitalized),rareExtractor(edu.stanford.nlp.tagger.maxent.ExtractorUpperDigitDash),rareExtractor(edu.stanford.nlp.tagger.maxent.ExtractorStartSentenceCap),rareExtractor(edu.stanford.nlp.tagger.maxent.ExtractorMidSentenceCapC),rareExtractor(edu.stanford.nlp.tagger.maxent.ExtractorMidSentenceCap),prefix(10),suffix(10),unicodeshapes(0),rareExtractor(edu.stanford.nlp.tagger.maxent.ExtractorNonAlphanumeric) +wordFunction = edu.stanford.nlp.process.AmericanizeFunction +trainFile = /u/nlp/data/pos-tagger/models-4.0.0/data/experiments/english-bidirectional-distsim-prod1/train/questionbank-train.txt;/u/nlp/data/pos-tagger/models-4.0.0/data/experiments/english-bidirectional-distsim-prod1/train/handparsed-train.txt;/u/nlp/data/pos-tagger/models-4.0.0/data/experiments/english-bidirectional-distsim-prod1/train/train-currency.txt;/u/nlp/data/pos-tagger/models-4.0.0/data/experiments/english-bidirectional-distsim-prod1/train/wsj-train.txt;/u/nlp/data/pos-tagger/models-4.0.0/data/experiments/english-bidirectional-distsim-prod1/train/ontonotes-train.txt;/u/nlp/data/pos-tagger/models-4.0.0/data/experiments/english-bidirectional-distsim-prod1/train/craft-train.txt;/u/nlp/data/pos-tagger/models-4.0.0/data/experiments/english-bidirectional-distsim-prod1/train/ewt-train.txt;/u/nlp/data/pos-tagger/models-4.0.0/data/experiments/english-bidirectional-distsim-prod1/train/train-tech-english.txt +closedClassTags = +closedClassTagThreshold = 40 +curWordMinFeatureThresh = 2 +debug = false +debugPrefix = +tagSeparator = _ +encoding = UTF-8 +iterations = 100 +lang = english +learnClosedClassTags = false +minFeatureThresh = 2 +openClassTags = +rareWordMinFeatureThresh = 5 +rareWordThresh = 5 +search = owlqn +sgml = false +sigmaSquared = 0.5 +regL1 = 0.75 +tagInside = +tokenize = true +tokenizerFactory = +tokenizerOptions = +verbose = false +verboseResults = true +veryCommonWordThresh = 250 +xmlInput = +outputFile = +outputFormat = slashTags +outputFormatOptions = +nthreads = 1 +minWordsLockTags = 1 diff --git a/CoreNLP/stanford-postagger-full-2020-11-17/models/english-caseless-left3words-distsim.tagger b/CoreNLP/stanford-postagger-full-2020-11-17/models/english-caseless-left3words-distsim.tagger new file mode 100644 index 0000000000000000000000000000000000000000..c3e67b2873af9f18cf783320bac1aaf1184dc7ae --- /dev/null +++ b/CoreNLP/stanford-postagger-full-2020-11-17/models/english-caseless-left3words-distsim.tagger @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f57ba3bca617dc8732b7d1c66f16a0f147cccbc19315938c0e03a6d4569c0488 +size 13937235 diff --git a/CoreNLP/stanford-postagger-full-2020-11-17/models/english-caseless-left3words-distsim.tagger.props b/CoreNLP/stanford-postagger-full-2020-11-17/models/english-caseless-left3words-distsim.tagger.props new file mode 100644 index 0000000000000000000000000000000000000000..b40d5ed67cf6e2c37e6b0fa359d9bdf274dec0f9 --- /dev/null +++ b/CoreNLP/stanford-postagger-full-2020-11-17/models/english-caseless-left3words-distsim.tagger.props @@ -0,0 +1,36 @@ +## tagger training invoked at Sat Feb 08 23:44:06 PST 2020 with arguments: + model = /u/nlp/data/pos-tagger/models-4.0.0/models/english-caseless-left3words-distsim-prod2.tagger + arch = left3words,wordshapes(-1,1),distsim(/u/nlp/data/pos_tags_are_useless/egw4-reut.512.clusters,-1,1),distsimconjunction(/u/nlp/data/pos_tags_are_useless/egw4-reut.512.clusters,-1,1),rareExtractor(edu.stanford.nlp.tagger.maxent.ExtractorCNumber),rareExtractor(edu.stanford.nlp.tagger.maxent.ExtractorDash),rareExtractor(edu.stanford.nlp.tagger.maxent.ExtractorLetterDigitDash),rareExtractor(edu.stanford.nlp.tagger.maxent.CaselessCompanyNameDetector),prefix(10),suffix(10),unicodeshapes(0),rareExtractor(edu.stanford.nlp.tagger.maxent.ExtractorNonAlphanumeric) + wordFunction = edu.stanford.nlp.process.LowercaseAndAmericanizeFunction + trainFile = /u/nlp/data/pos-tagger/models-4.0.0/data/experiments/english-caseless-left3words-distsim-prod2/train/ewt-train.txt;/u/nlp/data/pos-tagger/models-4.0.0/data/experiments/english-caseless-left3words-distsim-prod2/train/train-currency.txt;/u/nlp/data/pos-tagger/models-4.0.0/data/experiments/english-caseless-left3words-distsim-prod2/train/questionbank-train.txt;/u/nlp/data/pos-tagger/models-4.0.0/data/experiments/english-caseless-left3words-distsim-prod2/train/craft-train.txt;/u/nlp/data/pos-tagger/models-4.0.0/data/experiments/english-caseless-left3words-distsim-prod2/train/wsj-train.txt;/u/nlp/data/pos-tagger/models-4.0.0/data/experiments/english-caseless-left3words-distsim-prod2/train/train-tech-english.txt;/u/nlp/data/pos-tagger/models-4.0.0/data/experiments/english-caseless-left3words-distsim-prod2/train/ontonotes-train.txt;/u/nlp/data/pos-tagger/models-4.0.0/data/experiments/english-caseless-left3words-distsim-prod2/train/handparsed-train.txt + closedClassTags = + closedClassTagThreshold = 40 + curWordMinFeatureThresh = 2 + debug = false + debugPrefix = + tagSeparator = _ + encoding = UTF-8 + iterations = 100 + lang = english + learnClosedClassTags = false + minFeatureThresh = 2 + openClassTags = +rareWordMinFeatureThresh = 5 + rareWordThresh = 5 + search = owlqn + sgml = false + sigmaSquared = 0.0 + regL1 = 0.75 + tagInside = + tokenize = true + tokenizerFactory = + tokenizerOptions = + verbose = false + verboseResults = true + veryCommonWordThresh = 250 + xmlInput = + outputFile = + outputFormat = slashTags + outputFormatOptions = + nthreads = 1 + minWordsLockTags = 1 diff --git a/CoreNLP/stanford-postagger-full-2020-11-17/models/english-left3words-distsim.tagger b/CoreNLP/stanford-postagger-full-2020-11-17/models/english-left3words-distsim.tagger new file mode 100644 index 0000000000000000000000000000000000000000..4b61d6c82ee81e24281b7976e28f734b3542e71f --- /dev/null +++ b/CoreNLP/stanford-postagger-full-2020-11-17/models/english-left3words-distsim.tagger @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ebb5f7454da95775ecdb3ee20d3c58488cd87aa9999585951645f949e962089f +size 15198877 diff --git a/CoreNLP/stanford-postagger-full-2020-11-17/models/english-left3words-distsim.tagger.props b/CoreNLP/stanford-postagger-full-2020-11-17/models/english-left3words-distsim.tagger.props new file mode 100644 index 0000000000000000000000000000000000000000..dde3b1e01be6a8a8516aea045abb30c22b1a5175 --- /dev/null +++ b/CoreNLP/stanford-postagger-full-2020-11-17/models/english-left3words-distsim.tagger.props @@ -0,0 +1,35 @@ +model = /u/nlp/data/pos-tagger/models-4.0.0/models/english-left3words-distsim-prod1.tagger +arch = left3words,wordshapes(-1,1),distsim(/u/nlp/data/pos_tags_are_useless/egw4-reut.512.clusters,-1,1),distsimconjunction(/u/nlp/data/pos_tags_are_useless/egw4-reut.512.clusters,-1,1),rareExtractor(edu.stanford.nlp.tagger.maxent.ExtractorUCase),rareExtractor(edu.stanford.nlp.tagger.maxent.ExtractorCNumber),rareExtractor(edu.stanford.nlp.tagger.maxent.ExtractorDash),rareExtractor(edu.stanford.nlp.tagger.maxent.ExtractorLetterDigitDash),rareExtractor(edu.stanford.nlp.tagger.maxent.CompanyNameDetector),rareExtractor(edu.stanford.nlp.tagger.maxent.ExtractorAllCapitalized),rareExtractor(edu.stanford.nlp.tagger.maxent.ExtractorUpperDigitDash),rareExtractor(edu.stanford.nlp.tagger.maxent.ExtractorStartSentenceCap),rareExtractor(edu.stanford.nlp.tagger.maxent.ExtractorMidSentenceCapC),rareExtractor(edu.stanford.nlp.tagger.maxent.ExtractorMidSentenceCap),prefix(10),suffix(10),unicodeshapes(0),rareExtractor(edu.stanford.nlp.tagger.maxent.ExtractorNonAlphanumeric) +wordFunction = edu.stanford.nlp.process.AmericanizeFunction +trainFile = /u/nlp/data/pos-tagger/models-4.0.0/data/experiments/english-left3words-distsim-prod1/train/craft-train.txt;/u/nlp/data/pos-tagger/models-4.0.0/data/experiments/english-left3words-distsim-prod1/train/ewt-train.txt;/u/nlp/data/pos-tagger/models-4.0.0/data/experiments/english-left3words-distsim-prod1/train/questionbank-train.txt;/u/nlp/data/pos-tagger/models-4.0.0/data/experiments/english-left3words-distsim-prod1/train/train-currency.txt;/u/nlp/data/pos-tagger/models-4.0.0/data/experiments/english-left3words-distsim-prod1/train/handparsed-train.txt;/u/nlp/data/pos-tagger/models-4.0.0/data/experiments/english-left3words-distsim-prod1/train/ontonotes-train.txt;/u/nlp/data/pos-tagger/models-4.0.0/data/experiments/english-left3words-distsim-prod1/train/wsj-train.txt;/u/nlp/data/pos-tagger/models-4.0.0/data/experiments/english-left3words-distsim-prod1/train/train-tech-english.txt +closedClassTags = +closedClassTagThreshold = 40 +curWordMinFeatureThresh = 2 +debug = false +debugPrefix = +tagSeparator = _ +encoding = UTF-8 +iterations = 100 +lang = english +learnClosedClassTags = false +minFeatureThresh = 2 +openClassTags = +rareWordMinFeatureThresh = 5 +rareWordThresh = 5 +search = owlqn +sgml = false +sigmaSquared = 0.5 +regL1 = 0.75 +tagInside = +tokenize = true +tokenizerFactory = +tokenizerOptions = +verbose = false +verboseResults = true +veryCommonWordThresh = 250 +xmlInput = +outputFile = +outputFormat = slashTags +outputFormatOptions = +nthreads = 1 +minWordsLockTags = 1 diff --git a/CoreNLP/stanford-postagger-full-2020-11-17/models/french-ud.tagger b/CoreNLP/stanford-postagger-full-2020-11-17/models/french-ud.tagger new file mode 100644 index 0000000000000000000000000000000000000000..21c7a643ced534afa0ea71d04692171d142bf662 --- /dev/null +++ b/CoreNLP/stanford-postagger-full-2020-11-17/models/french-ud.tagger @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b71ac1193d406f368d0525edc2ab295e7138c184c06a27f6363caa88429d4526 +size 1591008 diff --git a/CoreNLP/stanford-postagger-full-2020-11-17/models/french-ud.tagger.props b/CoreNLP/stanford-postagger-full-2020-11-17/models/french-ud.tagger.props new file mode 100644 index 0000000000000000000000000000000000000000..bd77247c19f30bdbbfaf5fec09b79760bc7a1dd7 --- /dev/null +++ b/CoreNLP/stanford-postagger-full-2020-11-17/models/french-ud.tagger.props @@ -0,0 +1,35 @@ +## tagger training invoked at Mon Jul 01 00:54:56 PDT 2019 with arguments: + model = french-ud.tagger + arch = left3words,naacl2003unknowns,unicodeshapes(-1,1) + wordFunction = + trainFile = format=TSV,wordColumn=1,tagColumn=3,/u/nlp/data/depparser/nn/models-4.0.0/data/clean/fr_gsd-ud-train.conllu.clean + closedClassTags = + closedClassTagThreshold = 40 + curWordMinFeatureThresh = 2 + debug = false + debugPrefix = + tagSeparator = _ + encoding = utf-8 + iterations = 100 + lang = french + learnClosedClassTags = false + minFeatureThresh = 2 + openClassTags = +rareWordMinFeatureThresh = 10 + rareWordThresh = 5 + search = owlqn2 + sgml = false + sigmaSquared = 0.0 + regL1 = 0.75 + tagInside = + tokenize = true + tokenizerFactory = + tokenizerOptions = asciiQuotes + verbose = false + verboseResults = true + veryCommonWordThresh = 250 + xmlInput = null + outputFile = + outputFormat = slashTags + outputFormatOptions = + nthreads = 1 diff --git a/CoreNLP/stanford-postagger-full-2020-11-17/models/german-ud.tagger b/CoreNLP/stanford-postagger-full-2020-11-17/models/german-ud.tagger new file mode 100644 index 0000000000000000000000000000000000000000..f04bdb37babfb1e13073422c193025dc464882bb --- /dev/null +++ b/CoreNLP/stanford-postagger-full-2020-11-17/models/german-ud.tagger @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1537adaf468f4005882207c88fb3a7eda93d82764b24d1de7900776131fc8878 +size 71524450 diff --git a/CoreNLP/stanford-postagger-full-2020-11-17/models/german-ud.tagger.props b/CoreNLP/stanford-postagger-full-2020-11-17/models/german-ud.tagger.props new file mode 100644 index 0000000000000000000000000000000000000000..46a025b570d114274b5cd521c1042982e01cf093 --- /dev/null +++ b/CoreNLP/stanford-postagger-full-2020-11-17/models/german-ud.tagger.props @@ -0,0 +1,35 @@ +## tagger training invoked at Mon Jul 01 01:05:00 PDT 2019 with arguments: + model = german-ud.tagger + arch = left3words,naacl2003unknowns,unicodeshapes(-2,2),distsim(/u/nlp/data/german/ner/hgc_175m_600,-1,1),distsimconjunction(/u/nlp/data/german/ner/hgc_175m_600,-1,1),unicodeshapeconjunction(-1,1) + wordFunction = + trainFile = format=TSV,wordColumn=1,tagColumn=3,/u/nlp/data/depparser/nn/models-4.0.0/data/clean/de_gsd-ud-train.conllu.clean + closedClassTags = + closedClassTagThreshold = 40 + curWordMinFeatureThresh = 2 + debug = false + debugPrefix = + tagSeparator = _ + encoding = utf-8 + iterations = 100 + lang = german + learnClosedClassTags = false + minFeatureThresh = 2 + openClassTags = +rareWordMinFeatureThresh = 10 + rareWordThresh = 5 + search = owlqn2 + sgml = false + sigmaSquared = 0.0 + regL1 = 0.625 + tagInside = + tokenize = true + tokenizerFactory = + tokenizerOptions = asciiQuotes + verbose = false + verboseResults = true + veryCommonWordThresh = 250 + xmlInput = null + outputFile = + outputFormat = slashTags + outputFormatOptions = + nthreads = 1 diff --git a/CoreNLP/stanford-postagger-full-2020-11-17/models/spanish-ud.tagger b/CoreNLP/stanford-postagger-full-2020-11-17/models/spanish-ud.tagger new file mode 100644 index 0000000000000000000000000000000000000000..12284f09c503172e03ad3cb4f4fa9b4697965a29 --- /dev/null +++ b/CoreNLP/stanford-postagger-full-2020-11-17/models/spanish-ud.tagger @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5dba9b09f6cb0e0f58ee0d694ad5c920dec3a08c89c952c64fa52b67011e7e5d +size 9443457 diff --git a/CoreNLP/stanford-postagger-full-2020-11-17/models/spanish-ud.tagger.props b/CoreNLP/stanford-postagger-full-2020-11-17/models/spanish-ud.tagger.props new file mode 100644 index 0000000000000000000000000000000000000000..258fdef0cefd8d99af1616109f9288d4755a7410 --- /dev/null +++ b/CoreNLP/stanford-postagger-full-2020-11-17/models/spanish-ud.tagger.props @@ -0,0 +1,35 @@ +## tagger training invoked at Mon Jul 01 01:04:01 PDT 2019 with arguments: + model = spanish-ud.tagger + arch = left3words,naacl2003unknowns,allwordshapes(-1,1),distsim(/u/nlp/data/spanish/distsim/spanish.spence512.cls,-1,1),distsimconjunction(/u/nlp/data/spanish/distsim/spanish.spence512.cls,-1,1) + wordFunction = + trainFile = format=TSV,wordColumn=1,tagColumn=4,/u/nlp/data/depparser/nn/models-4.0.0/data/clean/es_ancora-ud-train.conllu.clean + closedClassTags = + closedClassTagThreshold = 40 + curWordMinFeatureThresh = 2 + debug = false + debugPrefix = + tagSeparator = _ + encoding = utf-8 + iterations = 100 + lang = spanish + learnClosedClassTags = false + minFeatureThresh = 2 + openClassTags = +rareWordMinFeatureThresh = 10 + rareWordThresh = 5 + search = owlqn2 + sgml = false + sigmaSquared = 0.0 + regL1 = 0.75 + tagInside = + tokenize = true + tokenizerFactory = + tokenizerOptions = asciiQuotes + verbose = false + verboseResults = true + veryCommonWordThresh = 250 + xmlInput = null + outputFile = + outputFormat = slashTags + outputFormatOptions = + nthreads = 16 diff --git a/CoreNLP/stanford-postagger-full-2020-11-17/sample-input.txt b/CoreNLP/stanford-postagger-full-2020-11-17/sample-input.txt new file mode 100644 index 0000000000000000000000000000000000000000..8faea4655726edad8ebcc1eb77520c118e18d092 --- /dev/null +++ b/CoreNLP/stanford-postagger-full-2020-11-17/sample-input.txt @@ -0,0 +1,6 @@ +A passenger plane has crashed shortly after take-off from Kyrgyzstan's +capital, Bishkek, killing a large number of those on board. The head of +Kyrgyzstan's civil aviation authority said that out of about 90 +passengers and crew, only about 20 people have survived. The Itek Air +Boeing 737 took off bound for Mashhad, in north-eastern Iran, but turned +round some 10 minutes later. diff --git a/CoreNLP/stanford-postagger-full-2020-11-17/sample-output.txt b/CoreNLP/stanford-postagger-full-2020-11-17/sample-output.txt new file mode 100644 index 0000000000000000000000000000000000000000..a1a32753982218c46c130935d00f631e211002d7 --- /dev/null +++ b/CoreNLP/stanford-postagger-full-2020-11-17/sample-output.txt @@ -0,0 +1,3 @@ +A_DT passenger_NN plane_NN has_VBZ crashed_VBN shortly_RB after_IN take-off_NN from_IN Kyrgyzstan_NNP 's_POS capital_NN ,_, Bishkek_NNP ,_, killing_VBG a_DT large_JJ number_NN of_IN those_DT on_IN board_NN ._. +The_DT head_NN of_IN Kyrgyzstan_NNP 's_POS civil_JJ aviation_NN authority_NN said_VBD that_IN out_IN of_IN about_IN 90_CD passengers_NNS and_CC crew_NN ,_, only_RB about_IN 20_CD people_NNS have_VBP survived_VBN ._. +The_DT Itek_NNP Air_NNP Boeing_NNP 737_CD took_VBD off_RP bound_VBN for_IN Mashhad_NNP ,_, in_IN north-eastern_JJ Iran_NNP ,_, but_CC turned_VBD round_NN some_DT 10_CD minutes_NNS later_RB ._. diff --git a/CoreNLP/stanford-postagger-full-2020-11-17/stanford-postagger-4.2.0-javadoc.jar b/CoreNLP/stanford-postagger-full-2020-11-17/stanford-postagger-4.2.0-javadoc.jar new file mode 100644 index 0000000000000000000000000000000000000000..dfff5b761f0fb18a4980542080924a70ea73971f --- /dev/null +++ b/CoreNLP/stanford-postagger-full-2020-11-17/stanford-postagger-4.2.0-javadoc.jar @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:197a84a195a7fbdef461144b07f8b7475b7145f3643a45f5ead295367fe6d323 +size 4429314 diff --git a/CoreNLP/stanford-postagger-full-2020-11-17/stanford-postagger-4.2.0-sources.jar b/CoreNLP/stanford-postagger-full-2020-11-17/stanford-postagger-4.2.0-sources.jar new file mode 100644 index 0000000000000000000000000000000000000000..ce2d84ae44790c0eee86a5abb30f209288ac5e4f --- /dev/null +++ b/CoreNLP/stanford-postagger-full-2020-11-17/stanford-postagger-4.2.0-sources.jar @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6e7f56b55bd3ec2a5236c7a57b28923bce6a2d72d9faa5ab6fa98309ff5f25e4 +size 2919886 diff --git a/CoreNLP/stanford-postagger-full-2020-11-17/stanford-postagger-4.2.0.jar b/CoreNLP/stanford-postagger-full-2020-11-17/stanford-postagger-4.2.0.jar new file mode 100644 index 0000000000000000000000000000000000000000..638f4ec7d8c5442219d63bb636e457a1b3a5ac54 --- /dev/null +++ b/CoreNLP/stanford-postagger-full-2020-11-17/stanford-postagger-4.2.0.jar @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f6090106c57da13d2ac8a1b2798dd7f437e07a9909a00f917e884bf6fa52fc8d +size 3650039 diff --git a/CoreNLP/stanford-postagger-full-2020-11-17/stanford-postagger-gui.bat b/CoreNLP/stanford-postagger-full-2020-11-17/stanford-postagger-gui.bat new file mode 100644 index 0000000000000000000000000000000000000000..7d2284972566af967da31c6912640eb32e055be2 --- /dev/null +++ b/CoreNLP/stanford-postagger-full-2020-11-17/stanford-postagger-gui.bat @@ -0,0 +1,3 @@ +:: runs the POS tagger (toy) GUI +:: usage stanford-postagger-gui +java -mx200m -cp "stanford-postagger.jar;" edu.stanford.nlp.tagger.maxent.MaxentTaggerGUI diff --git a/CoreNLP/stanford-postagger-full-2020-11-17/stanford-postagger-gui.sh b/CoreNLP/stanford-postagger-full-2020-11-17/stanford-postagger-gui.sh new file mode 100644 index 0000000000000000000000000000000000000000..4e43047645493e912bee53657777fec55a3efe0c --- /dev/null +++ b/CoreNLP/stanford-postagger-full-2020-11-17/stanford-postagger-gui.sh @@ -0,0 +1,2 @@ +#!/bin/sh +java -mx200m -cp 'stanford-postagger.jar:' edu.stanford.nlp.tagger.maxent.MaxentTaggerGUI diff --git a/CoreNLP/stanford-postagger-full-2020-11-17/stanford-postagger.bat b/CoreNLP/stanford-postagger-full-2020-11-17/stanford-postagger.bat new file mode 100644 index 0000000000000000000000000000000000000000..59205506e39203b45aa592d4f8a4c0cc8e2072a2 --- /dev/null +++ b/CoreNLP/stanford-postagger-full-2020-11-17/stanford-postagger.bat @@ -0,0 +1,4 @@ +:: usage: stanford-postagger model textFile +:: e.g., stanford-postagger models\english-left3words-distsim.tagger sample-input.txt + +java -mx300m -cp "stanford-postagger.jar;" edu.stanford.nlp.tagger.maxent.MaxentTagger -model %1 -textFile %2 diff --git a/CoreNLP/stanford-postagger-full-2020-11-17/stanford-postagger.jar b/CoreNLP/stanford-postagger-full-2020-11-17/stanford-postagger.jar new file mode 100644 index 0000000000000000000000000000000000000000..638f4ec7d8c5442219d63bb636e457a1b3a5ac54 --- /dev/null +++ b/CoreNLP/stanford-postagger-full-2020-11-17/stanford-postagger.jar @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f6090106c57da13d2ac8a1b2798dd7f437e07a9909a00f917e884bf6fa52fc8d +size 3650039 diff --git a/CoreNLP/stanford-postagger-full-2020-11-17/stanford-postagger.sh b/CoreNLP/stanford-postagger-full-2020-11-17/stanford-postagger.sh new file mode 100644 index 0000000000000000000000000000000000000000..87e8a63b2f155b0dcc7ff7179eb48496eeb01b10 --- /dev/null +++ b/CoreNLP/stanford-postagger-full-2020-11-17/stanford-postagger.sh @@ -0,0 +1,6 @@ +#!/bin/sh +# +# usage: ./stanford-postagger.sh model textFile +# e.g., ./stanford-postagger.sh models/english-left3words-distsim.tagger sample-input.txt + +java -mx300m -cp 'stanford-postagger.jar:' edu.stanford.nlp.tagger.maxent.MaxentTagger -model $1 -textFile $2 diff --git a/UDPipe/v1/CorpusExplorer/udpipe_addon/CorpusExplorer.Sdk.Extern.UdPipe.dll b/UDPipe/v1/CorpusExplorer/udpipe_addon/CorpusExplorer.Sdk.Extern.UdPipe.dll new file mode 100644 index 0000000000000000000000000000000000000000..ffada5b70205a837415d1c4550ca03aa46a81400 Binary files /dev/null and b/UDPipe/v1/CorpusExplorer/udpipe_addon/CorpusExplorer.Sdk.Extern.UdPipe.dll differ diff --git a/UDPipe/v1/CorpusExplorer/udpipe_addon/CorpusExplorer.Sdk.Extern.UdPipe.dll.config b/UDPipe/v1/CorpusExplorer/udpipe_addon/CorpusExplorer.Sdk.Extern.UdPipe.dll.config new file mode 100644 index 0000000000000000000000000000000000000000..f4da6e43349d60d9132020f057822523f8b585ff --- /dev/null +++ b/UDPipe/v1/CorpusExplorer/udpipe_addon/CorpusExplorer.Sdk.Extern.UdPipe.dll.config @@ -0,0 +1,83 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/UDPipe/v1/XDependencies/UDPipe/AUTHORS b/UDPipe/v1/XDependencies/UDPipe/AUTHORS new file mode 100644 index 0000000000000000000000000000000000000000..64175b1315c451f837802cbcc88e73007fea064e --- /dev/null +++ b/UDPipe/v1/XDependencies/UDPipe/AUTHORS @@ -0,0 +1,2 @@ +Milan Straka +Jana Straková diff --git a/UDPipe/v1/XDependencies/UDPipe/CHANGES b/UDPipe/v1/XDependencies/UDPipe/CHANGES new file mode 100644 index 0000000000000000000000000000000000000000..2ec54027f3874c23f23fac0ebcd31ad4ac3a1964 --- /dev/null +++ b/UDPipe/v1/XDependencies/UDPipe/CHANGES @@ -0,0 +1,36 @@ +Version 1.2.0 [01 Aug 17] +------------------------- +- On-demand loading of models in REST server, with a pool + of least recently used models. +- Make GRU tokenizer dimension configurable (16, 24, 64 supported). +- Track paragraph boundaries even under normalized_spaces. +- Support experimental sentence segmentation using + jointly both the tokenizer and the parser. +- Add EPE output format. +- Make default model in REST server explicit. +- Support pre-filling according to URL params in the webapp. + + +Version 1.1.0 [29 Mar 17] +------------------------- +- Morphodita_parsito models (now version 3) require at least + UDPipe version 1.1.0. +- CoNLL-U v2 format is supported. Notably spaces in forms + and lemmas are now allowed, as are empty nodes. +- Support options for input_format and output_format instances. +- Preserve all spacing when tokenizing. +- Optionally generate document-level token ranges in the original text. +- Optionally respect given segmentation during tokenization. +- Tokenizer can be trained to allow spaces in tokens + (default if there are forms with spaces in the training data). +- Parser can be trained to return always one root per sentence (default). +- Improve input_format API to allow inter-block state (for correct + tracking of inter-sentence spaces and document-level offsets). +- Improve output_format API to support begin/end document marks + and to allow state in the output_format instance (to allow + numbering output sentences, for example). + + +Version 1.0.0 [27 May 16] +------------------------- +- Initial public release. diff --git a/UDPipe/v1/XDependencies/UDPipe/INSTALL b/UDPipe/v1/XDependencies/UDPipe/INSTALL new file mode 100644 index 0000000000000000000000000000000000000000..4dc70a2115f35f0eafa5b4a22a2fc0740a8d55d7 --- /dev/null +++ b/UDPipe/v1/XDependencies/UDPipe/INSTALL @@ -0,0 +1,122 @@ +UDPipe Installation +=================== + +UDPipe releases are available on GitHub (http://github.com/ufal/udpipe), either +as a pre-compiled binary package, or source code only. The binary package +contains Linux, Windows and OS X binaries, Java bindings binary, C# bindings +binary, and source code of UDPipe and all language bindings. While the binary +packages do not contain compiled Python or Perl bindings, packages for those +languages are available in standard package repositories, i.e. on PyPI and CPAN. + +To use UDPipe, a language model is needed. Here is a list of available language +models (http://ufal.mff.cuni.cz/udpipe#language_models). + +If you want to compile UDPipe manually, sources are available on on GitHub +(http://github.com/ufal/udpipe), both in the pre-compiled binary package +releases (http://github.com/ufal/udpipe/releases) and in the repository itself. + + +Requirements +============ + +- g++ 4.7 or newer, clang 3.2 or newer, Visual C++ 2015 or newer +- make +- SWIG 3.0.8 or newer for language bindings other than C++ + + +Compilation +=========== + +To compile UDPipe, run make in the src directory. + +Make targets and options: +- exe: compile the binaries (default) +- server: compile the REST server +- lib: compile the static library +- BITS=32 or BITS=64: compile for specified 32-bit or 64-bit architecture + instead of the default one +- MODE=release: create release build which statically links the C++ runtime and + uses LTO +- MODE=debug: create debug build +- MODE=profile: create profile build + + +Platforms +--------- + +Platform can be selected using one of the following options: +- PLATFORM=linux, PLATFORM=linux-gcc: gcc compiler on Linux operating system, + default on Linux +- PLATFORM=linux-clang: clang compiler on Linux, must be selected manually +- PLATFORM=osx, PLATFORM=osx-clang: clang compiler on OS X, default on OS X; + BITS=32+64 enables multiarch build +- PLATFORM=win, PLATFORM=win-gcc: gcc compiler on Windows (TDM-GCC is well + tested), default on Windows +- PLATFORM=win-vs: Visual C++ 2015 compiler on Windows, must be selected + manually; note that the cl.exe compiler must be already present in PATH and + corresponding BITS=32 or BITS=64 must be specified + +Either POSIX shell or Windows CMD can be used as shell, it is detected +automatically. + + +Further Details +--------------- + +UDPipe uses C++ BuilTem system (http://github.com/ufal/cpp_builtem), please +refer to its manual if interested in all supported options. + + +Other language bindings +======================= + + +C# +-- + +Binary C# bindings are available in UDPipe binary packages. + +To compile C# bindings manually, run make in the bindings/csharp directory, +optionally with the options described in UDPipe Installation. + + +Java +---- + +Binary Java bindings are available in UDPipe binary packages. + +To compile Java bindings manually, run make in the bindings/java directory, +optionally with the options described in UDPipe Installation. Java 6 and newer +is supported. + +The Java installation specified in the environment variable JAVA_HOME is used. +If the environment variable does not exist, the JAVA_HOME can be specified using + make JAVA_HOME=path_to_Java_installation + + +Perl +---- + +The Perl bindings are available as Ufal-UDPipe package on CPAN. + +To compile Perl bindings manually, run make in the bindings/perl directory, +optionally with the options described in UDPipe Installation. Perl 5.10 and +later is supported. + +Path to the include headers of the required Perl version must be specified in +the PERL_INCLUDE variable using + make PERL_INCLUDE=path_to_Perl_includes + + +Python +------ + +The Python bindings are available as ufal.udpipe package on PyPI. + +To compile Python bindings manually, run make in the bindings/python directory, +optionally with options described in UDPipe Installation. Both Python 2.6+ and +Python 3+ are supported. + +Path to the include headers of the required Python version must be specified in +the PYTHON_INCLUDE variable using + make PYTHON_INCLUDE=path_to_Python_includes diff --git a/UDPipe/v1/XDependencies/UDPipe/LICENSE b/UDPipe/v1/XDependencies/UDPipe/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..a612ad9813b006ce81d1ee438dd784da99a54007 --- /dev/null +++ b/UDPipe/v1/XDependencies/UDPipe/LICENSE @@ -0,0 +1,373 @@ +Mozilla Public License Version 2.0 +================================== + +1. Definitions +-------------- + +1.1. "Contributor" + means each individual or legal entity that creates, contributes to + the creation of, or owns Covered Software. + +1.2. "Contributor Version" + means the combination of the Contributions of others (if any) used + by a Contributor and that particular Contributor's Contribution. + +1.3. "Contribution" + means Covered Software of a particular Contributor. + +1.4. "Covered Software" + means Source Code Form to which the initial Contributor has attached + the notice in Exhibit A, the Executable Form of such Source Code + Form, and Modifications of such Source Code Form, in each case + including portions thereof. + +1.5. "Incompatible With Secondary Licenses" + means + + (a) that the initial Contributor has attached the notice described + in Exhibit B to the Covered Software; or + + (b) that the Covered Software was made available under the terms of + version 1.1 or earlier of the License, but not also under the + terms of a Secondary License. + +1.6. "Executable Form" + means any form of the work other than Source Code Form. + +1.7. "Larger Work" + means a work that combines Covered Software with other material, in + a separate file or files, that is not Covered Software. + +1.8. "License" + means this document. + +1.9. "Licensable" + means having the right to grant, to the maximum extent possible, + whether at the time of the initial grant or subsequently, any and + all of the rights conveyed by this License. + +1.10. "Modifications" + means any of the following: + + (a) any file in Source Code Form that results from an addition to, + deletion from, or modification of the contents of Covered + Software; or + + (b) any new file in Source Code Form that contains any Covered + Software. + +1.11. "Patent Claims" of a Contributor + means any patent claim(s), including without limitation, method, + process, and apparatus claims, in any patent Licensable by such + Contributor that would be infringed, but for the grant of the + License, by the making, using, selling, offering for sale, having + made, import, or transfer of either its Contributions or its + Contributor Version. + +1.12. "Secondary License" + means either the GNU General Public License, Version 2.0, the GNU + Lesser General Public License, Version 2.1, the GNU Affero General + Public License, Version 3.0, or any later versions of those + licenses. + +1.13. "Source Code Form" + means the form of the work preferred for making modifications. + +1.14. "You" (or "Your") + means an individual or a legal entity exercising rights under this + License. For legal entities, "You" includes any entity that + controls, is controlled by, or is under common control with You. For + purposes of this definition, "control" means (a) the power, direct + or indirect, to cause the direction or management of such entity, + whether by contract or otherwise, or (b) ownership of more than + fifty percent (50%) of the outstanding shares or beneficial + ownership of such entity. + +2. License Grants and Conditions +-------------------------------- + +2.1. Grants + +Each Contributor hereby grants You a world-wide, royalty-free, +non-exclusive license: + +(a) under intellectual property rights (other than patent or trademark) + Licensable by such Contributor to use, reproduce, make available, + modify, display, perform, distribute, and otherwise exploit its + Contributions, either on an unmodified basis, with Modifications, or + as part of a Larger Work; and + +(b) under Patent Claims of such Contributor to make, use, sell, offer + for sale, have made, import, and otherwise transfer either its + Contributions or its Contributor Version. + +2.2. Effective Date + +The licenses granted in Section 2.1 with respect to any Contribution +become effective for each Contribution on the date the Contributor first +distributes such Contribution. + +2.3. Limitations on Grant Scope + +The licenses granted in this Section 2 are the only rights granted under +this License. No additional rights or licenses will be implied from the +distribution or licensing of Covered Software under this License. +Notwithstanding Section 2.1(b) above, no patent license is granted by a +Contributor: + +(a) for any code that a Contributor has removed from Covered Software; + or + +(b) for infringements caused by: (i) Your and any other third party's + modifications of Covered Software, or (ii) the combination of its + Contributions with other software (except as part of its Contributor + Version); or + +(c) under Patent Claims infringed by Covered Software in the absence of + its Contributions. + +This License does not grant any rights in the trademarks, service marks, +or logos of any Contributor (except as may be necessary to comply with +the notice requirements in Section 3.4). + +2.4. Subsequent Licenses + +No Contributor makes additional grants as a result of Your choice to +distribute the Covered Software under a subsequent version of this +License (see Section 10.2) or under the terms of a Secondary License (if +permitted under the terms of Section 3.3). + +2.5. Representation + +Each Contributor represents that the Contributor believes its +Contributions are its original creation(s) or it has sufficient rights +to grant the rights to its Contributions conveyed by this License. + +2.6. Fair Use + +This License is not intended to limit any rights You have under +applicable copyright doctrines of fair use, fair dealing, or other +equivalents. + +2.7. Conditions + +Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted +in Section 2.1. + +3. Responsibilities +------------------- + +3.1. Distribution of Source Form + +All distribution of Covered Software in Source Code Form, including any +Modifications that You create or to which You contribute, must be under +the terms of this License. You must inform recipients that the Source +Code Form of the Covered Software is governed by the terms of this +License, and how they can obtain a copy of this License. You may not +attempt to alter or restrict the recipients' rights in the Source Code +Form. + +3.2. Distribution of Executable Form + +If You distribute Covered Software in Executable Form then: + +(a) such Covered Software must also be made available in Source Code + Form, as described in Section 3.1, and You must inform recipients of + the Executable Form how they can obtain a copy of such Source Code + Form by reasonable means in a timely manner, at a charge no more + than the cost of distribution to the recipient; and + +(b) You may distribute such Executable Form under the terms of this + License, or sublicense it under different terms, provided that the + license for the Executable Form does not attempt to limit or alter + the recipients' rights in the Source Code Form under this License. + +3.3. Distribution of a Larger Work + +You may create and distribute a Larger Work under terms of Your choice, +provided that You also comply with the requirements of this License for +the Covered Software. If the Larger Work is a combination of Covered +Software with a work governed by one or more Secondary Licenses, and the +Covered Software is not Incompatible With Secondary Licenses, this +License permits You to additionally distribute such Covered Software +under the terms of such Secondary License(s), so that the recipient of +the Larger Work may, at their option, further distribute the Covered +Software under the terms of either this License or such Secondary +License(s). + +3.4. Notices + +You may not remove or alter the substance of any license notices +(including copyright notices, patent notices, disclaimers of warranty, +or limitations of liability) contained within the Source Code Form of +the Covered Software, except that You may alter any license notices to +the extent required to remedy known factual inaccuracies. + +3.5. Application of Additional Terms + +You may choose to offer, and to charge a fee for, warranty, support, +indemnity or liability obligations to one or more recipients of Covered +Software. However, You may do so only on Your own behalf, and not on +behalf of any Contributor. You must make it absolutely clear that any +such warranty, support, indemnity, or liability obligation is offered by +You alone, and You hereby agree to indemnify every Contributor for any +liability incurred by such Contributor as a result of warranty, support, +indemnity or liability terms You offer. You may include additional +disclaimers of warranty and limitations of liability specific to any +jurisdiction. + +4. Inability to Comply Due to Statute or Regulation +--------------------------------------------------- + +If it is impossible for You to comply with any of the terms of this +License with respect to some or all of the Covered Software due to +statute, judicial order, or regulation then You must: (a) comply with +the terms of this License to the maximum extent possible; and (b) +describe the limitations and the code they affect. Such description must +be placed in a text file included with all distributions of the Covered +Software under this License. Except to the extent prohibited by statute +or regulation, such description must be sufficiently detailed for a +recipient of ordinary skill to be able to understand it. + +5. Termination +-------------- + +5.1. The rights granted under this License will terminate automatically +if You fail to comply with any of its terms. However, if You become +compliant, then the rights granted under this License from a particular +Contributor are reinstated (a) provisionally, unless and until such +Contributor explicitly and finally terminates Your grants, and (b) on an +ongoing basis, if such Contributor fails to notify You of the +non-compliance by some reasonable means prior to 60 days after You have +come back into compliance. Moreover, Your grants from a particular +Contributor are reinstated on an ongoing basis if such Contributor +notifies You of the non-compliance by some reasonable means, this is the +first time You have received notice of non-compliance with this License +from such Contributor, and You become compliant prior to 30 days after +Your receipt of the notice. + +5.2. If You initiate litigation against any entity by asserting a patent +infringement claim (excluding declaratory judgment actions, +counter-claims, and cross-claims) alleging that a Contributor Version +directly or indirectly infringes any patent, then the rights granted to +You by any and all Contributors for the Covered Software under Section +2.1 of this License shall terminate. + +5.3. In the event of termination under Sections 5.1 or 5.2 above, all +end user license agreements (excluding distributors and resellers) which +have been validly granted by You or Your distributors under this License +prior to termination shall survive termination. + +************************************************************************ +* * +* 6. Disclaimer of Warranty * +* ------------------------- * +* * +* Covered Software is provided under this License on an "as is" * +* basis, without warranty of any kind, either expressed, implied, or * +* statutory, including, without limitation, warranties that the * +* Covered Software is free of defects, merchantable, fit for a * +* particular purpose or non-infringing. The entire risk as to the * +* quality and performance of the Covered Software is with You. * +* Should any Covered Software prove defective in any respect, You * +* (not any Contributor) assume the cost of any necessary servicing, * +* repair, or correction. This disclaimer of warranty constitutes an * +* essential part of this License. No use of any Covered Software is * +* authorized under this License except under this disclaimer. * +* * +************************************************************************ + +************************************************************************ +* * +* 7. Limitation of Liability * +* -------------------------- * +* * +* Under no circumstances and under no legal theory, whether tort * +* (including negligence), contract, or otherwise, shall any * +* Contributor, or anyone who distributes Covered Software as * +* permitted above, be liable to You for any direct, indirect, * +* special, incidental, or consequential damages of any character * +* including, without limitation, damages for lost profits, loss of * +* goodwill, work stoppage, computer failure or malfunction, or any * +* and all other commercial damages or losses, even if such party * +* shall have been informed of the possibility of such damages. This * +* limitation of liability shall not apply to liability for death or * +* personal injury resulting from such party's negligence to the * +* extent applicable law prohibits such limitation. Some * +* jurisdictions do not allow the exclusion or limitation of * +* incidental or consequential damages, so this exclusion and * +* limitation may not apply to You. * +* * +************************************************************************ + +8. Litigation +------------- + +Any litigation relating to this License may be brought only in the +courts of a jurisdiction where the defendant maintains its principal +place of business and such litigation shall be governed by laws of that +jurisdiction, without reference to its conflict-of-law provisions. +Nothing in this Section shall prevent a party's ability to bring +cross-claims or counter-claims. + +9. Miscellaneous +---------------- + +This License represents the complete agreement concerning the subject +matter hereof. If any provision of this License is held to be +unenforceable, such provision shall be reformed only to the extent +necessary to make it enforceable. Any law or regulation which provides +that the language of a contract shall be construed against the drafter +shall not be used to construe this License against a Contributor. + +10. Versions of the License +--------------------------- + +10.1. New Versions + +Mozilla Foundation is the license steward. Except as provided in Section +10.3, no one other than the license steward has the right to modify or +publish new versions of this License. Each version will be given a +distinguishing version number. + +10.2. Effect of New Versions + +You may distribute the Covered Software under the terms of the version +of the License under which You originally received the Covered Software, +or under the terms of any subsequent version published by the license +steward. + +10.3. Modified Versions + +If you create software not governed by this License, and you want to +create a new license for such software, you may create and use a +modified version of this License if you rename the license and remove +any references to the name of the license steward (except to note that +such modified license differs from this License). + +10.4. Distributing Source Code Form that is Incompatible With Secondary +Licenses + +If You choose to distribute Source Code Form that is Incompatible With +Secondary Licenses under the terms of this version of the License, the +notice described in Exhibit B of this License must be attached. + +Exhibit A - Source Code Form License Notice +------------------------------------------- + + This Source Code Form is subject to the terms of the Mozilla Public + License, v. 2.0. If a copy of the MPL was not distributed with this + file, You can obtain one at http://mozilla.org/MPL/2.0/. + +If it is not possible or desirable to put the notice in a particular +file, then You may include the notice in a location (such as a LICENSE +file in a relevant directory) where a recipient would be likely to look +for such a notice. + +You may add additional accurate notices of copyright ownership. + +Exhibit B - "Incompatible With Secondary Licenses" Notice +--------------------------------------------------------- + + This Source Code Form is "Incompatible With Secondary Licenses", as + defined by the Mozilla Public License, v. 2.0. diff --git a/UDPipe/v1/XDependencies/UDPipe/MANUAL b/UDPipe/v1/XDependencies/UDPipe/MANUAL new file mode 100644 index 0000000000000000000000000000000000000000..24b5cd8206054032b00c2b93981942a99619b10c --- /dev/null +++ b/UDPipe/v1/XDependencies/UDPipe/MANUAL @@ -0,0 +1,2638 @@ +UDPipe +Version 1.2.0 + +Introduction +============ + +UDPipe is a trainable pipeline for tokenization, tagging, lemmatization and +dependency parsing of CoNLL-U files. UDPipe is language-agnostic and can be +trained given annotated data in CoNLL-U format +(http://universaldependencies.org/format.html). Trained models are provided for +nearly all UD treebanks (http://universaldependencies.org). UDPipe is available +as a binary for Linux/Windows/OS X, as a library for C++, Python, Perl, Java, +C#, and as a web service. + +UDPipe is a free software distributed under the Mozilla Public License 2.0 +(http://www.mozilla.org/MPL/2.0/) and the linguistic models are free for +non-commercial use and distributed under the CC BY-NC-SA +(http://creativecommons.org/licenses/by-nc-sa/4.0/) license, although for some +models the original data used to create the model may impose additional +licensing conditions. UDPipe is versioned using Semantic Versioning +(http://semver.org/). + +Copyright 2017 by Institute of Formal and Applied Linguistics, Faculty of +Mathematics and Physics, Charles University, Czech Republic. + + +Online Web Application and Web Service +====================================== + +UDPipe Web Application is available at +http://lindat.mff.cuni.cz/services/udpipe/ using LINDAT/CLARIN infrastructure +(http://lindat.cz). + +UDPipe REST Web Service is also available, with the API documentation available +at http://lindat.mff.cuni.cz/services/udpipe/api-reference.php. + + +Release +======= + + +Download +-------- + +UDPipe releases are available on GitHub (http://github.com/ufal/udpipe), both as +source code and as a pre-compiled binary package. The binary package contains +Linux, Windows and OS X binaries, Java bindings binary, C# bindings binary, and +source code of UDPipe and all language bindings). While the binary packages do +not contain compiled Python or Perl bindings, packages for those languages are +available in standard package repositories, i.e. on PyPI +(https://pypi.python.org/pypi/ufal.udpipe/) and CPAN +(https://metacpan.org/pod/Ufal::UDPipe). + +- Latest release (http://github.com/ufal/udpipe/releases/latest) +- All releases (http://github.com/ufal/udpipe/releases), Changelog + (https://github.com/ufal/udpipe/blob/master/CHANGES) + + +Language Models +--------------- + +To use UDPipe, a language model is needed. The language models are available +from LINDAT/CLARIN (http://www.lindat.cz) infrastructure and described further +in the UDPipe User's Manual. Currently, the following language models are +available: + +- Universal Dependencies 2.0 Models: udpipe-ud2.0-170801 + (http://hdl.handle.net/11234/1-2364) (documentation + (http://ufal.mff.cuni.cz/udpipe/users-manual#universal_dependencies_20_models)) + +- CoNLL17 Shared Task Baseline UD 2.0 Models: udpipe-ud2.0-conll17-170315 + (http://hdl.handle.net/11234/1-1990) (documentation + (http://ufal.mff.cuni.cz/udpipe/users-manual#conll17_shared_task_baseline_ud_20_models)) + +- Universal Dependencies 1.2 Models: udpipe-ud1.2-160523 + (http://hdl.handle.net/11234/1-1659) (documentation + (http://ufal.mff.cuni.cz/udpipe/users-manual#universal_dependencies_12_models)) + + + +License +------- + +UDPipe is an open-source project and is freely available for non-commercial +purposes. The library is distributed under Mozilla Public License 2.0 +(http://www.mozilla.org/MPL/2.0/) and the associated models and data under CC +BY-NC-SA (http://creativecommons.org/licenses/by-nc-sa/4.0/), although for some +models the original data used to create the model may impose additional +licensing conditions. + +If you use this tool for scientific work, please give credit to us by +referencing Straka et al. 2016 and the UDPipe website +(http://ufal.mff.cuni.cz/udpipe). + + +UDPipe Installation +=================== + +UDPipe releases are available on GitHub (http://github.com/ufal/udpipe), either +as a pre-compiled binary package, or source code only. The binary package +contains Linux, Windows and OS X binaries, Java bindings binary, C# bindings +binary, and source code of UDPipe and all language bindings. While the binary +packages do not contain compiled Python or Perl bindings, packages for those +languages are available in standard package repositories, i.e. on PyPI and CPAN. + +To use UDPipe, a language model is needed. Here is a list of available language +models (http://ufal.mff.cuni.cz/udpipe#language_models). + +If you want to compile UDPipe manually, sources are available on on GitHub +(http://github.com/ufal/udpipe), both in the pre-compiled binary package +releases (http://github.com/ufal/udpipe/releases) and in the repository itself. + + +Requirements +------------ + +- g++ 4.7 or newer, clang 3.2 or newer, Visual C++ 2015 or newer +- make +- SWIG 3.0.8 or newer for language bindings other than C++ + + +Compilation +----------- + +To compile UDPipe, run make in the src directory. + +Make targets and options: +- exe: compile the binaries (default) +- server: compile the REST server +- lib: compile the static library +- BITS=32 or BITS=64: compile for specified 32-bit or 64-bit architecture + instead of the default one +- MODE=release: create release build which statically links the C++ runtime and + uses LTO +- MODE=debug: create debug build +- MODE=profile: create profile build + + +Platforms +--------- + +Platform can be selected using one of the following options: +- PLATFORM=linux, PLATFORM=linux-gcc: gcc compiler on Linux operating system, + default on Linux +- PLATFORM=linux-clang: clang compiler on Linux, must be selected manually +- PLATFORM=osx, PLATFORM=osx-clang: clang compiler on OS X, default on OS X; + BITS=32+64 enables multiarch build +- PLATFORM=win, PLATFORM=win-gcc: gcc compiler on Windows (TDM-GCC is well + tested), default on Windows +- PLATFORM=win-vs: Visual C++ 2015 compiler on Windows, must be selected + manually; note that the cl.exe compiler must be already present in PATH and + corresponding BITS=32 or BITS=64 must be specified + +Either POSIX shell or Windows CMD can be used as shell, it is detected +automatically. + + +Further Details +--------------- + +UDPipe uses C++ BuilTem system (http://github.com/ufal/cpp_builtem), please +refer to its manual if interested in all supported options. + + +Other language bindings +----------------------- + + +C# +-- + +Binary C# bindings are available in UDPipe binary packages. + +To compile C# bindings manually, run make in the bindings/csharp directory, +optionally with the options described in UDPipe Installation. + + +Java +---- + +Binary Java bindings are available in UDPipe binary packages. + +To compile Java bindings manually, run make in the bindings/java directory, +optionally with the options described in UDPipe Installation. Java 6 and newer +is supported. + +The Java installation specified in the environment variable JAVA_HOME is used. +If the environment variable does not exist, the JAVA_HOME can be specified using + make JAVA_HOME=path_to_Java_installation + + +Perl +---- + +The Perl bindings are available as Ufal-UDPipe package on CPAN. + +To compile Perl bindings manually, run make in the bindings/perl directory, +optionally with the options described in UDPipe Installation. Perl 5.10 and +later is supported. + +Path to the include headers of the required Perl version must be specified in +the PERL_INCLUDE variable using + make PERL_INCLUDE=path_to_Perl_includes + + +Python +------ + +The Python bindings are available as ufal.udpipe package on PyPI. + +To compile Python bindings manually, run make in the bindings/python directory, +optionally with options described in UDPipe Installation. Both Python 2.6+ and +Python 3+ are supported. + +Path to the include headers of the required Python version must be specified in +the PYTHON_INCLUDE variable using + make PYTHON_INCLUDE=path_to_Python_includes + + +UDPipe User's Manual +==================== + +Like any supervised machine-learning tool, UDPipe needs a trained linguistic +model. This section describes the available language models and also the command +line tools and interfaces. + + +Running UDPipe +-------------- + +Probably the most common usage of UDPipe is to tokenize, tag and parse the input +using + udpipe --tokenize --tag --parse udpipe_model + +The input is assumed to be in UTF-8 encoding and can be either already tokenized +and segmented, or it can be a plain text which will be tokenized and segmented +automatically. + +Any number of input files can be specified after the udpipe_model and if no file +is given, the standard input is used. The output is by default saved to the +standard output, but if --outfile=name is used, it is saved to the given file +name. The output file name can contain a {}, which is replaced by a base name of +the processed file (i.e., without directories and an extension). + +The full command syntax of running UDPipe is + Usage: udpipe [running_opts] udpipe_model [input_files] + udpipe --train [training_opts] udpipe_model [input_files] + udpipe --detokenize [detokenize_opts] raw_text_file [input_files] + Running opts: --accuracy (measure accuracy only) + --input=[conllu|generic_tokenizer|horizontal|vertical] + --immediate (process sentences immediately during loading) + --outfile=output file template + --output=[conllu|matxin|horizontal|plaintext|vertical] + --tokenize (perform tokenization) + --tokenizer=tokenizer options, implies --tokenize + --tag (perform tagging) + --tagger=tagger options, implies --tag + --parse (perform parsing) + --parser=parser options, implies --parse + Training opts: --method=[morphodita_parsito] which method to use + --heldout=heldout data file name + --tokenizer=tokenizer options + --tagger=tagger options + --parser=parser options + Detokenize opts: --outfile=output file template + Generic opts: --version + --help + + +Immediate Mode +-------------- + +By default UDPipe loads the whole input file into memory before starting to +process it. That allows to store the space markup (see the following Tokenizer +section) in most consistent way, i.e., store all spaces following a sentence in +the last token of that sentence. + +However, sometimes it is desirable to process the input as soon as possible, +which can be achieved by specifying the --immediate option. In immediate mode, +the input is processed and printed as soon as a block of input guaranteed to +contain whole sentences is loaded. Specifically, for most input formats the +input is processed after loading an empty line (with the exception of horizontal +input format and presegmented tokenizer, where the input is processed after each +line). + + +Loading Model On Demand +----------------------- + +Although a model for UDPipe always has to be specified, the model is loaded only +if really needed. It is therefore possible to use for example none as the model +in case it is not required for performing the requested operation (e.g., +converting between formats or using a generic tokenizer). + + +Tokenizer +--------- + +If the --tokenize option is supplied, the input is assumed to be plain text and +is tokenized using model tokenizer. Additional arguments to the tokenizer might +be specified using --tokenizer=data option (which implies --tokenize), where +data is a semicolon-separated list of the following options: +- normalized_spaces: by default, UDPipe uses custom MISC fields to exactly + encode spaces in the original document (as described below). If the + normalized_spaces option is given, only the standard CoNLL-U v2 markup + (SpaceAfter=No and # newpar) is used. +- presegmented: the input file is assumed to be already segmented, with each + sentence on a separate line, and is only tokenized (respecting sentence + breaks) +- ranges: for each token, a range in the original document is stored in the + format described below. +- joint_with_parsing: an experimental mode performing sentence segmentation + jointly using the tokenizer and the parser (see Milan Straka and Jana + Straková: Tokenizing, POS Tagging, Lemmatizing and Parsing UD 2.0 with UDPipe + (http://ufal.mff.cuni.cz/~straka/papers/2017-conll_udpipe.pdf) paper for + details). The following options are utilized: + - joint_max_sentence_len (default 20): maximum sentence length + - joint_change_boundary_logprob (default -0.5): logprob of using sentence + boundary not generated by the tokenizer + - joint_sentence_logprob (default -0.5): additional logprob of every sentence + The logprob of a sentence is computed using logprob of its best dependency + parsing tree, together with joint_sentence_logprob and also + joint_change_boundary_logprob for every sentence boundary not returned by the + tokenizer (i.e., either 0, 1 or 2 times). The joint sentence segmentation + chooses such a segmentation, where every sentence has length at most + joint_max_sentence_len and the sum of logprobs of all sentences is as large as + possible. + + +Preserving Original Spaces +-------------------------- + +By default, UDPipe uses custom MISC fields to store all spaces in the original +document. This markup is backward compatible with CoNLL-U v2 SpaceAfter=No +feature. This markup can be utilized by the plaintext output format, which +allows reconstructing the original document. + +Note that in theory not only spaces, but also other original content can be +saved in this way (for example XML tags if the input was encoded in a XML file). + +The markup uses the following MISC fields on tokens (not words in multi-word +tokens): +- SpacesBefore=content (by default empty): spaces/other content preceding the + token +- SpacesAfter=content (by default a space if SpaceAfter=No feature is not + present, empty otherwise): spaces/other content following the token +- SpacesInToken=content (by default equal to the FORM of the token): FORM of + the token including original spaces (this is needed only if tokens are allowed + to contain spaces and a token contains a tab or newline characters) + +The content of all the three fields must be escaped to allow storing tabs and +newlines. The following C-like schema is used: +- \s: space +- \t: tab +- \r: CR character +- \n: LF character +- \p: | (pipe character) +- \\: \ (backslash character) + + +Preserving Token Ranges +----------------------- + +When the ranges tokenizer option is used, the range of each token in the +original document is stored in the TokenRange MISC field. + +The format of the TokenRange field (inspired by Python) is TokenRange=start:end, +where start is a zero-based document-level index of the start of the token +(counted in Unicode characters) and end is a zero-based document-level index of +the first character following the token (i.e., the length of the token is +end-start). + + +Input Formats +------------- + +If the tokenizer is not used, the input format can be specified using the +--input option. The individual input formats can be parametrized in the same way +a tokenizer is, by using format=data syntax. Currently supported input formats +are: +- conllu (default): the CoNLL-U format + (http://universaldependencies.org/docs/format.html). Supported options: + - v2 (default): use CoNLL-U v2 + - v1: allow loading only CoNLL-U v1 (i.e., no empty nodes and no spaces in + forms and lemmas) +- generic_tokenizer: generic tokenizer for English-like languages (with spaces + separating tokens and English-like punctuation). The tokenizer is rule-based + and needs no trained model. It supports the same options as a model tokenizer, + i.e., normalized_spaces, presegmented and ranges. +- horizontal: each sentence on a separate line, with tokens separated by + spaces. In order to allow spaces in tokens, Unicode character 'NO-BREAK SPACE' + (U+00A0) is considered part of token and converted to a space during loading. +- vertical: each token on a separate line, with an empty line denoting end of + sentence; only the first tab-separated word is used as a token, the rest of + the line is ignored. + +Note that a model tokenizer can be specified using the --input option too, by +using the tokenizer input format, for example using --input tokenizer=ranges. + + +Tagger +------ + +If the --tag option is supplied, the input is POS tagged and lemmatized using +the model tagger. Additional arguments to the tagger might be specified using +the --tagger=data option (which implies --tag). + + +Dependency Parsing +------------------ + +If the --parse option is supplied, the input is parsed using the model +dependency parser. Additional arguments to the parser might be specified using +the --parser=data option (which implies --parse). + + +Output Formats +-------------- + +The output format is specified using the --output option. The individual output +formats can be parametrized in the same way as input formats, by using the +format=data syntax. Currently supported output formats are: +- conllu (default): the CoNLL-U format + (http://universaldependencies.org/docs/format.html) Supported options: + - v2 (default): use CoNLL-U v2 + - v1: produce output in CoNLL-U v1 format. Note that this is a lossy process, + as empty nodes are ignored and spaces in forms and lemmas are converted to + underscores. +- matxin: the Matxin format (http://wiki.apertium.org/wiki/Matxin) +- horizontal: writes the words (in the UD sense) in horizontal format, that is, + each sentence is on a separate line, with words separated by a single space. + Because words can contain spaces in CoNLL-U v2, the spaces in words are + converted to Unicode character 'NO-BREAK SPACE' (U+00A0). Supported options: + - paragraphs: an empty line is printed after the end of a paragraph or a + document (recognized by # newpar or # newdoc comments) +- plaintext: writes the tokens (in the UD sense) using original spacing. By + default, UDPipe's custom MISC features (SpacesBefore, SpacesAfter and + SpacesInToken, see the description in the Tokenizer section) are used to + reconstruct the exact original spaces. However, if the document does not + contain these features or if you want only normalized spacing, you can use the + following option: + - normalized_spaces: write one sentence on a line, and either one or no space + between tokens according to the SpaceAfter=No feature +- vertical: each word on a separate line, with an empty line denoting the end + of sentence. Supported options: + - paragraphs: an empty line is printed after the end of a paragraph or a + document (recognized by # newpar or # newdoc comments) + + +Running the UDPipe REST Server +------------------------------ + +UDPipe also provides a REST server binary called udpipe_server. The binary uses +MicroRestD (http://github.com/ufal/microrestd) as a REST server implementation +and provides UDPipe REST API +(http://lindat.mff.cuni.cz/services/udpipe/api-reference.php). + +The full command syntax of udpipe_server is + udpipe_server [options] port default_model (rest_id model_file acknowledgements)* + Options: --concurrent_models=maximum concurrently loaded models (default 10) + --daemon (daemonize after start) + --no_check_models_loadable (do not check models are loadable) + --no_preload_default (do not preload default model) + +The udpipe_server can run either in foreground or in background (when --daemon +is used). + +Since UDPipe 1.1.1, the models are loaded on demand, so that at most +concurrent_models (default 10) are kept in memory at the same time. The model +files are opened during start and never closed until the server stops. Unless +no_check_models_loadable is specified, the model files are also checked to be +loadable during start. Note that the default model is preloaded and never +released, unless no_preload_default is given. (Before UDPipe 1.1.1, specified +model files were loaded during start and kept in memory all the time.) + + +Training UDPipe Models +---------------------- + +Custom UDPipe models can be trained using the following syntax: + udpipe --train model.output [--heldout=heldout_data] training_file ... + +The training data should be in the CoNLL-U format +(http://universaldependencies.org/docs/format.html). + +By default, three model components are trained - tokenizer, tagger and parser. +Any subset of the model components can be trained and a model component may be +copied from an existing model. + +The training options are specified for each model component separately using the +--tokenizer, --tagger and --parser options. If a model component should not be +trained, value none should be used (e.g., --tagger=none). + +The options are name=value pairs separated by a semicolon. The value can be +either a simple string value (ending by a semicolon), file content specified as +name=file:filename, or an arbitrary string value specified as +name=data:length:value, where the value is exactly length bytes long. + + +Reusing Components from Existing Models +--------------------------------------- + +The model components (tagger, parser or tagger) can be reused from existing +models, by specifying the from_model=file:filename option. + + +Random Hyperparameter Search +---------------------------- + +The default values of hyperparameters are set to the values which were used the +most during UD 1.2 models training, but if you want to reach best performance, +the hyperparameters must be tuned. + +Apart from manual grid search, UDPipe can perform a simple random search. You +can perform the random search by repeatedly training UDPipe (preferably in +parallel, most likely on different computers) while specifying different +training run number - some of the hyperparameters (chosen by us; you can of +course override their value by specifying it on the command line) change their +values in different training runs. The pseudorandom sequences of hyperparameters +are of course deterministic. + +The training run can be specified by providing the run=number option to a model +component. The run number 1 is the default one (with the best hyperparameters +for the UD 1.2 models), run numbers 2 and more randomize the hyperparameters. + + +Tokenizer +--------- + +The tokenizer is trained using the SpaceAfter=No features in the CoNLL-U files. +If the feature is not present, a detokenizer can be used to guess the +SpaceAfter=No features according to a supplied plain text (which typically does +not overlap with the texts in the CoNLL-U files). + +In order to use the detokenizer, use the +detokenizer=file:filename_with_plaintext option. In UD 1.2 models, the optimal +performance is achieved with very small plain texts - only 500kB. + +The tokenizer recognizes the following options: +- tokenize_url (default 1): tokenize URLs and emails using a manually + implemented recognizer +- allow_spaces (default 1 if any token contains a space, 0 otherwise): allow + tokens to contain spaces +- dimension (default 24): dimension of character embeddings and of the + per-character bidirectional GRU. Note that inference time is quadratic in this + parameter. Supported values are only 16, 24 and 64, with 64 needed only for + languages with complicated tokenization like Japanese, Chinese or Vietnamese. +- epochs (default 100): the number of epochs to train the tokenizer for +- batch_size (default 50): batch size used during tokenizer training +- learning_rate (default 0.005): the learning rate used during tokenizer + training +- dropout (default 0.1): dropout used during tokenizer training +- early_stopping (default 1 if heldout is given, 0 otherwise): perform early + stopping, choosing training iteration maximizing sentences F1 score plus + tokens F1 score on heldout data + +During random hyperparameter search, batch_size is chosen uniformly from +{50,100} and learning_rate logarithmically from <0.0005, 0.01). + + +Detokenizing CoNLL-U Files +-------------------------- + +The --detokenizer option allows generating the SpaceAfter=No features +automatically from a given plain text. Even if the current algorithm is very +simple and makes quite a lot of mistakes, the tokenizer trained on generated +features is very close to a tokenizer trained on gold SpaceAfter=No features +(the difference in token F1 score is usually one or two tenths of percent). + +The generated SpaceAfter=No features are only used during tokenizer training, +not printed. However, if you would like to obtain the CoNLL-U files with +automatic detokenization (generated SpaceAfter=No features), you can run UDPipe +with the --detokenize option. In this case, you have to supply plain text in the +given language (usually the best results are achieved with just 500kB or 1MB of +text) and UDPipe then detokenizes all the given CoNLL-U files. + +The complete usage of the --detokenize option is: + udpipe --detokenize [detokenize_opts] raw_text_file [input_files] + Detokenize opts: --outfile=output file template + + +Tagger +------ + +The tagging is currently performed using MorphoDiTa +(http://ufal.mff.cuni.cz/morphodita). The UDPipe tagger consists of possibly +several MorphoDiTa models, each tagging some of the POS tags and/or lemmas. + +By default, only one model is constructed, which generates all available tags +(UPOS, XPOS, Feats and Lemma). However, we found out during the UD 1.2 models +training that performance improves if one model tags the UPOS, XPOS and Feats +tags, while the other is performing lemmatization. Therefore, if you utilize two +MorphoDiTa models, by default the first one generates all tags (except lemmas) +and the second one performs lemmatization. + +The number of MorphoDiTa models can be specified using the models=number +parameter. All other parameters may be either generic for all models +(guesser_suffix_rules=5), or specific for a given model +(guesser_suffix_rules_2=6), including the from_model option (therefore, +MorphoDiTa models can be trained separately and then combined together into one +UDPipe model). + +Every model utilizes UPOS for disambiguation and the first model is the one +producing the UPOS tags on output. + +The tagger recognizes the following options: +- use_lemma (default for the second model and also if there is only one model): + use the lemma field internally to perform disambiguation; the lemma may be not + outputted +- provide_lemma (default for the second model and also if there is only one + model): produce the disambiguated lemma on output +- use_xpostag (default for the first model): use the XPOS tags internally to + perform disambiguation; it may not be outputted +- provide_xpostag (default for the first model): produce the disambiguated XPOS + tag on output +- use_feats (default for the first model): use the Feats internally to perform + disambiguation; it may not be outputted +- provide_feats (default for the first model): produce the disambiguated Feats + field on output +- dictionary_max_form_analyses (default 0 - unlimited): the maximum number of + (most frequent) form analyses from UD training data that are to be kept in the + morphological dictionary +- dictionary_file (default empty): use a given custom morphological dictionary, + where each line contains 5 tab-separated fields FORM, LEMMA, UPOSTAG, XPOSTAG + and FEATS. Note that this dictionary data is appended to the dictionary + created from the UD training data, not replacing it. +- guesser_suffix_rules (default 8): number of rules generated for every suffix +- guesser_prefixes_max (default 4 if ``provide_lemma`, 0 otherwise): maximum + number of form-generating prefixes to use in the guesser +- guesser_prefix_min_count (default 10): minimum number of occurrences of + form-generating prefix to consider using it in the guesser +- guesser_enrich_dictionary (default 6 if no dictionary_file is passed, 0 + otherwise): number of rules generated for forms present in training data + (assuming that the analyses from the training data may not be all) +- iterations (default 20): number of training iterations to perform +- early_stopping (default 1 if heldout is given, 0 otherwise): perform early + stopping, choosing training iteration maximizing tagging accuracy on the + heldout data +- templates (default lemmatizer for second model, tagger otherwise): MorphoDiTa + feature templates to use, either lemmatizer which focuses more on lemmas, or + tagger which focuses more on UPOS/XPOS/FEATS + +During random hyperparameter search, guesser_suffix_rules is chosen uniformly +from {5,6,7,8,9,10,11,12} and guesser_enrich_dictionary is chosen uniformly from +{3,4,5,6,7,8,9,10}. + + +Parser +------ + +The parsing is performed using Parsito (http://ufal.mff.cuni.cz/parsito), which +is a transition-based parser using a neural-network classifier. + +The transition-based systems can be configured by the following options: +- transition_system (default projective): which transition system to use for + parsing (language dependent, you can choose according to language properties + or try all and choose the best one) + - projective: projective stack-based arc standard system with shift, left_arc + and right_arc transitions + - swap: fully non-projective system which extends projective system by adding + the swap transition + - link2: partially non-projective system which extends projective system by + adding left_arc2 and right_arc2 transitions +- transition_oracle (default dynamic/static_lazy_static whichever first is + applicable): which transition oracle to use for the chosen transition_system: + - transition_system=projective: available oracles are static and dynamic + (dynamic usually gives better results, but training time is slower) + - transition_system=swap: available oracles are static_eager and static_lazy + (static_lazy almost always gives better results) + - transition_system=link2: only available oracle is static +- structured_interval (default 8): use search-based oracle in addition to the + translation_oracle specified. This almost always gives better results, but + makes training 2-3 times slower. For details, see the paper Straka et al. + 2015: Parsing Universal Dependency Treebanks using Neural Networks and + Search-Based Oracle +- single_root (default 1): allow only single root when parsing, and make sure + only the root node has the root deprel (note that training data are checked to + be in this format) + +The Lemmas/UPOS/XPOS/FEATS used by the parser are configured by: +- use_gold_tags (default 0): if false and a tagger exists, the + Lemmas/UPOS/XPOS/FEATS for both the training and heldout data are generated by + the tagger, otherwise they are taken from the gold data + +The embeddings used by the parser can be specified as follows: +- embedding_upostag (default 20): the dimension of the UPos embedding used in + the parser +- embedding_feats (default 20): the dimension of the Feats embedding used in + the parser +- embedding_xpostag (default 0): the dimension of the XPos embedding used in + the parser +- embedding_form (default 50): the dimension of the Form embedding used in the + parser +- embedding_lemma (default 0): the dimension of the Lemma embedding used in the + parser +- embedding_deprel (default 20): the dimension of the Deprel embedding used in + the parser +- embedding_form_file: pre-trained word embeddings in word2vec textual format +- embedding_lemma_file: pre-trained lemma embeddings in word2vec textual format +- embedding_form_mincount (default 2): for forms not present in the pre-trained + embeddings, generate random embeddings if the form appears at least this + number of times in the trainig data (forms not present in the pre-trained + embeddings and appearing less number of times are considered OOV) +- embedding_lemma_mincount (default 2): for lemmas not present in the + pre-trained embeddings, generate random embeddings if the lemma appears at + least this number of times in the trainig data (lemmas not present in the + pre-trained embeddings and appearing less number of times are considered OOV) + +The neural-network training options: +- iterations (default 10): number of training iterations to use +- hidden_layer (default 200): the size of the hidden layer +- batch_size (default 10): batch size used during neural-network training +- learning_rate (default 0.02): the learning rate used during neural-network + training +- learning_rate_final (0.001): the final learning rate used during + neural-network training +- l2 (0.5): the L2 regularization used during neural-network training +- early_stopping (default 1 if heldout is given, 0 otherwise): perform early + stopping, choosing training iteration maximizing LAS on heldout data + +During random hyperparameter search, structured_interval is chosen uniformly +from {0,8,10}, learning_rate is chosen logarithmically from <0.005,0.04) and l2 +is chosen uniformly from <0.2,0.6). + + +Pre-trained Word Embeddings +--------------------------- + +The pre-trained word embeddings for forms and lemmas can be specified in the +word2vec textual format using the embedding_form_file and embedding_lemma_file +options. + +Note that pre-training word embeddings even on the UD data itself improves the +accuracy (we use word2vec with -cbow 0 -size 50 -window 10 -negative 5 -hs 0 +-sample 1e-1 -threads 12 -binary 0 -iter 15 -min-count 2 options to pre-train on +the UD data after converting it to the horizontal format using udpipe +--output=horizontal). + +Forms and lemmas can contain spaces in CoNLL-U v2, so these spaces are converted +to a Unicode character 'NO-BREAK SPACE' (U+00A0) before performing the embedding +lookup, because spaces are usually used to delimit tokens in word embedding +generating software (both word2vec and glove use spaces to separate words on +input and on output). When using UDPipe to generate plain texts from CoNLL-U +format using --output=horizontal, this space replacing happens automatically. + +When looking up an embedding for a given word, the following possibilities are +tried in the following order until a match is found (or an embedding for unknown +word is returned): +- original word +- all but the first character lowercased +- all characters lowercased +- if the word contains only digits, just the first digit is tried + + +Measuring Model Accuracy +------------------------ + +Measuring custom model accuracy can be performed by running: + udpipe --accuracy [udpipe_options] udpipe_model file ... + +The command syntax is similar to the regular UDPipe operation, only the input +must be always in the CoNLL-U format +(http://universaldependencies.org/docs/format.html) and the --input and --output +options are ignored. + +Three different settings (depending on --tokenize(r), --tag(ger) and --parse(r)) +can be evaluated: +- --tokenize(r) [--tag(ger) [--parse(r)]]: Tokenizer is used to segment and + tokenize plain text (obtained by SpaceAfter=No features and # newdoc and # + newpar comments in the input file). Optionally, a tagger is used on the + resulting data to obtain Lemma/UPOS/XPOS/Feats columns and eventually a parser + can be used to parse the results. + + The tokenizer is evaluated using F1-score on tokens, multi-word tokens, + sentences and words. The words are aligned using a word-alignment algorithm + described in the CoNLL 2017 Shared Task in UD Parsing + (http://universaldependencies.org/conll17). The tagger and parser are + evaluated on aligned words, resulting in F1 scores of + Lemmas/UPOS/XPOS/Feats/UAS/LAS. + +- --tag(ger) [--parse(r)]: The gold segmented and tokenized input is tagged + (and then optionally parsed using the tagger outputs) and then evaluated. + +- --parse(r): The gold segmented and tokenized input is parsed using gold + morphology (Lemmas/UPOS/XPOS/Feats) and evaluated. + + + +Universal Dependencies 2.0 Models +--------------------------------- + +Universal Dependencies 2.0 Models are distributed under the CC BY-NC-SA +(http://creativecommons.org/licenses/by-nc-sa/4.0/) licence. The models are +based solely on Universal Dependencies 2.0 (http://hdl.handle.net/11234/1-1983) +treebanks. The models work in UDPipe version 1.2 and later. + +Universal Dependencies 2.0 Models are versioned according to the date released +in the format YYMMDD, where YY, MM and DD are two-digit representation of year, +month and day, respectively. The latest version is 170801. + + +Download +-------- + +The latest version 170801 of the Universal Dependencies 2.0 models can be +downloaded from LINDAT/CLARIN repository (http://hdl.handle.net/11234/1-2364). + + +Acknowledgements +---------------- + +This work has been partially supported and has been using language resources and +tools developed, stored and distributed by the LINDAT/CLARIN project of the +Ministry of Education, Youth and Sports of the Czech Republic (project +LM2015071). The wark was also partially supported by OP VVV projects +CZ.02.1.01/0.0/0.0/16\_013/0001781 and CZ.02.2.69/0.0/0.0/16\_018/0002373, and +by SVV project number 260 453. + +The models were trained on Universal Dependencies 2.0 +(http://hdl.handle.net/11234/1-1983) treebanks. + +For the UD treebanks which do not contain original plain text version, raw text +is used to train the tokenizer instead. The plain texts were taken from the W2C +- Web to Corpus (http://hdl.handle.net/11858/00-097C-0000-0022-6133-9). + + +Publications +------------ + +- (Straka et al. 2017) Milan Straka and Jana Straková. Tokenizing, POS + Tagging, Lemmatizing and Parsing UD 2.0 with UDPipe + (http://ufal.mff.cuni.cz/~straka/papers/2017-conll_udpipe.pdf). In Proceedings + of the CoNLL 2017 Shared Task: Multilingual Parsing from Raw Text to Universal + Dependencies, Vancouver, Canada, August 2017. +- (Straka et al. 2016) Straka Milan, Hajič Jan, Straková Jana. UDPipe: + Trainable Pipeline for Processing CoNLL-U Files Performing Tokenization, + Morphological Analysis, POS Tagging and Parsing + (http://ufal.mff.cuni.cz/~straka/papers/2016-lrec_udpipe.pdf). In Proceedings + of the Tenth International Conference on Language Resources and Evaluation + (LREC 2016), Portorož, Slovenia, May 2016. + + +Model Description +----------------- + +The Universal Dependencies 2.0 models contain 68 models of 50 languages, each +consisting of a tokenizer, tagger, lemmatizer and dependency parser, all trained +using the UD data. Note that we use custom train-dev split, by moving sentences +from the beginning of dev data to the end of train data, until the training data +is at least 9 times the dev data. + +The tokenizer is trained using the SpaceAfter=No features. If the features are +not present in the data, they can be filled in using raw text in the language in +question. + +The tagger, lemmatizer and parser are trained using gold UD data. + +Details about model architecture and training process can be found in the +(Straka et al. 2017) paper. + + +Reproducible Training +--------------------- + +In case you want to train the same models, scripts for downloading and +resplitting UD 2.0 data, precomputed word embedding, raw texts for tokenizers, +all hyperparameter values and training scripts are available in the second +archive on the model download page (http://hdl.handle.net/11234/1-2364). + + +Model Performance +----------------- + +We present the tagger, lemmatizer and parser performance, measured on the +testing portion of the data, evaluated in three different settings: using raw +text only, using gold tokenization only, and using gold tokenization plus gold +morphology (UPOS, XPOS, FEATS and Lemma). + + || Treebank | Mode | Words | Sents | UPOS | XPOS | Feats | AllTags | Lemma | UAS | LAS | + | Ancient Greek | Raw text | 100.0% | 98.7% | 82.4% | 72.3% | 85.8% | 72.3% | 82.6% | 64.4% | 57.8% | + | Ancient Greek | Gold tok | - | - | 82.4% | 72.4% | 85.8% | 72.3% | 82.7% | 64.6% | 57.9% | + | Ancient Greek | Gold tok+morph | - | - | - | - | - | - | - | 69.2% | 64.4% | + | Ancient Greek-PROIEL | Raw text | 100.0% | 47.2% | 95.8% | 96.0% | 88.6% | 87.2% | 92.6% | 71.8% | 67.1% | + | Ancient Greek-PROIEL | Gold tok | - | - | 95.8% | 96.1% | 88.7% | 87.2% | 92.8% | 77.2% | 72.3% | + | Ancient Greek-PROIEL | Gold tok+morph | - | - | - | - | - | - | - | 79.7% | 76.1% | + | Arabic | Raw text | 93.8% | 83.1% | 88.4% | 83.4% | 83.5% | 82.3% | 87.5% | 71.7% | 65.8% | + | Arabic | Gold tok | - | - | 94.4% | 89.5% | 89.6% | 88.3% | 92.6% | 81.3% | 74.3% | + | Arabic | Gold tok+morph | - | - | - | - | - | - | - | 82.9% | 77.9% | + | Basque | Raw text | 100.0% | 99.5% | 93.2% | - | 87.6% | - | 93.8% | 75.8% | 70.7% | + | Basque | Gold tok | - | - | 93.3% | - | 87.7% | - | 93.9% | 75.9% | 70.8% | + | Basque | Gold tok+morph | - | - | - | - | - | - | - | 82.3% | 78.4% | + | Belarusian | Raw text | 99.4% | 76.8% | 88.2% | 85.6% | 71.7% | 68.6% | 81.3% | 68.0% | 60.6% | + | Belarusian | Gold tok | - | - | 88.7% | 85.7% | 72.4% | 69.2% | 81.5% | 69.4% | 61.9% | + | Belarusian | Gold tok+morph | - | - | - | - | - | - | - | 76.8% | 74.0% | + | Bulgarian | Raw text | 99.9% | 93.9% | 97.6% | 94.6% | 95.6% | 94.0% | 94.6% | 88.8% | 84.8% | + | Bulgarian | Gold tok | - | - | 97.7% | 94.7% | 95.6% | 94.1% | 94.7% | 89.5% | 85.5% | + | Bulgarian | Gold tok+morph | - | - | - | - | - | - | - | 92.6% | 89.1% | + | Catalan | Raw text | 100.0% | 99.2% | 98.0% | 98.0% | 97.1% | 96.5% | 97.9% | 88.8% | 85.7% | + | Catalan | Gold tok | - | - | 98.0% | 98.0% | 97.2% | 96.5% | 97.9% | 88.8% | 85.8% | + | Catalan | Gold tok+morph | - | - | - | - | - | - | - | 91.1% | 88.7% | + | Chinese | Raw text | 90.2% | 98.8% | 84.0% | 83.8% | 89.0% | 82.7% | 90.2% | 62.9% | 58.7% | + | Chinese | Gold tok | - | - | 92.2% | 92.0% | 98.7% | 90.8% | 100.0% | 75.6% | 70.1% | + | Chinese | Gold tok+morph | - | - | - | - | - | - | - | 84.1% | 81.4% | + | Coptic | Raw text | 65.8% | 35.7% | 62.6% | 62.1% | 65.7% | 62.1% | 64.6% | 41.1% | 39.3% | + | Coptic | Gold tok | - | - | 95.1% | 94.3% | 99.7% | 94.2% | 96.2% | 83.2% | 79.2% | + | Coptic | Gold tok+morph | - | - | - | - | - | - | - | 88.1% | 84.9% | + | Croatian | Raw text | 99.9% | 97.0% | 95.9% | - | 84.3% | - | 94.4% | 83.6% | 77.9% | + | Croatian | Gold tok | - | - | 96.0% | - | 84.4% | - | 94.4% | 83.9% | 78.1% | + | Croatian | Gold tok+morph | - | - | - | - | - | - | - | 87.1% | 83.2% | + | Czech | Raw text | 99.9% | 91.6% | 98.3% | 92.8% | 92.1% | 91.7% | 97.8% | 86.8% | 83.2% | + | Czech | Gold tok | - | - | 98.4% | 92.9% | 92.2% | 91.9% | 97.9% | 87.7% | 84.1% | + | Czech | Gold tok+morph | - | - | - | - | - | - | - | 90.2% | 87.5% | + | Czech-CAC | Raw text | 100.0% | 99.8% | 98.1% | 90.6% | 89.4% | 89.1% | 97.0% | 86.9% | 82.7% | + | Czech-CAC | Gold tok | - | - | 98.1% | 90.7% | 89.5% | 89.1% | 97.1% | 87.0% | 82.8% | + | Czech-CAC | Gold tok+morph | - | - | - | - | - | - | - | 89.7% | 86.6% | + | Czech-CLTT | Raw text | 99.5% | 92.3% | 96.5% | 87.5% | 87.8% | 87.3% | 96.8% | 80.2% | 76.6% | + | Czech-CLTT | Gold tok | - | - | 97.0% | 87.9% | 88.3% | 87.7% | 97.2% | 81.0% | 77.6% | + | Czech-CLTT | Gold tok+morph | - | - | - | - | - | - | - | 83.8% | 80.8% | + | Danish | Raw text | 99.8% | 77.9% | 95.2% | - | 94.2% | - | 94.9% | 78.4% | 74.7% | + | Danish | Gold tok | - | - | 95.5% | - | 94.5% | - | 95.0% | 80.4% | 76.6% | + | Danish | Gold tok+morph | - | - | - | - | - | - | - | 85.6% | 82.7% | + | Dutch | Raw text | 99.8% | 77.6% | 91.4% | 88.1% | 89.3% | 87.0% | 89.9% | 75.4% | 69.6% | + | Dutch | Gold tok | - | - | 91.8% | 88.8% | 89.9% | 87.7% | 90.1% | 77.0% | 71.2% | + | Dutch | Gold tok+morph | - | - | - | - | - | - | - | 82.9% | 79.4% | + | Dutch-LassySmall | Raw text | 100.0% | 80.4% | 97.6% | - | 97.2% | - | 98.1% | 84.4% | 82.0% | + | Dutch-LassySmall | Gold tok | - | - | 97.7% | - | 97.4% | - | 98.2% | 87.5% | 85.0% | + | Dutch-LassySmall | Gold tok+morph | - | - | - | - | - | - | - | 89.7% | 87.4% | + | English | Raw text | 99.0% | 76.6% | 93.5% | 92.9% | 94.4% | 91.5% | 96.0% | 80.2% | 77.2% | + | English | Gold tok | - | - | 94.5% | 93.9% | 95.4% | 92.5% | 96.9% | 84.3% | 81.2% | + | English | Gold tok+morph | - | - | - | - | - | - | - | 87.8% | 86.0% | + | English-LinES | Raw text | 99.9% | 86.2% | 95.0% | 92.7% | - | - | - | 78.6% | 74.4% | + | English-LinES | Gold tok | - | - | 95.1% | 92.8% | - | - | - | 79.5% | 75.3% | + | English-LinES | Gold tok+morph | - | - | - | - | - | - | - | 84.1% | 81.1% | + | English-ParTUT | Raw text | 99.6% | 97.5% | 94.2% | 94.0% | 93.3% | 92.0% | 96.9% | 81.6% | 77.9% | + | English-ParTUT | Gold tok | - | - | 94.6% | 94.4% | 93.6% | 92.3% | 97.3% | 82.1% | 78.4% | + | English-ParTUT | Gold tok+morph | - | - | - | - | - | - | - | 86.4% | 84.5% | + | Estonian | Raw text | 99.9% | 94.2% | 91.2% | 93.2% | 85.0% | 83.2% | 84.5% | 72.4% | 65.6% | + | Estonian | Gold tok | - | - | 91.3% | 93.2% | 85.0% | 83.3% | 84.5% | 72.8% | 66.0% | + | Estonian | Gold tok+morph | - | - | - | - | - | - | - | 83.1% | 79.6% | + | Finnish | Raw text | 99.7% | 86.7% | 94.5% | 95.7% | 91.5% | 90.3% | 86.5% | 80.5% | 76.9% | + | Finnish | Gold tok | - | - | 94.9% | 96.0% | 91.8% | 90.7% | 86.8% | 82.0% | 78.4% | + | Finnish | Gold tok+morph | - | - | - | - | - | - | - | 86.9% | 84.7% | + | Finnish-FTB | Raw text | 100.0% | 86.4% | 92.0% | 91.0% | 92.5% | 89.2% | 88.9% | 80.1% | 75.7% | + | Finnish-FTB | Gold tok | - | - | 92.2% | 91.3% | 92.7% | 89.5% | 88.9% | 81.7% | 77.3% | + | Finnish-FTB | Gold tok+morph | - | - | - | - | - | - | - | 88.8% | 86.5% | + | French | Raw text | 98.9% | 94.6% | 95.4% | - | 95.5% | - | 96.6% | 84.2% | 80.7% | + | French | Gold tok | - | - | 96.5% | - | 96.5% | - | 97.6% | 85.4% | 82.0% | + | French | Gold tok+morph | - | - | - | - | - | - | - | 88.4% | 86.0% | + | French-ParTUT | Raw text | 99.0% | 97.8% | 94.5% | 94.2% | 91.9% | 90.8% | 94.3% | 82.9% | 78.7% | + | French-ParTUT | Gold tok | - | - | 95.6% | 95.3% | 92.7% | 91.6% | 95.2% | 84.1% | 80.2% | + | French-ParTUT | Gold tok+morph | - | - | - | - | - | - | - | 88.1% | 85.3% | + | French-Sequoia | Raw text | 99.1% | 84.0% | 95.9% | - | 95.1% | - | 96.8% | 83.2% | 80.6% | + | French-Sequoia | Gold tok | - | - | 96.8% | - | 96.0% | - | 97.7% | 85.1% | 82.7% | + | French-Sequoia | Gold tok+morph | - | - | - | - | - | - | - | 88.7% | 87.4% | + | Galician | Raw text | 99.9% | 95.8% | 97.2% | 96.7% | 99.7% | 96.4% | 97.1% | 81.0% | 77.8% | + | Galician | Gold tok | - | - | 97.2% | 96.8% | 99.8% | 96.4% | 97.1% | 81.2% | 77.9% | + | Galician | Gold tok+morph | - | - | - | - | - | - | - | 83.1% | 80.5% | + | Galician-TreeGal | Raw text | 98.7% | 86.7% | 91.1% | 87.8% | 89.9% | 87.0% | 92.6% | 71.5% | 66.3% | + | Galician-TreeGal | Gold tok | - | - | 92.4% | 88.8% | 91.0% | 88.0% | 93.7% | 74.4% | 68.7% | + | Galician-TreeGal | Gold tok+morph | - | - | - | - | - | - | - | 81.5% | 77.1% | + | German | Raw text | 99.7% | 79.3% | 90.7% | 94.7% | 80.5% | 76.3% | 95.4% | 74.0% | 68.6% | + | German | Gold tok | - | - | 91.2% | 95.0% | 80.9% | 76.7% | 95.6% | 76.5% | 70.7% | + | German | Gold tok+morph | - | - | - | - | - | - | - | 84.7% | 82.2% | + | Gothic | Raw text | 100.0% | 29.5% | 94.2% | 94.8% | 87.6% | 85.6% | 92.9% | 69.7% | 63.5% | + | Gothic | Gold tok | - | - | 94.8% | 95.3% | 88.0% | 86.5% | 92.9% | 78.8% | 72.6% | + | Gothic | Gold tok+morph | - | - | - | - | - | - | - | 82.2% | 78.3% | + | Greek | Raw text | 99.9% | 88.2% | 95.8% | 95.8% | 90.3% | 89.1% | 94.5% | 84.2% | 80.4% | + | Greek | Gold tok | - | - | 96.0% | 96.0% | 90.5% | 89.3% | 94.6% | 85.0% | 81.1% | + | Greek | Gold tok+morph | - | - | - | - | - | - | - | 87.9% | 85.9% | + | Hebrew | Raw text | 85.2% | 100.0% | 80.9% | 80.9% | 77.6% | 76.8% | 79.6% | 62.2% | 57.9% | + | Hebrew | Gold tok | - | - | 95.1% | 95.1% | 91.3% | 90.5% | 93.2% | 84.5% | 78.9% | + | Hebrew | Gold tok+morph | - | - | - | - | - | - | - | 87.8% | 84.3% | + | Hindi | Raw text | 100.0% | 99.1% | 95.8% | 94.9% | 90.3% | 87.7% | 98.0% | 91.3% | 87.3% | + | Hindi | Gold tok | - | - | 95.8% | 94.9% | 90.3% | 87.7% | 98.0% | 91.4% | 87.3% | + | Hindi | Gold tok+morph | - | - | - | - | - | - | - | 93.9% | 91.0% | + | Hungarian | Raw text | 99.8% | 96.2% | 91.6% | - | 70.5% | - | 89.3% | 74.1% | 68.1% | + | Hungarian | Gold tok | - | - | 91.8% | - | 70.6% | - | 89.5% | 74.5% | 68.5% | + | Hungarian | Gold tok+morph | - | - | - | - | - | - | - | 81.2% | 78.5% | + | Indonesian | Raw text | 100.0% | 92.0% | 93.5% | - | 99.5% | - | - | 80.6% | 74.3% | + | Indonesian | Gold tok | - | - | 93.5% | - | 99.6% | - | - | 80.8% | 74.5% | + | Indonesian | Gold tok+morph | - | - | - | - | - | - | - | 83.1% | 79.1% | + | Irish | Raw text | 99.4% | 94.3% | 88.0% | 86.9% | 75.1% | 72.7% | 85.5% | 72.5% | 62.4% | + | Irish | Gold tok | - | - | 88.5% | 87.4% | 75.5% | 73.1% | 86.0% | 73.3% | 63.1% | + | Irish | Gold tok+morph | - | - | - | - | - | - | - | 78.1% | 71.4% | + | Italian | Raw text | 99.8% | 97.1% | 97.2% | 97.0% | 97.0% | 96.1% | 97.3% | 88.8% | 86.1% | + | Italian | Gold tok | - | - | 97.4% | 97.2% | 97.2% | 96.3% | 97.5% | 89.3% | 86.6% | + | Italian | Gold tok+morph | - | - | - | - | - | - | - | 91.3% | 89.7% | + | Japanese | Raw text | 91.9% | 95.1% | 89.1% | - | 91.8% | - | 91.1% | 78.0% | 76.6% | + | Japanese | Gold tok | - | - | 96.6% | - | 100.0% | - | 99.0% | 93.4% | 91.5% | + | Japanese | Gold tok+morph | - | - | - | - | - | - | - | 95.6% | 95.0% | + | Kazakh | Raw text | 94.0% | 84.9% | 52.0% | 52.1% | 47.2% | 40.0% | 59.2% | 40.2% | 23.9% | + | Kazakh | Gold tok | - | - | 55.4% | 55.4% | 50.1% | 42.2% | 63.1% | 45.2% | 27.0% | + | Kazakh | Gold tok+morph | - | - | - | - | - | - | - | 60.5% | 42.5% | + | Korean | Raw text | 99.7% | 92.7% | 94.4% | 89.7% | 99.3% | 89.7% | 99.4% | 67.4% | 60.5% | + | Korean | Gold tok | - | - | 94.7% | 90.0% | 99.6% | 90.0% | 99.7% | 68.4% | 61.5% | + | Korean | Gold tok+morph | - | - | - | - | - | - | - | 71.7% | 65.8% | + | Latin | Raw text | 100.0% | 98.0% | 83.4% | 67.6% | 72.5% | 67.6% | 51.2% | 56.5% | 46.0% | + | Latin | Gold tok | - | - | 83.4% | 67.6% | 72.5% | 67.6% | 51.2% | 56.6% | 46.1% | + | Latin | Gold tok+morph | - | - | - | - | - | - | - | 67.8% | 61.5% | + | Latin-ITTB | Raw text | 99.9% | 82.5% | 97.2% | 92.7% | 93.5% | 91.3% | 97.8% | 79.7% | 76.0% | + | Latin-ITTB | Gold tok | - | - | 97.3% | 92.8% | 93.6% | 91.4% | 97.9% | 81.8% | 78.1% | + | Latin-ITTB | Gold tok+morph | - | - | - | - | - | - | - | 87.6% | 85.2% | + | Latin-PROIEL | Raw text | 99.9% | 31.0% | 94.9% | 95.0% | 87.7% | 86.7% | 94.8% | 66.1% | 60.7% | + | Latin-PROIEL | Gold tok | - | - | 95.2% | 95.2% | 88.4% | 87.4% | 95.0% | 75.3% | 69.4% | + | Latin-PROIEL | Gold tok+morph | - | - | - | - | - | - | - | 79.0% | 75.0% | + | Latvian | Raw text | 99.2% | 97.1% | 89.6% | 76.2% | 83.2% | 75.7% | 87.6% | 69.2% | 62.8% | + | Latvian | Gold tok | - | - | 90.2% | 76.8% | 84.0% | 76.3% | 88.3% | 70.3% | 63.9% | + | Latvian | Gold tok+morph | - | - | - | - | - | - | - | 78.7% | 74.9% | + | Lithuanian | Raw text | 98.2% | 92.0% | 74.0% | 73.0% | 68.9% | 63.7% | 73.5% | 44.0% | 32.4% | + | Lithuanian | Gold tok | - | - | 74.6% | 73.5% | 69.7% | 64.2% | 74.2% | 44.6% | 33.0% | + | Lithuanian | Gold tok+morph | - | - | - | - | - | - | - | 55.6% | 46.5% | + | Norwegian-Bokmaal | Raw text | 99.8% | 96.5% | 96.9% | - | 95.3% | - | 96.6% | 86.9% | 84.1% | + | Norwegian-Bokmaal | Gold tok | - | - | 97.1% | - | 95.5% | - | 96.8% | 87.5% | 84.7% | + | Norwegian-Bokmaal | Gold tok+morph | - | - | - | - | - | - | - | 91.7% | 89.6% | + | Norwegian-Nynorsk | Raw text | 99.9% | 92.2% | 96.5% | - | 94.9% | - | 96.4% | 85.6% | 82.5% | + | Norwegian-Nynorsk | Gold tok | - | - | 96.6% | - | 95.0% | - | 96.5% | 86.5% | 83.3% | + | Norwegian-Nynorsk | Gold tok+morph | - | - | - | - | - | - | - | 91.0% | 88.6% | + | Old Church Slavonic | Raw text | 100.0% | 40.5% | 93.8% | 93.8% | 86.9% | 85.7% | 91.2% | 73.6% | 66.9% | + | Old Church Slavonic | Gold tok | - | - | 94.1% | 94.1% | 87.6% | 86.5% | 91.2% | 81.6% | 74.7% | + | Old Church Slavonic | Gold tok+morph | - | - | - | - | - | - | - | 86.7% | 82.2% | + | Persian | Raw text | 99.7% | 98.2% | 96.0% | 96.0% | 96.1% | 95.4% | 93.5% | 83.3% | 79.4% | + | Persian | Gold tok | - | - | 96.4% | 96.3% | 96.4% | 95.7% | 93.8% | 83.8% | 80.0% | + | Persian | Gold tok+morph | - | - | - | - | - | - | - | 87.7% | 84.9% | + | Polish | Raw text | 99.9% | 99.7% | 95.6% | 84.0% | 84.1% | 83.1% | 93.4% | 86.7% | 80.7% | + | Polish | Gold tok | - | - | 95.7% | 84.1% | 84.2% | 83.3% | 93.6% | 87.0% | 81.0% | + | Polish | Gold tok+morph | - | - | - | - | - | - | - | 92.9% | 89.5% | + | Portuguese | Raw text | 99.6% | 89.4% | 96.4% | 72.7% | 93.3% | 71.6% | 96.8% | 86.0% | 82.6% | + | Portuguese | Gold tok | - | - | 96.8% | 73.0% | 93.7% | 71.9% | 97.2% | 87.2% | 83.6% | + | Portuguese | Gold tok+morph | - | - | - | - | - | - | - | 89.6% | 87.5% | + | Portuguese-BR | Raw text | 99.9% | 96.8% | 97.0% | 97.0% | 99.7% | 97.0% | 98.8% | 88.5% | 86.3% | + | Portuguese-BR | Gold tok | - | - | 97.2% | 97.2% | 99.9% | 97.2% | 98.9% | 88.8% | 86.6% | + | Portuguese-BR | Gold tok+morph | - | - | - | - | - | - | - | 90.5% | 89.1% | + | Romanian | Raw text | 99.7% | 93.9% | 96.6% | 95.9% | 96.0% | 95.7% | 96.5% | 85.6% | 80.2% | + | Romanian | Gold tok | - | - | 96.9% | 96.2% | 96.3% | 96.0% | 96.8% | 86.2% | 80.8% | + | Romanian | Gold tok+morph | - | - | - | - | - | - | - | 87.8% | 83.0% | + | Russian | Raw text | 99.9% | 96.9% | 94.7% | 94.4% | 84.4% | 82.8% | 75.0% | 80.3% | 75.5% | + | Russian | Gold tok | - | - | 94.8% | 94.5% | 84.5% | 82.9% | 75.1% | 80.8% | 76.0% | + | Russian | Gold tok+morph | - | - | - | - | - | - | - | 84.8% | 81.9% | + | Russian-SynTagRus | Raw text | 99.6% | 98.0% | 98.0% | - | 93.6% | - | 95.6% | 89.8% | 87.2% | + | Russian-SynTagRus | Gold tok | - | - | 98.4% | - | 93.9% | - | 95.9% | 90.4% | 87.9% | + | Russian-SynTagRus | Gold tok+morph | - | - | - | - | - | - | - | 91.8% | 90.5% | + | Sanskrit | Raw text | 88.1% | 29.0% | 52.0% | - | 35.2% | - | 50.2% | 38.8% | 22.5% | + | Sanskrit | Gold tok | - | - | 57.6% | - | 43.6% | - | 60.6% | 58.5% | 34.3% | + | Sanskrit | Gold tok+morph | - | - | - | - | - | - | - | 72.9% | 58.5% | + | Slovak | Raw text | 100.0% | 83.5% | 93.2% | 77.5% | 79.7% | 77.1% | 85.9% | 80.4% | 75.2% | + | Slovak | Gold tok | - | - | 93.3% | 77.6% | 79.9% | 77.2% | 86.0% | 82.0% | 76.9% | + | Slovak | Gold tok+morph | - | - | - | - | - | - | - | 88.2% | 85.5% | + | Slovenian | Raw text | 99.9% | 98.9% | 96.2% | 88.2% | 88.5% | 87.7% | 95.3% | 84.9% | 81.6% | + | Slovenian | Gold tok | - | - | 96.2% | 88.2% | 88.6% | 87.7% | 95.4% | 85.0% | 81.7% | + | Slovenian | Gold tok+morph | - | - | - | - | - | - | - | 91.8% | 90.5% | + | Slovenian-SST | Raw text | 99.9% | 17.8% | 89.0% | 81.1% | 81.3% | 78.6% | 91.6% | 53.0% | 46.6% | + | Slovenian-SST | Gold tok | - | - | 89.4% | 81.6% | 81.8% | 79.3% | 91.7% | 63.4% | 56.0% | + | Slovenian-SST | Gold tok+morph | - | - | - | - | - | - | - | 75.5% | 70.6% | + | Spanish | Raw text | 99.7% | 95.3% | 95.5% | - | 96.1% | - | 95.9% | 84.9% | 81.4% | + | Spanish | Gold tok | - | - | 95.8% | - | 96.3% | - | 96.1% | 85.5% | 81.9% | + | Spanish | Gold tok+morph | - | - | - | - | - | - | - | 88.0% | 85.3% | + | Spanish-AnCora | Raw text | 99.9% | 98.0% | 98.1% | 98.1% | 97.5% | 96.8% | 98.1% | 87.7% | 84.5% | + | Spanish-AnCora | Gold tok | - | - | 98.2% | 98.2% | 97.5% | 96.9% | 98.1% | 87.8% | 84.7% | + | Spanish-AnCora | Gold tok+morph | - | - | - | - | - | - | - | 90.2% | 87.6% | + | Swedish | Raw text | 99.8% | 94.6% | 95.6% | 93.9% | 94.4% | 92.8% | 95.5% | 81.4% | 77.8% | + | Swedish | Gold tok | - | - | 95.8% | 94.1% | 94.6% | 93.1% | 95.7% | 82.1% | 78.4% | + | Swedish | Gold tok+morph | - | - | - | - | - | - | - | 88.0% | 85.0% | + | Swedish-LinES | Raw text | 100.0% | 85.7% | 94.8% | 92.2% | - | - | - | 80.4% | 75.7% | + | Swedish-LinES | Gold tok | - | - | 94.8% | 92.3% | - | - | - | 81.3% | 76.6% | + | Swedish-LinES | Gold tok+morph | - | - | - | - | - | - | - | 86.0% | 82.6% | + | Tamil | Raw text | 95.3% | 89.2% | 82.2% | 77.7% | 80.9% | 77.2% | 85.3% | 59.5% | 52.0% | + | Tamil | Gold tok | - | - | 85.8% | 81.0% | 84.2% | 80.3% | 89.1% | 64.9% | 56.5% | + | Tamil | Gold tok+morph | - | - | - | - | - | - | - | 78.9% | 71.8% | + | Turkish | Raw text | 98.1% | 96.8% | 92.4% | 91.5% | 87.3% | 85.5% | 90.2% | 62.9% | 55.8% | + | Turkish | Gold tok | - | - | 94.0% | 93.0% | 88.9% | 87.0% | 91.7% | 65.5% | 58.0% | + | Turkish | Gold tok+morph | - | - | - | - | - | - | - | 66.8% | 61.1% | + | Ukrainian | Raw text | 99.8% | 95.1% | 88.5% | 70.7% | 70.9% | 67.6% | 86.7% | 69.9% | 61.5% | + | Ukrainian | Gold tok | - | - | 88.6% | 70.8% | 71.0% | 67.7% | 86.9% | 70.2% | 61.8% | + | Ukrainian | Gold tok+morph | - | - | - | - | - | - | - | 79.0% | 74.5% | + | Urdu | Raw text | 100.0% | 98.3% | 92.4% | 90.5% | 80.6% | 76.3% | 93.0% | 84.6% | 77.6% | + | Urdu | Gold tok | - | - | 92.4% | 90.5% | 80.7% | 76.3% | 93.0% | 84.7% | 77.7% | + | Urdu | Gold tok+morph | - | - | - | - | - | - | - | 88.2% | 83.0% | + | Uyghur | Raw text | 99.8% | 67.2% | 74.7% | 79.1% | - | - | - | 55.1% | 35.0% | + | Uyghur | Gold tok | - | - | 75.1% | 79.3% | - | - | - | 56.5% | 35.8% | + | Uyghur | Gold tok+morph | - | - | - | - | - | - | - | 62.3% | 42.0% | + | Vietnamese | Raw text | 85.3% | 92.9% | 77.4% | 75.4% | 85.1% | 75.4% | 84.5% | 46.9% | 42.5% | + | Vietnamese | Gold tok | - | - | 89.3% | 86.8% | 99.6% | 86.8% | 99.0% | 64.4% | 57.2% | + | Vietnamese | Gold tok+morph | - | - | - | - | - | - | - | 70.7% | 67.9% | + + +CoNLL17 Shared Task Baseline UD 2.0 Models +------------------------------------------ + +As part of CoNLL 2017 Shared Task in UD Parsing, baseline models for UDPipe were +released. The CoNLL 2017 Shared Task models were trained on most of UD 2.0 +treebanks (64 of them) and are distributed under the CC BY-NC-SA +(http://creativecommons.org/licenses/by-nc-sa/4.0/) licence. + +Note that the models were released when the test set of UD 2.0 was unknown. +Therefore, the models were trained on a subset of training data only, to allow +fair comparison on the development data (which were unused during training and +hyperparameter settings). Consequently, the performance of the models is not +directly comparable to other models. Details about the concrete data split, +hyperparameter values and model performance are available in the model archive. + + +Download +-------- + +The CoNLL17 Shared Task Baseline UD 2.0 Models can be downloaded from +LINDAT/CLARIN repository (http://hdl.handle.net/11234/1-1990). + + +Acknowledgements +---------------- + +This work has been partially supported and has been using language resources and +tools developed, stored and distributed by the LINDAT/CLARIN project of the +Ministry of Education, Youth and Sports of the Czech Republic (project +LM2015071). + +The models were trained on a Universal Dependencies 2.0 +(http://hdl.handle.net/11234/1-1983) treebanks. + + +Universal Dependencies 1.2 Models +--------------------------------- + +Universal Dependencies 1.2 Models are distributed under the CC BY-NC-SA +(http://creativecommons.org/licenses/by-nc-sa/4.0/) licence. The models are +based solely on Universal Dependencies 1.2 (http://hdl.handle.net/11234/1-1548) +treebanks. The models work in UDPipe version 1.0. + +Universal Dependencies 1.2 Models are versioned according to the date released +in the format YYMMDD, where YY, MM and DD are two-digit representation of year, +month and day, respectively. The latest version is 160523. + + +Download +-------- + +The latest version 160523 of the Universal Dependencies 1.2 models can be +downloaded from LINDAT/CLARIN repository (http://hdl.handle.net/11234/1-1659). + + +Acknowledgements +---------------- + +This work has been partially supported and has been using language resources and +tools developed, stored and distributed by the LINDAT/CLARIN project of the +Ministry of Education, Youth and Sports of the Czech Republic (project +LM2015071). + +The models were trained on Universal Dependencies 1.2 +(http://hdl.handle.net/11234/1-1548) treebanks. + +For the UD treebanks which do not contain original plain text version, raw text +is used to train the tokenizer instead. The plain texts were taken from the W2C +- Web to Corpus (http://hdl.handle.net/11858/00-097C-0000-0022-6133-9). + + +Publications +------------ + +- (Straka et al. 2016) Straka Milan, Hajič Jan, Straková Jana. UDPipe: + Trainable Pipeline for Processing CoNLL-U Files Performing Tokenization, + Morphological Analysis, POS Tagging and Parsing. LREC 2016, Portorož, + Slovenia, May 2016. + + +Model Description +----------------- + +The Universal Dependencies 1.2 models contain 36 models, each consisting of a +tokenizer, tagger, lemmatizer and dependency parser, all trained using the UD +data. The model for Japanese is missing, because we do not have the license for +the required corpus of Mainichi Shinbun 1995. + +The tokenizer is trained using the SpaceAfter=No features. If the features are +not present in the data, they can be filled in using raw text in the language in +question (surprisingly, quite little data suffices, we use 500kB). + +The tagger, lemmatizer and parser are trained using gold UD data. + +Details about model architecture and training process can be found in the +(Straka et al. 2016) paper. + + +Model Performance +----------------- + +We present the tagger, lemmatizer and parser performance, measured on the +testing portion of the data. Only the segmentation and the tokenization of the +testing data is retained before evaluation. Therefore, the dependency parser is +evaluated without gold POS tags. + + || Treebank | UPOS | XPOS | Feats | All Tags | Lemma | UAS | LAS | + | Ancient Greek | 91.1% | 77.8% | 88.7% | 77.7% | 86.9% | 68.1% | 61.6% | + | Ancient Greek-PROIEL | 96.7% | 96.4% | 89.3% | 88.4% | 93.4% | 75.8% | 69.6% | + | Arabic | 98.8% | 97.7% | 97.8% | 97.6% | - | 80.4% | 75.6% | + | Basque | 93.3% | - | 87.2% | 85.4% | 93.5% | 74.8% | 69.5% | + | Bulgarian | 97.8% | 94.8% | 94.4% | 93.1% | 94.6% | 89.0% | 84.2% | + | Croatian | 94.9% | - | 85.5% | 85.0% | 93.1% | 78.6% | 71.0% | + | Czech | 98.4% | 93.2% | 92.6% | 92.2% | 97.8% | 86.9% | 83.0% | + | Danish | 95.8% | - | 94.8% | 93.6% | 95.2% | 78.6% | 74.8% | + | Dutch | 89.7% | 88.7% | 91.2% | 86.4% | 88.9% | 78.1% | 70.7% | + | English | 94.5% | 93.8% | 95.4% | 92.5% | 97.0% | 84.2% | 80.6% | + | Estonian | 88.0% | 73.7% | 80.0% | 73.6% | 77.0% | 79.9% | 71.5% | + | Finnish | 94.9% | 96.0% | 93.2% | 92.1% | 86.8% | 81.0% | 76.5% | + | Finnish-FTB | 94.0% | 91.6% | 93.3% | 91.2% | 89.1% | 81.5% | 76.9% | + | French | 95.8% | - | - | 95.8% | - | 82.8% | 78.4% | + | German | 90.5% | - | - | 90.5% | - | 78.2% | 72.2% | + | Gothic | 95.5% | 95.7% | 88.0% | 86.3% | 93.4% | 76.4% | 68.2% | + | Greek | 97.3% | 97.3% | 92.8% | 91.7% | 94.8% | 80.3% | 76.5% | + | Hebrew | 94.9% | 94.9% | 91.3% | 90.5% | - | 82.6% | 76.8% | + | Hindi | 95.8% | 94.8% | 90.2% | 87.7% | 98.0% | 91.7% | 87.5% | + | Hungarian | 92.6% | - | 89.9% | 88.9% | 86.9% | 77.0% | 70.6% | + | Indonesian | 93.5% | - | - | 93.5% | - | 79.9% | 73.3% | + | Irish | 91.8% | 90.3% | 79.4% | 76.6% | 87.3% | 74.4% | 66.1% | + | Italian | 97.2% | 97.0% | 97.1% | 96.2% | 97.7% | 88.6% | 85.8% | + | Latin | 91.2% | 75.8% | 79.3% | 75.6% | 79.9% | 57.1% | 46.7% | + | Latin-ITT | 98.8% | 94.0% | 94.6% | 93.8% | 98.3% | 79.9% | 76.4% | + | Latin-PROIEL | 96.4% | 96.0% | 88.9% | 88.2% | 95.3% | 75.3% | 68.3% | + | Norwegian | 97.2% | - | 95.5% | 94.7% | 96.9% | 86.7% | 84.1% | + | Old Church Slavonic | 95.3% | 95.1% | 89.1% | 88.2% | 92.9% | 80.6% | 73.4% | + | Persian | 97.0% | 96.3% | 96.5% | 96.2% | - | 83.8% | 79.4% | + | Polish | 95.8% | 84.0% | 84.1% | 83.8% | 92.8% | 86.3% | 79.6% | + | Portuguese | 97.6% | 92.3% | 95.3% | 92.0% | 97.8% | 85.8% | 81.9% | + | Romanian | 89.0% | 81.0% | 82.3% | 81.0% | 75.3% | 68.6% | 56.9% | + | Slovenian | 95.7% | 88.2% | 88.6% | 87.5% | 95.0% | 84.1% | 80.3% | + | Spanish | 95.3% | - | 95.9% | 93.4% | 96.3% | 84.2% | 80.3% | + | Swedish | 95.8% | 93.9% | 94.8% | 93.2% | 95.5% | 81.4% | 77.1% | + | Tamil | 85.9% | 80.8% | 84.3% | 80.2% | 88.0% | 67.2% | 58.8% | + + +UDPipe API Reference +==================== + +The UDPipe API is defined in header udpipe.h and resides in ufal::udpipe +namespace. The API allows only using existing models, for custom model creation +you have to use the train_parser binary. + +The strings used in the UDPipe API are always UTF-8 encoded (except from file +paths, whose encoding is system dependent). + + +UDPipe Versioning +----------------- + +UDPipe is versioned using Semantic Versioning (http://semver.org/). Therefore, a +version consists of three numbers major.minor.patch, optionally followed by a +hyphen and pre-release version info, with the following semantics: + +- Stable versions have no pre-release version info, development have non-empty + pre-release version info. +- Two versions with the same major.minor have the same API with the same + behaviour, apart from bugs. Therefore, if only patch is increased, the new + version is only a bug-fix release. +- If two versions v and u have the same major, but minor(v) is greater than + minor(u), version v contains only additions to the API. In other words, the + API of u is all present in v with the same behaviour (once again apart from + bugs). It is therefore safe to upgrade to a newer UDPipe version with the same + major. +- If two versions differ in major, their API may differ in any way. + +Models created by UDPipe have the same behaviour in all UDPipe versions with +same major, apart from obvious bugfixes. On the other hand, models created from +the same data by different major.minor UDPipe versions may have different +behaviour. + + +Struct string_piece +------------------- + + struct string_piece { + const char* str; + size_t len; + + string_piece(); + string_piece(const char* str); + string_piece(const char* str, size_t len); + string_piece(const std::string& str); + } + +The string_piece is used for efficient string passing. The string referenced in +string_piece is not owned by it, so users have to make sure the referenced +string exists as long as the string_piece. + + +Class token +----------- + + class token { + public: + string form; + string misc; + + token(string_piece form = string_piece(), string_piece misc = string_piece()); + + // CoNLL-U defined SpaceAfter=No feature + bool get_space_after() const; + void set_space_after(bool space_after); + + // UDPipe-specific all-spaces-preserving SpacesBefore and SpacesAfter features + void get_spaces_before(string& spaces_before) const; + void set_spaces_before(string_piece spaces_before); + void get_spaces_after(string& spaces_after) const; + void set_spaces_after(string_piece spaces_after); + void get_spaces_in_token(string& spaces_in_token) const; + void set_spaces_in_token(string_piece spaces_in_token); + + // UDPipe-specific TokenRange feature + bool get_token_range(size_t& start, size_t& end) const; + void set_token_range(size_t start, size_t end); + }; + +The token class represents a sentence token, with form and misc fields +corresponding to CoNLL-U fields +(http://universaldependencies.org/docs/format.html). The token class acts mostly +as a parent to word and multiword_token classes. + +The class also offers several methods for manipulating features in the misc +field. Notably, UDPipe uses custom misc fields to store all spaces in the +original document. This markup is backward compatible with CoNLL-U v2 +SpaceAfter=No feature. This markup can be utilized by plaintext output format, +which allows reconstructing the original document. + +The markup uses the following misc fields: +- SpacesBefore=content (by default empty): spaces/other content preceding the + token +- SpacesAfter=content (by default a space if SpaceAfter=No feature is not + present, empty otherwise): spaces/other content following the token +- SpacesInToken=content (by default equal to the FORM of the token): FORM of + the token including original spaces (this is needed only if tokens are allowed + to contain spaces and a token contains a tab or newline characters) + +The content of all above three fields must be escaped to allow storing tabs and +newlines. The following C-like schema is used: +- \s: space +- \t: tab +- \r: CR character +- \n: LF character +- \p: | (pipe character) +- \\: \ (backslash character) + + +token::get_space_after() +------------------------ + + bool get_space_after() const; + +Returns true if the token should be followed by a spaces, false if not, +according to the absence or presence of the SpaceAfter=No feature in the misc +field. + + +token::set_space_after() +------------------------ + + void set_space_after(bool space_after); + +Adds or removes the SpaceAfter=No feature in the misc field. + + +token::get_spaces_before() +-------------------------- + + void get_spaces_before(string& spaces_before) const; + +Return spaces preceding current token, stored in the SpacesBefore feature in the +misc field. If SpacesBefore is not present, empty string is returned. + + +token::set_spaces_before() +-------------------------- + + void set_spaces_before(string_piece spaces_before); + +Set the SpacesBefore feature in the misc field. + + +token::get_spaces_after() +------------------------- + + void get_spaces_after(string& spaces_after) const; + +Return spaces after current token, stored in the SpacesAfter feature in the misc +field. + +If SpacesAfter is not present and SpaceAfter=No is present, return an empty +string; if neither feature is present, one space is returned. + + +token::set_spaces_after() +------------------------- + + void set_spaces_after(string_piece spaces_after); + +Set the SpacesAfter and SpaceAfter=No features in the misc field. + + +token::get_spaces_in_token() +---------------------------- + + void get_spaces_in_token(string& spaces_in_token) const; + +Return the value of the SpacesInToken feature, if present. Otherwise, empty +string is returned. + + +token::set_spaces_in_token() +---------------------------- + + void set_spaces_in_token(string_piece spaces_in_token); + +Set the SpacesInToken feature in the misc field. + + +token::get_token_range() +------------------------ + + bool get_token_range(size_t& start, size_t& end) const; + +If present, return the value of the TokenRange feature in the misc field. The +format of the feature (inspired by Python) is TokenRange=start:end, where start +is zero-based document-level index of the start of the token (counted in Unicode +characters) and end is zero-based document-level index of the first character +following the token (i.e., the length of the token is end-start). + + +token::set_token_range() +------------------------ + + void set_token_range(size_t start, size_t end); + +Set the TokenRange feature in the misc field. If string::npos is passed in the +start argument, TokenRange feature is removed from the misc field. + + +Class word +---------- + + class word : public token { + public: + // form and misc are inherited from token + int id; // 0 is root, >0 is sentence word, <0 is undefined + string lemma; // lemma + string upostag; // universal part-of-speech tag + string xpostag; // language-specific part-of-speech tag + string feats; // list of morphological features + int head; // head, 0 is root, <0 is undefined + string deprel; // dependency relation to the head + string deps; // secondary dependencies + + vector children; + + word(int id = -1, string_piece form = string_piece()); + }; + +The word class represents a sentence word. The word fields correspond to CoNLL-U +fields (http://universaldependencies.org/docs/format.html), with the children +field representing the opposite direction of head links (the elements of the +children array are in ascending order). + + +Class multiword_token +--------------------- + + class multiword_token : public token { + public: + // form and misc are inherited from token + int id_first, id_last; + + multiword_token(int id_first = -1, int id_last = -1, string_piece form = string_piece(), string_piece misc = string_piece()); + }; + +The multiword_token represents a multi-word token described in CoNLL-U format +(http://universaldependencies.org/docs/format.html). The multi-word token has a +form and a misc field, other CoNLL-U word fields are guaranteed to be empty. + + +Class empty_node +---------------- + + class empty_node { + public: + int id; // 0 is root, >0 is sentence word, <0 is undefined + int index; // index for the current id, should be numbered from 1, 0=undefined + string form; // form + string lemma; // lemma + string upostag; // universal part-of-speech tag + string xpostag; // language-specific part-of-speech tag + string feats; // list of morphological features + string deps; // secondary dependencies + string misc; // miscellaneous information + + empty_node(int id = -1, int index = 0) : id(id), index(index) {} + }; + +The empty_node class represents an empty node from CoNLL-U 2.0, with the fields +corresponding to CoNLL-U fields +(http://universaldependencies.org/docs/format.html). For a specified id, the +index are numbered sequentially from 1. + + +Class sentence +-------------- + + class sentence { + public: + sentence(); + + vector words; + vector multiword_tokens; + vector empty_nodes; + vector comments; + static const string root_form; + + // Basic sentence modifications + bool empty(); + void clear(); + word& add_word(string_piece form = string_piece()); + void set_head(int id, int head, const string& deprel); + void unlink_all_words(); + + // CoNLL-U defined comments + bool get_new_doc(string* id = nullptr) const; + void set_new_doc(bool new_doc, string_piece id = string_piece()); + bool get_new_par(string* id = nullptr) const; + void set_new_par(bool new_par, string_piece id = string_piece()); + bool get_sent_id(string& id) const; + void set_sent_id(string_piece id); + bool get_text(string& text) const; + void set_text(string_piece text); + }; + +The sentence class represents a sentence CoNLL-U sentence +(http://universaldependencies.org/docs/format.html), which consists of: +- sequence of words stored in ascending order, with the first word (with index + 0) always being a technical root with form root_form +- sequence of multiword_tokens also stored in ascending order +- sequence of empty_nodes also stored in ascending order +- comments + +Although you can manipulate the words directly, the sentence class offers +several simple node manipulation methods. There are also several methods +manipulating CoNLL-U v2 comments. + + +sentence::empty() +----------------- + + bool empty(); + +Returns true if the sentence is empty. i.e., if it contains only a technical +root node. + + +sentence::clear() +----------------- + + void clear(); + +Removes all words, multi-word tokens and comments (only the technical root word +is kept). + + +sentence::add_word() +-------------------- + + word& add_word(string_piece form = string_piece()); + +Adds a new word to the sentence. The new word has first unused id, specified +form and is not linked to any other node. Reference to the new word is returned +so that other fields can be also filled. + + +sentence:set_head() +------------------- + + void set_head(int id, int head, const std::string& deprel); + +Link the word id to the word head, with the specified dependency relation. If +the head is negative, the word id is unlinked from its current head, if any. + + +sentence::unlink_all_words() +---------------------------- + + void unlink_all_words(); + +Unlink all words. + + +sentence::get_new_doc() +----------------------- + + bool get_new_doc(string* id = nullptr) const; + +Return true if # newdoc comment is present. Optionally, document id is also +returned (in # newdoc id = ... format). + + +sentence::set_new_doc() +----------------------- + + void set_new_doc(bool new_doc, string_piece id = string_piece()); + +Adds/removes # newdoc comment, optionally with a given document id. + + +sentence::get_new_par() +----------------------- + + bool get_new_par(string* id = nullptr) const; + +Return true if # newpar comment is present. Optionally, paragraph id is also +returned (in # newpar id = ... format). + + +sentence::set_new_par() +----------------------- + + void set_new_par(bool new_par, string_piece id = string_piece()); + +Adds/removes # newpar comment, optionally with a given paragraph id. + + +sentence::get_sent_id() +----------------------- + + bool get_sent_id(string& id) const; + +Return true if # sent_id = ... comment is present, and fill given id with +sentence id. Otherwise, return false and clear id. + + +sentence::set_sent_id() +----------------------- + + void set_sent_id(string_piece id); + +Set the # sent_id = ... comment using given sentence id; if the sentence id is +empty, remove all present # sent_id comment. + + +sentence::get_text() +-------------------- + + bool get_text(string& text) const; + +Return true if # text = ... comment is present, and fill given text with +sentence text. Otherwise, return false and clear text. + + +sentence::set_text() +-------------------- + + void set_text(string_piece text); + +Set the # text = ... comment using given text; if the given text is empty, +remove all present # text comment. + + +Class input_format +------------------ + + class input_format { + public: + virtual ~input_format() {} + + virtual bool read_block(istream& is, string& block) const = 0; + virtual void reset_document(string_piece id = string_piece()) = 0; + virtual void set_text(string_piece text, bool make_copy = false) = 0; + virtual bool next_sentence(sentence& s, string& error) = 0; + + // Static factory methods + static input_format* new_input_format(const string& name); + static input_format* new_conllu_input_format(const string& options = std::string()); + static input_format* new_generic_tokenizer_input_format(const string& options = std::string()); + static input_format* new_horizontal_input_format(const string& options = std::string()); + static input_format* new_vertical_input_format(const string& options = std::string()); + + static input_format* new_presegmented_tokenizer(input_format* tokenizer); + + static const string CONLLU_V1; + static const string CONLLU_V2; + static const string GENERIC_TOKENIZER_NORMALIZED_SPACES; + static const string GENERIC_TOKENIZER_PRESEGMENTED; + static const string GENERIC_TOKENIZER_RANGES; + }; + +The input_format class allows loading sentences in various formats. + +Th class instances may store internal state and are not thread-safe. + + +input_format::read_block() +-------------------------- + + virtual bool read_block(istream& is, string& block) const = 0; + +Read a portion of input, which is guaranteed to contain only complete sentences. +Such portion is usually a paragraph (text followed by an empty line) or a line, +but it may be more complex (i.e., in a XML-like format). + + +input_format::reset_document() +------------------------------ + + virtual void reset_document(string_piece id = string_piece()) = 0; + +Resets the input_format instance state. Such state is needed not only for +remembering unprocessed text of the last set_text call, but also for correct +inter-block state tracking (for example to track document-level ranges or +inter-sentence spaces -- if you pass only spaces to set_text, these spaces has +to accumulate and be returned as preceding spaces of the next sentence). + +If applicable, first read sentence will have the # newdoc comment, optionally +with given document id. + + +input_format::set_text() +------------------------ + + virtual void set_text(string_piece text, bool make_copy = false) = 0; + +Set the text from which the sentences will be read. + +If make_copy is false, only a reference to the given text is stored and the user +has to make sure it exists until the instance is destroyed or set_text is called +again. If make_copy is true, a copy of the given text is made and retained until +the instance is destroyed or set_text is called again. + + +input_format::next_sentence() +----------------------------- + + virtual bool next_sentence(sentence& s, string& error) = 0; + +Try reading another sentence from the text specified by set_text. Returns true +if the sentence was read and false if the text ended or there was a read error. +The latter two conditions can be distinguished by the error parameter - if it is +empty, the text ended, if it is nonempty, it contains a description of the read +error. + + +input_format::new_input_format() +-------------------------------- + + static input_format* new_input_format(const string& name); + +Create new input_format instance, given its name. The individual input formats +can be parametrized by using format=data syntax. The following input formats are +currently supported: +- conllu: return the new_conllu_input_format +- generic_tokenizer: return the new_generic_tokenizer_input_format +- horizontal: return the new_horizontal_input_format +- vertical: return the new_vertical_input_format + +The new instance must be deleted after use. + + +input_format::new_conllu_input_format() +--------------------------------------- + + static input_format* new_conllu_input_format(const string() options = std::string()); + +Create input_format instance which loads sentences in the CoNLL-U format +(http://universaldependencies.github.io/docs/format.html). The new instance must +be deleted after use. + +Supported options: +- v2 (default): use CoNLL-U v2 +- v1: allow loading only CoNLL-U v1 (i.e., no empty nodes and no spaces in + forms and lemmas) + + +input_format::new_generic_tokenizer_input_format() +-------------------------------------------------- + + static input_format* new_generic_tokenizer_input_format(const string() options = std::string()); + +Create rule-based generic tokenizer for English-like languages (with spaces +separating tokens and English-like punctuation). The new instance must be +deleted after use. + +Supported options: +- normalized_spaces: by default, UDPipe uses custom misc fields to exactly + encode spaces in the original document. If normalized_spaces option is given, + only standard CoNLL-U v2 markup (SpaceAfter=No and # newpar) is used. +- presegmented: input is assumed to be already segmented, with every sentence + on a line, and is only tokenized (respecting sentence breaks) +- ranges: for every token, range in the original document is stored in a format + described in token class + + +input_format::new_horizontal_input_format() +------------------------------------------- + + static input_format* new_horizontal_input_format(const string() options = std::string()); + +Create input_format instance which loads forms from a simple horizontal format - +each sentence on a line, with word forms separated by spaces. The new instance +must be deleted after use. + +In order to allow spaces in tokens, Unicode character 'NO-BREAK SPACE' (U+00A0) +is considered part of token and converted to a space during loading. + + +input_format::new_vertical_input_format() +----------------------------------------- + + static input_format* new_vertical_input_format(const string() options = std::string()); + +Create input_format instance which loads forms from a simple vertical format - +each word on a line, with empty line denoting end of sentence. The new instance +must be deleted after use. + + +input_format::new_presegmented_tokenizer() +------------------------------------------ + + static input_format* new_presegmented_tokenizer(input_format* tokenizer); + +Create input_format instance which acts as a tokenizer adapter - given a +tokenizer which segments anywhere, it creates a tokenizer which segments on +newline characters (by calling the tokenizer on individual lines, and if the +tokenizer segments in the middle of the line, it calls it repeatedly and merges +the results). + +The new instance must be deleted after use. Note that the new instance takes +ownership of the given tokenizer and deletes it during its own deletion. + + +Class output_format +------------------- + + class output_format { + public: + virtual ~output_format() {} + + virtual void write_sentence(const sentence& s, ostream& os) = 0; + virtual void finish_document(ostream& os) {}; + + // Static factory methods + static output_format* new_output_format(const string& name); + static output_format* new_conllu_output_format(const string() options = std::string()); + static output_format* new_epe_output_format(const string() options = std::string()); + static output_format* new_matxin_output_format(const string() options = std::string()); + static output_format* new_horizontal_output_format(const string() options = std::string()); + static output_format* new_plaintext_output_format(const string() options = std::string()); + static output_format* new_vertical_output_format(const string() options = std::string()); + + static const string CONLLU_V1; + static const string CONLLU_V2; + static const string HORIZONTAL_PARAGRAPHS; + static const string PLAINTEXT_NORMALIZED_SPACES; + static const string VERTICAL_PARAGRAPHS; + }; + +The output_format class allows printing sentences in various formats. + +The class instances may store internal state and are not thread-safe. + + +output_format::write_sentence() +------------------------------- + + virtual void write_sentence(const sentence& s, ostream& os) = 0; + +Write given sentence to the given output stream. + +When the output format requires document-level markup, it is written +automatically when the first sentence is written using this output_format +instance (or after finish_document call). + + +output_format::finish_document() +-------------------------------- + + virtual void finish_document(ostream& os) {}; + +When the output format requires document-level markup, write the end-of-document +mark and reset the output_format instance state (i.e., the next write_sentence +will write start-of-document mark). + + +output_format::new_output_format() +---------------------------------- + + static output_format* new_output_format(const string& name); + +Create new output_format instance, given its name. The following output formats +are currently supported: +- conllu: return the new_conllu_output_format +- epe: return the new_epe_output_format +- matxin: return the new_matxin_output_format +- horizontal: return the new_horizontal_output_format +- plaintext: return the new_plaintext_output_format +- vertical: return the new_vertical_output_format + +The new instance must be deleted after use. + + +output_format::new_conllu_output_format() +----------------------------------------- + + static output_format* new_conllu_output_format(const string() options = std::string()); + +Creates output_format instance for writing sentences in the CoNLL-U format +(http://universaldependencies.github.io/docs/format.html). The new instance must +be deleted after use. + +Supported options: +- v2 (default): use CoNLL-U v2 +- v1: produce output in CoNLL-U v1 format. Note that this is a lossy process, + as empty nodes are ignored and spaces in forms and lemmas are converted to + underscores. + + +output_format::new_epe_output_format() +-------------------------------------- + + static output_format* new_epe_output_format(const string() options = std::string()); + +Creates output_format instance for writing sentences in the EPE (Extrinsic +Parser Evaluation 2017) interchange format. The new instance must be deleted +after use. + + +output_format::new_matxin_output_format() +----------------------------------------- + + static output_format* new_matxin_output_format(const string() options = std::string()); + +Creates output_format instance for writing sentences in the Matxin format - +UDPipe produces a XML with the following DTD: + + + + + + +The new instance must be deleted after use. + + +output_format::new_plaintext_output_format() +-------------------------------------------- + + static output_format* new_plaintext_output_format(const string() options = std::string()); + +Creates output_format instance for writing sentence tokens (in the UD sense) +using original spacing. By default, UDPipe custom misc features (see description +of token class) are used to reconstruct the exact original spaces. However, if +the document does not contain these features or if only normalized spacing is +wanted, you can use the following option: +- normalized_spaces: write one sentence on a line, and either one or no space + between tokens, using the SpaceAfter=No feature + + +output_format::new_horizontal_output_format() +--------------------------------------------- + + static output_format* new_horizontal_output_format(const string() options = std::string()); + +Creates output_format instance for writing sentences in a simple horizontal +format - each sentence on a line, with word forms separated by spaces. The new +instance must be deleted after use. + +Because words can contain spaces in CoNLL-U v2, the spaces in words are +converted to Unicode character 'NO-BREAK SPACE' (U+00A0). + +Supported options: +- paragraphs: if given, an empty line is printed after the end of a paragraph + or a document (recognized by # newpar or # newdoc comments) + + +output_format::new_vertical_output_format() +------------------------------------------- + + static output_format* new_vertical_output_format(const string() options = std::string()); + +Creates output_format instance for writing sentences in a simple vertical format +- each word form on a line, with empty line denoting end of sentence. The new +instance must be deleted after use. + +Supported options: +- paragraphs: if given, an empty line is printed after the end of a paragraph + or a document (recognized by # newpar or # newdoc comments) + + +Class model +----------- + + class model { + public: + virtual ~model() {} + + static model* load(const char* fname); + static model* load(istream& is); + + virtual input_format* new_tokenizer(const string& options) const = 0; + virtual bool tag(sentence& s, const string& options, string& error) const = 0; + virtual bool parse(sentence& s, const string& options, string& error) const = 0; + + static const string DEFAULT; + static const string TOKENIZER_NORMALIZED_SPACES; + static const string TOKENIZER_PRESEGMENTED; + static const string TOKENIZER_RANGES; + }; + +Class representing UDPipe model, allowing to perform tokenization, tagging and +parsing. + + +model::load(const char*) +------------------------ + + static model* load(const char* fname); + +Load a new model from a given file, returning NULL on failure. The new instance +must be deleted after use. + + +model::load(istream&) +--------------------- + + static model* load(istream& is); + +Load a new model from a given input stream, returning NULL on failure. The new +instance must be deleted after use. + + +model::new_tokenizer() +---------------------- + + virtual input_format* new_tokenizer(const string& options) const = 0; + +Construct a new tokenizer (or NULL if no tokenizer is specified by the model). +The new instance must be deleted after use. + + +model::tag() +------------ + + virtual bool tag(sentence& s, const string& options, string& error) const = 0; + +Tag the given sentence. + + +model::parse() +-------------- + + virtual bool parse(sentence& s, const string& options, string& error) const = 0; + +Parse the given sentence. + + +Class pipeline +-------------- + + class pipeline { + public: + pipeline(const model* m, const string& input, const string& tagger, const string& parser, const string& output); + + void set_model(const model* m); + void set_input(const string& input); + void set_tagger(const string& tagger); + void set_parser(const string& parser); + void set_output(const string& output); + + void set_immediate(bool immediate); + void [set_document_id #pipeline_set_document_id[(const string& document_id); + + bool process(istream& is, ostream& os, string& error) const; + + static const string DEFAULT; + static const string NONE; + }; + +The pipeline class allows simple file-to-file processing. A model and +input/tagger/parser/output options can be specified in the pipeline. + +The input file can be processed either after fully loaded (default), or in +immediate mode, in which case is the input processed and printed as soon as a +block of input guaranteed to contain whole sentences is loaded. Specifically, +for most input formats the input is processed after loading an empty line (with +the exception of horizontal input format and presegmented tokenizer, where the +input is processed after loading every line). + + +pipeline::set_model() +--------------------- + + void set_model(const model* m); + +Use the given model. + + +pipeline::set_input() +--------------------- + + void set_input(const string& input); + +Use the given input format. In addition to formats described in +new_input_format, a special tokenizer or tokenizer=options format allows using +the model tokenizer. + + +pipeline::set_tagger() +---------------------- + + void set_tagger(const string& tagger); + +Use the given tagger options. + + +pipeline::set_parser() +---------------------- + + void set_parser(const string& parser); + +Use the given parser options. + + +pipeline::set_output() +---------------------- + + void set_output(const string& output); + +Use the given output format (see new_output_format for a list). + + +pipeline::set_immediate() +------------------------- + + void set_immediate(bool immediate); + +Set or reset the immediate mode (default is immediate=false). + + +pipeline::set_document_id() +--------------------------- + + void set_document_id(const string& document_id); + +Set document id, which is passed to input_format::reset_document). + + +pipeline::process() +------------------- + + bool process(istream& is, ostream& os, string& error) const; + +Process the given input stream, writing results to the given output stream. If +the processing succeeded, true is returned; otherwise, false is returned with an +error stored in the error argument. + + +Class trainer +------------- + + class trainer { + public: + static bool train(const string& method, const vector& train, const vector& heldout, + const string& tokenizer, const string& tagger, const string& parser, + ostream& os, string& error); + + static const string DEFAULT; + static const string NONE; + }; + +Class allowing training a UDPipe model. + + +trainer::train() +---------------- + + static bool train(const string& method, const vector& train, const vector& heldout, + const string& tokenizer, const string& tagger, const string& parser, + ostream& os, string& error); + +Train a UDPipe model. The only supported method is currently morphodita_parsito. +Use the supplied train and heldout data, and given tokenizer, tagger and parser +options (see the Training UDPipe Models section in the User's Manual). + +If the training succeeded, true is returned and the model is saved to the given +os stream; otherwise, false is returned with an error stored in the error +argument. + + +Class evaluator +--------------- + + class evaluator { + public: + evaluator(const model* m, const string& tokenizer, const string& tagger, const string& parser); + + void set_model(const model* m); + void set_tokenizer(const string& tokenizer); + void set_tagger(const string& tagger); + void set_parser(const string& parser); + + bool evaluate(istream& is, ostream& os, string& error) const; + + static const string DEFAULT; + static const string NONE; + }; + +Class evaluating performance of given model on CoNLL-U file. + +Three different settings (depending on whether tokenizer, tagger and parser is +used) can be evaluated. For details, see Measuring Model Accuracy in User's +Manual. + + +evaluator::set_model() +---------------------- + + void set_model(const model* m); + +Use the given model. + + +evaluator::set_tokenizer() +-------------------------- + + void set_tokenizer(const string& tokenizer); + +Use the given tokenizer options; pass DEFAULT to use default options or NONE not +to use a tokenizer. + + +evaluator::set_tagger() +----------------------- + + void set_tagger(const string& tagger); + +Use the given tagger options; pass DEFAULT to use default options or NONE not to +use a tagger. + + +evaluator::set_parser() +----------------------- + + void set_parser(const string& parser); + +Use the given parser options; pass DEFAULT to use default options or NONE not to +use a parser. + + +evaluator::evaluate() +--------------------- + + bool evaluate(istream& is, ostream& os, string& error) const; + +Evaluate the specified model on the given CoNLL-U input read from is stream. + +If the evaluation succeeded, true is returned and the evaluation results are +written to the os stream in a plain text format; otherwise, false is returned +with an error stored in the error argument. + + +Class version +------------- + + class version { + public: + unsigned major; + unsigned minor; + unsigned patch; + string prerelease; + + static version current(); + }; + +The version class represents UDPipe version. See UDPipe Versioning for more +information. + + +version::current +---------------- + + static version current(); + +Returns current UDPipe version. + + +C++ Bindings API +---------------- + +Bindings for other languages than C++ are created using SWIG from the C++ +bindings API, which is a slightly modified version of the native C++ API. Main +changes are replacement of string_piece type by native strings and removal of +methods using istream. Here is the C++ bindings API declaration: + + +Helper Structures +----------------- + + typedef vector Children; + + typedef vector Comments; + + class ProcessingError { + public: + bool occurred(); + string message; + }; + + class Token { + public: + string form; + string misc; + + Token(const string& form = string(), const string& misc = string()); + + // CoNLL-U defined SpaceAfter=No feature + bool getSpaceAfter() const; + void setSpaceAfter(bool space_after); + + // UDPipe-specific all-spaces-preserving SpacesBefore and SpacesAfter features + string getSpacesBefore() const; + void setSpacesBefore(const string& spaces_before); + string getSpacesAfter() const; + void setSpacesAfter(const string& spaces_after); + string getSpacesInToken() const; + void setSpacesInToken(const string& spaces_in_token); + + // UDPipe-specific TokenRange feature + bool getTokenRange() const; + size_t getTokenRangeStart() const; + size_t getTokenRangeEnd() const; + void setTokenRange(size_t start, size_t end); + }; + + class Word : public Token { + public: + // form and misc are inherited from token + int id; // 0 is root, >0 is sentence word, <0 is undefined + string lemma; // lemma + string upostag; // universal part-of-speech tag + string xpostag; // language-specific part-of-speech tag + string feats; // list of morphological features + int head; // head, 0 is root, <0 is undefined + string deprel; // dependency relation to the head + string deps; // secondary dependencies + + Children children; + + Word(int id = -1, const string& form = string()); + }; + typedef vector Words; + + class MultiwordToken : public Token { + public: + // form and misc are inherited from token + int idFirst, idLast; + + MultiwordToken(int id_first = -1, int id_last = -1, const string& form = string(), const string& misc = string()); + }; + typedef vector MultiwordTokens; + + class EmptyNode { + public: + int id; // 0 is root, >0 is sentence word, <0 is undefined + int index; // index for the current id, should be numbered from 1, 0=undefined + string form; // form + string lemma; // lemma + string upostag; // universal part-of-speech tag + string xpostag; // language-specific part-of-speech tag + string feats; // list of morphological features + string deps; // secondary dependencies + string misc; // miscellaneous information + + EmptyNode(int id = -1, int index = 0) : id(id), index(index) {} + }; + typedef vector EmptyNodes; + + class Sentence { + public: + Sentence(); + + Words words; + MultiwordTokens multiwordTokens; + EmptyNodes emptyNodes; + Comments comments; + static const string rootForm; + + // Basic sentence modifications + bool empty(); + void clear(); + virtual Word& addWord(const char* form); + void setHead(int id, int head, const string& deprel); + void unlinkAllWords(); + + // CoNLL-U defined comments + bool getNewDoc() const; + string getNewDocId() const; + void setNewDoc(bool new_doc, const string& id = string()); + bool getNewPar() const; + string getNewParId() const; + void setNewPar(bool new_par, const string& id = string()); + + string getSentId() const; + void setSentId(const string& id); + string getText() const; + void setText(const string& id); + }; + typedef vector Sentences; + + +Main Classes +------------ + + class InputFormat { + public: + virtual void resetDocument(const string& id = string()); + virtual void setText(const char* text); + virtual bool nextSentence(Sentence& s, ProcessingError* error = nullptr); + + static InputFormat* newInputFormat(const string& name); + static InputFormat* newConlluInputFormat(const string& id = string()); + static InputFormat* newGenericTokenizerInputFormat(const string& id = string()); + static InputFormat* newHorizontalInputFormat(const string& id = string()); + static InputFormat* newVerticalInputFormat(const string& id = string()); + + static InputFormat* newPresegmentedTokenizer(InputFormat tokenizer); + + static const string CONLLU_V1; + static const string CONLLU_V2; + static const string GENERIC_TOKENIZER_NORMALIZED_SPACES; + static const string GENERIC_TOKENIZER_PRESEGMENTED; + static const string GENERIC_TOKENIZER_RANGES; + }; + + class OutputFormat { + public: + virtual string writeSentence(const Sentence& s); + virtual string finishDocument(); + + static OutputFormat* newOutputFormat(const string& name); + static OutputFormat* newConlluOutputFormat(const string& options = string()); + static OutputFormat* newEpeOutputFormat(const string& options = string()); + static OutputFormat* newMatxinOutputFormat(const string& options = string()); + static OutputFormat* newHorizontalOutputFormat(const string& options = string()); + static OutputFormat* newPlaintextOutputFormat(const string& options = string()); + static OutputFormat* newVerticalOutputFormat(const string& options = string()); + + static const string CONLLU_V1; + static const string CONLLU_V2; + static const string HORIZONTAL_PARAGRAPHS; + static const string PLAINTEXT_NORMALIZED_SPACES; + static const string VERTICAL_PARAGRAPHS; + }; + + class Model { + public: + static Model* load(const char* fname); + + virtual InputFormat* newTokenizer(const string& options) const; + virtual bool tag(Sentence& s, const string& options, ProcessingError* error = nullptr) const; + virtual bool parse(Sentence& s, const string& options, ProcessingError* error) const; + + static const string DEFAULT; + static const string TOKENIZER_PRESEGMENTED; + }; + + class Pipeline { + public: + Pipeline(const Model* m, const string& input, const string& tagger, const string& parser, const string& output); + + void setModel(const Model* m); + void setInput(const string& input); + void setTagger(const string& tagger); + void setParser(const string& parser); + void setOutput(const string& output); + + void setImmediate(bool immediate); + void setDocumentId(const string& document_id); + + string process(const string& data, ProcessingError* error = nullptr) const; + + static const string DEFAULT; + static const string NONE; + }; + + class Trainer { + public: + + static string train(const string& method, const Sentences& train, const Sentences& heldout, + const string& tokenizer, const string& tagger, const string& parser, + ProcessingError* error = nullptr); + + static const string DEFAULT; + static const string NONE; + }; + + class Evaluator { + public: + Evaluator(const Model* m, const string& tokenizer, const string& tagger, const string& parser); + + void setModel(const Model* m); + void setTokenizer(const string& tokenizer); + void setTagger(const string& tagger); + void setParser(const string& parser); + + string evaluate(const string& data, ProcessingError* error = nullptr) const; + + static const string DEFAULT; + static const string NONE; + }; + + class Version { + public: + unsigned major; + unsigned minor; + unsigned patch; + string prerelease; + + // Returns current version. + static version current(); + }; + + +C# Bindings +----------- + +UDPipe library bindings is available in the Ufal.UDPipe namespace. + +The bindings is a straightforward conversion of the C++ bindings API. The +bindings requires native C++ library libudpipe_csharp (called udpipe_csharp on +Windows). + + +Java Bindings +------------- + +UDPipe library bindings is available in the cz.cuni.mff.ufal.udpipe package. + +The bindings is a straightforward conversion of the C++ bindings API. Vectors do +not have native Java interface, see cz.cuni.mff.ufal.udpipe.Words class for +reference. Also, class members are accessible and modifiable using using +getField and setField wrappers. + +The bindings require native C++ library libudpipe_java (called udpipe_java on +Windows). If the library is found in the current directory, it is used, +otherwise standard library search process is used. The path to the C++ library +can also be specified using static udpipe_java.setLibraryPath(String path) call +(before the first call inside the C++ library, of course). + + +Perl Bindings +------------- + +UDPipe library bindings is available in the Ufal::UDPipe +(http://search.cpan.org/~straka/Ufal-UDPipe/) package. The classes can be +imported into the current namespace using the :all export tag. + +The bindings is a straightforward conversion of the C++ bindings API. Vectors do +not have native Perl interface, see Ufal::UDPipe::Words for reference. Static +methods and enumerations are available only through the module, not through +object instance. + + +Python Bindings +--------------- + +UDPipe library bindings is available in the ufal.udpipe +(http://pypi.python.org/pypi/ufal.udpipe) module. + +The bindings is a straightforward conversion of the C++ bindings API. In Python +2, strings can be both unicode and UTF-8 encoded str, and the library always +produces unicode. In Python 3, strings must be only str. + + +Contact +======= + +Authors: +- Milan Straka (http://ufal.mff.cuni.cz/milan-straka), straka@ufal.mff.cuni.cz + +UDPipe website (http://ufal.mff.cuni.cz/udpipe). + +UDPipe LINDAT/CLARIN entry (http://hdl.handle.net/11234/1-1702). + + +Acknowledgements +================ + +This work has been using language resources developed and/or stored and/or +distributed by the LINDAT/CLARIN project of the Ministry of Education of the +Czech Republic (project LM2010013). + +Acknowledgements for individual language models are listed in UDPipe User's +Manual. + + +Publications +------------ + +- (Straka et al. 2017) Milan Straka and Jana Straková. Tokenizing, POS + Tagging, Lemmatizing and Parsing UD 2.0 with UDPipe + (http://ufal.mff.cuni.cz/~straka/papers/2017-conll_udpipe.pdf). In Proceedings + of the CoNLL 2017 Shared Task: Multilingual Parsing from Raw Text to Universal + Dependencies, Vancouver, Canada, August 2017. +- (Straka et al. 2016) Straka Milan, Hajič Jan, Straková Jana. UDPipe: + Trainable Pipeline for Processing CoNLL-U Files Performing Tokenization, + Morphological Analysis, POS Tagging and Parsing + (http://ufal.mff.cuni.cz/~straka/papers/2016-lrec_udpipe.pdf). In Proceedings + of the Tenth International Conference on Language Resources and Evaluation + (LREC 2016), Portorož, Slovenia, May 2016. + + +Bibtex for Referencing +---------------------- + + @InProceedings{udpipe:2017, + author = {Straka, Milan and Strakov\'{a}, Jana}, + title = {Tokenizing, POS Tagging, Lemmatizing and Parsing UD 2.0 with UDPipe}, + booktitle = {Proceedings of the CoNLL 2017 Shared Task: Multilingual Parsing from Raw Text to Universal Dependencies}, + month = {August}, + year = {2017}, + address = {Vancouver, Canada}, + publisher = {Association for Computational Linguistics}, + pages = {88--99}, + url = {http://www.aclweb.org/anthology/K/K17/K17-3009.pdf} + } + + +Persistent Identifier +--------------------- + +If you prefer to reference UDPipe by a persistent identifier (PID), you can use +http://hdl.handle.net/11234/1-1702. diff --git a/UDPipe/v1/XDependencies/UDPipe/MANUAL.html b/UDPipe/v1/XDependencies/UDPipe/MANUAL.html new file mode 100644 index 0000000000000000000000000000000000000000..ce7449d078b2c6234e74a6246ad44016c3fd7760 --- /dev/null +++ b/UDPipe/v1/XDependencies/UDPipe/MANUAL.html @@ -0,0 +1,6372 @@ + + + + + +UDPipe + + + + + +
+ +
    +
  1. Introduction +
    2. +
  2. Online Web Application and Web Service +
    3. +
  3. Release + +
    4. +
  4. UDPipe Installation + +
    5. +
  5. UDPipe User's Manual + +
    6. +
  6. UDPipe API Reference + +
    7. +
  7. Contact +
    8. +
  8. Acknowledgements + +
    9. +
+ +
+
+ + +

1. Introduction

+ +

+UDPipe is a trainable pipeline for tokenization, tagging, lemmatization and +dependency parsing of CoNLL-U files. UDPipe is language-agnostic and can be trained given +annotated data in CoNLL-U format. Trained models are provided for +nearly all UD treebanks. UDPipe is available as a binary for Linux/Windows/OS X, as a library for +C++, Python, Perl, Java, C#, and as a web service. +

+

+UDPipe is a free software distributed under the +Mozilla Public License 2.0 and the linguistic models +are free for non-commercial use and distributed under the +CC BY-NC-SA license, although for some +models the original data used to create the model may impose additional +licensing conditions. UDPipe is versioned using Semantic Versioning. +

+

+Copyright 2017 by Institute of Formal and Applied Linguistics, Faculty of +Mathematics and Physics, Charles University, Czech Republic. +

+ + +

2. Online Web Application and Web Service

+ +

+UDPipe Web Application is available at http://lindat.mff.cuni.cz/services/udpipe/ +using LINDAT/CLARIN infrastructure. +

+

+UDPipe REST Web Service is also available, with the API documentation available at +http://lindat.mff.cuni.cz/services/udpipe/api-reference.php. +

+ + +

3. Release

+ + +

3.1. Download

+ +

+UDPipe releases are available on GitHub, both as +source code and as a pre-compiled binary package. The binary package contains Linux, +Windows and OS X binaries, Java bindings binary, C# bindings binary, and source +code of UDPipe and all language bindings). While the binary +packages do not contain compiled Python or Perl bindings, packages for those +languages are available in standard package repositories, +i.e. on PyPI +and CPAN. +

+ + + + +

3.1.1. Language Models

+ +

+To use UDPipe, a language model is needed. The language models are available +from LINDAT/CLARIN infrastructure and described further +in the +UDPipe User's Manual. +Currently, the following language models are available: +

+ + + + +

3.2. License

+ +

+UDPipe is an open-source project and is freely available for non-commercial +purposes. The library is distributed under +Mozilla Public License 2.0 and the associated models and data +under CC BY-NC-SA, although +for some models the original data used to create the model may impose +additional licensing conditions. +

+

+If you use this tool for scientific work, please give credit to us by +referencing Straka et al. 2016 and the +UDPipe website. +

+ + +

4. UDPipe Installation

+ +

+UDPipe releases are available on GitHub, either as +a pre-compiled binary package, or source code only. The binary package contains Linux, +Windows and OS X binaries, Java bindings binary, C# bindings binary, and source +code of UDPipe and all language bindings. While the binary +packages do not contain compiled Python or Perl bindings, packages for those +languages are available in standard package repositories, i.e. on PyPI and CPAN. +

+

+To use UDPipe, a language model is needed. +Here is a list of available language models. +

+

+If you want to compile UDPipe manually, sources are available on on +GitHub, both in the +pre-compiled binary package releases +and in the repository itself. +

+ + +

4.1. Requirements

+ +
    +
  • g++ 4.7 or newer, clang 3.2 or newer, Visual C++ 2015 or newer +
    • +
  • make +
    • +
  • SWIG 3.0.8 or newer for language bindings other than C++ +
    • +
+ + +

4.2. Compilation

+ +

+To compile UDPipe, run make in the src directory. +

+

+Make targets and options: +

+
    +
  • exe: compile the binaries (default) +
    • +
  • server: compile the REST server +
    • +
  • lib: compile the static library +
    • +
  • BITS=32 or BITS=64: compile for specified 32-bit or 64-bit architecture instead of the default one +
    • +
  • MODE=release: create release build which statically links the C++ runtime and uses LTO +
    • +
  • MODE=debug: create debug build +
    • +
  • MODE=profile: create profile build +
    • +
+ + +

4.2.1. Platforms

+ +

+Platform can be selected using one of the following options: +

+
    +
  • PLATFORM=linux, PLATFORM=linux-gcc: gcc compiler on Linux operating system, default on Linux +
    • +
  • PLATFORM=linux-clang: clang compiler on Linux, must be selected manually +
    • +
  • PLATFORM=osx, PLATFORM=osx-clang: clang compiler on OS X, default on OS X; BITS=32+64 enables multiarch build +
    • +
  • PLATFORM=win, PLATFORM=win-gcc: gcc compiler on Windows (TDM-GCC is well tested), default on Windows +
    • +
  • PLATFORM=win-vs: Visual C++ 2015 compiler on Windows, must be selected manually; note that the + cl.exe compiler must be already present in PATH and corresponding BITS=32 or BITS=64 + must be specified +
    • +
+ +

+Either POSIX shell or Windows CMD can be used as shell, it is detected automatically. +

+ + +

4.2.2. Further Details

+ +

+UDPipe uses C++ BuilTem system, +please refer to its manual if interested in all supported options. +

+ + +

4.3. Other language bindings

+ + +

4.3.1. C#

+ +

+Binary C# bindings are available in UDPipe binary packages. +

+

+To compile C# bindings manually, run make in the bindings/csharp +directory, optionally with the options described in UDPipe Installation. +

+ + +

4.3.2. Java

+ +

+Binary Java bindings are available in UDPipe binary packages. +

+

+To compile Java bindings manually, run make in the bindings/java +directory, optionally with the options described in UDPipe Installation. +Java 6 and newer is supported. +

+

+The Java installation specified in the environment variable JAVA_HOME is +used. If the environment variable does not exist, the JAVA_HOME can be +specified using +

+
+make JAVA_HOME=path_to_Java_installation
+
+ + +

4.3.3. Perl

+ +

+The Perl bindings are available as Ufal-UDPipe package on CPAN. +

+

+To compile Perl bindings manually, run make in the bindings/perl +directory, optionally with the options described in UDPipe Installation. +Perl 5.10 and later is supported. +

+

+Path to the include headers of the required Perl version must be specified +in the PERL_INCLUDE variable using +

+
+make PERL_INCLUDE=path_to_Perl_includes
+
+ + +

4.3.4. Python

+ +

+The Python bindings are available as ufal.udpipe package on PyPI. +

+

+To compile Python bindings manually, run make in the bindings/python +directory, optionally with options described in UDPipe Installation. Both +Python 2.6+ and Python 3+ are supported. +

+

+Path to the include headers of the required Python version must be specified +in the PYTHON_INCLUDE variable using +

+
+make PYTHON_INCLUDE=path_to_Python_includes
+
+ + +

5. UDPipe User's Manual

+ +

+Like any supervised machine-learning tool, UDPipe needs a trained linguistic model. +This section describes the available language models and also the command line +tools and interfaces. +

+ + +

5.1. Running UDPipe

+ +

+Probably the most common usage of UDPipe is to tokenize, tag and parse the input using +

+
+udpipe --tokenize --tag --parse udpipe_model
+
+ +

+The input is assumed to be in UTF-8 encoding and can be either already tokenized +and segmented, or it can be a plain text which will be tokenized and segmented automatically. +

+

+Any number of input files can be specified after the udpipe_model and if no +file is given, the standard input is used. The output is by default +saved to the standard output, but if --outfile=name is used, it is saved +to the given file name. The output file name can contain a {}, which is +replaced by a base name of the processed file (i.e., without directories +and an extension). +

+

+The full command syntax of running UDPipe is +

+
+Usage: udpipe [running_opts] udpipe_model [input_files]
+       udpipe --train [training_opts] udpipe_model [input_files]
+       udpipe --detokenize [detokenize_opts] raw_text_file [input_files]
+Running opts: --accuracy (measure accuracy only)
+              --input=[conllu|generic_tokenizer|horizontal|vertical]
+              --immediate (process sentences immediately during loading)
+              --outfile=output file template
+              --output=[conllu|matxin|horizontal|plaintext|vertical]
+              --tokenize (perform tokenization)
+              --tokenizer=tokenizer options, implies --tokenize
+              --tag (perform tagging)
+              --tagger=tagger options, implies --tag
+              --parse (perform parsing)
+              --parser=parser options, implies --parse
+Training opts: --method=[morphodita_parsito] which method to use
+               --heldout=heldout data file name
+               --tokenizer=tokenizer options
+               --tagger=tagger options
+               --parser=parser options
+Detokenize opts: --outfile=output file template
+Generic opts: --version
+              --help
+
+ + +

5.1.1. Immediate Mode

+ +

+By default UDPipe loads the whole input file into memory before starting +to process it. That allows to store the space markup (see the following Tokenizer +section) in most consistent way, i.e., store all spaces following a sentence +in the last token of that sentence. +

+

+However, sometimes it is desirable to process the input as soon as possible, +which can be achieved by specifying the --immediate option. In immediate mode, +the input is processed and printed as soon as a block of input guaranteed to contain +whole sentences is loaded. Specifically, for most input formats the input is +processed after loading an empty line (with the exception of horizontal +input format and presegmented tokenizer, where the input is processed after +each line). +

+ + +

5.1.2. Loading Model On Demand

+ +

+Although a model for UDPipe always has to be specified, the model is loaded +only if really needed. It is therefore possible to use for example none +as the model in case it is not required for performing the requested +operation (e.g., converting between formats or using a generic tokenizer). +

+ + +

5.1.3. Tokenizer

+ +

+If the --tokenize option is supplied, the input is assumed to be +plain text and is tokenized using model tokenizer. Additional arguments to the +tokenizer might be specified using --tokenizer=data option (which implies +--tokenize), where data is a semicolon-separated list of the following options: +

+
    +
  • normalized_spaces: by default, UDPipe uses custom MISC fields to exactly + encode spaces in the original document (as described below). If the + normalized_spaces option is given, only the standard CoNLL-U v2 markup + (SpaceAfter=No and # newpar) is used. +
    • +
  • presegmented: the input file is assumed to be already segmented, with each + sentence on a separate line, and is only tokenized (respecting sentence breaks) +
    • +
  • ranges: for each token, a range in the original document is stored in the + format described below. +
    • +
  • joint_with_parsing: an experimental mode performing sentence segmentation + jointly using the tokenizer and the parser (see Milan Straka and Jana Straková: Tokenizing, POS Tagging, Lemmatizing and Parsing UD 2.0 with UDPipe paper for details). + The following options are utilized: +
      +
    • joint_max_sentence_len (default 20): maximum sentence length +
      • +
    • joint_change_boundary_logprob (default -0.5): logprob of using sentence boundary not generated by the tokenizer +
      • +
    • joint_sentence_logprob (default -0.5): additional logprob of every sentence +
      • +
    + The logprob of a sentence is computed using logprob of its best dependency parsing tree, + together with joint_sentence_logprob and also joint_change_boundary_logprob + for every sentence boundary not returned by the tokenizer (i.e., either 0, 1 or 2 times). + The joint sentence segmentation chooses such a segmentation, where every + sentence has length at most joint_max_sentence_len and the sum of logprobs of all sentences + is as large as possible. +
    • +
+ + +

5.1.3.1. Preserving Original Spaces

+ +

+By default, UDPipe uses custom MISC fields to store all spaces in the original +document. This markup is backward compatible with CoNLL-U v2 SpaceAfter=No feature. +This markup can be utilized by the plaintext output format, which allows reconstructing +the original document. +

+

+Note that in theory not only spaces, but also other original content can be saved in this +way (for example XML tags if the input was encoded in a XML file). +

+

+The markup uses the following MISC fields on tokens (not words in multi-word tokens): +

+
    +
  • SpacesBefore=content (by default empty): spaces/other content preceding the token +
    • +
  • SpacesAfter=content (by default a space if SpaceAfter=No feature is not present, empty otherwise): + spaces/other content following the token +
    • +
  • SpacesInToken=content (by default equal to the FORM of the token): FORM of the token + including original spaces (this is needed only if tokens are allowed to contain spaces and + a token contains a tab or newline characters) +
    • +
+ +

+The content of all the three fields must be escaped to allow storing tabs and newlines. +The following C-like schema is used: +

+
    +
  • \s: space +
    • +
  • \t: tab +
    • +
  • \r: CR character +
    • +
  • \n: LF character +
    • +
  • \p: | (pipe character) +
    • +
  • \\: \ (backslash character) +
    • +
+ + +

5.1.3.2. Preserving Token Ranges

+ +

+When the ranges tokenizer option is used, the range of each token in the original document +is stored in the TokenRange MISC field. +

+

+The format of the TokenRange field (inspired by Python) is TokenRange=start:end, +where start is a zero-based document-level index of the start of the token +(counted in Unicode characters) and end is a zero-based document-level index +of the first character following the token (i.e., the length of the token is end-start). +

+ + +

5.1.4. Input Formats

+ +

+If the tokenizer is not used, the input format can be specified using the +--input option. The individual input formats can be parametrized in the +same way a tokenizer is, by using format=data syntax. Currently supported +input formats are: +

+
    +
  • conllu (default): the CoNLL-U format. + Supported options: +
      +
    • v2 (default): use CoNLL-U v2 +
      • +
    • v1: allow loading only CoNLL-U v1 (i.e., no empty nodes and no spaces in forms and lemmas) +
      • +
    +
    • +
  • generic_tokenizer: generic tokenizer for English-like languages (with spaces separating tokens + and English-like punctuation). The tokenizer is rule-based and needs no trained model. + It supports the same options as a model tokenizer, i.e., normalized_spaces, presegmented + and ranges. +
    • +
  • horizontal: each sentence on a separate line, with tokens separated by spaces. In order to allow + spaces in tokens, Unicode character 'NO-BREAK SPACE' (U+00A0) is considered part of token + and converted to a space during loading. +
    • +
  • vertical: each token on a separate line, with an empty line denoting end of sentence; + only the first tab-separated word is used as a token, the rest of the line is ignored. +
    • +
+ +

+Note that a model tokenizer can be specified using the --input option too, by +using the tokenizer input format, for example using --input tokenizer=ranges. +

+ + +

5.1.5. Tagger

+ +

+If the --tag option is supplied, the input is POS tagged and lemmatized +using the model tagger. Additional arguments to the tagger might be +specified using the --tagger=data option (which implies --tag). +

+ + +

5.1.6. Dependency Parsing

+ +

+If the --parse option is supplied, the input is parsed using +the model dependency parser. Additional arguments to the parser might be +specified using the --parser=data option (which implies --parse). +

+ + +

5.1.7. Output Formats

+ +

+The output format is specified using the --output option. The individual +output formats can be parametrized in the same way as input formats, by using the +format=data syntax. Currently supported output formats are: +

+
    +
  • conllu (default): the CoNLL-U format + Supported options: +
      +
    • v2 (default): use CoNLL-U v2 +
      • +
    • v1: produce output in CoNLL-U v1 format. Note that this is a lossy process, as + empty nodes are ignored and spaces in forms and lemmas are converted to underscores. +
      • +
    +
    • +
  • matxin: the Matxin format +
    • +
  • horizontal: writes the words (in the UD sense) in horizontal format, + that is, each sentence is on a separate line, with words separated by + a single space. Because words can contain spaces in CoNLL-U v2, the spaces in + words are converted to Unicode character 'NO-BREAK SPACE' (U+00A0). + Supported options: +
      +
    • paragraphs: an empty line is printed after the end of a paragraph + or a document (recognized by # newpar or # newdoc comments) +
      • +
    +
    • +
  • plaintext: writes the tokens (in the UD sense) using original spacing. + By default, UDPipe's custom MISC features (SpacesBefore, SpacesAfter and SpacesInToken, + see the description in the Tokenizer section) are used to reconstruct the exact original spaces. + However, if the document does not contain these features or if you want only normalized + spacing, you can use the following option: +
      +
    • normalized_spaces: write one sentence on a line, and either one or no space between + tokens according to the SpaceAfter=No feature +
      • +
    +
    • +
  • vertical: each word on a separate line, with an empty line denoting the end of sentence. + Supported options: +
      +
    • paragraphs: an empty line is printed after the end of a paragraph + or a document (recognized by # newpar or # newdoc comments) +
      • +
    +
    • +
+ + +

5.2. Running the UDPipe REST Server

+ +

+UDPipe also provides a REST server binary called udpipe_server. +The binary uses MicroRestD as a REST +server implementation and provides +UDPipe REST API. +

+

+The full command syntax of udpipe_server is +

+
+udpipe_server [options] port default_model (rest_id model_file acknowledgements)*
+Options: --concurrent_models=maximum concurrently loaded models (default 10)
+         --daemon (daemonize after start)
+         --no_check_models_loadable (do not check models are loadable)
+         --no_preload_default (do not preload default model)
+
+ +

+The udpipe_server can run either in foreground or in background (when +--daemon is used). +

+

+Since UDPipe 1.1.1, the models are loaded on demand, so that at most +concurrent_models (default 10) are kept in memory at the same time. +The model files are opened during start and never closed until the server +stops. Unless no_check_models_loadable is specified, the model files +are also checked to be loadable during start. Note that the default model +is preloaded and never released, unless no_preload_default is given. +(Before UDPipe 1.1.1, specified model files were loaded during start and +kept in memory all the time.) +

+ + +

5.3. Training UDPipe Models

+ +

+Custom UDPipe models can be trained using the following syntax: +

+
+udpipe --train model.output [--heldout=heldout_data] training_file ...
+
+ +

+The training data should be in the CoNLL-U format. +

+

+By default, three model components are trained – tokenizer, tagger and +parser. Any subset of the model components can be trained and a model +component may be copied from an existing model. +

+

+The training options are specified for each model component separately +using the --tokenizer, --tagger and --parser options. +If a model component should not be trained, value none should +be used (e.g., --tagger=none). +

+

+The options are name=value pairs separated by a semicolon. The +value can be either a simple string value (ending by a semicolon), +file content specified as name=file:filename, or an arbitrary +string value specified as name=data:length:value, where the value +is exactly length bytes long. +

+ + +

5.3.1. Reusing Components from Existing Models

+ +

+The model components (tagger, parser or tagger) can be reused from +existing models, by specifying the from_model=file:filename option. +

+ + +

5.3.2. Random Hyperparameter Search

+ +

+The default values of hyperparameters are set to the values +which were used the most during UD 1.2 models training, but if you +want to reach best performance, the hyperparameters must be tuned. +

+

+Apart from manual grid search, UDPipe can perform a simple random search. +You can perform the random search by repeatedly training UDPipe +(preferably in parallel, most likely on different computers) +while specifying different training run number – some of the +hyperparameters (chosen by us; you can of course override their value +by specifying it on the command line) change their values in different +training runs. The pseudorandom sequences of hyperparameters +are of course deterministic. +

+

+The training run can be specified by providing the run=number option +to a model component. The run number 1 is the default one (with the best +hyperparameters for the UD 1.2 models), run numbers 2 and more randomize +the hyperparameters. +

+ + +

5.3.3. Tokenizer

+ +

+The tokenizer is trained using the SpaceAfter=No features in the CoNLL-U files. +If the feature is not present, a detokenizer can be used to guess +the SpaceAfter=No features according to a supplied plain text +(which typically does not overlap with the texts in the CoNLL-U files). +

+

+In order to use the detokenizer, use the detokenizer=file:filename_with_plaintext +option. In UD 1.2 models, the optimal performance is achieved with very small plain +texts – only 500kB. +

+

+The tokenizer recognizes the following options: +

+
    +
  • tokenize_url (default 1): tokenize URLs and emails using a manually + implemented recognizer +
    • +
  • allow_spaces (default 1 if any token contains a space, 0 otherwise): allow tokens to contain spaces +
    • +
  • dimension (default 24): dimension of character embeddings and of the per-character bidirectional + GRU. Note that inference time is quadratic in this parameter. Supported values + are only 16, 24 and 64, with 64 needed only for languages with complicated tokenization + like Japanese, Chinese or Vietnamese. +
    • +
  • epochs (default 100): the number of epochs to train the tokenizer for +
    • +
  • batch_size (default 50): batch size used during tokenizer training +
    • +
  • learning_rate (default 0.005): the learning rate used during tokenizer training +
    • +
  • dropout (default 0.1): dropout used during tokenizer training +
    • +
  • early_stopping (default 1 if heldout is given, 0 otherwise): perform + early stopping, choosing training iteration maximizing sentences F1 score plus + tokens F1 score on heldout data +
    • +
+ +

+During random hyperparameter search, batch_size is chosen uniformly from {50,100} +and learning_rate logarithmically from <0.0005, 0.01). +

+ + +

5.3.3.1. Detokenizing CoNLL-U Files

+ +

+The --detokenizer option allows generating the SpaceAfter=No features +automatically from a given plain text. Even if the current algorithm is very +simple and makes quite a lot of mistakes, the tokenizer trained on generated +features is very close to a tokenizer trained on gold SpaceAfter=No +features (the difference in token F1 score is usually one or two tenths of percent). +

+

+The generated SpaceAfter=No features are only used during tokenizer +training, not printed. However, if you would like to obtain the CoNLL-U files +with automatic detokenization (generated SpaceAfter=No features), you can +run UDPipe with the --detokenize option. In this case, you have to supply +plain text in the given language (usually the best results are achieved with +just 500kB or 1MB of text) and UDPipe then detokenizes all the given CoNLL-U files. +

+

+The complete usage of the --detokenize option is: +

+
+udpipe --detokenize [detokenize_opts] raw_text_file [input_files]
+Detokenize opts: --outfile=output file template
+
+ + +

5.3.4. Tagger

+ +

+The tagging is currently performed using MorphoDiTa. +The UDPipe tagger consists of possibly several MorphoDiTa models, each tagging +some of the POS tags and/or lemmas. +

+

+By default, only one model is constructed, which generates all available tags (UPOS, +XPOS, Feats and Lemma). However, we found out during the UD 1.2 models training +that performance improves if one model tags the UPOS, XPOS and Feats tags, while the +other is performing lemmatization. Therefore, if you utilize two MorphoDiTa models, +by default the first one generates all tags (except lemmas) and the second one performs lemmatization. +

+

+The number of MorphoDiTa models can be specified using the models=number parameter. +All other parameters may be either generic for all models (guesser_suffix_rules=5), +or specific for a given model (guesser_suffix_rules_2=6), including the +from_model option (therefore, MorphoDiTa models can be trained separately +and then combined together into one UDPipe model). +

+

+Every model utilizes UPOS for disambiguation and the first model is the one producing +the UPOS tags on output. +

+

+The tagger recognizes the following options: +

+
    +
  • use_lemma (default for the second model and also if there is only one model): use the + lemma field internally to perform disambiguation; the lemma may be not outputted +
    • +
  • provide_lemma (default for the second model and also if there is only one model): + produce the disambiguated lemma on output +
    • +
  • use_xpostag (default for the first model): use the + XPOS tags internally to perform disambiguation; it may not be outputted +
    • +
  • provide_xpostag (default for the first model): produce the disambiguated XPOS tag on output +
    • +
  • use_feats (default for the first model): use the + Feats internally to perform disambiguation; it may not be outputted +
    • +
  • provide_feats (default for the first model): produce the disambiguated Feats field on output +
    • +
  • dictionary_max_form_analyses (default 0 - unlimited): the maximum number of + (most frequent) form analyses from UD training data that are to be + kept in the morphological dictionary +
    • +
  • dictionary_file (default empty): use a given custom morphological dictionary, where each line contains + 5 tab-separated fields FORM, LEMMA, UPOSTAG, XPOSTAG and FEATS. Note that this dictionary + data is appended to the dictionary created from the UD training data, not replacing it. +
    • +
  • guesser_suffix_rules (default 8): number of rules generated for every suffix +
    • +
  • guesser_prefixes_max (default 4 if ``provide_lemma`, 0 otherwise): maximum + number of form-generating prefixes to use in the guesser +
    • +
  • guesser_prefix_min_count (default 10): minimum number of occurrences of form-generating + prefix to consider using it in the guesser +
    • +
  • guesser_enrich_dictionary (default 6 if no dictionary_file is passed, 0 otherwise): number of rules generated for forms present + in training data (assuming that the analyses from the training data may not be all) +
    • +
  • iterations (default 20): number of training iterations to perform +
    • +
  • early_stopping (default 1 if heldout is given, 0 otherwise): perform + early stopping, choosing training iteration maximizing tagging accuracy on the heldout data +
    • +
  • templates (default lemmatizer for second model, tagger otherwise): MorphoDiTa + feature templates to use, either lemmatizer which focuses more on lemmas, or + tagger which focuses more on UPOS/XPOS/FEATS +
    • +
+ +

+During random hyperparameter search, guesser_suffix_rules is chosen uniformly from +{5,6,7,8,9,10,11,12} and guesser_enrich_dictionary is chosen uniformly from +{3,4,5,6,7,8,9,10}. +

+ + +

5.3.5. Parser

+ +

+The parsing is performed using Parsito, which is a +transition-based parser using a neural-network classifier. +

+

+The transition-based systems can be configured by the following options: +

+
    +
  • transition_system (default projective): which transition system to use for parsing (language dependent, you can choose according + to language properties or try all and choose the best one) +
      +
    • projective: projective stack-based arc standard system with shift, left_arc and right_arc transitions +
      • +
    • swap: fully non-projective system which extends projective system by adding the swap transition +
      • +
    • link2: partially non-projective system which extends projective system by adding left_arc2 and right_arc2 transitions +
      • +
    +
    • +
  • transition_oracle (default dynamic/static_lazy_static whichever first is applicable): which transition oracle to use for the chosen transition_system: +
      +
    • transition_system=projective: available oracles are static and dynamic (dynamic usually gives better results, but training time is slower) +
      • +
    • transition_system=swap: available oracles are static_eager and static_lazy (static_lazy almost always gives better results) +
      • +
    • transition_system=link2: only available oracle is static +
      • +
    +
    • +
  • structured_interval (default 8): use search-based oracle in addition to the translation_oracle specified. This almost always gives better results, but makes training 2-3 times slower. For details, see the paper Straka et al. 2015: Parsing Universal Dependency Treebanks using Neural Networks and Search-Based Oracle +
    • +
  • single_root (default 1): allow only single root when parsing, and make sure only the root node has the root deprel (note that training data are checked to be in this format) +
    • +
+ +

+The Lemmas/UPOS/XPOS/FEATS used by the parser are configured by: +

+
    +
  • use_gold_tags (default 0): if false and a tagger exists, the + Lemmas/UPOS/XPOS/FEATS for both the training and heldout data are generated + by the tagger, otherwise they are taken from the gold data +
    • +
+ +

+The embeddings used by the parser can be specified as follows: +

+
    +
  • embedding_upostag (default 20): the dimension of the UPos embedding used in the parser +
    • +
  • embedding_feats (default 20): the dimension of the Feats embedding used in the parser +
    • +
  • embedding_xpostag (default 0): the dimension of the XPos embedding used in the parser +
    • +
  • embedding_form (default 50): the dimension of the Form embedding used in the parser +
    • +
  • embedding_lemma (default 0): the dimension of the Lemma embedding used in the parser +
    • +
  • embedding_deprel (default 20): the dimension of the Deprel embedding used in the parser +
    • +
  • embedding_form_file: pre-trained word embeddings in word2vec textual format +
    • +
  • embedding_lemma_file: pre-trained lemma embeddings in word2vec textual format +
    • +
  • embedding_form_mincount (default 2): for forms not present in the pre-trained embeddings, + generate random embeddings if the form appears at least this number of times in the + trainig data (forms not present in the pre-trained embeddings and appearing less number + of times are considered OOV) +
    • +
  • embedding_lemma_mincount (default 2): for lemmas not present in the pre-trained embeddings, + generate random embeddings if the lemma appears at least this number of times in the + trainig data (lemmas not present in the pre-trained embeddings and appearing less number + of times are considered OOV) +
    • +
+ +

+The neural-network training options: +

+
    +
  • iterations (default 10): number of training iterations to use +
    • +
  • hidden_layer (default 200): the size of the hidden layer +
    • +
  • batch_size (default 10): batch size used during neural-network training +
    • +
  • learning_rate (default 0.02): the learning rate used during neural-network training +
    • +
  • learning_rate_final (0.001): the final learning rate used during neural-network training +
    • +
  • l2 (0.5): the L2 regularization used during neural-network training +
    • +
  • early_stopping (default 1 if heldout is given, 0 otherwise): perform + early stopping, choosing training iteration maximizing LAS on heldout data +
    • +
+ +

+During random hyperparameter search, structured_interval is chosen uniformly from +{0,8,10}, learning_rate is chosen logarithmically from <0.005,0.04) and +l2 is chosen uniformly from <0.2,0.6). +

+ + +

5.3.5.1. Pre-trained Word Embeddings

+ +

+The pre-trained word embeddings for forms and lemmas can be specified in the +word2vec textual format using the embedding_form_file and +embedding_lemma_file options. +

+

+Note that pre-training word embeddings even on the UD data itself improves the +accuracy (we use word2vec with +-cbow 0 -size 50 -window 10 -negative 5 -hs 0 -sample 1e-1 -threads 12 -binary 0 -iter 15 -min-count 2 +options to pre-train on the UD data after converting it to the horizontal format using +udpipe --output=horizontal). +

+

+Forms and lemmas can contain spaces in CoNLL-U v2, so these spaces are +converted to a Unicode character 'NO-BREAK SPACE' (U+00A0) before performing the +embedding lookup, because spaces are usually used to delimit tokens in word +embedding generating software (both word2vec and glove use spaces to +separate words on input and on output). When using UDPipe to generate +plain texts from CoNLL-U format using --output=horizontal, this space +replacing happens automatically. +

+

+When looking up an embedding for a given word, the following possibilities are +tried in the following order until a match is found (or an embedding for unknown word is returned): +

+
    +
  • original word +
    • +
  • all but the first character lowercased +
    • +
  • all characters lowercased +
    • +
  • if the word contains only digits, just the first digit is tried +
    • +
+ + +

5.3.6. Measuring Model Accuracy

+ +

+Measuring custom model accuracy can be performed by running: +

+
+udpipe --accuracy [udpipe_options] udpipe_model file ...
+
+ +

+The command syntax is similar to the regular UDPipe operation, only +the input must be always in the CoNLL-U format +and the --input and --output options are ignored. +

+

+Three different settings (depending on --tokenize(r), --tag(ger) and --parse(r)) +can be evaluated: +

+
    +
  • --tokenize(r) [--tag(ger) [--parse(r)]]: Tokenizer is used to segment + and tokenize plain text (obtained by SpaceAfter=No features and # newdoc + and # newpar comments in the input file). Optionally, a tagger is used on the + resulting data to obtain Lemma/UPOS/XPOS/Feats columns and eventually a parser + can be used to parse the results. +

    + The tokenizer is evaluated using F1-score on tokens, multi-word tokens, sentences + and words. The words are aligned using a word-alignment algorithm + described in the CoNLL 2017 Shared Task in UD Parsing. + The tagger and parser are evaluated on aligned + words, resulting in F1 scores of Lemmas/UPOS/XPOS/Feats/UAS/LAS. +

    +
    • +
  • --tag(ger) [--parse(r)]: The gold segmented and tokenized input + is tagged (and then optionally parsed using the tagger outputs) + and then evaluated. +

    +
    • +
  • --parse(r): The gold segmented and tokenized input is parsed using + gold morphology (Lemmas/UPOS/XPOS/Feats) and evaluated. +

    +
    • +
+ + +

5.4. Universal Dependencies 2.0 Models

+ +

+Universal Dependencies 2.0 Models are distributed under the +CC BY-NC-SA licence. +The models are based solely on +Universal Dependencies 2.0 treebanks. +The models work in UDPipe version 1.2 and later. +

+

+Universal Dependencies 2.0 Models are versioned according to the date released +in the format YYMMDD, where YY, MM and DD are two-digit +representation of year, month and day, respectively. The latest version is 170801. +

+ + +

5.4.1. Download

+ +

+The latest version 170801 of the Universal Dependencies 2.0 models can be downloaded +from LINDAT/CLARIN repository. +

+ + +

5.4.2. Acknowledgements

+ +

+This work has been partially supported and has been using language resources +and tools developed, stored and distributed by the LINDAT/CLARIN project of the +Ministry of Education, Youth and Sports of the Czech Republic (project LM2015071). +The wark was also partially supported by OP VVV projects +CZ.02.1.01/0.0/0.0/16\_013/0001781 and CZ.02.2.69/0.0/0.0/16\_018/0002373, and +by SVV project number 260 453. +

+

+The models were trained on Universal Dependencies 2.0 treebanks. +

+

+For the UD treebanks which do not contain original plain text version, +raw text is used to train the tokenizer instead. The plain texts +were taken from the W2C – Web to Corpus. +

+ + +

5.4.2.1. Publications

+ + + + +

5.4.3. Model Description

+ +

+The Universal Dependencies 2.0 models contain 68 models of 50 languages, each consisting of +a tokenizer, tagger, lemmatizer and dependency parser, all trained using +the UD data. Note that we use custom train-dev split, by moving sentences from the beginning +of dev data to the end of train data, until the training data is at least 9 times the dev data. +

+

+The tokenizer is trained using the SpaceAfter=No features. If the features +are not present in the data, they can be filled in using raw text in the +language in question. +

+

+The tagger, lemmatizer and parser are trained using gold UD data. +

+

+Details about model architecture and training process can be found in the +(Straka et al. 2017) paper. +

+ + +

5.4.3.1. Reproducible Training

+ +

+In case you want to train the same models, scripts for downloading and +resplitting UD 2.0 data, precomputed word embedding, raw texts for tokenizers, +all hyperparameter values and training scripts are available in the +second archive on the model download page. +

+ + +

5.4.4. Model Performance

+ +

+We present the tagger, lemmatizer and parser performance, measured +on the testing portion of the data, evaluated in three different settings: +using raw text only, using gold tokenization only, and using gold tokenization +plus gold morphology (UPOS, XPOS, FEATS and Lemma). +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
TreebankModeWordsSentsUPOSXPOSFeatsAllTagsLemmaUASLAS
Ancient GreekRaw text100.0%98.7%82.4%72.3%85.8%72.3%82.6%64.4%57.8%
Ancient GreekGold tok--82.4%72.4%85.8%72.3%82.7%64.6%57.9%
Ancient GreekGold tok+morph-------69.2%64.4%
Ancient Greek-PROIELRaw text100.0%47.2%95.8%96.0%88.6%87.2%92.6%71.8%67.1%
Ancient Greek-PROIELGold tok--95.8%96.1%88.7%87.2%92.8%77.2%72.3%
Ancient Greek-PROIELGold tok+morph-------79.7%76.1%
ArabicRaw text93.8%83.1%88.4%83.4%83.5%82.3%87.5%71.7%65.8%
ArabicGold tok--94.4%89.5%89.6%88.3%92.6%81.3%74.3%
ArabicGold tok+morph-------82.9%77.9%
BasqueRaw text100.0%99.5%93.2%-87.6%-93.8%75.8%70.7%
BasqueGold tok--93.3%-87.7%-93.9%75.9%70.8%
BasqueGold tok+morph-------82.3%78.4%
BelarusianRaw text99.4%76.8%88.2%85.6%71.7%68.6%81.3%68.0%60.6%
BelarusianGold tok--88.7%85.7%72.4%69.2%81.5%69.4%61.9%
BelarusianGold tok+morph-------76.8%74.0%
BulgarianRaw text99.9%93.9%97.6%94.6%95.6%94.0%94.6%88.8%84.8%
BulgarianGold tok--97.7%94.7%95.6%94.1%94.7%89.5%85.5%
BulgarianGold tok+morph-------92.6%89.1%
CatalanRaw text100.0%99.2%98.0%98.0%97.1%96.5%97.9%88.8%85.7%
CatalanGold tok--98.0%98.0%97.2%96.5%97.9%88.8%85.8%
CatalanGold tok+morph-------91.1%88.7%
ChineseRaw text90.2%98.8%84.0%83.8%89.0%82.7%90.2%62.9%58.7%
ChineseGold tok--92.2%92.0%98.7%90.8%100.0%75.6%70.1%
ChineseGold tok+morph-------84.1%81.4%
CopticRaw text65.8%35.7%62.6%62.1%65.7%62.1%64.6%41.1%39.3%
CopticGold tok--95.1%94.3%99.7%94.2%96.2%83.2%79.2%
CopticGold tok+morph-------88.1%84.9%
CroatianRaw text99.9%97.0%95.9%-84.3%-94.4%83.6%77.9%
CroatianGold tok--96.0%-84.4%-94.4%83.9%78.1%
CroatianGold tok+morph-------87.1%83.2%
CzechRaw text99.9%91.6%98.3%92.8%92.1%91.7%97.8%86.8%83.2%
CzechGold tok--98.4%92.9%92.2%91.9%97.9%87.7%84.1%
CzechGold tok+morph-------90.2%87.5%
Czech-CACRaw text100.0%99.8%98.1%90.6%89.4%89.1%97.0%86.9%82.7%
Czech-CACGold tok--98.1%90.7%89.5%89.1%97.1%87.0%82.8%
Czech-CACGold tok+morph-------89.7%86.6%
Czech-CLTTRaw text99.5%92.3%96.5%87.5%87.8%87.3%96.8%80.2%76.6%
Czech-CLTTGold tok--97.0%87.9%88.3%87.7%97.2%81.0%77.6%
Czech-CLTTGold tok+morph-------83.8%80.8%
DanishRaw text99.8%77.9%95.2%-94.2%-94.9%78.4%74.7%
DanishGold tok--95.5%-94.5%-95.0%80.4%76.6%
DanishGold tok+morph-------85.6%82.7%
DutchRaw text99.8%77.6%91.4%88.1%89.3%87.0%89.9%75.4%69.6%
DutchGold tok--91.8%88.8%89.9%87.7%90.1%77.0%71.2%
DutchGold tok+morph-------82.9%79.4%
Dutch-LassySmallRaw text100.0%80.4%97.6%-97.2%-98.1%84.4%82.0%
Dutch-LassySmallGold tok--97.7%-97.4%-98.2%87.5%85.0%
Dutch-LassySmallGold tok+morph-------89.7%87.4%
EnglishRaw text99.0%76.6%93.5%92.9%94.4%91.5%96.0%80.2%77.2%
EnglishGold tok--94.5%93.9%95.4%92.5%96.9%84.3%81.2%
EnglishGold tok+morph-------87.8%86.0%
English-LinESRaw text99.9%86.2%95.0%92.7%---78.6%74.4%
English-LinESGold tok--95.1%92.8%---79.5%75.3%
English-LinESGold tok+morph-------84.1%81.1%
English-ParTUTRaw text99.6%97.5%94.2%94.0%93.3%92.0%96.9%81.6%77.9%
English-ParTUTGold tok--94.6%94.4%93.6%92.3%97.3%82.1%78.4%
English-ParTUTGold tok+morph-------86.4%84.5%
EstonianRaw text99.9%94.2%91.2%93.2%85.0%83.2%84.5%72.4%65.6%
EstonianGold tok--91.3%93.2%85.0%83.3%84.5%72.8%66.0%
EstonianGold tok+morph-------83.1%79.6%
FinnishRaw text99.7%86.7%94.5%95.7%91.5%90.3%86.5%80.5%76.9%
FinnishGold tok--94.9%96.0%91.8%90.7%86.8%82.0%78.4%
FinnishGold tok+morph-------86.9%84.7%
Finnish-FTBRaw text100.0%86.4%92.0%91.0%92.5%89.2%88.9%80.1%75.7%
Finnish-FTBGold tok--92.2%91.3%92.7%89.5%88.9%81.7%77.3%
Finnish-FTBGold tok+morph-------88.8%86.5%
FrenchRaw text98.9%94.6%95.4%-95.5%-96.6%84.2%80.7%
FrenchGold tok--96.5%-96.5%-97.6%85.4%82.0%
FrenchGold tok+morph-------88.4%86.0%
French-ParTUTRaw text99.0%97.8%94.5%94.2%91.9%90.8%94.3%82.9%78.7%
French-ParTUTGold tok--95.6%95.3%92.7%91.6%95.2%84.1%80.2%
French-ParTUTGold tok+morph-------88.1%85.3%
French-SequoiaRaw text99.1%84.0%95.9%-95.1%-96.8%83.2%80.6%
French-SequoiaGold tok--96.8%-96.0%-97.7%85.1%82.7%
French-SequoiaGold tok+morph-------88.7%87.4%
GalicianRaw text99.9%95.8%97.2%96.7%99.7%96.4%97.1%81.0%77.8%
GalicianGold tok--97.2%96.8%99.8%96.4%97.1%81.2%77.9%
GalicianGold tok+morph-------83.1%80.5%
Galician-TreeGalRaw text98.7%86.7%91.1%87.8%89.9%87.0%92.6%71.5%66.3%
Galician-TreeGalGold tok--92.4%88.8%91.0%88.0%93.7%74.4%68.7%
Galician-TreeGalGold tok+morph-------81.5%77.1%
GermanRaw text99.7%79.3%90.7%94.7%80.5%76.3%95.4%74.0%68.6%
GermanGold tok--91.2%95.0%80.9%76.7%95.6%76.5%70.7%
GermanGold tok+morph-------84.7%82.2%
GothicRaw text100.0%29.5%94.2%94.8%87.6%85.6%92.9%69.7%63.5%
GothicGold tok--94.8%95.3%88.0%86.5%92.9%78.8%72.6%
GothicGold tok+morph-------82.2%78.3%
GreekRaw text99.9%88.2%95.8%95.8%90.3%89.1%94.5%84.2%80.4%
GreekGold tok--96.0%96.0%90.5%89.3%94.6%85.0%81.1%
GreekGold tok+morph-------87.9%85.9%
HebrewRaw text85.2%100.0%80.9%80.9%77.6%76.8%79.6%62.2%57.9%
HebrewGold tok--95.1%95.1%91.3%90.5%93.2%84.5%78.9%
HebrewGold tok+morph-------87.8%84.3%
HindiRaw text100.0%99.1%95.8%94.9%90.3%87.7%98.0%91.3%87.3%
HindiGold tok--95.8%94.9%90.3%87.7%98.0%91.4%87.3%
HindiGold tok+morph-------93.9%91.0%
HungarianRaw text99.8%96.2%91.6%-70.5%-89.3%74.1%68.1%
HungarianGold tok--91.8%-70.6%-89.5%74.5%68.5%
HungarianGold tok+morph-------81.2%78.5%
IndonesianRaw text100.0%92.0%93.5%-99.5%--80.6%74.3%
IndonesianGold tok--93.5%-99.6%--80.8%74.5%
IndonesianGold tok+morph-------83.1%79.1%
IrishRaw text99.4%94.3%88.0%86.9%75.1%72.7%85.5%72.5%62.4%
IrishGold tok--88.5%87.4%75.5%73.1%86.0%73.3%63.1%
IrishGold tok+morph-------78.1%71.4%
ItalianRaw text99.8%97.1%97.2%97.0%97.0%96.1%97.3%88.8%86.1%
ItalianGold tok--97.4%97.2%97.2%96.3%97.5%89.3%86.6%
ItalianGold tok+morph-------91.3%89.7%
JapaneseRaw text91.9%95.1%89.1%-91.8%-91.1%78.0%76.6%
JapaneseGold tok--96.6%-100.0%-99.0%93.4%91.5%
JapaneseGold tok+morph-------95.6%95.0%
KazakhRaw text94.0%84.9%52.0%52.1%47.2%40.0%59.2%40.2%23.9%
KazakhGold tok--55.4%55.4%50.1%42.2%63.1%45.2%27.0%
KazakhGold tok+morph-------60.5%42.5%
KoreanRaw text99.7%92.7%94.4%89.7%99.3%89.7%99.4%67.4%60.5%
KoreanGold tok--94.7%90.0%99.6%90.0%99.7%68.4%61.5%
KoreanGold tok+morph-------71.7%65.8%
LatinRaw text100.0%98.0%83.4%67.6%72.5%67.6%51.2%56.5%46.0%
LatinGold tok--83.4%67.6%72.5%67.6%51.2%56.6%46.1%
LatinGold tok+morph-------67.8%61.5%
Latin-ITTBRaw text99.9%82.5%97.2%92.7%93.5%91.3%97.8%79.7%76.0%
Latin-ITTBGold tok--97.3%92.8%93.6%91.4%97.9%81.8%78.1%
Latin-ITTBGold tok+morph-------87.6%85.2%
Latin-PROIELRaw text99.9%31.0%94.9%95.0%87.7%86.7%94.8%66.1%60.7%
Latin-PROIELGold tok--95.2%95.2%88.4%87.4%95.0%75.3%69.4%
Latin-PROIELGold tok+morph-------79.0%75.0%
LatvianRaw text99.2%97.1%89.6%76.2%83.2%75.7%87.6%69.2%62.8%
LatvianGold tok--90.2%76.8%84.0%76.3%88.3%70.3%63.9%
LatvianGold tok+morph-------78.7%74.9%
LithuanianRaw text98.2%92.0%74.0%73.0%68.9%63.7%73.5%44.0%32.4%
LithuanianGold tok--74.6%73.5%69.7%64.2%74.2%44.6%33.0%
LithuanianGold tok+morph-------55.6%46.5%
Norwegian-BokmaalRaw text99.8%96.5%96.9%-95.3%-96.6%86.9%84.1%
Norwegian-BokmaalGold tok--97.1%-95.5%-96.8%87.5%84.7%
Norwegian-BokmaalGold tok+morph-------91.7%89.6%
Norwegian-NynorskRaw text99.9%92.2%96.5%-94.9%-96.4%85.6%82.5%
Norwegian-NynorskGold tok--96.6%-95.0%-96.5%86.5%83.3%
Norwegian-NynorskGold tok+morph-------91.0%88.6%
Old Church SlavonicRaw text100.0%40.5%93.8%93.8%86.9%85.7%91.2%73.6%66.9%
Old Church SlavonicGold tok--94.1%94.1%87.6%86.5%91.2%81.6%74.7%
Old Church SlavonicGold tok+morph-------86.7%82.2%
PersianRaw text99.7%98.2%96.0%96.0%96.1%95.4%93.5%83.3%79.4%
PersianGold tok--96.4%96.3%96.4%95.7%93.8%83.8%80.0%
PersianGold tok+morph-------87.7%84.9%
PolishRaw text99.9%99.7%95.6%84.0%84.1%83.1%93.4%86.7%80.7%
PolishGold tok--95.7%84.1%84.2%83.3%93.6%87.0%81.0%
PolishGold tok+morph-------92.9%89.5%
PortugueseRaw text99.6%89.4%96.4%72.7%93.3%71.6%96.8%86.0%82.6%
PortugueseGold tok--96.8%73.0%93.7%71.9%97.2%87.2%83.6%
PortugueseGold tok+morph-------89.6%87.5%
Portuguese-BRRaw text99.9%96.8%97.0%97.0%99.7%97.0%98.8%88.5%86.3%
Portuguese-BRGold tok--97.2%97.2%99.9%97.2%98.9%88.8%86.6%
Portuguese-BRGold tok+morph-------90.5%89.1%
RomanianRaw text99.7%93.9%96.6%95.9%96.0%95.7%96.5%85.6%80.2%
RomanianGold tok--96.9%96.2%96.3%96.0%96.8%86.2%80.8%
RomanianGold tok+morph-------87.8%83.0%
RussianRaw text99.9%96.9%94.7%94.4%84.4%82.8%75.0%80.3%75.5%
RussianGold tok--94.8%94.5%84.5%82.9%75.1%80.8%76.0%
RussianGold tok+morph-------84.8%81.9%
Russian-SynTagRusRaw text99.6%98.0%98.0%-93.6%-95.6%89.8%87.2%
Russian-SynTagRusGold tok--98.4%-93.9%-95.9%90.4%87.9%
Russian-SynTagRusGold tok+morph-------91.8%90.5%
SanskritRaw text88.1%29.0%52.0%-35.2%-50.2%38.8%22.5%
SanskritGold tok--57.6%-43.6%-60.6%58.5%34.3%
SanskritGold tok+morph-------72.9%58.5%
SlovakRaw text100.0%83.5%93.2%77.5%79.7%77.1%85.9%80.4%75.2%
SlovakGold tok--93.3%77.6%79.9%77.2%86.0%82.0%76.9%
SlovakGold tok+morph-------88.2%85.5%
SlovenianRaw text99.9%98.9%96.2%88.2%88.5%87.7%95.3%84.9%81.6%
SlovenianGold tok--96.2%88.2%88.6%87.7%95.4%85.0%81.7%
SlovenianGold tok+morph-------91.8%90.5%
Slovenian-SSTRaw text99.9%17.8%89.0%81.1%81.3%78.6%91.6%53.0%46.6%
Slovenian-SSTGold tok--89.4%81.6%81.8%79.3%91.7%63.4%56.0%
Slovenian-SSTGold tok+morph-------75.5%70.6%
SpanishRaw text99.7%95.3%95.5%-96.1%-95.9%84.9%81.4%
SpanishGold tok--95.8%-96.3%-96.1%85.5%81.9%
SpanishGold tok+morph-------88.0%85.3%
Spanish-AnCoraRaw text99.9%98.0%98.1%98.1%97.5%96.8%98.1%87.7%84.5%
Spanish-AnCoraGold tok--98.2%98.2%97.5%96.9%98.1%87.8%84.7%
Spanish-AnCoraGold tok+morph-------90.2%87.6%
SwedishRaw text99.8%94.6%95.6%93.9%94.4%92.8%95.5%81.4%77.8%
SwedishGold tok--95.8%94.1%94.6%93.1%95.7%82.1%78.4%
SwedishGold tok+morph-------88.0%85.0%
Swedish-LinESRaw text100.0%85.7%94.8%92.2%---80.4%75.7%
Swedish-LinESGold tok--94.8%92.3%---81.3%76.6%
Swedish-LinESGold tok+morph-------86.0%82.6%
TamilRaw text95.3%89.2%82.2%77.7%80.9%77.2%85.3%59.5%52.0%
TamilGold tok--85.8%81.0%84.2%80.3%89.1%64.9%56.5%
TamilGold tok+morph-------78.9%71.8%
TurkishRaw text98.1%96.8%92.4%91.5%87.3%85.5%90.2%62.9%55.8%
TurkishGold tok--94.0%93.0%88.9%87.0%91.7%65.5%58.0%
TurkishGold tok+morph-------66.8%61.1%
UkrainianRaw text99.8%95.1%88.5%70.7%70.9%67.6%86.7%69.9%61.5%
UkrainianGold tok--88.6%70.8%71.0%67.7%86.9%70.2%61.8%
UkrainianGold tok+morph-------79.0%74.5%
UrduRaw text100.0%98.3%92.4%90.5%80.6%76.3%93.0%84.6%77.6%
UrduGold tok--92.4%90.5%80.7%76.3%93.0%84.7%77.7%
UrduGold tok+morph-------88.2%83.0%
UyghurRaw text99.8%67.2%74.7%79.1%---55.1%35.0%
UyghurGold tok--75.1%79.3%---56.5%35.8%
UyghurGold tok+morph-------62.3%42.0%
VietnameseRaw text85.3%92.9%77.4%75.4%85.1%75.4%84.5%46.9%42.5%
VietnameseGold tok--89.3%86.8%99.6%86.8%99.0%64.4%57.2%
VietnameseGold tok+morph-------70.7%67.9%
+ + +

5.5. CoNLL17 Shared Task Baseline UD 2.0 Models

+ +

+As part of CoNLL 2017 Shared Task in UD Parsing, baseline models +for UDPipe were released. The CoNLL 2017 Shared Task models were trained on +most of UD 2.0 treebanks (64 of them) and are distributed under the +CC BY-NC-SA licence. +

+

+Note that the models were released when the test set of UD 2.0 was unknown. Therefore, +the models were trained on a subset of training data only, to allow fair comparison +on the development data (which were unused during training and hyperparameter settings). +Consequently, the performance of the models is not directly comparable to other models. +Details about the concrete data split, hyperparameter values and model +performance are available in the model archive. +

+ + +

5.5.1. Download

+ +

+The CoNLL17 Shared Task Baseline UD 2.0 Models can be downloaded +from LINDAT/CLARIN repository. +

+ + +

5.5.2. Acknowledgements

+ +

+This work has been partially supported and has been using language resources +and tools developed, stored and distributed by the LINDAT/CLARIN project of the +Ministry of Education, Youth and Sports of the Czech Republic (project LM2015071). +

+

+The models were trained on a Universal Dependencies 2.0 treebanks. +

+ + +

5.6. Universal Dependencies 1.2 Models

+ +

+Universal Dependencies 1.2 Models are distributed under the +CC BY-NC-SA licence. +The models are based solely on +Universal Dependencies 1.2 treebanks. +The models work in UDPipe version 1.0. +

+

+Universal Dependencies 1.2 Models are versioned according to the date released +in the format YYMMDD, where YY, MM and DD are two-digit +representation of year, month and day, respectively. The latest version is 160523. +

+ + +

5.6.1. Download

+ +

+The latest version 160523 of the Universal Dependencies 1.2 models can be downloaded +from LINDAT/CLARIN repository. +

+ + +

5.6.2. Acknowledgements

+ +

+This work has been partially supported and has been using language resources +and tools developed, stored and distributed by the LINDAT/CLARIN project of the +Ministry of Education, Youth and Sports of the Czech Republic (project LM2015071). +

+

+The models were trained on Universal Dependencies 1.2 treebanks. +

+

+For the UD treebanks which do not contain original plain text version, +raw text is used to train the tokenizer instead. The plain texts +were taken from the W2C – Web to Corpus. +

+ + +

5.6.2.1. Publications

+ +
    +
  • (Straka et al. 2016) Straka Milan, Hajič Jan, Straková Jana. UDPipe: Trainable Pipeline for Processing CoNLL-U Files Performing Tokenization, Morphological Analysis, POS Tagging and Parsing. LREC 2016, Portorož, Slovenia, May 2016. +
    • +
+ + +

5.6.3. Model Description

+ +

+The Universal Dependencies 1.2 models contain 36 models, each consisting of +a tokenizer, tagger, lemmatizer and dependency parser, all trained using +the UD data. The model for Japanese is missing, because we do not have +the license for the required corpus of Mainichi Shinbun 1995. +

+

+The tokenizer is trained using the SpaceAfter=No features. If the features +are not present in the data, they can be filled in using raw text in the +language in question (surprisingly, quite little data suffices, we use 500kB). +

+

+The tagger, lemmatizer and parser are trained using gold UD data. +

+

+Details about model architecture and training process can be found in the +(Straka et al. 2016) paper. +

+ + +

5.6.4. Model Performance

+ +

+We present the tagger, lemmatizer and parser performance, measured +on the testing portion of the data. Only the segmentation and the +tokenization of the testing data is retained before evaluation. +Therefore, the dependency parser is evaluated without gold POS tags. +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
TreebankUPOSXPOSFeatsAll TagsLemmaUASLAS
Ancient Greek91.1%77.8%88.7%77.7%86.9%68.1%61.6%
Ancient Greek-PROIEL96.7%96.4%89.3%88.4%93.4%75.8%69.6%
Arabic98.8%97.7%97.8%97.6%-80.4%75.6%
Basque93.3%-87.2%85.4%93.5%74.8%69.5%
Bulgarian97.8%94.8%94.4%93.1%94.6%89.0%84.2%
Croatian94.9%-85.5%85.0%93.1%78.6%71.0%
Czech98.4%93.2%92.6%92.2%97.8%86.9%83.0%
Danish95.8%-94.8%93.6%95.2%78.6%74.8%
Dutch89.7%88.7%91.2%86.4%88.9%78.1%70.7%
English94.5%93.8%95.4%92.5%97.0%84.2%80.6%
Estonian88.0%73.7%80.0%73.6%77.0%79.9%71.5%
Finnish94.9%96.0%93.2%92.1%86.8%81.0%76.5%
Finnish-FTB94.0%91.6%93.3%91.2%89.1%81.5%76.9%
French95.8%--95.8%-82.8%78.4%
German90.5%--90.5%-78.2%72.2%
Gothic95.5%95.7%88.0%86.3%93.4%76.4%68.2%
Greek97.3%97.3%92.8%91.7%94.8%80.3%76.5%
Hebrew94.9%94.9%91.3%90.5%-82.6%76.8%
Hindi95.8%94.8%90.2%87.7%98.0%91.7%87.5%
Hungarian92.6%-89.9%88.9%86.9%77.0%70.6%
Indonesian93.5%--93.5%-79.9%73.3%
Irish91.8%90.3%79.4%76.6%87.3%74.4%66.1%
Italian97.2%97.0%97.1%96.2%97.7%88.6%85.8%
Latin91.2%75.8%79.3%75.6%79.9%57.1%46.7%
Latin-ITT98.8%94.0%94.6%93.8%98.3%79.9%76.4%
Latin-PROIEL96.4%96.0%88.9%88.2%95.3%75.3%68.3%
Norwegian97.2%-95.5%94.7%96.9%86.7%84.1%
Old Church Slavonic95.3%95.1%89.1%88.2%92.9%80.6%73.4%
Persian97.0%96.3%96.5%96.2%-83.8%79.4%
Polish95.8%84.0%84.1%83.8%92.8%86.3%79.6%
Portuguese97.6%92.3%95.3%92.0%97.8%85.8%81.9%
Romanian89.0%81.0%82.3%81.0%75.3%68.6%56.9%
Slovenian95.7%88.2%88.6%87.5%95.0%84.1%80.3%
Spanish95.3%-95.9%93.4%96.3%84.2%80.3%
Swedish95.8%93.9%94.8%93.2%95.5%81.4%77.1%
Tamil85.9%80.8%84.3%80.2%88.0%67.2%58.8%
+ + +

6. UDPipe API Reference

+ +

+The UDPipe API is defined in header udpipe.h and resides in +ufal::udpipe namespace. The API allows only using existing models, +for custom model creation you have to use the train_parser binary. +

+

+The strings used in the UDPipe API are always UTF-8 encoded (except from +file paths, whose encoding is system dependent). +

+ + +

6.1. UDPipe Versioning

+ +

+UDPipe is versioned using Semantic Versioning. +Therefore, a version consists of three numbers major.minor.patch, optionally +followed by a hyphen and pre-release version info, with the following semantics: +

+ +
    +
  • Stable versions have no pre-release version info, development have non-empty + pre-release version info. +
    • +
  • Two versions with the same major.minor have the same API with the same + behaviour, apart from bugs. Therefore, if only patch is increased, the + new version is only a bug-fix release. +
    • +
  • If two versions v and u have the same major, but minor(v) is + greater than minor(u), version v contains only additions to the API. + In other words, the API of u is all present in v with the same + behaviour (once again apart from bugs). It is therefore safe to upgrade to + a newer UDPipe version with the same major. +
    • +
  • If two versions differ in major, their API may differ in any way. +
    • +
+ +

+Models created by UDPipe have the same behaviour in all UDPipe +versions with same major, apart from obvious bugfixes. On the other hand, +models created from the same data by different major.minor UDPipe +versions may have different behaviour. +

+ + +

6.2. Struct string_piece

+ +
+struct string_piece {
+  const char* str;
+  size_t len;
+
+  string_piece();
+  string_piece(const char* str);
+  string_piece(const char* str, size_t len);
+  string_piece(const std::string& str);
+}
+
+ +

+The string_piece is used for efficient string passing. The string +referenced in string_piece is not owned by it, so users have to make sure +the referenced string exists as long as the string_piece. +

+ + +

6.3. Class token

+ +
+class token {
+ public:
+  string form;
+  string misc;
+
+  token(string_piece form = string_piece(), string_piece misc = string_piece());
+
+  // CoNLL-U defined SpaceAfter=No feature
+  bool get_space_after() const;
+  void set_space_after(bool space_after);
+
+  // UDPipe-specific all-spaces-preserving SpacesBefore and SpacesAfter features
+  void get_spaces_before(string& spaces_before) const;
+  void set_spaces_before(string_piece spaces_before);
+  void get_spaces_after(string& spaces_after) const;
+  void set_spaces_after(string_piece spaces_after);
+  void get_spaces_in_token(string& spaces_in_token) const;
+  void set_spaces_in_token(string_piece spaces_in_token);
+
+  // UDPipe-specific TokenRange feature
+  bool get_token_range(size_t& start, size_t& end) const;
+  void set_token_range(size_t start, size_t end);
+};
+
+ +

+The token class represents a sentence token, +with form and misc fields corresponding to CoNLL-U fields. +The token class acts mostly as a parent to word +and multiword_token classes. +

+

+The class also offers several methods for manipulating features in the misc field. +Notably, UDPipe uses custom misc fields to store all spaces in the original +document. This markup is backward compatible with CoNLL-U v2 SpaceAfter=No feature. +This markup can be utilized by plaintext output format, which allows reconstructing +the original document. +

+

+The markup uses the following misc fields: +

+
    +
  • SpacesBefore=content (by default empty): spaces/other content preceding the token +
    • +
  • SpacesAfter=content (by default a space if SpaceAfter=No feature is not present, empty otherwise): + spaces/other content following the token +
    • +
  • SpacesInToken=content (by default equal to the FORM of the token): FORM of the token + including original spaces (this is needed only if tokens are allowed to contain spaces and + a token contains a tab or newline characters) +
    • +
+ +

+The content of all above three fields must be escaped to allow storing tabs and newlines. +The following C-like schema is used: +

+
    +
  • \s: space +
    • +
  • \t: tab +
    • +
  • \r: CR character +
    • +
  • \n: LF character +
    • +
  • \p: | (pipe character) +
    • +
  • \\: \ (backslash character) +
    • +
+ + +

6.3.1. token::get_space_after()

+ +
+bool get_space_after() const;
+
+ +

+Returns true if the token should be followed by a spaces, false if not, +according to the absence or presence of the SpaceAfter=No feature in the misc field. +

+ + +

6.3.2. token::set_space_after()

+ +
+void set_space_after(bool space_after);
+
+ +

+Adds or removes the SpaceAfter=No feature in the misc field. +

+ + +

6.3.3. token::get_spaces_before()

+ +
+void get_spaces_before(string& spaces_before) const;
+
+ +

+Return spaces preceding current token, stored in the SpacesBefore +feature in the misc field. If SpacesBefore is not present, empty string +is returned. +

+ + +

6.3.4. token::set_spaces_before()

+ +
+void set_spaces_before(string_piece spaces_before);
+
+ +

+Set the SpacesBefore feature in the misc field. +

+ + +

6.3.5. token::get_spaces_after()

+ +
+void get_spaces_after(string& spaces_after) const;
+
+ +

+Return spaces after current token, stored in the SpacesAfter +feature in the misc field. +

+

+If SpacesAfter is not present and SpaceAfter=No is present, +return an empty string; if neither feature is present, one space is returned. +

+ + +

6.3.6. token::set_spaces_after()

+ +
+void set_spaces_after(string_piece spaces_after);
+
+ +

+Set the SpacesAfter and SpaceAfter=No features in the misc field. +

+ + +

6.3.7. token::get_spaces_in_token()

+ +
+void get_spaces_in_token(string& spaces_in_token) const;
+
+ +

+Return the value of the SpacesInToken feature, if present. +Otherwise, empty string is returned. +

+ + +

6.3.8. token::set_spaces_in_token()

+ +
+void set_spaces_in_token(string_piece spaces_in_token);
+
+ +

+Set the SpacesInToken feature in the misc field. +

+ + +

6.3.9. token::get_token_range()

+ +
+bool get_token_range(size_t& start, size_t& end) const;
+
+ +

+If present, return the value of the TokenRange feature in the misc field. +The format of the feature (inspired by Python) is TokenRange=start:end, +where start is zero-based document-level index of the start of the token +(counted in Unicode characters) and end is zero-based document-level index +of the first character following the token (i.e., the length of the token is end-start). +

+ + +

6.3.10. token::set_token_range()

+ +
+void set_token_range(size_t start, size_t end);
+
+ +

+Set the TokenRange feature in the misc field. If string::npos +is passed in the start argument, TokenRange feature is removed +from the misc field. +

+ + +

6.4. Class word

+ +
+class word : public token {
+ public:
+  // form and misc are inherited from token
+  int id;         // 0 is root, >0 is sentence word, <0 is undefined
+  string lemma;   // lemma
+  string upostag; // universal part-of-speech tag
+  string xpostag; // language-specific part-of-speech tag
+  string feats;   // list of morphological features
+  int head;       // head, 0 is root, <0 is undefined
+  string deprel;  // dependency relation to the head
+  string deps;    // secondary dependencies
+
+  vector<int> children;
+
+  word(int id = -1, string_piece form = string_piece());
+};
+
+ +

+The word class represents a sentence word. +The word fields correspond to CoNLL-U fields, +with the children field representing the opposite direction of +head links (the elements of the children array are in ascending order). +

+ + +

6.5. Class multiword_token

+ +
+class multiword_token : public token {
+ public:
+  // form and misc are inherited from token
+  int id_first, id_last;
+
+  multiword_token(int id_first = -1, int id_last = -1, string_piece form = string_piece(), string_piece misc = string_piece());
+};
+
+ +

+The multiword_token represents a multi-word token +described in CoNLL-U format. +The multi-word token has a form and a misc field, other CoNLL-U word +fields are guaranteed to be empty. +

+ + +

6.6. Class empty_node

+ +
+class empty_node {
+ public:
+  int id;         // 0 is root, >0 is sentence word, <0 is undefined
+  int index;      // index for the current id, should be numbered from 1, 0=undefined
+  string form;    // form
+  string lemma;   // lemma
+  string upostag; // universal part-of-speech tag
+  string xpostag; // language-specific part-of-speech tag
+  string feats;   // list of morphological features
+  string deps;    // secondary dependencies
+  string misc;    // miscellaneous information
+
+  empty_node(int id = -1, int index = 0) : id(id), index(index) {}
+};
+
+ +

+The empty_node class represents an empty node from CoNLL-U 2.0, +with the fields corresponding to CoNLL-U fields. +For a specified id, the index are numbered sequentially from 1. +

+ + +

6.7. Class sentence

+ +
+class sentence {
+ public:
+  sentence();
+
+  vector<word> words;
+  vector<multiword_token> multiword_tokens;
+  vector<empty_node> empty_nodes;
+  vector<string> comments;
+  static const string root_form;
+
+  // Basic sentence modifications
+  bool empty();
+  void clear();
+  word& add_word(string_piece form = string_piece());
+  void set_head(int id, int head, const string& deprel);
+  void unlink_all_words();
+
+  // CoNLL-U defined comments
+  bool get_new_doc(string* id = nullptr) const;
+  void set_new_doc(bool new_doc, string_piece id = string_piece());
+  bool get_new_par(string* id = nullptr) const;
+  void set_new_par(bool new_par, string_piece id = string_piece());
+  bool get_sent_id(string& id) const;
+  void set_sent_id(string_piece id);
+  bool get_text(string& text) const;
+  void set_text(string_piece text);
+};
+
+ +

+The sentence class represents a sentence CoNLL-U sentence, +which consists of: +

+
    +
  • sequence of words stored in ascending order, with the first word + (with index 0) always being a technical root with form root_form +
    • +
  • sequence of multiword_tokens also stored in ascending + order +
    • +
  • sequence of empty_nodes also stored in ascending order +
    • +
  • comments +
    • +
+ +

+Although you can manipulate the words directly, the +sentence class offers several simple node manipulation methods. +There are also several methods manipulating CoNLL-U v2 comments. +

+ + +

6.7.1. sentence::empty()

+ +
+bool empty();
+
+ +

+Returns true if the sentence is empty. i.e., if it contains only a technical root node. +

+ + +

6.7.2. sentence::clear()

+ +
+void clear();
+
+ +

+Removes all words, multi-word tokens and comments (only the technical root word is kept). +

+ + +

6.7.3. sentence::add_word()

+ +
+word& add_word(string_piece form = string_piece());
+
+ +

+Adds a new word to the sentence. The new word has first unused id, +specified form and is not linked to any other node. Reference to the new +word is returned so that other fields can be also filled. +

+ + +

6.7.4. sentence:set_head()

+ +
+void set_head(int id, int head, const std::string& deprel);
+
+ +

+Link the word id to the word head, with the specified dependency relation. +If the head is negative, the word id is unlinked from its current head, +if any. +

+ + +

6.7.5. sentence::unlink_all_words()

+ +
+void unlink_all_words();
+
+ +

+Unlink all words. +

+ + +

6.7.6. sentence::get_new_doc()

+ +
+bool get_new_doc(string* id = nullptr) const;
+
+ +

+Return true if # newdoc comment is present. Optionally, +document id is also returned (in # newdoc id = ... format). +

+ + +

6.7.7. sentence::set_new_doc()

+ +
+void set_new_doc(bool new_doc, string_piece id = string_piece());
+
+ +

+Adds/removes # newdoc comment, optionally with a given +document id. +

+ + +

6.7.8. sentence::get_new_par()

+ +
+bool get_new_par(string* id = nullptr) const;
+
+ +

+Return true if # newpar comment is present. Optionally, +paragraph id is also returned (in # newpar id = ... format). +

+ + +

6.7.9. sentence::set_new_par()

+ +
+void set_new_par(bool new_par, string_piece id = string_piece());
+
+ +

+Adds/removes # newpar comment, optionally with a given +paragraph id. +

+ + +

6.7.10. sentence::get_sent_id()

+ +
+bool get_sent_id(string& id) const;
+
+ +

+Return true if # sent_id = ... comment is present, +and fill given id with sentence id. Otherwise, return false +and clear id. +

+ + +

6.7.11. sentence::set_sent_id()

+ +
+void set_sent_id(string_piece id);
+
+ +

+Set the # sent_id = ... comment using given sentence id; +if the sentence id is empty, remove all present # sent_id comment. +

+ + +

6.7.12. sentence::get_text()

+ +
+bool get_text(string& text) const;
+
+ +

+Return true if # text = ... comment is present, +and fill given text with sentence text. Otherwise, return false +and clear text. +

+ + +

6.7.13. sentence::set_text()

+ +
+void set_text(string_piece text);
+
+ +

+Set the # text = ... comment using given text; +if the given text is empty, remove all present # text comment. +

+ + +

6.8. Class input_format

+ +
+class input_format {
+ public:
+  virtual ~input_format() {}
+
+  virtual bool read_block(istream& is, string& block) const = 0;
+  virtual void reset_document(string_piece id = string_piece()) = 0;
+  virtual void set_text(string_piece text, bool make_copy = false) = 0;
+  virtual bool next_sentence(sentence& s, string& error) = 0;
+
+  // Static factory methods
+  static input_format* new_input_format(const string& name);
+  static input_format* new_conllu_input_format(const string& options = std::string());
+  static input_format* new_generic_tokenizer_input_format(const string& options = std::string());
+  static input_format* new_horizontal_input_format(const string& options = std::string());
+  static input_format* new_vertical_input_format(const string& options = std::string());
+
+  static input_format* new_presegmented_tokenizer(input_format* tokenizer);
+
+  static const string CONLLU_V1;
+  static const string CONLLU_V2;
+  static const string GENERIC_TOKENIZER_NORMALIZED_SPACES;
+  static const string GENERIC_TOKENIZER_PRESEGMENTED;
+  static const string GENERIC_TOKENIZER_RANGES;
+};
+
+ +

+The input_format class allows loading sentences in various formats. +

+

+Th class instances may store internal state and are not thread-safe. +

+ + +

6.8.1. input_format::read_block()

+ +
+virtual bool read_block(istream& is, string& block) const = 0;
+
+ +

+Read a portion of input, which is guaranteed to contain only complete +sentences. Such portion is usually a paragraph (text followed by an empty line) +or a line, but it may be more complex (i.e., in a XML-like format). +

+ + +

6.8.2. input_format::reset_document()

+ +
+virtual void reset_document(string_piece id = string_piece()) = 0;
+
+ +

+Resets the input_format instance state. Such state +is needed not only for remembering unprocessed text of the last +set_text call, but also for correct inter-block +state tracking (for example to track document-level ranges or inter-sentence spaces +-- if you pass only spaces to set_text, these +spaces has to accumulate and be returned as preceding spaces of the next +sentence). +

+

+If applicable, first read sentence will have the # newdoc comment, optionally +with given document id. +

+ + +

6.8.3. input_format::set_text()

+ +
+virtual void set_text(string_piece text, bool make_copy = false) = 0;
+
+ +

+Set the text from which the sentences will be read. +

+

+If make_copy is false, only a reference to the given text is +stored and the user has to make sure it exists until the instance +is destroyed or set_text is called again. If make_copy +is true, a copy of the given text is made and retained until the +instance is destroyed or set_text is called again. +

+ + +

6.8.4. input_format::next_sentence()

+ +
+virtual bool next_sentence(sentence& s, string& error) = 0;
+
+ +

+Try reading another sentence from the text specified by +set_text. Returns true if the sentence was +read and false if the text ended or there was a read error. The latter +two conditions can be distinguished by the error parameter – if it is +empty, the text ended, if it is nonempty, it contains a description of the +read error. +

+ + +

6.8.5. input_format::new_input_format()

+ +
+static input_format* new_input_format(const string& name);
+
+ +

+Create new input_format instance, given its name. +The individual input formats can be parametrized by using format=data +syntax. The following input formats are currently supported: +

+ + +

+The new instance must be deleted after use. +

+ + +

6.8.6. input_format::new_conllu_input_format()

+ +
+static input_format* new_conllu_input_format(const string() options = std::string());
+
+ +

+Create input_format instance which loads sentences +in the CoNLL-U format. +The new instance must be deleted after use. +

+

+Supported options: +

+
    +
  • v2 (default): use CoNLL-U v2 +
    • +
  • v1: allow loading only CoNLL-U v1 (i.e., no empty nodes and no spaces in forms and lemmas) +
    • +
+ + +

6.8.7. input_format::new_generic_tokenizer_input_format()

+ +
+static input_format* new_generic_tokenizer_input_format(const string() options = std::string());
+
+ +

+Create rule-based generic tokenizer for English-like languages (with spaces +separating tokens and English-like punctuation). The new instance must be +deleted after use. +

+

+Supported options: +

+
    +
  • normalized_spaces: by default, UDPipe uses custom misc fields to exactly + encode spaces in the original document. If normalized_spaces option is + given, only standard CoNLL-U v2 markup (SpaceAfter=No and # newpar) + is used. +
    • +
  • presegmented: input is assumed to be already segmented, with every + sentence on a line, and is only tokenized (respecting sentence breaks) +
    • +
  • ranges: for every token, range in the original document is stored in + a format described in token class +
    • +
+ + +

6.8.8. input_format::new_horizontal_input_format()

+ +
+static input_format* new_horizontal_input_format(const string() options = std::string());
+
+ +

+Create input_format instance which loads forms from a simple +horizontal format – each sentence on a line, with word forms separated by spaces. +The new instance must be deleted after use. +

+

+In order to allow spaces in tokens, Unicode character 'NO-BREAK SPACE' (U+00A0) +is considered part of token and converted to a space during loading. +

+ + +

6.8.9. input_format::new_vertical_input_format()

+ +
+static input_format* new_vertical_input_format(const string() options = std::string());
+
+ +

+Create input_format instance which loads forms from a simple +vertical format – each word on a line, with empty line denoting end of sentence. +The new instance must be deleted after use. +

+ + +

6.8.10. input_format::new_presegmented_tokenizer()

+ +
+static input_format* new_presegmented_tokenizer(input_format* tokenizer);
+
+ +

+Create input_format instance which acts as a tokenizer +adapter – given a tokenizer which segments anywhere, it creates a tokenizer +which segments on newline characters (by calling the tokenizer on individual lines, +and if the tokenizer segments in the middle of the line, it calls it repeatedly +and merges the results). +

+

+The new instance must be deleted after use. Note that the new instance +takes ownership of the given tokenizer and deletes it during +its own deletion. +

+ + +

6.9. Class output_format

+ +
+class output_format {
+ public:
+  virtual ~output_format() {}
+
+  virtual void write_sentence(const sentence& s, ostream& os) = 0;
+  virtual void finish_document(ostream& os) {};
+
+  // Static factory methods
+  static output_format* new_output_format(const string& name);
+  static output_format* new_conllu_output_format(const string() options = std::string());
+  static output_format* new_epe_output_format(const string() options = std::string());
+  static output_format* new_matxin_output_format(const string() options = std::string());
+  static output_format* new_horizontal_output_format(const string() options = std::string());
+  static output_format* new_plaintext_output_format(const string() options = std::string());
+  static output_format* new_vertical_output_format(const string() options = std::string());
+
+  static const string CONLLU_V1;
+  static const string CONLLU_V2;
+  static const string HORIZONTAL_PARAGRAPHS;
+  static const string PLAINTEXT_NORMALIZED_SPACES;
+  static const string VERTICAL_PARAGRAPHS;
+};
+
+ +

+The output_format class allows printing sentences +in various formats. +

+

+The class instances may store internal state and are not thread-safe. +

+ + +

6.9.1. output_format::write_sentence()

+ +
+virtual void write_sentence(const sentence& s, ostream& os) = 0;
+
+ +

+Write given sentence to the given output stream. +

+

+When the output format requires document-level markup, it is written +automatically when the first sentence is written using this +output_format instance (or after +finish_document call). +

+ + +

6.9.2. output_format::finish_document()

+ +
+virtual void finish_document(ostream& os) {};
+
+ +

+When the output format requires document-level markup, write +the end-of-document mark and reset the output_format +instance state (i.e., the next write_sentence +will write start-of-document mark). +

+ + +

6.9.3. output_format::new_output_format()

+ +
+static output_format* new_output_format(const string& name);
+
+ +

+Create new output_format instance, given its name. +The following output formats are currently supported: +

+ + +

+The new instance must be deleted after use. +

+ + +

6.9.4. output_format::new_conllu_output_format()

+ +
+static output_format* new_conllu_output_format(const string() options = std::string());
+
+ +

+Creates output_format instance for writing sentences +in the CoNLL-U format. +The new instance must be deleted after use. +

+

+Supported options: +

+
    +
  • v2 (default): use CoNLL-U v2 +
    • +
  • v1: produce output in CoNLL-U v1 format. Note that this is a lossy process, as +empty nodes are ignored and spaces in forms and lemmas are converted to underscores. +
    • +
+ + +

6.9.5. output_format::new_epe_output_format()

+ +
+static output_format* new_epe_output_format(const string() options = std::string());
+
+ +

+Creates output_format instance for writing sentences +in the EPE (Extrinsic Parser Evaluation 2017) interchange format. +The new instance must be deleted after use. +

+ + +

6.9.6. output_format::new_matxin_output_format()

+ +
+static output_format* new_matxin_output_format(const string() options = std::string());
+
+ +

+Creates output_format instance for writing sentences +in the Matxin format – UDPipe produces a XML with the following DTD: +

+
+<!ELEMENT    corpus     (SENTENCE*)>
+<!ELEMENT    SENTENCE   (NODE*)>
+<!ATTLIST    SENTENCE    ord           CDATA        #REQUIRED
+                         alloc         CDATA        #REQUIRED>
+<!ELEMENT    NODE   (NODE*)>
+<!ATTLIST    NODE        ord           CDATA        #REQUIRED
+                         alloc         CDATA        #REQUIRED
+                         form          CDATA        #REQUIRED
+                         lem           CDATA        #REQUIRED
+                         mi            CDATA        #REQUIRED
+                         si            CDATA        #REQUIRED
+                         sub           CDATA        #REQUIRED>
+
+ +

+The new instance must be deleted after use. +

+ + +

6.9.7. output_format::new_plaintext_output_format()

+ +
+static output_format* new_plaintext_output_format(const string() options = std::string());
+
+ +

+Creates output_format instance for writing sentence +tokens (in the UD sense) using original spacing. +By default, UDPipe custom misc features (see description of +token class) are used to reconstruct the exact original spaces. +However, if the document does not contain these features or if only +normalized spacing is wanted, you can use the following option: +

+
    +
  • normalized_spaces: write one sentence on a line, and either one or no space between + tokens, using the SpaceAfter=No feature +
    • +
+ + +

6.9.8. output_format::new_horizontal_output_format()

+ +
+static output_format* new_horizontal_output_format(const string() options = std::string());
+
+ +

+Creates output_format instance for writing sentences +in a simple horizontal format – each sentence on a line, with word forms separated +by spaces. The new instance must be deleted after use. +

+

+Because words can contain spaces in CoNLL-U v2, the spaces in words are +converted to Unicode character 'NO-BREAK SPACE' (U+00A0). +

+

+Supported options: +

+
    +
  • paragraphs: if given, an empty line is printed after the end of a paragraph +or a document (recognized by # newpar or # newdoc comments) +
    • +
+ + +

6.9.9. output_format::new_vertical_output_format()

+ +
+static output_format* new_vertical_output_format(const string() options = std::string());
+
+ +

+Creates output_format instance for writing sentences +in a simple vertical format – each word form on a line, with empty line +denoting end of sentence. The new instance must be deleted after use. +

+

+Supported options: +

+
    +
  • paragraphs: if given, an empty line is printed after the end of a paragraph +or a document (recognized by # newpar or # newdoc comments) +
    • +
+ + +

6.10. Class model

+ +
+class model {
+ public:
+  virtual ~model() {}
+
+  static model* load(const char* fname);
+  static model* load(istream& is);
+
+  virtual input_format* new_tokenizer(const string& options) const = 0;
+  virtual bool tag(sentence& s, const string& options, string& error) const = 0;
+  virtual bool parse(sentence& s, const string& options, string& error) const = 0;
+
+  static const string DEFAULT;
+  static const string TOKENIZER_NORMALIZED_SPACES;
+  static const string TOKENIZER_PRESEGMENTED;
+  static const string TOKENIZER_RANGES;
+};
+
+ +

+Class representing UDPipe model, allowing to perform tokenization, +tagging and parsing. +

+ + +

6.10.1. model::load(const char*)

+ +
+static model* load(const char* fname);
+
+ +

+Load a new model from a given file, returning NULL on failure. +The new instance must be deleted after use. +

+ + +

6.10.2. model::load(istream&)

+ +
+static model* load(istream& is);
+
+ +

+Load a new model from a given input stream, returning NULL on failure. +The new instance must be deleted after use. +

+ + +

6.10.3. model::new_tokenizer()

+ +
+virtual input_format* new_tokenizer(const string& options) const = 0;
+
+ +

+Construct a new tokenizer (or NULL if no tokenizer is specified by the model). +The new instance must be deleted after use. +

+ + +

6.10.4. model::tag()

+ +
+virtual bool tag(sentence& s, const string& options, string& error) const = 0;
+
+ +

+Tag the given sentence. +

+ + +

6.10.5. model::parse()

+ +
+virtual bool parse(sentence& s, const string& options, string& error) const = 0;
+
+ +

+Parse the given sentence. +

+ + +

6.11. Class pipeline

+ +
+class pipeline {
+ public:
+  pipeline(const model* m, const string& input, const string& tagger, const string& parser, const string& output);
+
+  void set_model(const model* m);
+  void set_input(const string& input);
+  void set_tagger(const string& tagger);
+  void set_parser(const string& parser);
+  void set_output(const string& output);
+
+  void set_immediate(bool immediate);
+  void [set_document_id #pipeline_set_document_id[(const string& document_id);
+
+  bool process(istream& is, ostream& os, string& error) const;
+
+  static const string DEFAULT;
+  static const string NONE;
+};
+
+ +

+The pipeline class allows simple file-to-file processing. +A model and input/tagger/parser/output options can be specified in the pipeline. +

+

+The input file can be processed either after fully loaded (default), +or in immediate mode, in which case is the input processed and printed as soon +as a block of input guaranteed to contain whole sentences is loaded. +Specifically, for most input formats the input is processed after loading an +empty line (with the exception of horizontal input format and +presegmented tokenizer, where the input is processed after loading every +line). +

+ + +

6.11.1. pipeline::set_model()

+ +
+void set_model(const model* m);
+
+ +

+Use the given model. +

+ + +

6.11.2. pipeline::set_input()

+ +
+void set_input(const string& input);
+
+ +

+Use the given input format. In addition to formats described in +new_input_format, a special +tokenizer or tokenizer=options format allows using the +model tokenizer. +

+ + +

6.11.3. pipeline::set_tagger()

+ +
+void set_tagger(const string& tagger);
+
+ +

+Use the given tagger options. +

+ + +

6.11.4. pipeline::set_parser()

+ +
+void set_parser(const string& parser);
+
+ +

+Use the given parser options. +

+ + +

6.11.5. pipeline::set_output()

+ +
+void set_output(const string& output);
+
+ +

+Use the given output format (see +new_output_format for a list). +

+ + +

6.11.6. pipeline::set_immediate()

+ +
+void set_immediate(bool immediate);
+
+ +

+Set or reset the immediate mode (default is immediate=false). +

+ + +

6.11.7. pipeline::set_document_id()

+ +
+void set_document_id(const string& document_id);
+
+ +

+Set document id, which is passed to +input_format::reset_document). +

+ + +

6.11.8. pipeline::process()

+ +
+bool process(istream& is, ostream& os, string& error) const;
+
+ +

+Process the given input stream, writing results to the given output stream. +If the processing succeeded, true is returned; otherwise, false +is returned with an error stored in the error argument. +

+ + +

6.12. Class trainer

+ +
+class trainer {
+ public:
+  static bool train(const string& method, const vector<sentence>& train, const vector<sentence>& heldout,
+                    const string& tokenizer, const string& tagger, const string& parser,
+                    ostream& os, string& error);
+
+  static const string DEFAULT;
+  static const string NONE;
+};
+
+ +

+Class allowing training a UDPipe model. +

+ + +

6.12.1. trainer::train()

+ +
+static bool train(const string& method, const vector<sentence>& train, const vector<sentence>& heldout,
+                  const string& tokenizer, const string& tagger, const string& parser,
+                  ostream& os, string& error);
+
+ +

+Train a UDPipe model. The only supported method is currently morphodita_parsito. +Use the supplied train and heldout data, and given tokenizer, tagger and parser +options (see the Training UDPipe Models section in the User's Manual). +

+

+If the training succeeded, true is returned and the model is saved to the +given os stream; otherwise, false is returned with an error stored in +the error argument. +

+ + +

6.13. Class evaluator

+ +
+class evaluator {
+ public:
+  evaluator(const model* m, const string& tokenizer, const string& tagger, const string& parser);
+
+  void set_model(const model* m);
+  void set_tokenizer(const string& tokenizer);
+  void set_tagger(const string& tagger);
+  void set_parser(const string& parser);
+
+  bool evaluate(istream& is, ostream& os, string& error) const;
+
+  static const string DEFAULT;
+  static const string NONE;
+};
+
+ +

+Class evaluating performance of given model on CoNLL-U file. +

+

+Three different settings (depending on whether tokenizer, tagger and parser is used) +can be evaluated. For details, see Measuring Model Accuracy in User's Manual. +

+ + +

6.13.1. evaluator::set_model()

+ +
+void set_model(const model* m);
+
+ +

+Use the given model. +

+ + +

6.13.2. evaluator::set_tokenizer()

+ +
+void set_tokenizer(const string& tokenizer);
+
+ +

+Use the given tokenizer options; pass DEFAULT to use default +options or NONE not to use a tokenizer. +

+ + +

6.13.3. evaluator::set_tagger()

+ +
+void set_tagger(const string& tagger);
+
+ +

+Use the given tagger options; pass DEFAULT to use default +options or NONE not to use a tagger. +

+ + +

6.13.4. evaluator::set_parser()

+ +
+void set_parser(const string& parser);
+
+ +

+Use the given parser options; pass DEFAULT to use default +options or NONE not to use a parser. +

+ + +

6.13.5. evaluator::evaluate()

+ +
+bool evaluate(istream& is, ostream& os, string& error) const;
+
+ +

+Evaluate the specified model on the given CoNLL-U input read +from is stream. +

+

+If the evaluation succeeded, true is returned and the evaluation +results are written to the os stream in a plain text format; +otherwise, false is returned with an error stored in +the error argument. +

+ + +

6.14. Class version

+ +
+class version {
+ public:
+  unsigned major;
+  unsigned minor;
+  unsigned patch;
+  string prerelease;
+
+  static version current();
+};
+
+ +

+The version class represents UDPipe version. +See UDPipe Versioning for more information. +

+ + +

6.14.1. version::current

+ +
+static version current();
+
+ +

+Returns current UDPipe version. +

+ + +

6.15. C++ Bindings API

+ +

+Bindings for other languages than C++ are created using SWIG from the C++ +bindings API, which is a slightly modified version of the native C++ API. +Main changes are replacement of string_piece type by native +strings and removal of methods using istream. Here is the C++ bindings API +declaration: +

+ + +

6.15.1. Helper Structures

+ +
+typedef vector<int> Children;
+
+typedef vector<string> Comments;
+
+class ProcessingError {
+public:
+  bool occurred();
+  string message;
+};
+
+class Token {
+ public:
+  string form;
+  string misc;
+
+  Token(const string& form = string(), const string& misc = string());
+
+  // CoNLL-U defined SpaceAfter=No feature
+  bool getSpaceAfter() const;
+  void setSpaceAfter(bool space_after);
+
+  // UDPipe-specific all-spaces-preserving SpacesBefore and SpacesAfter features
+  string getSpacesBefore() const;
+  void setSpacesBefore(const string& spaces_before);
+  string getSpacesAfter() const;
+  void setSpacesAfter(const string& spaces_after);
+  string getSpacesInToken() const;
+  void setSpacesInToken(const string& spaces_in_token);
+
+  // UDPipe-specific TokenRange feature
+  bool getTokenRange() const;
+  size_t getTokenRangeStart() const;
+  size_t getTokenRangeEnd() const;
+  void setTokenRange(size_t start, size_t end);
+};
+
+class Word : public Token {
+ public:
+  // form and misc are inherited from token
+  int id;         // 0 is root, >0 is sentence word, <0 is undefined
+  string lemma;   // lemma
+  string upostag; // universal part-of-speech tag
+  string xpostag; // language-specific part-of-speech tag
+  string feats;   // list of morphological features
+  int head;       // head, 0 is root, <0 is undefined
+  string deprel;  // dependency relation to the head
+  string deps;    // secondary dependencies
+
+  Children children;
+
+  Word(int id = -1, const string& form = string());
+};
+typedef vector<Word> Words;
+
+class MultiwordToken : public Token {
+ public:
+  // form and misc are inherited from token
+  int idFirst, idLast;
+
+  MultiwordToken(int id_first = -1, int id_last = -1, const string& form = string(), const string& misc = string());
+};
+typedef vector<MultiwordToken> MultiwordTokens;
+
+class EmptyNode {
+ public:
+  int id;          // 0 is root, >0 is sentence word, <0 is undefined
+  int index;       // index for the current id, should be numbered from 1, 0=undefined
+  string form;     // form
+  string lemma;    // lemma
+  string upostag;  // universal part-of-speech tag
+  string xpostag;  // language-specific part-of-speech tag
+  string feats;    // list of morphological features
+  string deps;     // secondary dependencies
+  string misc;     // miscellaneous information
+
+  EmptyNode(int id = -1, int index = 0) : id(id), index(index) {}
+};
+typedef vector<empty_node> EmptyNodes;
+
+class Sentence {
+ public:
+  Sentence();
+
+  Words words;
+  MultiwordTokens multiwordTokens;
+  EmptyNodes emptyNodes;
+  Comments comments;
+  static const string rootForm;
+
+  // Basic sentence modifications
+  bool empty();
+  void clear();
+  virtual Word& addWord(const char* form);
+  void setHead(int id, int head, const string& deprel);
+  void unlinkAllWords();
+
+  // CoNLL-U defined comments
+  bool getNewDoc() const;
+  string getNewDocId() const;
+  void setNewDoc(bool new_doc, const string& id = string());
+  bool getNewPar() const;
+  string getNewParId() const;
+  void setNewPar(bool new_par, const string& id = string());
+
+  string getSentId() const;
+  void setSentId(const string& id);
+  string getText() const;
+  void setText(const string& id);
+};
+typedef vector<Sentence> Sentences;
+
+ + +

6.15.2. Main Classes

+ +
+class InputFormat {
+ public:
+  virtual void resetDocument(const string& id = string());
+  virtual void setText(const char* text);
+  virtual bool nextSentence(Sentence& s, ProcessingError* error = nullptr);
+
+  static InputFormat* newInputFormat(const string& name);
+  static InputFormat* newConlluInputFormat(const string& id = string());
+  static InputFormat* newGenericTokenizerInputFormat(const string& id = string());
+  static InputFormat* newHorizontalInputFormat(const string& id = string());
+  static InputFormat* newVerticalInputFormat(const string& id = string());
+
+  static InputFormat* newPresegmentedTokenizer(InputFormat tokenizer);
+
+  static const string CONLLU_V1;
+  static const string CONLLU_V2;
+  static const string GENERIC_TOKENIZER_NORMALIZED_SPACES;
+  static const string GENERIC_TOKENIZER_PRESEGMENTED;
+  static const string GENERIC_TOKENIZER_RANGES;
+};
+
+class OutputFormat {
+ public:
+  virtual string writeSentence(const Sentence& s);
+  virtual string finishDocument();
+
+  static OutputFormat* newOutputFormat(const string& name);
+  static OutputFormat* newConlluOutputFormat(const string& options = string());
+  static OutputFormat* newEpeOutputFormat(const string& options = string());
+  static OutputFormat* newMatxinOutputFormat(const string& options = string());
+  static OutputFormat* newHorizontalOutputFormat(const string& options = string());
+  static OutputFormat* newPlaintextOutputFormat(const string& options = string());
+  static OutputFormat* newVerticalOutputFormat(const string& options = string());
+
+  static const string CONLLU_V1;
+  static const string CONLLU_V2;
+  static const string HORIZONTAL_PARAGRAPHS;
+  static const string PLAINTEXT_NORMALIZED_SPACES;
+  static const string VERTICAL_PARAGRAPHS;
+};
+
+class Model {
+ public:
+  static Model* load(const char* fname);
+
+  virtual InputFormat* newTokenizer(const string& options) const;
+  virtual bool tag(Sentence& s, const string& options, ProcessingError* error = nullptr) const;
+  virtual bool parse(Sentence& s, const string& options, ProcessingError* error) const;
+
+  static const string DEFAULT;
+  static const string TOKENIZER_PRESEGMENTED;
+};
+
+class Pipeline {
+ public:
+  Pipeline(const Model* m, const string& input, const string& tagger, const string& parser, const string& output);
+
+  void setModel(const Model* m);
+  void setInput(const string& input);
+  void setTagger(const string& tagger);
+  void setParser(const string& parser);
+  void setOutput(const string& output);
+
+  void setImmediate(bool immediate);
+  void setDocumentId(const string& document_id);
+
+  string process(const string& data, ProcessingError* error = nullptr) const;
+
+  static const string DEFAULT;
+  static const string NONE;
+};
+
+class Trainer {
+ public:
+
+  static string train(const string& method, const Sentences& train, const Sentences& heldout,
+                      const string& tokenizer, const string& tagger, const string& parser,
+                      ProcessingError* error = nullptr);
+
+  static const string DEFAULT;
+  static const string NONE;
+};
+
+class Evaluator {
+ public:
+  Evaluator(const Model* m, const string& tokenizer, const string& tagger, const string& parser);
+
+  void setModel(const Model* m);
+  void setTokenizer(const string& tokenizer);
+  void setTagger(const string& tagger);
+  void setParser(const string& parser);
+
+  string evaluate(const string& data, ProcessingError* error = nullptr) const;
+
+  static const string DEFAULT;
+  static const string NONE;
+};
+
+class Version {
+ public:
+  unsigned major;
+  unsigned minor;
+  unsigned patch;
+  string prerelease;
+
+  // Returns current version.
+  static version current();
+};
+
+ + +

6.16. C# Bindings

+ +

+UDPipe library bindings is available in the Ufal.UDPipe namespace. +

+

+The bindings is a straightforward conversion of the C++ bindings API. +The bindings requires native C++ library libudpipe_csharp (called +udpipe_csharp on Windows). +

+ + +

6.17. Java Bindings

+ +

+UDPipe library bindings is available in the cz.cuni.mff.ufal.udpipe +package. +

+

+The bindings is a straightforward conversion of the C++ bindings API. +Vectors do not have native Java interface, see +cz.cuni.mff.ufal.udpipe.Words class for reference. Also, class members +are accessible and modifiable using using getField and setField +wrappers. +

+

+The bindings require native C++ library libudpipe_java (called +udpipe_java on Windows). If the library is found in the current +directory, it is used, otherwise standard library search process is used. +The path to the C++ library can also be specified using static +udpipe_java.setLibraryPath(String path) call (before the first call +inside the C++ library, of course). +

+ + +

6.18. Perl Bindings

+ +

+UDPipe library bindings is available in the +Ufal::UDPipe package. +The classes can be imported into the current namespace using the :all +export tag. +

+

+The bindings is a straightforward conversion of the C++ bindings API. +Vectors do not have native Perl interface, see Ufal::UDPipe::Words for +reference. Static methods and enumerations are available only through the +module, not through object instance. +

+ + +

6.19. Python Bindings

+ +

+UDPipe library bindings is available in the +ufal.udpipe module. +

+

+The bindings is a straightforward conversion of the C++ bindings API. +In Python 2, strings can be both unicode and UTF-8 encoded str, and the +library always produces unicode. In Python 3, strings must be only str. +

+ + +

7. Contact

+ +

+Authors: +

+ + +

+UDPipe website. +

+

+UDPipe LINDAT/CLARIN entry. +

+ + +

8. Acknowledgements

+ +

+This work has been using language resources developed and/or stored and/or distributed by the LINDAT/CLARIN project of the Ministry of Education of the Czech Republic (project LM2010013). +

+

+Acknowledgements for individual language models are listed in UDPipe User's Manual. +

+ + +

8.1. Publications

+ + + + +

8.2. Bibtex for Referencing

+ +
+@InProceedings{udpipe:2017,
+  author    = {Straka, Milan  and  Strakov\'{a}, Jana},
+  title     = {Tokenizing, POS Tagging, Lemmatizing and Parsing UD 2.0 with UDPipe},
+  booktitle = {Proceedings of the CoNLL 2017 Shared Task: Multilingual Parsing from Raw Text to Universal Dependencies},
+  month     = {August},
+  year      = {2017},
+  address   = {Vancouver, Canada},
+  publisher = {Association for Computational Linguistics},
+  pages     = {88--99},
+  url       = {http://www.aclweb.org/anthology/K/K17/K17-3009.pdf}
+}
+
+ + +

8.3. Persistent Identifier

+ +

+If you prefer to reference UDPipe by a persistent identifier (PID), +you can use http://hdl.handle.net/11234/1-1702. +

+
+ + + + diff --git a/UDPipe/v1/XDependencies/UDPipe/MANUAL.pdf b/UDPipe/v1/XDependencies/UDPipe/MANUAL.pdf new file mode 100644 index 0000000000000000000000000000000000000000..ad263a640edbae6c8b6a64de38e9ea94dc35d710 --- /dev/null +++ b/UDPipe/v1/XDependencies/UDPipe/MANUAL.pdf @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ee77e0cace6c95acaf0452f87e0abb6f93f3321761f79099b1732f2e64eab5b8 +size 306431 diff --git a/UDPipe/v1/XDependencies/UDPipe/Models/Ancient_greek-PROIEL.udpipe b/UDPipe/v1/XDependencies/UDPipe/Models/Ancient_greek-PROIEL.udpipe new file mode 100644 index 0000000000000000000000000000000000000000..0f94d53c9b5045380e3b467b01aa7e6e883017ee --- /dev/null +++ b/UDPipe/v1/XDependencies/UDPipe/Models/Ancient_greek-PROIEL.udpipe @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:98aa15768a2ba109e18364e19257043567559b745cca3b68de7106e681d681d2 +size 24103587 diff --git a/UDPipe/v1/XDependencies/UDPipe/Models/Ancient_greek.udpipe b/UDPipe/v1/XDependencies/UDPipe/Models/Ancient_greek.udpipe new file mode 100644 index 0000000000000000000000000000000000000000..89eaf54fe7c222f778acc2971d7600ea741c8728 --- /dev/null +++ b/UDPipe/v1/XDependencies/UDPipe/Models/Ancient_greek.udpipe @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b57269272069ded75ba3f22789684d2d3e98ef0df48e1cbba33e92b3b3cdf12b +size 18362920 diff --git a/UDPipe/v1/XDependencies/UDPipe/Models/Arabic.udpipe b/UDPipe/v1/XDependencies/UDPipe/Models/Arabic.udpipe new file mode 100644 index 0000000000000000000000000000000000000000..69c5e8c60cb0add63944fac0403e157e1e7c0f51 --- /dev/null +++ b/UDPipe/v1/XDependencies/UDPipe/Models/Arabic.udpipe @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ee3664353596242025adc6e73fed46049ce127d9dcd90a7f9351a7645334a57f +size 18562251 diff --git a/UDPipe/v1/XDependencies/UDPipe/Models/Basque.udpipe b/UDPipe/v1/XDependencies/UDPipe/Models/Basque.udpipe new file mode 100644 index 0000000000000000000000000000000000000000..7983d3e3762e7c6517de87b86c889fd20cca2f8a --- /dev/null +++ b/UDPipe/v1/XDependencies/UDPipe/Models/Basque.udpipe @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:548ce89ad9a0abd60537e735ad823cf6038ab77b6e1322792ee7c62685868c6b +size 14026875 diff --git a/UDPipe/v1/XDependencies/UDPipe/Models/Belarusian.udpipe b/UDPipe/v1/XDependencies/UDPipe/Models/Belarusian.udpipe new file mode 100644 index 0000000000000000000000000000000000000000..d2bcad088c6ebc46f9ff36cf8d0659f0db5f87d7 --- /dev/null +++ b/UDPipe/v1/XDependencies/UDPipe/Models/Belarusian.udpipe @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1081b4962188206f8f263efae1b0e4072bf976b212acf85ce7cf355829d16d2f +size 2958603 diff --git a/UDPipe/v1/XDependencies/UDPipe/Models/Bulgarian.udpipe b/UDPipe/v1/XDependencies/UDPipe/Models/Bulgarian.udpipe new file mode 100644 index 0000000000000000000000000000000000000000..74781c255946990d0c76ad316b5779c1d307408f --- /dev/null +++ b/UDPipe/v1/XDependencies/UDPipe/Models/Bulgarian.udpipe @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:505b997d1df5d968de2902261de6a0285cdb75b417832d266d4e887090b13540 +size 13953864 diff --git a/UDPipe/v1/XDependencies/UDPipe/Models/Catalan.udpipe b/UDPipe/v1/XDependencies/UDPipe/Models/Catalan.udpipe new file mode 100644 index 0000000000000000000000000000000000000000..776de4fc1cfe0caf65b733928629622ab41c4378 --- /dev/null +++ b/UDPipe/v1/XDependencies/UDPipe/Models/Catalan.udpipe @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:60907886b7b9ad24c1a2775833194ea0e06cc4d22877d49a4731f7cfa09c305d +size 18965989 diff --git a/UDPipe/v1/XDependencies/UDPipe/Models/Chinese.udpipe b/UDPipe/v1/XDependencies/UDPipe/Models/Chinese.udpipe new file mode 100644 index 0000000000000000000000000000000000000000..0beba770e36f8facd85ba8666f48a750b677cc3b --- /dev/null +++ b/UDPipe/v1/XDependencies/UDPipe/Models/Chinese.udpipe @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:310db0ba758c102bcb2486d93b6d1cef3ef7603257b55d2649ece518cf5103b0 +size 14279097 diff --git a/UDPipe/v1/XDependencies/UDPipe/Models/Coptic.udpipe b/UDPipe/v1/XDependencies/UDPipe/Models/Coptic.udpipe new file mode 100644 index 0000000000000000000000000000000000000000..10c1d14fa64d314f3c976882e209e6b7419beca4 --- /dev/null +++ b/UDPipe/v1/XDependencies/UDPipe/Models/Coptic.udpipe @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6239f493b3de9ccc9c0ed9dc04b63b4d8565c402663a08c5f5b9432281620718 +size 2334983 diff --git a/UDPipe/v1/XDependencies/UDPipe/Models/Croatian.udpipe b/UDPipe/v1/XDependencies/UDPipe/Models/Croatian.udpipe new file mode 100644 index 0000000000000000000000000000000000000000..c4c9b517d37e32cd57c97010a18d1524e5266049 --- /dev/null +++ b/UDPipe/v1/XDependencies/UDPipe/Models/Croatian.udpipe @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5056855e37b83a5f51bf8b428f62ef3d2a2d219cde3e0136e50df8033aa2acf7 +size 21354407 diff --git a/UDPipe/v1/XDependencies/UDPipe/Models/Czech-CAC.udpipe b/UDPipe/v1/XDependencies/UDPipe/Models/Czech-CAC.udpipe new file mode 100644 index 0000000000000000000000000000000000000000..587ccf5cce473418ebd1d0a579ad419137e4e346 --- /dev/null +++ b/UDPipe/v1/XDependencies/UDPipe/Models/Czech-CAC.udpipe @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:cff707fa455a6e4be31bf34fab530d7fd1dcbf0ac47418f1c10e2b3ad3b1f5d9 +size 32320130 diff --git a/UDPipe/v1/XDependencies/UDPipe/Models/Czech-CLTT.udpipe b/UDPipe/v1/XDependencies/UDPipe/Models/Czech-CLTT.udpipe new file mode 100644 index 0000000000000000000000000000000000000000..9baf9801be126486033beb00416ee100fc4b3ba3 --- /dev/null +++ b/UDPipe/v1/XDependencies/UDPipe/Models/Czech-CLTT.udpipe @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:01d96ef72b4d9987c86a2a81fd829c75eb35cfc1191cb370c54d88aa89ec62f9 +size 3589041 diff --git a/UDPipe/v1/XDependencies/UDPipe/Models/Czech.udpipe b/UDPipe/v1/XDependencies/UDPipe/Models/Czech.udpipe new file mode 100644 index 0000000000000000000000000000000000000000..ebb5f47e5dcf47d5267e799afe037f52b9548edd --- /dev/null +++ b/UDPipe/v1/XDependencies/UDPipe/Models/Czech.udpipe @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c7048f52e669d579f33cb4444738684b18921bdf7fe936b3aa22e69d22f6a86c +size 56181452 diff --git a/UDPipe/v1/XDependencies/UDPipe/Models/Danish.udpipe b/UDPipe/v1/XDependencies/UDPipe/Models/Danish.udpipe new file mode 100644 index 0000000000000000000000000000000000000000..a85c14f2cc6f49a96ecdc9372121efd8800c8ab7 --- /dev/null +++ b/UDPipe/v1/XDependencies/UDPipe/Models/Danish.udpipe @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:68fa1887f549b13b86d9bd412c0db198376ee487b69c6e36b002d165a3acf86f +size 9968167 diff --git a/UDPipe/v1/XDependencies/UDPipe/Models/Dutch-LASSYSMALL.udpipe b/UDPipe/v1/XDependencies/UDPipe/Models/Dutch-LASSYSMALL.udpipe new file mode 100644 index 0000000000000000000000000000000000000000..58a8f16d2871a5d41e32409aed80cc53aef98eb9 --- /dev/null +++ b/UDPipe/v1/XDependencies/UDPipe/Models/Dutch-LASSYSMALL.udpipe @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e9cb72864093fda36246578f522f4ea16bb4c41def572e30cdf3b38a2df36943 +size 9208258 diff --git a/UDPipe/v1/XDependencies/UDPipe/Models/Dutch.udpipe b/UDPipe/v1/XDependencies/UDPipe/Models/Dutch.udpipe new file mode 100644 index 0000000000000000000000000000000000000000..2d63c729622e322fcd6f65a20355a41667712bfa --- /dev/null +++ b/UDPipe/v1/XDependencies/UDPipe/Models/Dutch.udpipe @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:095395cab2dfe5344072f24142289e5dc6735f617d2bcdaf8ad975f9bdb5be78 +size 19992491 diff --git a/UDPipe/v1/XDependencies/UDPipe/Models/English-LINES.udpipe b/UDPipe/v1/XDependencies/UDPipe/Models/English-LINES.udpipe new file mode 100644 index 0000000000000000000000000000000000000000..be5b6a4c144a951f8dbe98f77be39f6102f92cb3 --- /dev/null +++ b/UDPipe/v1/XDependencies/UDPipe/Models/English-LINES.udpipe @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d355da14a859bbfd52b56583b3a834503764be5d9afcd60da54b59bebae64402 +size 6650816 diff --git a/UDPipe/v1/XDependencies/UDPipe/Models/English-PARTUT.udpipe b/UDPipe/v1/XDependencies/UDPipe/Models/English-PARTUT.udpipe new file mode 100644 index 0000000000000000000000000000000000000000..5487b474629b180d6feeed738d0d3cda50ffcc7e --- /dev/null +++ b/UDPipe/v1/XDependencies/UDPipe/Models/English-PARTUT.udpipe @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e2d7d603d8e5850da79caf1e7b558510d4788ee7a45052e7179627ee8f6a4bfa +size 5254512 diff --git a/UDPipe/v1/XDependencies/UDPipe/Models/English.udpipe b/UDPipe/v1/XDependencies/UDPipe/Models/English.udpipe new file mode 100644 index 0000000000000000000000000000000000000000..7f37f4ce55ffa7ca8e7347fe9f16acdbca9a7d12 --- /dev/null +++ b/UDPipe/v1/XDependencies/UDPipe/Models/English.udpipe @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:02c16913b5a1428d10d40c1f1a3ddc4b8440aa1a7cac91ad8130e91382deacad +size 16741882 diff --git a/UDPipe/v1/XDependencies/UDPipe/Models/Estonian.udpipe b/UDPipe/v1/XDependencies/UDPipe/Models/Estonian.udpipe new file mode 100644 index 0000000000000000000000000000000000000000..d35628d545b90737b93a918d76c2ea887fcdaf1e --- /dev/null +++ b/UDPipe/v1/XDependencies/UDPipe/Models/Estonian.udpipe @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c544633aa48be251df503121098325c74cfd0a72126b2d64c1c2a4be9edf6cbe +size 7341117 diff --git a/UDPipe/v1/XDependencies/UDPipe/Models/Finnish-FTB.udpipe b/UDPipe/v1/XDependencies/UDPipe/Models/Finnish-FTB.udpipe new file mode 100644 index 0000000000000000000000000000000000000000..e5ac52214dd56f9db0e1fb055dc51753740e1c7f --- /dev/null +++ b/UDPipe/v1/XDependencies/UDPipe/Models/Finnish-FTB.udpipe @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:114c1a4b4d4fcb7f79d8e7e2333ae3f6c1fb4439675ab7eecb2e218521d7166f +size 19943808 diff --git a/UDPipe/v1/XDependencies/UDPipe/Models/Finnish.udpipe b/UDPipe/v1/XDependencies/UDPipe/Models/Finnish.udpipe new file mode 100644 index 0000000000000000000000000000000000000000..7408f11cb8e5500cbf9879cbc552dd17b817c597 --- /dev/null +++ b/UDPipe/v1/XDependencies/UDPipe/Models/Finnish.udpipe @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0d98d56f2582e5f1ab4ac424afe43c5ac83c463c3552619adb861b990e5910a8 +size 24729705 diff --git a/UDPipe/v1/XDependencies/UDPipe/Models/French-PARTUT.udpipe b/UDPipe/v1/XDependencies/UDPipe/Models/French-PARTUT.udpipe new file mode 100644 index 0000000000000000000000000000000000000000..9df92ce50ca718eba997abfc2f063de4e3688d9e --- /dev/null +++ b/UDPipe/v1/XDependencies/UDPipe/Models/French-PARTUT.udpipe @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ea598eef2763977b25cb63446e3c55f42c33ec22391be5d551bdb6e89e9bd57c +size 3817103 diff --git a/UDPipe/v1/XDependencies/UDPipe/Models/French-SEQUOIA.udpipe b/UDPipe/v1/XDependencies/UDPipe/Models/French-SEQUOIA.udpipe new file mode 100644 index 0000000000000000000000000000000000000000..83608e56aa498e5e81341185dfe7730fdcfc7ca9 --- /dev/null +++ b/UDPipe/v1/XDependencies/UDPipe/Models/French-SEQUOIA.udpipe @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e6ff70e8802c01df95e5a7ce28681597f9279e6f72b38a7cd2e671536e0472e0 +size 6277254 diff --git a/UDPipe/v1/XDependencies/UDPipe/Models/French.udpipe b/UDPipe/v1/XDependencies/UDPipe/Models/French.udpipe new file mode 100644 index 0000000000000000000000000000000000000000..41a315831b800ff39d7cd0b594caad0a4058bac5 --- /dev/null +++ b/UDPipe/v1/XDependencies/UDPipe/Models/French.udpipe @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5376cbeb8ebf2165c95c93ca5f5281534cbdb7228a4e48fa5ad94e2abe97a928 +size 22002723 diff --git a/UDPipe/v1/XDependencies/UDPipe/Models/Galician-TREEGAL.udpipe b/UDPipe/v1/XDependencies/UDPipe/Models/Galician-TREEGAL.udpipe new file mode 100644 index 0000000000000000000000000000000000000000..961b6f73b7dea710b8f4c276f2990942c49d6a8c --- /dev/null +++ b/UDPipe/v1/XDependencies/UDPipe/Models/Galician-TREEGAL.udpipe @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:deb76bc99bb8bab1ab43a68add4a2446f1f722c378b12581c62d7ca9ea38461d +size 3755885 diff --git a/UDPipe/v1/XDependencies/UDPipe/Models/Galician.udpipe b/UDPipe/v1/XDependencies/UDPipe/Models/Galician.udpipe new file mode 100644 index 0000000000000000000000000000000000000000..3aec169fd41c9977cde308236e3f3c941cafda8d --- /dev/null +++ b/UDPipe/v1/XDependencies/UDPipe/Models/Galician.udpipe @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d8bc6833a0b0019166d12cdcb938dd59d197eab5cae3cacac3f31cfb9b2d980e +size 8720279 diff --git a/UDPipe/v1/XDependencies/UDPipe/Models/German.udpipe b/UDPipe/v1/XDependencies/UDPipe/Models/German.udpipe new file mode 100644 index 0000000000000000000000000000000000000000..4dde9ce6edda7e32b5d67da8b181946e0b79dace --- /dev/null +++ b/UDPipe/v1/XDependencies/UDPipe/Models/German.udpipe @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a9536b5b14558302987809382dfe00d034478f81f17282ba1b7da432967d90af +size 26747299 diff --git a/UDPipe/v1/XDependencies/UDPipe/Models/Gothic.udpipe b/UDPipe/v1/XDependencies/UDPipe/Models/Gothic.udpipe new file mode 100644 index 0000000000000000000000000000000000000000..1d17fcf44ea02c383ecf8784f819acffe4d4628e --- /dev/null +++ b/UDPipe/v1/XDependencies/UDPipe/Models/Gothic.udpipe @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d2956e420595b54d9f255309e8cb233781a91e3f1b62e95c81a2efe452ccfe12 +size 7296884 diff --git a/UDPipe/v1/XDependencies/UDPipe/Models/Greek.udpipe b/UDPipe/v1/XDependencies/UDPipe/Models/Greek.udpipe new file mode 100644 index 0000000000000000000000000000000000000000..87559ca4180f520a9dbf5f1fae285057f33d8384 --- /dev/null +++ b/UDPipe/v1/XDependencies/UDPipe/Models/Greek.udpipe @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8eb75344ef6a0e6bdd1d07ef8db9c4ca7150a12b7d35b82cb27210a8394467eb +size 7503487 diff --git a/UDPipe/v1/XDependencies/UDPipe/Models/Hebrew.udpipe b/UDPipe/v1/XDependencies/UDPipe/Models/Hebrew.udpipe new file mode 100644 index 0000000000000000000000000000000000000000..874825e5efe04c25259dc39481a6c8d8606144fa --- /dev/null +++ b/UDPipe/v1/XDependencies/UDPipe/Models/Hebrew.udpipe @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e516577e2f845ef746c37bb722eef7cfb03bf81005c0558f4ee51d36176a1d96 +size 15344313 diff --git a/UDPipe/v1/XDependencies/UDPipe/Models/Hindi.udpipe b/UDPipe/v1/XDependencies/UDPipe/Models/Hindi.udpipe new file mode 100644 index 0000000000000000000000000000000000000000..62459a017c338f99a246abfb2885e9bc8b4e5888 --- /dev/null +++ b/UDPipe/v1/XDependencies/UDPipe/Models/Hindi.udpipe @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2bcaa86d48f6b4cd1710616cccd4798d4765cf591b7a7f9f7b5514ba3e28a780 +size 26137581 diff --git a/UDPipe/v1/XDependencies/UDPipe/Models/Hungarian.udpipe b/UDPipe/v1/XDependencies/UDPipe/Models/Hungarian.udpipe new file mode 100644 index 0000000000000000000000000000000000000000..ef9bf44189d2fcb6f0635e4e578f2aa4536c74b3 --- /dev/null +++ b/UDPipe/v1/XDependencies/UDPipe/Models/Hungarian.udpipe @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8668f75a14e27a866cad55733170e812873bf463ebd45e210567e6878f32844b +size 7343092 diff --git a/UDPipe/v1/XDependencies/UDPipe/Models/Indonesian.udpipe b/UDPipe/v1/XDependencies/UDPipe/Models/Indonesian.udpipe new file mode 100644 index 0000000000000000000000000000000000000000..5748e681a666db7167967ac5d16637c0b1ca5b78 --- /dev/null +++ b/UDPipe/v1/XDependencies/UDPipe/Models/Indonesian.udpipe @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a14f44a2ce18ffc13ceaab97eb546ff0dacc9ce2c57acf2d0f7c2ae992630a15 +size 9851141 diff --git a/UDPipe/v1/XDependencies/UDPipe/Models/Irish.udpipe b/UDPipe/v1/XDependencies/UDPipe/Models/Irish.udpipe new file mode 100644 index 0000000000000000000000000000000000000000..b5bc51d8a5f6eb40e0a17abb3ea2d53ef7914f24 --- /dev/null +++ b/UDPipe/v1/XDependencies/UDPipe/Models/Irish.udpipe @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a292dd8b8e43f7a919689af2694731d83947177072e744cc003eeefdd0458bf5 +size 4008759 diff --git a/UDPipe/v1/XDependencies/UDPipe/Models/Italian.udpipe b/UDPipe/v1/XDependencies/UDPipe/Models/Italian.udpipe new file mode 100644 index 0000000000000000000000000000000000000000..add862b14ab1743613d576b973e7a38e275eaf28 --- /dev/null +++ b/UDPipe/v1/XDependencies/UDPipe/Models/Italian.udpipe @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6979ec05136cbc3637c708ade9e280beb92f2e1961578661832e7e2807eca7d0 +size 15453544 diff --git a/UDPipe/v1/XDependencies/UDPipe/Models/Japanese.udpipe b/UDPipe/v1/XDependencies/UDPipe/Models/Japanese.udpipe new file mode 100644 index 0000000000000000000000000000000000000000..6fc4ee79e41957bda0947fb30118db370b1b9ff5 --- /dev/null +++ b/UDPipe/v1/XDependencies/UDPipe/Models/Japanese.udpipe @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5c45f140374e7beb30c5e3d55aef9af8bce2b81c1344b3b391287710b12582c4 +size 13190195 diff --git a/UDPipe/v1/XDependencies/UDPipe/Models/Kazakh.udpipe b/UDPipe/v1/XDependencies/UDPipe/Models/Kazakh.udpipe new file mode 100644 index 0000000000000000000000000000000000000000..761c7db8d95ecceb22a52244414674e46b210e26 --- /dev/null +++ b/UDPipe/v1/XDependencies/UDPipe/Models/Kazakh.udpipe @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:dd7af7cd262e386963068dccbb90153fabc89ca3916c257324593da8c7a88f78 +size 1766621 diff --git a/UDPipe/v1/XDependencies/UDPipe/Models/Korean.udpipe b/UDPipe/v1/XDependencies/UDPipe/Models/Korean.udpipe new file mode 100644 index 0000000000000000000000000000000000000000..0eb124c98941176e9636d3713904de9d3b995b82 --- /dev/null +++ b/UDPipe/v1/XDependencies/UDPipe/Models/Korean.udpipe @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:11ae07647bb5350d082e2bb8be36351c5be48c2ec149b146873f236a33a5412a +size 13698995 diff --git a/UDPipe/v1/XDependencies/UDPipe/Models/LICENSE b/UDPipe/v1/XDependencies/UDPipe/Models/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..d9e352b2f77a35accd82f8ce91c2fef5dab1df22 --- /dev/null +++ b/UDPipe/v1/XDependencies/UDPipe/Models/LICENSE @@ -0,0 +1,435 @@ +Attribution-NonCommercial-ShareAlike 4.0 International + +======================================================================= + +Creative Commons Corporation ("Creative Commons") is not a law firm and +does not provide legal services or legal advice. Distribution of +Creative Commons public licenses does not create a lawyer-client or +other relationship. Creative Commons makes its licenses and related +information available on an "as-is" basis. Creative Commons gives no +warranties regarding its licenses, any material licensed under their +terms and conditions, or any related information. Creative Commons +disclaims all liability for damages resulting from their use to the +fullest extent possible. + +Using Creative Commons Public Licenses + +Creative Commons public licenses provide a standard set of terms and +conditions that creators and other rights holders may use to share +original works of authorship and other material subject to copyright +and certain other rights specified in the public license below. The +following considerations are for informational purposes only, are not +exhaustive, and do not form part of our licenses. + + Considerations for licensors: Our public licenses are + intended for use by those authorized to give the public + permission to use material in ways otherwise restricted by + copyright and certain other rights. Our licenses are + irrevocable. Licensors should read and understand the terms + and conditions of the license they choose before applying it. + Licensors should also secure all rights necessary before + applying our licenses so that the public can reuse the + material as expected. Licensors should clearly mark any + material not subject to the license. This includes other CC- + licensed material, or material used under an exception or + limitation to copyright. More considerations for licensors: + wiki.creativecommons.org/Considerations_for_licensors + + Considerations for the public: By using one of our public + licenses, a licensor grants the public permission to use the + licensed material under specified terms and conditions. If + the licensor's permission is not necessary for any reason--for + example, because of any applicable exception or limitation to + copyright--then that use is not regulated by the license. Our + licenses grant only permissions under copyright and certain + other rights that a licensor has authority to grant. Use of + the licensed material may still be restricted for other + reasons, including because others have copyright or other + rights in the material. A licensor may make special requests, + such as asking that all changes be marked or described. + Although not required by our licenses, you are encouraged to + respect those requests where reasonable. More_considerations + for the public: + wiki.creativecommons.org/Considerations_for_licensees + +======================================================================= + +Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International +Public License + +By exercising the Licensed Rights (defined below), You accept and agree +to be bound by the terms and conditions of this Creative Commons +Attribution-NonCommercial-ShareAlike 4.0 International Public License +("Public License"). To the extent this Public License may be +interpreted as a contract, You are granted the Licensed Rights in +consideration of Your acceptance of these terms and conditions, and the +Licensor grants You such rights in consideration of benefits the +Licensor receives from making the Licensed Material available under +these terms and conditions. + + +Section 1 -- Definitions. + + a. Adapted Material means material subject to Copyright and Similar + Rights that is derived from or based upon the Licensed Material + and in which the Licensed Material is translated, altered, + arranged, transformed, or otherwise modified in a manner requiring + permission under the Copyright and Similar Rights held by the + Licensor. For purposes of this Public License, where the Licensed + Material is a musical work, performance, or sound recording, + Adapted Material is always produced where the Licensed Material is + synched in timed relation with a moving image. + + b. Adapter's License means the license You apply to Your Copyright + and Similar Rights in Your contributions to Adapted Material in + accordance with the terms and conditions of this Public License. + + c. BY-NC-SA Compatible License means a license listed at + creativecommons.org/compatiblelicenses, approved by Creative + Commons as essentially the equivalent of this Public License. + + d. Copyright and Similar Rights means copyright and/or similar rights + closely related to copyright including, without limitation, + performance, broadcast, sound recording, and Sui Generis Database + Rights, without regard to how the rights are labeled or + categorized. For purposes of this Public License, the rights + specified in Section 2(b)(1)-(2) are not Copyright and Similar + Rights. + + e. Effective Technological Measures means those measures that, in the + absence of proper authority, may not be circumvented under laws + fulfilling obligations under Article 11 of the WIPO Copyright + Treaty adopted on December 20, 1996, and/or similar international + agreements. + + f. Exceptions and Limitations means fair use, fair dealing, and/or + any other exception or limitation to Copyright and Similar Rights + that applies to Your use of the Licensed Material. + + g. License Elements means the license attributes listed in the name + of a Creative Commons Public License. The License Elements of this + Public License are Attribution, NonCommercial, and ShareAlike. + + h. Licensed Material means the artistic or literary work, database, + or other material to which the Licensor applied this Public + License. + + i. Licensed Rights means the rights granted to You subject to the + terms and conditions of this Public License, which are limited to + all Copyright and Similar Rights that apply to Your use of the + Licensed Material and that the Licensor has authority to license. + + j. Licensor means the individual(s) or entity(ies) granting rights + under this Public License. + + k. NonCommercial means not primarily intended for or directed towards + commercial advantage or monetary compensation. For purposes of + this Public License, the exchange of the Licensed Material for + other material subject to Copyright and Similar Rights by digital + file-sharing or similar means is NonCommercial provided there is + no payment of monetary compensation in connection with the + exchange. + + l. Share means to provide material to the public by any means or + process that requires permission under the Licensed Rights, such + as reproduction, public display, public performance, distribution, + dissemination, communication, or importation, and to make material + available to the public including in ways that members of the + public may access the material from a place and at a time + individually chosen by them. + + m. Sui Generis Database Rights means rights other than copyright + resulting from Directive 96/9/EC of the European Parliament and of + the Council of 11 March 1996 on the legal protection of databases, + as amended and/or succeeded, as well as other essentially + equivalent rights anywhere in the world. + + n. You means the individual or entity exercising the Licensed Rights + under this Public License. Your has a corresponding meaning. + + +Section 2 -- Scope. + + a. License grant. + + 1. Subject to the terms and conditions of this Public License, + the Licensor hereby grants You a worldwide, royalty-free, + non-sublicensable, non-exclusive, irrevocable license to + exercise the Licensed Rights in the Licensed Material to: + + a. reproduce and Share the Licensed Material, in whole or + in part, for NonCommercial purposes only; and + + b. produce, reproduce, and Share Adapted Material for + NonCommercial purposes only. + + 2. Exceptions and Limitations. For the avoidance of doubt, where + Exceptions and Limitations apply to Your use, this Public + License does not apply, and You do not need to comply with + its terms and conditions. + + 3. Term. The term of this Public License is specified in Section + 6(a). + + 4. Media and formats; technical modifications allowed. The + Licensor authorizes You to exercise the Licensed Rights in + all media and formats whether now known or hereafter created, + and to make technical modifications necessary to do so. The + Licensor waives and/or agrees not to assert any right or + authority to forbid You from making technical modifications + necessary to exercise the Licensed Rights, including + technical modifications necessary to circumvent Effective + Technological Measures. For purposes of this Public License, + simply making modifications authorized by this Section 2(a) + (4) never produces Adapted Material. + + 5. Downstream recipients. + + a. Offer from the Licensor -- Licensed Material. Every + recipient of the Licensed Material automatically + receives an offer from the Licensor to exercise the + Licensed Rights under the terms and conditions of this + Public License. + + b. Additional offer from the Licensor -- Adapted Material. + Every recipient of Adapted Material from You + automatically receives an offer from the Licensor to + exercise the Licensed Rights in the Adapted Material + under the conditions of the Adapter's License You apply. + + c. No downstream restrictions. You may not offer or impose + any additional or different terms or conditions on, or + apply any Effective Technological Measures to, the + Licensed Material if doing so restricts exercise of the + Licensed Rights by any recipient of the Licensed + Material. + + 6. No endorsement. Nothing in this Public License constitutes or + may be construed as permission to assert or imply that You + are, or that Your use of the Licensed Material is, connected + with, or sponsored, endorsed, or granted official status by, + the Licensor or others designated to receive attribution as + provided in Section 3(a)(1)(A)(i). + + b. Other rights. + + 1. Moral rights, such as the right of integrity, are not + licensed under this Public License, nor are publicity, + privacy, and/or other similar personality rights; however, to + the extent possible, the Licensor waives and/or agrees not to + assert any such rights held by the Licensor to the limited + extent necessary to allow You to exercise the Licensed + Rights, but not otherwise. + + 2. Patent and trademark rights are not licensed under this + Public License. + + 3. To the extent possible, the Licensor waives any right to + collect royalties from You for the exercise of the Licensed + Rights, whether directly or through a collecting society + under any voluntary or waivable statutory or compulsory + licensing scheme. In all other cases the Licensor expressly + reserves any right to collect such royalties, including when + the Licensed Material is used other than for NonCommercial + purposes. + + +Section 3 -- License Conditions. + +Your exercise of the Licensed Rights is expressly made subject to the +following conditions. + + a. Attribution. + + 1. If You Share the Licensed Material (including in modified + form), You must: + + a. retain the following if it is supplied by the Licensor + with the Licensed Material: + + i. identification of the creator(s) of the Licensed + Material and any others designated to receive + attribution, in any reasonable manner requested by + the Licensor (including by pseudonym if + designated); + + ii. a copyright notice; + + iii. a notice that refers to this Public License; + + iv. a notice that refers to the disclaimer of + warranties; + + v. a URI or hyperlink to the Licensed Material to the + extent reasonably practicable; + + b. indicate if You modified the Licensed Material and + retain an indication of any previous modifications; and + + c. indicate the Licensed Material is licensed under this + Public License, and include the text of, or the URI or + hyperlink to, this Public License. + + 2. You may satisfy the conditions in Section 3(a)(1) in any + reasonable manner based on the medium, means, and context in + which You Share the Licensed Material. For example, it may be + reasonable to satisfy the conditions by providing a URI or + hyperlink to a resource that includes the required + information. + 3. If requested by the Licensor, You must remove any of the + information required by Section 3(a)(1)(A) to the extent + reasonably practicable. + + b. ShareAlike. + + In addition to the conditions in Section 3(a), if You Share + Adapted Material You produce, the following conditions also apply. + + 1. The Adapter's License You apply must be a Creative Commons + license with the same License Elements, this version or + later, or a BY-NC-SA Compatible License. + + 2. You must include the text of, or the URI or hyperlink to, the + Adapter's License You apply. You may satisfy this condition + in any reasonable manner based on the medium, means, and + context in which You Share Adapted Material. + + 3. You may not offer or impose any additional or different terms + or conditions on, or apply any Effective Technological + Measures to, Adapted Material that restrict exercise of the + rights granted under the Adapter's License You apply. + + +Section 4 -- Sui Generis Database Rights. + +Where the Licensed Rights include Sui Generis Database Rights that +apply to Your use of the Licensed Material: + + a. for the avoidance of doubt, Section 2(a)(1) grants You the right + to extract, reuse, reproduce, and Share all or a substantial + portion of the contents of the database for NonCommercial purposes + only; + + b. if You include all or a substantial portion of the database + contents in a database in which You have Sui Generis Database + Rights, then the database in which You have Sui Generis Database + Rights (but not its individual contents) is Adapted Material, + including for purposes of Section 3(b); and + + c. You must comply with the conditions in Section 3(a) if You Share + all or a substantial portion of the contents of the database. + +For the avoidance of doubt, this Section 4 supplements and does not +replace Your obligations under this Public License where the Licensed +Rights include other Copyright and Similar Rights. + + +Section 5 -- Disclaimer of Warranties and Limitation of Liability. + + a. UNLESS OTHERWISE SEPARATELY UNDERTAKEN BY THE LICENSOR, TO THE + EXTENT POSSIBLE, THE LICENSOR OFFERS THE LICENSED MATERIAL AS-IS + AND AS-AVAILABLE, AND MAKES NO REPRESENTATIONS OR WARRANTIES OF + ANY KIND CONCERNING THE LICENSED MATERIAL, WHETHER EXPRESS, + IMPLIED, STATUTORY, OR OTHER. THIS INCLUDES, WITHOUT LIMITATION, + WARRANTIES OF TITLE, MERCHANTABILITY, FITNESS FOR A PARTICULAR + PURPOSE, NON-INFRINGEMENT, ABSENCE OF LATENT OR OTHER DEFECTS, + ACCURACY, OR THE PRESENCE OR ABSENCE OF ERRORS, WHETHER OR NOT + KNOWN OR DISCOVERABLE. WHERE DISCLAIMERS OF WARRANTIES ARE NOT + ALLOWED IN FULL OR IN PART, THIS DISCLAIMER MAY NOT APPLY TO YOU. + + b. TO THE EXTENT POSSIBLE, IN NO EVENT WILL THE LICENSOR BE LIABLE + TO YOU ON ANY LEGAL THEORY (INCLUDING, WITHOUT LIMITATION, + NEGLIGENCE) OR OTHERWISE FOR ANY DIRECT, SPECIAL, INDIRECT, + INCIDENTAL, CONSEQUENTIAL, PUNITIVE, EXEMPLARY, OR OTHER LOSSES, + COSTS, EXPENSES, OR DAMAGES ARISING OUT OF THIS PUBLIC LICENSE OR + USE OF THE LICENSED MATERIAL, EVEN IF THE LICENSOR HAS BEEN + ADVISED OF THE POSSIBILITY OF SUCH LOSSES, COSTS, EXPENSES, OR + DAMAGES. WHERE A LIMITATION OF LIABILITY IS NOT ALLOWED IN FULL OR + IN PART, THIS LIMITATION MAY NOT APPLY TO YOU. + + c. The disclaimer of warranties and limitation of liability provided + above shall be interpreted in a manner that, to the extent + possible, most closely approximates an absolute disclaimer and + waiver of all liability. + + +Section 6 -- Term and Termination. + + a. This Public License applies for the term of the Copyright and + Similar Rights licensed here. However, if You fail to comply with + this Public License, then Your rights under this Public License + terminate automatically. + + b. Where Your right to use the Licensed Material has terminated under + Section 6(a), it reinstates: + + 1. automatically as of the date the violation is cured, provided + it is cured within 30 days of Your discovery of the + violation; or + + 2. upon express reinstatement by the Licensor. + + For the avoidance of doubt, this Section 6(b) does not affect any + right the Licensor may have to seek remedies for Your violations + of this Public License. + + c. For the avoidance of doubt, the Licensor may also offer the + Licensed Material under separate terms or conditions or stop + distributing the Licensed Material at any time; however, doing so + will not terminate this Public License. + + d. Sections 1, 5, 6, 7, and 8 survive termination of this Public + License. + + +Section 7 -- Other Terms and Conditions. + + a. The Licensor shall not be bound by any additional or different + terms or conditions communicated by You unless expressly agreed. + + b. Any arrangements, understandings, or agreements regarding the + Licensed Material not stated herein are separate from and + independent of the terms and conditions of this Public License. + + +Section 8 -- Interpretation. + + a. For the avoidance of doubt, this Public License does not, and + shall not be interpreted to, reduce, limit, restrict, or impose + conditions on any use of the Licensed Material that could lawfully + be made without permission under this Public License. + + b. To the extent possible, if any provision of this Public License is + deemed unenforceable, it shall be automatically reformed to the + minimum extent necessary to make it enforceable. If the provision + cannot be reformed, it shall be severed from this Public License + without affecting the enforceability of the remaining terms and + conditions. + + c. No term or condition of this Public License will be waived and no + failure to comply consented to unless expressly agreed to by the + Licensor. + + d. Nothing in this Public License constitutes or may be interpreted + as a limitation upon, or waiver of, any privileges and immunities + that apply to the Licensor or You, including from the legal + processes of any jurisdiction or authority. + +======================================================================= + +Creative Commons is not a party to its public licenses. +Notwithstanding, Creative Commons may elect to apply one of its public +licenses to material it publishes and in those instances will be +considered the "Licensor." Except for the limited purpose of indicating +that material is shared under a Creative Commons public license or as +otherwise permitted by the Creative Commons policies published at +creativecommons.org/policies, Creative Commons does not authorize the +use of the trademark "Creative Commons" or any other trademark or logo +of Creative Commons without its prior written consent including, +without limitation, in connection with any unauthorized modifications +to any of its public licenses or any other arrangements, +understandings, or agreements concerning use of licensed material. For +the avoidance of doubt, this paragraph does not form part of the public +licenses. + +Creative Commons may be contacted at creativecommons.org. diff --git a/UDPipe/v1/XDependencies/UDPipe/Models/Latin-ITTB.udpipe b/UDPipe/v1/XDependencies/UDPipe/Models/Latin-ITTB.udpipe new file mode 100644 index 0000000000000000000000000000000000000000..e729f6cd0af2c8fadc2fc988c44f338f92344421 --- /dev/null +++ b/UDPipe/v1/XDependencies/UDPipe/Models/Latin-ITTB.udpipe @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:fcc6ac1e5505dea75c4ea1fd6407c78cbd06e3474b1ad1938d195814e9d1be7a +size 18159411 diff --git a/UDPipe/v1/XDependencies/UDPipe/Models/Latin-PROIEL.udpipe b/UDPipe/v1/XDependencies/UDPipe/Models/Latin-PROIEL.udpipe new file mode 100644 index 0000000000000000000000000000000000000000..667d8282d76b4c1786865ae4b0ee023d26f46608 --- /dev/null +++ b/UDPipe/v1/XDependencies/UDPipe/Models/Latin-PROIEL.udpipe @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5c1e6289b6ebf0775ef9c3668edbbda124d63f3d05e449882682e710d4e4780a +size 19337153 diff --git a/UDPipe/v1/XDependencies/UDPipe/Models/Latin.udpipe b/UDPipe/v1/XDependencies/UDPipe/Models/Latin.udpipe new file mode 100644 index 0000000000000000000000000000000000000000..49fd53453aeec752d11f90c51572933432658681 --- /dev/null +++ b/UDPipe/v1/XDependencies/UDPipe/Models/Latin.udpipe @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:46d4372b691798f6ae879245041790ec97d32ddf8e8db7816415dc9f0c24cbae +size 6476124 diff --git a/UDPipe/v1/XDependencies/UDPipe/Models/Latvian.udpipe b/UDPipe/v1/XDependencies/UDPipe/Models/Latvian.udpipe new file mode 100644 index 0000000000000000000000000000000000000000..6fa7012a6041b2da7d4b9bf5dde6315a1e814bce --- /dev/null +++ b/UDPipe/v1/XDependencies/UDPipe/Models/Latvian.udpipe @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a867a1ca941d71e39cd1cb41443784df3ed3b35347c433aa4140fa3c2f9fc941 +size 9542343 diff --git a/UDPipe/v1/XDependencies/UDPipe/Models/Lithuanian.udpipe b/UDPipe/v1/XDependencies/UDPipe/Models/Lithuanian.udpipe new file mode 100644 index 0000000000000000000000000000000000000000..0b64788ea6bd6ea4572cc75d0bc449ddb2021e6f --- /dev/null +++ b/UDPipe/v1/XDependencies/UDPipe/Models/Lithuanian.udpipe @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6090dd498317241b70fa5e070a75c59edd8d10309dc0f71e470c4577175e0b2d +size 3005095 diff --git a/UDPipe/v1/XDependencies/UDPipe/Models/Norwegian-BOKMAAL.udpipe b/UDPipe/v1/XDependencies/UDPipe/Models/Norwegian-BOKMAAL.udpipe new file mode 100644 index 0000000000000000000000000000000000000000..9e01b680250e4fc649ab442063aa0e4207887f58 --- /dev/null +++ b/UDPipe/v1/XDependencies/UDPipe/Models/Norwegian-BOKMAAL.udpipe @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:836a1640d5bd0f89f0029249b6bf453ce12f8d27a12c081ba769dc0a3231a514 +size 20817725 diff --git a/UDPipe/v1/XDependencies/UDPipe/Models/Norwegian-NYNORSK.udpipe b/UDPipe/v1/XDependencies/UDPipe/Models/Norwegian-NYNORSK.udpipe new file mode 100644 index 0000000000000000000000000000000000000000..5e89a5fe1416ff59af53a08ccb4bac1428166fe2 --- /dev/null +++ b/UDPipe/v1/XDependencies/UDPipe/Models/Norwegian-NYNORSK.udpipe @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6996750ca443e21e84a82e813e32e6773bf321c0c74f79dbf5e4f2a4795a5394 +size 20618015 diff --git a/UDPipe/v1/XDependencies/UDPipe/Models/Old_church_slavonic.udpipe b/UDPipe/v1/XDependencies/UDPipe/Models/Old_church_slavonic.udpipe new file mode 100644 index 0000000000000000000000000000000000000000..7e9ebf33b8a60856453d00aaaae9c1c16bc30f8a --- /dev/null +++ b/UDPipe/v1/XDependencies/UDPipe/Models/Old_church_slavonic.udpipe @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1a0d873f66a0a3ee93e21e239cabe51455be5bc61a3622da840745dd07b6aaff +size 7806656 diff --git a/UDPipe/v1/XDependencies/UDPipe/Models/Persian.udpipe b/UDPipe/v1/XDependencies/UDPipe/Models/Persian.udpipe new file mode 100644 index 0000000000000000000000000000000000000000..637307f91741b23cea4c041357fc8fbe66d48dec --- /dev/null +++ b/UDPipe/v1/XDependencies/UDPipe/Models/Persian.udpipe @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:773de5ae0c7f62d8b2ccf349ce48977e6b492f8ddaddad98357f1be151e30490 +size 11658258 diff --git a/UDPipe/v1/XDependencies/UDPipe/Models/Polish.udpipe b/UDPipe/v1/XDependencies/UDPipe/Models/Polish.udpipe new file mode 100644 index 0000000000000000000000000000000000000000..4e98347232c4b23b28cde26d6c5f73d7fa01ba6e --- /dev/null +++ b/UDPipe/v1/XDependencies/UDPipe/Models/Polish.udpipe @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3256efd193f463e4e6d84e4651fe7ec50d14de4dff4b918b842d1897717f7e8b +size 12748619 diff --git a/UDPipe/v1/XDependencies/UDPipe/Models/Portuguese-BR.udpipe b/UDPipe/v1/XDependencies/UDPipe/Models/Portuguese-BR.udpipe new file mode 100644 index 0000000000000000000000000000000000000000..707942c0c9b7a9cc4a1676f27f267832505e6cc9 --- /dev/null +++ b/UDPipe/v1/XDependencies/UDPipe/Models/Portuguese-BR.udpipe @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a7308aa7739ac4e96508c87428d7bdaa90015a96bea641cf8750bf5b7e10d707 +size 13807527 diff --git a/UDPipe/v1/XDependencies/UDPipe/Models/Portuguese.udpipe b/UDPipe/v1/XDependencies/UDPipe/Models/Portuguese.udpipe new file mode 100644 index 0000000000000000000000000000000000000000..52e961cc1075d7fc857a6a74b95648f8046889b9 --- /dev/null +++ b/UDPipe/v1/XDependencies/UDPipe/Models/Portuguese.udpipe @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:df9157d03131e7dfd4758d7e439c198e230f37a43ccc85d8020b3cb309825b2e +size 18950119 diff --git a/UDPipe/v1/XDependencies/UDPipe/Models/README b/UDPipe/v1/XDependencies/UDPipe/Models/README new file mode 100644 index 0000000000000000000000000000000000000000..12fa3fe21f3c6007d3500a694c578109b7cb9ccb --- /dev/null +++ b/UDPipe/v1/XDependencies/UDPipe/Models/README @@ -0,0 +1,303 @@ +Universal Dependencies 2.0 Models for UDPipe +============================================ + +To use this model, you need UDPipe, an open-source tool for tokenization, +tagging, lemmatization and parsing of CoNLL-U files. Please visit the UDPipe +website http://ufal.mff.cuni.cz/udpipe for more information. + + +Universal Dependencies 2.0 Models +================================= + +Universal Dependencies 2.0 Models are distributed under the CC BY-NC-SA +(http://creativecommons.org/licenses/by-nc-sa/4.0/) licence. The models are +based solely on Universal Dependencies 2.0 (http://hdl.handle.net/11234/1-1983) +treebanks. The models work in UDPipe version 1.2 and later. + +Universal Dependencies 2.0 Models are versioned according to the date released +in the format YYMMDD, where YY, MM and DD are two-digit representation of year, +month and day, respectively. The latest version is 170801. + + +Download +-------- + +The latest version 170801 of the Universal Dependencies 2.0 models can be +downloaded from LINDAT/CLARIN repository (http://hdl.handle.net/11234/1-2364). + + +Acknowledgements +---------------- + +This work has been partially supported and has been using language resources and +tools developed, stored and distributed by the LINDAT/CLARIN project of the +Ministry of Education, Youth and Sports of the Czech Republic (project +LM2015071). The wark was also partially supported by OP VVV projects +CZ.02.1.01/0.0/0.0/16\_013/0001781 and CZ.02.2.69/0.0/0.0/16\_018/0002373, and +by SVV project number 260 453. + +The models were trained on Universal Dependencies 2.0 +(http://hdl.handle.net/11234/1-1983) treebanks. + +For the UD treebanks which do not contain original plain text version, raw text +is used to train the tokenizer instead. The plain texts were taken from the W2C +- Web to Corpus (http://hdl.handle.net/11858/00-097C-0000-0022-6133-9). + + +Publications +------------ + +- (Straka et al. 2017) Milan Straka and Jana Straková. Tokenizing, POS + Tagging, Lemmatizing and Parsing UD 2.0 with UDPipe + (http://ufal.mff.cuni.cz/~straka/papers/2017-conll_udpipe.pdf). In Proceedings + of the CoNLL 2017 Shared Task: Multilingual Parsing from Raw Text to Universal + Dependencies, Vancouver, Canada, August 2017. +- (Straka et al. 2016) Straka Milan, Hajič Jan, Straková Jana. UDPipe: + Trainable Pipeline for Processing CoNLL-U Files Performing Tokenization, + Morphological Analysis, POS Tagging and Parsing + (http://ufal.mff.cuni.cz/~straka/papers/2016-lrec_udpipe.pdf). In Proceedings + of the Tenth International Conference on Language Resources and Evaluation + (LREC 2016), Portorož, Slovenia, May 2016. + + +Model Description +----------------- + +The Universal Dependencies 2.0 models contain 68 models of 50 languages, each +consisting of a tokenizer, tagger, lemmatizer and dependency parser, all trained +using the UD data. Note that we use custom train-dev split, by moving sentences +from the beginning of dev data to the end of train data, until the training data +is at least 9 times the dev data. + +The tokenizer is trained using the SpaceAfter=No features. If the features are +not present in the data, they can be filled in using raw text in the language in +question. + +The tagger, lemmatizer and parser are trained using gold UD data. + +Details about model architecture and training process can be found in the +(Straka et al. 2017) paper. + + +Reproducible Training +--------------------- + +In case you want to train the same models, scripts for downloading and +resplitting UD 2.0 data, precomputed word embedding, raw texts for tokenizers, +all hyperparameter values and training scripts are available in the second +archive on the model download page (http://hdl.handle.net/11234/1-2364). + + +Model Performance +----------------- + +We present the tagger, lemmatizer and parser performance, measured on the +testing portion of the data, evaluated in three different settings: using raw +text only, using gold tokenization only, and using gold tokenization plus gold +morphology (UPOS, XPOS, FEATS and Lemma). + + || Treebank | Mode | Words | Sents | UPOS | XPOS | Feats | AllTags | Lemma | UAS | LAS | + | Ancient Greek | Raw text | 100.0% | 98.7% | 82.4% | 72.3% | 85.8% | 72.3% | 82.6% | 64.4% | 57.8% | + | Ancient Greek | Gold tok | - | - | 82.4% | 72.4% | 85.8% | 72.3% | 82.7% | 64.6% | 57.9% | + | Ancient Greek | Gold tok+morph | - | - | - | - | - | - | - | 69.2% | 64.4% | + | Ancient Greek-PROIEL | Raw text | 100.0% | 47.2% | 95.8% | 96.0% | 88.6% | 87.2% | 92.6% | 71.8% | 67.1% | + | Ancient Greek-PROIEL | Gold tok | - | - | 95.8% | 96.1% | 88.7% | 87.2% | 92.8% | 77.2% | 72.3% | + | Ancient Greek-PROIEL | Gold tok+morph | - | - | - | - | - | - | - | 79.7% | 76.1% | + | Arabic | Raw text | 93.8% | 83.1% | 88.4% | 83.4% | 83.5% | 82.3% | 87.5% | 71.7% | 65.8% | + | Arabic | Gold tok | - | - | 94.4% | 89.5% | 89.6% | 88.3% | 92.6% | 81.3% | 74.3% | + | Arabic | Gold tok+morph | - | - | - | - | - | - | - | 82.9% | 77.9% | + | Basque | Raw text | 100.0% | 99.5% | 93.2% | - | 87.6% | - | 93.8% | 75.8% | 70.7% | + | Basque | Gold tok | - | - | 93.3% | - | 87.7% | - | 93.9% | 75.9% | 70.8% | + | Basque | Gold tok+morph | - | - | - | - | - | - | - | 82.3% | 78.4% | + | Belarusian | Raw text | 99.4% | 76.8% | 88.2% | 85.6% | 71.7% | 68.6% | 81.3% | 68.0% | 60.6% | + | Belarusian | Gold tok | - | - | 88.7% | 85.7% | 72.4% | 69.2% | 81.5% | 69.4% | 61.9% | + | Belarusian | Gold tok+morph | - | - | - | - | - | - | - | 76.8% | 74.0% | + | Bulgarian | Raw text | 99.9% | 93.9% | 97.6% | 94.6% | 95.6% | 94.0% | 94.6% | 88.8% | 84.8% | + | Bulgarian | Gold tok | - | - | 97.7% | 94.7% | 95.6% | 94.1% | 94.7% | 89.5% | 85.5% | + | Bulgarian | Gold tok+morph | - | - | - | - | - | - | - | 92.6% | 89.1% | + | Catalan | Raw text | 100.0% | 99.2% | 98.0% | 98.0% | 97.1% | 96.5% | 97.9% | 88.8% | 85.7% | + | Catalan | Gold tok | - | - | 98.0% | 98.0% | 97.2% | 96.5% | 97.9% | 88.8% | 85.8% | + | Catalan | Gold tok+morph | - | - | - | - | - | - | - | 91.1% | 88.7% | + | Chinese | Raw text | 90.2% | 98.8% | 84.0% | 83.8% | 89.0% | 82.7% | 90.2% | 62.9% | 58.7% | + | Chinese | Gold tok | - | - | 92.2% | 92.0% | 98.7% | 90.8% | 100.0% | 75.6% | 70.1% | + | Chinese | Gold tok+morph | - | - | - | - | - | - | - | 84.1% | 81.4% | + | Coptic | Raw text | 65.8% | 35.7% | 62.6% | 62.1% | 65.7% | 62.1% | 64.6% | 41.1% | 39.3% | + | Coptic | Gold tok | - | - | 95.1% | 94.3% | 99.7% | 94.2% | 96.2% | 83.2% | 79.2% | + | Coptic | Gold tok+morph | - | - | - | - | - | - | - | 88.1% | 84.9% | + | Croatian | Raw text | 99.9% | 97.0% | 95.9% | - | 84.3% | - | 94.4% | 83.6% | 77.9% | + | Croatian | Gold tok | - | - | 96.0% | - | 84.4% | - | 94.4% | 83.9% | 78.1% | + | Croatian | Gold tok+morph | - | - | - | - | - | - | - | 87.1% | 83.2% | + | Czech | Raw text | 99.9% | 91.6% | 98.3% | 92.8% | 92.1% | 91.7% | 97.8% | 86.8% | 83.2% | + | Czech | Gold tok | - | - | 98.4% | 92.9% | 92.2% | 91.9% | 97.9% | 87.7% | 84.1% | + | Czech | Gold tok+morph | - | - | - | - | - | - | - | 90.2% | 87.5% | + | Czech-CAC | Raw text | 100.0% | 99.8% | 98.1% | 90.6% | 89.4% | 89.1% | 97.0% | 86.9% | 82.7% | + | Czech-CAC | Gold tok | - | - | 98.1% | 90.7% | 89.5% | 89.1% | 97.1% | 87.0% | 82.8% | + | Czech-CAC | Gold tok+morph | - | - | - | - | - | - | - | 89.7% | 86.6% | + | Czech-CLTT | Raw text | 99.5% | 92.3% | 96.5% | 87.5% | 87.8% | 87.3% | 96.8% | 80.2% | 76.6% | + | Czech-CLTT | Gold tok | - | - | 97.0% | 87.9% | 88.3% | 87.7% | 97.2% | 81.0% | 77.6% | + | Czech-CLTT | Gold tok+morph | - | - | - | - | - | - | - | 83.8% | 80.8% | + | Danish | Raw text | 99.8% | 77.9% | 95.2% | - | 94.2% | - | 94.9% | 78.4% | 74.7% | + | Danish | Gold tok | - | - | 95.5% | - | 94.5% | - | 95.0% | 80.4% | 76.6% | + | Danish | Gold tok+morph | - | - | - | - | - | - | - | 85.6% | 82.7% | + | Dutch | Raw text | 99.8% | 77.6% | 91.4% | 88.1% | 89.3% | 87.0% | 89.9% | 75.4% | 69.6% | + | Dutch | Gold tok | - | - | 91.8% | 88.8% | 89.9% | 87.7% | 90.1% | 77.0% | 71.2% | + | Dutch | Gold tok+morph | - | - | - | - | - | - | - | 82.9% | 79.4% | + | Dutch-LassySmall | Raw text | 100.0% | 80.4% | 97.6% | - | 97.2% | - | 98.1% | 84.4% | 82.0% | + | Dutch-LassySmall | Gold tok | - | - | 97.7% | - | 97.4% | - | 98.2% | 87.5% | 85.0% | + | Dutch-LassySmall | Gold tok+morph | - | - | - | - | - | - | - | 89.7% | 87.4% | + | English | Raw text | 99.0% | 76.6% | 93.5% | 92.9% | 94.4% | 91.5% | 96.0% | 80.2% | 77.2% | + | English | Gold tok | - | - | 94.5% | 93.9% | 95.4% | 92.5% | 96.9% | 84.3% | 81.2% | + | English | Gold tok+morph | - | - | - | - | - | - | - | 87.8% | 86.0% | + | English-LinES | Raw text | 99.9% | 86.2% | 95.0% | 92.7% | - | - | - | 78.6% | 74.4% | + | English-LinES | Gold tok | - | - | 95.1% | 92.8% | - | - | - | 79.5% | 75.3% | + | English-LinES | Gold tok+morph | - | - | - | - | - | - | - | 84.1% | 81.1% | + | English-ParTUT | Raw text | 99.6% | 97.5% | 94.2% | 94.0% | 93.3% | 92.0% | 96.9% | 81.6% | 77.9% | + | English-ParTUT | Gold tok | - | - | 94.6% | 94.4% | 93.6% | 92.3% | 97.3% | 82.1% | 78.4% | + | English-ParTUT | Gold tok+morph | - | - | - | - | - | - | - | 86.4% | 84.5% | + | Estonian | Raw text | 99.9% | 94.2% | 91.2% | 93.2% | 85.0% | 83.2% | 84.5% | 72.4% | 65.6% | + | Estonian | Gold tok | - | - | 91.3% | 93.2% | 85.0% | 83.3% | 84.5% | 72.8% | 66.0% | + | Estonian | Gold tok+morph | - | - | - | - | - | - | - | 83.1% | 79.6% | + | Finnish | Raw text | 99.7% | 86.7% | 94.5% | 95.7% | 91.5% | 90.3% | 86.5% | 80.5% | 76.9% | + | Finnish | Gold tok | - | - | 94.9% | 96.0% | 91.8% | 90.7% | 86.8% | 82.0% | 78.4% | + | Finnish | Gold tok+morph | - | - | - | - | - | - | - | 86.9% | 84.7% | + | Finnish-FTB | Raw text | 100.0% | 86.4% | 92.0% | 91.0% | 92.5% | 89.2% | 88.9% | 80.1% | 75.7% | + | Finnish-FTB | Gold tok | - | - | 92.2% | 91.3% | 92.7% | 89.5% | 88.9% | 81.7% | 77.3% | + | Finnish-FTB | Gold tok+morph | - | - | - | - | - | - | - | 88.8% | 86.5% | + | French | Raw text | 98.9% | 94.6% | 95.4% | - | 95.5% | - | 96.6% | 84.2% | 80.7% | + | French | Gold tok | - | - | 96.5% | - | 96.5% | - | 97.6% | 85.4% | 82.0% | + | French | Gold tok+morph | - | - | - | - | - | - | - | 88.4% | 86.0% | + | French-ParTUT | Raw text | 99.0% | 97.8% | 94.5% | 94.2% | 91.9% | 90.8% | 94.3% | 82.9% | 78.7% | + | French-ParTUT | Gold tok | - | - | 95.6% | 95.3% | 92.7% | 91.6% | 95.2% | 84.1% | 80.2% | + | French-ParTUT | Gold tok+morph | - | - | - | - | - | - | - | 88.1% | 85.3% | + | French-Sequoia | Raw text | 99.1% | 84.0% | 95.9% | - | 95.1% | - | 96.8% | 83.2% | 80.6% | + | French-Sequoia | Gold tok | - | - | 96.8% | - | 96.0% | - | 97.7% | 85.1% | 82.7% | + | French-Sequoia | Gold tok+morph | - | - | - | - | - | - | - | 88.7% | 87.4% | + | Galician | Raw text | 99.9% | 95.8% | 97.2% | 96.7% | 99.7% | 96.4% | 97.1% | 81.0% | 77.8% | + | Galician | Gold tok | - | - | 97.2% | 96.8% | 99.8% | 96.4% | 97.1% | 81.2% | 77.9% | + | Galician | Gold tok+morph | - | - | - | - | - | - | - | 83.1% | 80.5% | + | Galician-TreeGal | Raw text | 98.7% | 86.7% | 91.1% | 87.8% | 89.9% | 87.0% | 92.6% | 71.5% | 66.3% | + | Galician-TreeGal | Gold tok | - | - | 92.4% | 88.8% | 91.0% | 88.0% | 93.7% | 74.4% | 68.7% | + | Galician-TreeGal | Gold tok+morph | - | - | - | - | - | - | - | 81.5% | 77.1% | + | German | Raw text | 99.7% | 79.3% | 90.7% | 94.7% | 80.5% | 76.3% | 95.4% | 74.0% | 68.6% | + | German | Gold tok | - | - | 91.2% | 95.0% | 80.9% | 76.7% | 95.6% | 76.5% | 70.7% | + | German | Gold tok+morph | - | - | - | - | - | - | - | 84.7% | 82.2% | + | Gothic | Raw text | 100.0% | 29.5% | 94.2% | 94.8% | 87.6% | 85.6% | 92.9% | 69.7% | 63.5% | + | Gothic | Gold tok | - | - | 94.8% | 95.3% | 88.0% | 86.5% | 92.9% | 78.8% | 72.6% | + | Gothic | Gold tok+morph | - | - | - | - | - | - | - | 82.2% | 78.3% | + | Greek | Raw text | 99.9% | 88.2% | 95.8% | 95.8% | 90.3% | 89.1% | 94.5% | 84.2% | 80.4% | + | Greek | Gold tok | - | - | 96.0% | 96.0% | 90.5% | 89.3% | 94.6% | 85.0% | 81.1% | + | Greek | Gold tok+morph | - | - | - | - | - | - | - | 87.9% | 85.9% | + | Hebrew | Raw text | 85.2% | 100.0% | 80.9% | 80.9% | 77.6% | 76.8% | 79.6% | 62.2% | 57.9% | + | Hebrew | Gold tok | - | - | 95.1% | 95.1% | 91.3% | 90.5% | 93.2% | 84.5% | 78.9% | + | Hebrew | Gold tok+morph | - | - | - | - | - | - | - | 87.8% | 84.3% | + | Hindi | Raw text | 100.0% | 99.1% | 95.8% | 94.9% | 90.3% | 87.7% | 98.0% | 91.3% | 87.3% | + | Hindi | Gold tok | - | - | 95.8% | 94.9% | 90.3% | 87.7% | 98.0% | 91.4% | 87.3% | + | Hindi | Gold tok+morph | - | - | - | - | - | - | - | 93.9% | 91.0% | + | Hungarian | Raw text | 99.8% | 96.2% | 91.6% | - | 70.5% | - | 89.3% | 74.1% | 68.1% | + | Hungarian | Gold tok | - | - | 91.8% | - | 70.6% | - | 89.5% | 74.5% | 68.5% | + | Hungarian | Gold tok+morph | - | - | - | - | - | - | - | 81.2% | 78.5% | + | Indonesian | Raw text | 100.0% | 92.0% | 93.5% | - | 99.5% | - | - | 80.6% | 74.3% | + | Indonesian | Gold tok | - | - | 93.5% | - | 99.6% | - | - | 80.8% | 74.5% | + | Indonesian | Gold tok+morph | - | - | - | - | - | - | - | 83.1% | 79.1% | + | Irish | Raw text | 99.4% | 94.3% | 88.0% | 86.9% | 75.1% | 72.7% | 85.5% | 72.5% | 62.4% | + | Irish | Gold tok | - | - | 88.5% | 87.4% | 75.5% | 73.1% | 86.0% | 73.3% | 63.1% | + | Irish | Gold tok+morph | - | - | - | - | - | - | - | 78.1% | 71.4% | + | Italian | Raw text | 99.8% | 97.1% | 97.2% | 97.0% | 97.0% | 96.1% | 97.3% | 88.8% | 86.1% | + | Italian | Gold tok | - | - | 97.4% | 97.2% | 97.2% | 96.3% | 97.5% | 89.3% | 86.6% | + | Italian | Gold tok+morph | - | - | - | - | - | - | - | 91.3% | 89.7% | + | Japanese | Raw text | 91.9% | 95.1% | 89.1% | - | 91.8% | - | 91.1% | 78.0% | 76.6% | + | Japanese | Gold tok | - | - | 96.6% | - | 100.0% | - | 99.0% | 93.4% | 91.5% | + | Japanese | Gold tok+morph | - | - | - | - | - | - | - | 95.6% | 95.0% | + | Kazakh | Raw text | 94.0% | 84.9% | 52.0% | 52.1% | 47.2% | 40.0% | 59.2% | 40.2% | 23.9% | + | Kazakh | Gold tok | - | - | 55.4% | 55.4% | 50.1% | 42.2% | 63.1% | 45.2% | 27.0% | + | Kazakh | Gold tok+morph | - | - | - | - | - | - | - | 60.5% | 42.5% | + | Korean | Raw text | 99.7% | 92.7% | 94.4% | 89.7% | 99.3% | 89.7% | 99.4% | 67.4% | 60.5% | + | Korean | Gold tok | - | - | 94.7% | 90.0% | 99.6% | 90.0% | 99.7% | 68.4% | 61.5% | + | Korean | Gold tok+morph | - | - | - | - | - | - | - | 71.7% | 65.8% | + | Latin | Raw text | 100.0% | 98.0% | 83.4% | 67.6% | 72.5% | 67.6% | 51.2% | 56.5% | 46.0% | + | Latin | Gold tok | - | - | 83.4% | 67.6% | 72.5% | 67.6% | 51.2% | 56.6% | 46.1% | + | Latin | Gold tok+morph | - | - | - | - | - | - | - | 67.8% | 61.5% | + | Latin-ITTB | Raw text | 99.9% | 82.5% | 97.2% | 92.7% | 93.5% | 91.3% | 97.8% | 79.7% | 76.0% | + | Latin-ITTB | Gold tok | - | - | 97.3% | 92.8% | 93.6% | 91.4% | 97.9% | 81.8% | 78.1% | + | Latin-ITTB | Gold tok+morph | - | - | - | - | - | - | - | 87.6% | 85.2% | + | Latin-PROIEL | Raw text | 99.9% | 31.0% | 94.9% | 95.0% | 87.7% | 86.7% | 94.8% | 66.1% | 60.7% | + | Latin-PROIEL | Gold tok | - | - | 95.2% | 95.2% | 88.4% | 87.4% | 95.0% | 75.3% | 69.4% | + | Latin-PROIEL | Gold tok+morph | - | - | - | - | - | - | - | 79.0% | 75.0% | + | Latvian | Raw text | 99.2% | 97.1% | 89.6% | 76.2% | 83.2% | 75.7% | 87.6% | 69.2% | 62.8% | + | Latvian | Gold tok | - | - | 90.2% | 76.8% | 84.0% | 76.3% | 88.3% | 70.3% | 63.9% | + | Latvian | Gold tok+morph | - | - | - | - | - | - | - | 78.7% | 74.9% | + | Lithuanian | Raw text | 98.2% | 92.0% | 74.0% | 73.0% | 68.9% | 63.7% | 73.5% | 44.0% | 32.4% | + | Lithuanian | Gold tok | - | - | 74.6% | 73.5% | 69.7% | 64.2% | 74.2% | 44.6% | 33.0% | + | Lithuanian | Gold tok+morph | - | - | - | - | - | - | - | 55.6% | 46.5% | + | Norwegian-Bokmaal | Raw text | 99.8% | 96.5% | 96.9% | - | 95.3% | - | 96.6% | 86.9% | 84.1% | + | Norwegian-Bokmaal | Gold tok | - | - | 97.1% | - | 95.5% | - | 96.8% | 87.5% | 84.7% | + | Norwegian-Bokmaal | Gold tok+morph | - | - | - | - | - | - | - | 91.7% | 89.6% | + | Norwegian-Nynorsk | Raw text | 99.9% | 92.2% | 96.5% | - | 94.9% | - | 96.4% | 85.6% | 82.5% | + | Norwegian-Nynorsk | Gold tok | - | - | 96.6% | - | 95.0% | - | 96.5% | 86.5% | 83.3% | + | Norwegian-Nynorsk | Gold tok+morph | - | - | - | - | - | - | - | 91.0% | 88.6% | + | Old Church Slavonic | Raw text | 100.0% | 40.5% | 93.8% | 93.8% | 86.9% | 85.7% | 91.2% | 73.6% | 66.9% | + | Old Church Slavonic | Gold tok | - | - | 94.1% | 94.1% | 87.6% | 86.5% | 91.2% | 81.6% | 74.7% | + | Old Church Slavonic | Gold tok+morph | - | - | - | - | - | - | - | 86.7% | 82.2% | + | Persian | Raw text | 99.7% | 98.2% | 96.0% | 96.0% | 96.1% | 95.4% | 93.5% | 83.3% | 79.4% | + | Persian | Gold tok | - | - | 96.4% | 96.3% | 96.4% | 95.7% | 93.8% | 83.8% | 80.0% | + | Persian | Gold tok+morph | - | - | - | - | - | - | - | 87.7% | 84.9% | + | Polish | Raw text | 99.9% | 99.7% | 95.6% | 84.0% | 84.1% | 83.1% | 93.4% | 86.7% | 80.7% | + | Polish | Gold tok | - | - | 95.7% | 84.1% | 84.2% | 83.3% | 93.6% | 87.0% | 81.0% | + | Polish | Gold tok+morph | - | - | - | - | - | - | - | 92.9% | 89.5% | + | Portuguese | Raw text | 99.6% | 89.4% | 96.4% | 72.7% | 93.3% | 71.6% | 96.8% | 86.0% | 82.6% | + | Portuguese | Gold tok | - | - | 96.8% | 73.0% | 93.7% | 71.9% | 97.2% | 87.2% | 83.6% | + | Portuguese | Gold tok+morph | - | - | - | - | - | - | - | 89.6% | 87.5% | + | Portuguese-BR | Raw text | 99.9% | 96.8% | 97.0% | 97.0% | 99.7% | 97.0% | 98.8% | 88.5% | 86.3% | + | Portuguese-BR | Gold tok | - | - | 97.2% | 97.2% | 99.9% | 97.2% | 98.9% | 88.8% | 86.6% | + | Portuguese-BR | Gold tok+morph | - | - | - | - | - | - | - | 90.5% | 89.1% | + | Romanian | Raw text | 99.7% | 93.9% | 96.6% | 95.9% | 96.0% | 95.7% | 96.5% | 85.6% | 80.2% | + | Romanian | Gold tok | - | - | 96.9% | 96.2% | 96.3% | 96.0% | 96.8% | 86.2% | 80.8% | + | Romanian | Gold tok+morph | - | - | - | - | - | - | - | 87.8% | 83.0% | + | Russian | Raw text | 99.9% | 96.9% | 94.7% | 94.4% | 84.4% | 82.8% | 75.0% | 80.3% | 75.5% | + | Russian | Gold tok | - | - | 94.8% | 94.5% | 84.5% | 82.9% | 75.1% | 80.8% | 76.0% | + | Russian | Gold tok+morph | - | - | - | - | - | - | - | 84.8% | 81.9% | + | Russian-SynTagRus | Raw text | 99.6% | 98.0% | 98.0% | - | 93.6% | - | 95.6% | 89.8% | 87.2% | + | Russian-SynTagRus | Gold tok | - | - | 98.4% | - | 93.9% | - | 95.9% | 90.4% | 87.9% | + | Russian-SynTagRus | Gold tok+morph | - | - | - | - | - | - | - | 91.8% | 90.5% | + | Sanskrit | Raw text | 88.1% | 29.0% | 52.0% | - | 35.2% | - | 50.2% | 38.8% | 22.5% | + | Sanskrit | Gold tok | - | - | 57.6% | - | 43.6% | - | 60.6% | 58.5% | 34.3% | + | Sanskrit | Gold tok+morph | - | - | - | - | - | - | - | 72.9% | 58.5% | + | Slovak | Raw text | 100.0% | 83.5% | 93.2% | 77.5% | 79.7% | 77.1% | 85.9% | 80.4% | 75.2% | + | Slovak | Gold tok | - | - | 93.3% | 77.6% | 79.9% | 77.2% | 86.0% | 82.0% | 76.9% | + | Slovak | Gold tok+morph | - | - | - | - | - | - | - | 88.2% | 85.5% | + | Slovenian | Raw text | 99.9% | 98.9% | 96.2% | 88.2% | 88.5% | 87.7% | 95.3% | 84.9% | 81.6% | + | Slovenian | Gold tok | - | - | 96.2% | 88.2% | 88.6% | 87.7% | 95.4% | 85.0% | 81.7% | + | Slovenian | Gold tok+morph | - | - | - | - | - | - | - | 91.8% | 90.5% | + | Slovenian-SST | Raw text | 99.9% | 17.8% | 89.0% | 81.1% | 81.3% | 78.6% | 91.6% | 53.0% | 46.6% | + | Slovenian-SST | Gold tok | - | - | 89.4% | 81.6% | 81.8% | 79.3% | 91.7% | 63.4% | 56.0% | + | Slovenian-SST | Gold tok+morph | - | - | - | - | - | - | - | 75.5% | 70.6% | + | Spanish | Raw text | 99.7% | 95.3% | 95.5% | - | 96.1% | - | 95.9% | 84.9% | 81.4% | + | Spanish | Gold tok | - | - | 95.8% | - | 96.3% | - | 96.1% | 85.5% | 81.9% | + | Spanish | Gold tok+morph | - | - | - | - | - | - | - | 88.0% | 85.3% | + | Spanish-AnCora | Raw text | 99.9% | 98.0% | 98.1% | 98.1% | 97.5% | 96.8% | 98.1% | 87.7% | 84.5% | + | Spanish-AnCora | Gold tok | - | - | 98.2% | 98.2% | 97.5% | 96.9% | 98.1% | 87.8% | 84.7% | + | Spanish-AnCora | Gold tok+morph | - | - | - | - | - | - | - | 90.2% | 87.6% | + | Swedish | Raw text | 99.8% | 94.6% | 95.6% | 93.9% | 94.4% | 92.8% | 95.5% | 81.4% | 77.8% | + | Swedish | Gold tok | - | - | 95.8% | 94.1% | 94.6% | 93.1% | 95.7% | 82.1% | 78.4% | + | Swedish | Gold tok+morph | - | - | - | - | - | - | - | 88.0% | 85.0% | + | Swedish-LinES | Raw text | 100.0% | 85.7% | 94.8% | 92.2% | - | - | - | 80.4% | 75.7% | + | Swedish-LinES | Gold tok | - | - | 94.8% | 92.3% | - | - | - | 81.3% | 76.6% | + | Swedish-LinES | Gold tok+morph | - | - | - | - | - | - | - | 86.0% | 82.6% | + | Tamil | Raw text | 95.3% | 89.2% | 82.2% | 77.7% | 80.9% | 77.2% | 85.3% | 59.5% | 52.0% | + | Tamil | Gold tok | - | - | 85.8% | 81.0% | 84.2% | 80.3% | 89.1% | 64.9% | 56.5% | + | Tamil | Gold tok+morph | - | - | - | - | - | - | - | 78.9% | 71.8% | + | Turkish | Raw text | 98.1% | 96.8% | 92.4% | 91.5% | 87.3% | 85.5% | 90.2% | 62.9% | 55.8% | + | Turkish | Gold tok | - | - | 94.0% | 93.0% | 88.9% | 87.0% | 91.7% | 65.5% | 58.0% | + | Turkish | Gold tok+morph | - | - | - | - | - | - | - | 66.8% | 61.1% | + | Ukrainian | Raw text | 99.8% | 95.1% | 88.5% | 70.7% | 70.9% | 67.6% | 86.7% | 69.9% | 61.5% | + | Ukrainian | Gold tok | - | - | 88.6% | 70.8% | 71.0% | 67.7% | 86.9% | 70.2% | 61.8% | + | Ukrainian | Gold tok+morph | - | - | - | - | - | - | - | 79.0% | 74.5% | + | Urdu | Raw text | 100.0% | 98.3% | 92.4% | 90.5% | 80.6% | 76.3% | 93.0% | 84.6% | 77.6% | + | Urdu | Gold tok | - | - | 92.4% | 90.5% | 80.7% | 76.3% | 93.0% | 84.7% | 77.7% | + | Urdu | Gold tok+morph | - | - | - | - | - | - | - | 88.2% | 83.0% | + | Uyghur | Raw text | 99.8% | 67.2% | 74.7% | 79.1% | - | - | - | 55.1% | 35.0% | + | Uyghur | Gold tok | - | - | 75.1% | 79.3% | - | - | - | 56.5% | 35.8% | + | Uyghur | Gold tok+morph | - | - | - | - | - | - | - | 62.3% | 42.0% | + | Vietnamese | Raw text | 85.3% | 92.9% | 77.4% | 75.4% | 85.1% | 75.4% | 84.5% | 46.9% | 42.5% | + | Vietnamese | Gold tok | - | - | 89.3% | 86.8% | 99.6% | 86.8% | 99.0% | 64.4% | 57.2% | + | Vietnamese | Gold tok+morph | - | - | - | - | - | - | - | 70.7% | 67.9% | diff --git a/UDPipe/v1/XDependencies/UDPipe/Models/README.html b/UDPipe/v1/XDependencies/UDPipe/Models/README.html new file mode 100644 index 0000000000000000000000000000000000000000..60f5695be1c4672fc11e80688f9b1a607f2e08e8 --- /dev/null +++ b/UDPipe/v1/XDependencies/UDPipe/Models/README.html @@ -0,0 +1,2814 @@ + + + + + +Universal Dependencies 2.0 Models for UDPipe + + + + + +
+ +
    +
  1. Universal Dependencies 2.0 Models + +
    2. +
+ +
+
+

+To use this model, you need UDPipe, an open-source tool for tokenization, +tagging, lemmatization and parsing of CoNLL-U files. Please visit the UDPipe +website http://ufal.mff.cuni.cz/udpipe for more information. +

+ + +

1. Universal Dependencies 2.0 Models

+ +

+Universal Dependencies 2.0 Models are distributed under the +CC BY-NC-SA licence. +The models are based solely on +Universal Dependencies 2.0 treebanks. +The models work in UDPipe version 1.2 and later. +

+

+Universal Dependencies 2.0 Models are versioned according to the date released +in the format YYMMDD, where YY, MM and DD are two-digit +representation of year, month and day, respectively. The latest version is 170801. +

+ + +

1.1. Download

+ +

+The latest version 170801 of the Universal Dependencies 2.0 models can be downloaded +from LINDAT/CLARIN repository. +

+ + +

1.2. Acknowledgements

+ +

+This work has been partially supported and has been using language resources +and tools developed, stored and distributed by the LINDAT/CLARIN project of the +Ministry of Education, Youth and Sports of the Czech Republic (project LM2015071). +The wark was also partially supported by OP VVV projects +CZ.02.1.01/0.0/0.0/16\_013/0001781 and CZ.02.2.69/0.0/0.0/16\_018/0002373, and +by SVV project number 260 453. +

+

+The models were trained on Universal Dependencies 2.0 treebanks. +

+

+For the UD treebanks which do not contain original plain text version, +raw text is used to train the tokenizer instead. The plain texts +were taken from the W2C – Web to Corpus. +

+ + +

1.2.1. Publications

+ + + + +

1.3. Model Description

+ +

+The Universal Dependencies 2.0 models contain 68 models of 50 languages, each consisting of +a tokenizer, tagger, lemmatizer and dependency parser, all trained using +the UD data. Note that we use custom train-dev split, by moving sentences from the beginning +of dev data to the end of train data, until the training data is at least 9 times the dev data. +

+

+The tokenizer is trained using the SpaceAfter=No features. If the features +are not present in the data, they can be filled in using raw text in the +language in question. +

+

+The tagger, lemmatizer and parser are trained using gold UD data. +

+

+Details about model architecture and training process can be found in the +(Straka et al. 2017) paper. +

+ + +

1.3.1. Reproducible Training

+ +

+In case you want to train the same models, scripts for downloading and +resplitting UD 2.0 data, precomputed word embedding, raw texts for tokenizers, +all hyperparameter values and training scripts are available in the +second archive on the model download page. +

+ + +

1.4. Model Performance

+ +

+We present the tagger, lemmatizer and parser performance, measured +on the testing portion of the data, evaluated in three different settings: +using raw text only, using gold tokenization only, and using gold tokenization +plus gold morphology (UPOS, XPOS, FEATS and Lemma). +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
TreebankModeWordsSentsUPOSXPOSFeatsAllTagsLemmaUASLAS
Ancient GreekRaw text100.0%98.7%82.4%72.3%85.8%72.3%82.6%64.4%57.8%
Ancient GreekGold tok--82.4%72.4%85.8%72.3%82.7%64.6%57.9%
Ancient GreekGold tok+morph-------69.2%64.4%
Ancient Greek-PROIELRaw text100.0%47.2%95.8%96.0%88.6%87.2%92.6%71.8%67.1%
Ancient Greek-PROIELGold tok--95.8%96.1%88.7%87.2%92.8%77.2%72.3%
Ancient Greek-PROIELGold tok+morph-------79.7%76.1%
ArabicRaw text93.8%83.1%88.4%83.4%83.5%82.3%87.5%71.7%65.8%
ArabicGold tok--94.4%89.5%89.6%88.3%92.6%81.3%74.3%
ArabicGold tok+morph-------82.9%77.9%
BasqueRaw text100.0%99.5%93.2%-87.6%-93.8%75.8%70.7%
BasqueGold tok--93.3%-87.7%-93.9%75.9%70.8%
BasqueGold tok+morph-------82.3%78.4%
BelarusianRaw text99.4%76.8%88.2%85.6%71.7%68.6%81.3%68.0%60.6%
BelarusianGold tok--88.7%85.7%72.4%69.2%81.5%69.4%61.9%
BelarusianGold tok+morph-------76.8%74.0%
BulgarianRaw text99.9%93.9%97.6%94.6%95.6%94.0%94.6%88.8%84.8%
BulgarianGold tok--97.7%94.7%95.6%94.1%94.7%89.5%85.5%
BulgarianGold tok+morph-------92.6%89.1%
CatalanRaw text100.0%99.2%98.0%98.0%97.1%96.5%97.9%88.8%85.7%
CatalanGold tok--98.0%98.0%97.2%96.5%97.9%88.8%85.8%
CatalanGold tok+morph-------91.1%88.7%
ChineseRaw text90.2%98.8%84.0%83.8%89.0%82.7%90.2%62.9%58.7%
ChineseGold tok--92.2%92.0%98.7%90.8%100.0%75.6%70.1%
ChineseGold tok+morph-------84.1%81.4%
CopticRaw text65.8%35.7%62.6%62.1%65.7%62.1%64.6%41.1%39.3%
CopticGold tok--95.1%94.3%99.7%94.2%96.2%83.2%79.2%
CopticGold tok+morph-------88.1%84.9%
CroatianRaw text99.9%97.0%95.9%-84.3%-94.4%83.6%77.9%
CroatianGold tok--96.0%-84.4%-94.4%83.9%78.1%
CroatianGold tok+morph-------87.1%83.2%
CzechRaw text99.9%91.6%98.3%92.8%92.1%91.7%97.8%86.8%83.2%
CzechGold tok--98.4%92.9%92.2%91.9%97.9%87.7%84.1%
CzechGold tok+morph-------90.2%87.5%
Czech-CACRaw text100.0%99.8%98.1%90.6%89.4%89.1%97.0%86.9%82.7%
Czech-CACGold tok--98.1%90.7%89.5%89.1%97.1%87.0%82.8%
Czech-CACGold tok+morph-------89.7%86.6%
Czech-CLTTRaw text99.5%92.3%96.5%87.5%87.8%87.3%96.8%80.2%76.6%
Czech-CLTTGold tok--97.0%87.9%88.3%87.7%97.2%81.0%77.6%
Czech-CLTTGold tok+morph-------83.8%80.8%
DanishRaw text99.8%77.9%95.2%-94.2%-94.9%78.4%74.7%
DanishGold tok--95.5%-94.5%-95.0%80.4%76.6%
DanishGold tok+morph-------85.6%82.7%
DutchRaw text99.8%77.6%91.4%88.1%89.3%87.0%89.9%75.4%69.6%
DutchGold tok--91.8%88.8%89.9%87.7%90.1%77.0%71.2%
DutchGold tok+morph-------82.9%79.4%
Dutch-LassySmallRaw text100.0%80.4%97.6%-97.2%-98.1%84.4%82.0%
Dutch-LassySmallGold tok--97.7%-97.4%-98.2%87.5%85.0%
Dutch-LassySmallGold tok+morph-------89.7%87.4%
EnglishRaw text99.0%76.6%93.5%92.9%94.4%91.5%96.0%80.2%77.2%
EnglishGold tok--94.5%93.9%95.4%92.5%96.9%84.3%81.2%
EnglishGold tok+morph-------87.8%86.0%
English-LinESRaw text99.9%86.2%95.0%92.7%---78.6%74.4%
English-LinESGold tok--95.1%92.8%---79.5%75.3%
English-LinESGold tok+morph-------84.1%81.1%
English-ParTUTRaw text99.6%97.5%94.2%94.0%93.3%92.0%96.9%81.6%77.9%
English-ParTUTGold tok--94.6%94.4%93.6%92.3%97.3%82.1%78.4%
English-ParTUTGold tok+morph-------86.4%84.5%
EstonianRaw text99.9%94.2%91.2%93.2%85.0%83.2%84.5%72.4%65.6%
EstonianGold tok--91.3%93.2%85.0%83.3%84.5%72.8%66.0%
EstonianGold tok+morph-------83.1%79.6%
FinnishRaw text99.7%86.7%94.5%95.7%91.5%90.3%86.5%80.5%76.9%
FinnishGold tok--94.9%96.0%91.8%90.7%86.8%82.0%78.4%
FinnishGold tok+morph-------86.9%84.7%
Finnish-FTBRaw text100.0%86.4%92.0%91.0%92.5%89.2%88.9%80.1%75.7%
Finnish-FTBGold tok--92.2%91.3%92.7%89.5%88.9%81.7%77.3%
Finnish-FTBGold tok+morph-------88.8%86.5%
FrenchRaw text98.9%94.6%95.4%-95.5%-96.6%84.2%80.7%
FrenchGold tok--96.5%-96.5%-97.6%85.4%82.0%
FrenchGold tok+morph-------88.4%86.0%
French-ParTUTRaw text99.0%97.8%94.5%94.2%91.9%90.8%94.3%82.9%78.7%
French-ParTUTGold tok--95.6%95.3%92.7%91.6%95.2%84.1%80.2%
French-ParTUTGold tok+morph-------88.1%85.3%
French-SequoiaRaw text99.1%84.0%95.9%-95.1%-96.8%83.2%80.6%
French-SequoiaGold tok--96.8%-96.0%-97.7%85.1%82.7%
French-SequoiaGold tok+morph-------88.7%87.4%
GalicianRaw text99.9%95.8%97.2%96.7%99.7%96.4%97.1%81.0%77.8%
GalicianGold tok--97.2%96.8%99.8%96.4%97.1%81.2%77.9%
GalicianGold tok+morph-------83.1%80.5%
Galician-TreeGalRaw text98.7%86.7%91.1%87.8%89.9%87.0%92.6%71.5%66.3%
Galician-TreeGalGold tok--92.4%88.8%91.0%88.0%93.7%74.4%68.7%
Galician-TreeGalGold tok+morph-------81.5%77.1%
GermanRaw text99.7%79.3%90.7%94.7%80.5%76.3%95.4%74.0%68.6%
GermanGold tok--91.2%95.0%80.9%76.7%95.6%76.5%70.7%
GermanGold tok+morph-------84.7%82.2%
GothicRaw text100.0%29.5%94.2%94.8%87.6%85.6%92.9%69.7%63.5%
GothicGold tok--94.8%95.3%88.0%86.5%92.9%78.8%72.6%
GothicGold tok+morph-------82.2%78.3%
GreekRaw text99.9%88.2%95.8%95.8%90.3%89.1%94.5%84.2%80.4%
GreekGold tok--96.0%96.0%90.5%89.3%94.6%85.0%81.1%
GreekGold tok+morph-------87.9%85.9%
HebrewRaw text85.2%100.0%80.9%80.9%77.6%76.8%79.6%62.2%57.9%
HebrewGold tok--95.1%95.1%91.3%90.5%93.2%84.5%78.9%
HebrewGold tok+morph-------87.8%84.3%
HindiRaw text100.0%99.1%95.8%94.9%90.3%87.7%98.0%91.3%87.3%
HindiGold tok--95.8%94.9%90.3%87.7%98.0%91.4%87.3%
HindiGold tok+morph-------93.9%91.0%
HungarianRaw text99.8%96.2%91.6%-70.5%-89.3%74.1%68.1%
HungarianGold tok--91.8%-70.6%-89.5%74.5%68.5%
HungarianGold tok+morph-------81.2%78.5%
IndonesianRaw text100.0%92.0%93.5%-99.5%--80.6%74.3%
IndonesianGold tok--93.5%-99.6%--80.8%74.5%
IndonesianGold tok+morph-------83.1%79.1%
IrishRaw text99.4%94.3%88.0%86.9%75.1%72.7%85.5%72.5%62.4%
IrishGold tok--88.5%87.4%75.5%73.1%86.0%73.3%63.1%
IrishGold tok+morph-------78.1%71.4%
ItalianRaw text99.8%97.1%97.2%97.0%97.0%96.1%97.3%88.8%86.1%
ItalianGold tok--97.4%97.2%97.2%96.3%97.5%89.3%86.6%
ItalianGold tok+morph-------91.3%89.7%
JapaneseRaw text91.9%95.1%89.1%-91.8%-91.1%78.0%76.6%
JapaneseGold tok--96.6%-100.0%-99.0%93.4%91.5%
JapaneseGold tok+morph-------95.6%95.0%
KazakhRaw text94.0%84.9%52.0%52.1%47.2%40.0%59.2%40.2%23.9%
KazakhGold tok--55.4%55.4%50.1%42.2%63.1%45.2%27.0%
KazakhGold tok+morph-------60.5%42.5%
KoreanRaw text99.7%92.7%94.4%89.7%99.3%89.7%99.4%67.4%60.5%
KoreanGold tok--94.7%90.0%99.6%90.0%99.7%68.4%61.5%
KoreanGold tok+morph-------71.7%65.8%
LatinRaw text100.0%98.0%83.4%67.6%72.5%67.6%51.2%56.5%46.0%
LatinGold tok--83.4%67.6%72.5%67.6%51.2%56.6%46.1%
LatinGold tok+morph-------67.8%61.5%
Latin-ITTBRaw text99.9%82.5%97.2%92.7%93.5%91.3%97.8%79.7%76.0%
Latin-ITTBGold tok--97.3%92.8%93.6%91.4%97.9%81.8%78.1%
Latin-ITTBGold tok+morph-------87.6%85.2%
Latin-PROIELRaw text99.9%31.0%94.9%95.0%87.7%86.7%94.8%66.1%60.7%
Latin-PROIELGold tok--95.2%95.2%88.4%87.4%95.0%75.3%69.4%
Latin-PROIELGold tok+morph-------79.0%75.0%
LatvianRaw text99.2%97.1%89.6%76.2%83.2%75.7%87.6%69.2%62.8%
LatvianGold tok--90.2%76.8%84.0%76.3%88.3%70.3%63.9%
LatvianGold tok+morph-------78.7%74.9%
LithuanianRaw text98.2%92.0%74.0%73.0%68.9%63.7%73.5%44.0%32.4%
LithuanianGold tok--74.6%73.5%69.7%64.2%74.2%44.6%33.0%
LithuanianGold tok+morph-------55.6%46.5%
Norwegian-BokmaalRaw text99.8%96.5%96.9%-95.3%-96.6%86.9%84.1%
Norwegian-BokmaalGold tok--97.1%-95.5%-96.8%87.5%84.7%
Norwegian-BokmaalGold tok+morph-------91.7%89.6%
Norwegian-NynorskRaw text99.9%92.2%96.5%-94.9%-96.4%85.6%82.5%
Norwegian-NynorskGold tok--96.6%-95.0%-96.5%86.5%83.3%
Norwegian-NynorskGold tok+morph-------91.0%88.6%
Old Church SlavonicRaw text100.0%40.5%93.8%93.8%86.9%85.7%91.2%73.6%66.9%
Old Church SlavonicGold tok--94.1%94.1%87.6%86.5%91.2%81.6%74.7%
Old Church SlavonicGold tok+morph-------86.7%82.2%
PersianRaw text99.7%98.2%96.0%96.0%96.1%95.4%93.5%83.3%79.4%
PersianGold tok--96.4%96.3%96.4%95.7%93.8%83.8%80.0%
PersianGold tok+morph-------87.7%84.9%
PolishRaw text99.9%99.7%95.6%84.0%84.1%83.1%93.4%86.7%80.7%
PolishGold tok--95.7%84.1%84.2%83.3%93.6%87.0%81.0%
PolishGold tok+morph-------92.9%89.5%
PortugueseRaw text99.6%89.4%96.4%72.7%93.3%71.6%96.8%86.0%82.6%
PortugueseGold tok--96.8%73.0%93.7%71.9%97.2%87.2%83.6%
PortugueseGold tok+morph-------89.6%87.5%
Portuguese-BRRaw text99.9%96.8%97.0%97.0%99.7%97.0%98.8%88.5%86.3%
Portuguese-BRGold tok--97.2%97.2%99.9%97.2%98.9%88.8%86.6%
Portuguese-BRGold tok+morph-------90.5%89.1%
RomanianRaw text99.7%93.9%96.6%95.9%96.0%95.7%96.5%85.6%80.2%
RomanianGold tok--96.9%96.2%96.3%96.0%96.8%86.2%80.8%
RomanianGold tok+morph-------87.8%83.0%
RussianRaw text99.9%96.9%94.7%94.4%84.4%82.8%75.0%80.3%75.5%
RussianGold tok--94.8%94.5%84.5%82.9%75.1%80.8%76.0%
RussianGold tok+morph-------84.8%81.9%
Russian-SynTagRusRaw text99.6%98.0%98.0%-93.6%-95.6%89.8%87.2%
Russian-SynTagRusGold tok--98.4%-93.9%-95.9%90.4%87.9%
Russian-SynTagRusGold tok+morph-------91.8%90.5%
SanskritRaw text88.1%29.0%52.0%-35.2%-50.2%38.8%22.5%
SanskritGold tok--57.6%-43.6%-60.6%58.5%34.3%
SanskritGold tok+morph-------72.9%58.5%
SlovakRaw text100.0%83.5%93.2%77.5%79.7%77.1%85.9%80.4%75.2%
SlovakGold tok--93.3%77.6%79.9%77.2%86.0%82.0%76.9%
SlovakGold tok+morph-------88.2%85.5%
SlovenianRaw text99.9%98.9%96.2%88.2%88.5%87.7%95.3%84.9%81.6%
SlovenianGold tok--96.2%88.2%88.6%87.7%95.4%85.0%81.7%
SlovenianGold tok+morph-------91.8%90.5%
Slovenian-SSTRaw text99.9%17.8%89.0%81.1%81.3%78.6%91.6%53.0%46.6%
Slovenian-SSTGold tok--89.4%81.6%81.8%79.3%91.7%63.4%56.0%
Slovenian-SSTGold tok+morph-------75.5%70.6%
SpanishRaw text99.7%95.3%95.5%-96.1%-95.9%84.9%81.4%
SpanishGold tok--95.8%-96.3%-96.1%85.5%81.9%
SpanishGold tok+morph-------88.0%85.3%
Spanish-AnCoraRaw text99.9%98.0%98.1%98.1%97.5%96.8%98.1%87.7%84.5%
Spanish-AnCoraGold tok--98.2%98.2%97.5%96.9%98.1%87.8%84.7%
Spanish-AnCoraGold tok+morph-------90.2%87.6%
SwedishRaw text99.8%94.6%95.6%93.9%94.4%92.8%95.5%81.4%77.8%
SwedishGold tok--95.8%94.1%94.6%93.1%95.7%82.1%78.4%
SwedishGold tok+morph-------88.0%85.0%
Swedish-LinESRaw text100.0%85.7%94.8%92.2%---80.4%75.7%
Swedish-LinESGold tok--94.8%92.3%---81.3%76.6%
Swedish-LinESGold tok+morph-------86.0%82.6%
TamilRaw text95.3%89.2%82.2%77.7%80.9%77.2%85.3%59.5%52.0%
TamilGold tok--85.8%81.0%84.2%80.3%89.1%64.9%56.5%
TamilGold tok+morph-------78.9%71.8%
TurkishRaw text98.1%96.8%92.4%91.5%87.3%85.5%90.2%62.9%55.8%
TurkishGold tok--94.0%93.0%88.9%87.0%91.7%65.5%58.0%
TurkishGold tok+morph-------66.8%61.1%
UkrainianRaw text99.8%95.1%88.5%70.7%70.9%67.6%86.7%69.9%61.5%
UkrainianGold tok--88.6%70.8%71.0%67.7%86.9%70.2%61.8%
UkrainianGold tok+morph-------79.0%74.5%
UrduRaw text100.0%98.3%92.4%90.5%80.6%76.3%93.0%84.6%77.6%
UrduGold tok--92.4%90.5%80.7%76.3%93.0%84.7%77.7%
UrduGold tok+morph-------88.2%83.0%
UyghurRaw text99.8%67.2%74.7%79.1%---55.1%35.0%
UyghurGold tok--75.1%79.3%---56.5%35.8%
UyghurGold tok+morph-------62.3%42.0%
VietnameseRaw text85.3%92.9%77.4%75.4%85.1%75.4%84.5%46.9%42.5%
VietnameseGold tok--89.3%86.8%99.6%86.8%99.0%64.4%57.2%
VietnameseGold tok+morph-------70.7%67.9%
+ +
+ + + diff --git a/UDPipe/v1/XDependencies/UDPipe/Models/Romanian.udpipe b/UDPipe/v1/XDependencies/UDPipe/Models/Romanian.udpipe new file mode 100644 index 0000000000000000000000000000000000000000..cb71418fbfda127048b71304578bd6db6fb364e0 --- /dev/null +++ b/UDPipe/v1/XDependencies/UDPipe/Models/Romanian.udpipe @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:25e9d39cc633b5806332665c5496d633e642da94b2cd89c910963ba30739e656 +size 15262258 diff --git a/UDPipe/v1/XDependencies/UDPipe/Models/Russian-SYNTAGRUS.udpipe b/UDPipe/v1/XDependencies/UDPipe/Models/Russian-SYNTAGRUS.udpipe new file mode 100644 index 0000000000000000000000000000000000000000..c1ba96107ede9c76170e8ec5581f784534e82ce5 --- /dev/null +++ b/UDPipe/v1/XDependencies/UDPipe/Models/Russian-SYNTAGRUS.udpipe @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0e4181faae772a372c8a2ef043e124984367f19bff94b500308ab0a963843469 +size 45014943 diff --git a/UDPipe/v1/XDependencies/UDPipe/Models/Russian.udpipe b/UDPipe/v1/XDependencies/UDPipe/Models/Russian.udpipe new file mode 100644 index 0000000000000000000000000000000000000000..bf99ab9b90ebf748618ca45e280c366534402595 --- /dev/null +++ b/UDPipe/v1/XDependencies/UDPipe/Models/Russian.udpipe @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:148fb1012023f1ed2ed85951651443e4b593ee021a29de431a4640a22a9e2ded +size 13265262 diff --git a/UDPipe/v1/XDependencies/UDPipe/Models/Sanskrit.udpipe b/UDPipe/v1/XDependencies/UDPipe/Models/Sanskrit.udpipe new file mode 100644 index 0000000000000000000000000000000000000000..f88a2d8297ba452baeb82694701bbc1f83bcf571 --- /dev/null +++ b/UDPipe/v1/XDependencies/UDPipe/Models/Sanskrit.udpipe @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:32ffb8f0cb1cf4e940395d539e06b9e6ac8eba8fc528eafd1e7f9f59a1b8492f +size 2107925 diff --git a/UDPipe/v1/XDependencies/UDPipe/Models/Slovak.udpipe b/UDPipe/v1/XDependencies/UDPipe/Models/Slovak.udpipe new file mode 100644 index 0000000000000000000000000000000000000000..01a80db5f8617865798e6da72419fe570fd86320 --- /dev/null +++ b/UDPipe/v1/XDependencies/UDPipe/Models/Slovak.udpipe @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4dd424fc186dba88b24a53cba38c848598bd3f78860c56b212077354020d3bd6 +size 18167489 diff --git a/UDPipe/v1/XDependencies/UDPipe/Models/Slovenian-SST.udpipe b/UDPipe/v1/XDependencies/UDPipe/Models/Slovenian-SST.udpipe new file mode 100644 index 0000000000000000000000000000000000000000..e596120c3ead95bf3c629655442b955f6a4f6414 --- /dev/null +++ b/UDPipe/v1/XDependencies/UDPipe/Models/Slovenian-SST.udpipe @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:58bd2cf6c87b4bb26c20f19de2f64163a39090544be4f92b4e1053affcbe50c6 +size 4973024 diff --git a/UDPipe/v1/XDependencies/UDPipe/Models/Slovenian.udpipe b/UDPipe/v1/XDependencies/UDPipe/Models/Slovenian.udpipe new file mode 100644 index 0000000000000000000000000000000000000000..01497d0bdea4b9cb81c88fd746ef52786acd9a64 --- /dev/null +++ b/UDPipe/v1/XDependencies/UDPipe/Models/Slovenian.udpipe @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6261897d16a833fe66289e8badd86caee914f30d2334eea6bcced2bc769c6236 +size 17325703 diff --git a/UDPipe/v1/XDependencies/UDPipe/Models/Spanish-ANCORA.udpipe b/UDPipe/v1/XDependencies/UDPipe/Models/Spanish-ANCORA.udpipe new file mode 100644 index 0000000000000000000000000000000000000000..b7eda564ecfa3e8a754619621d27d0d4942f8111 --- /dev/null +++ b/UDPipe/v1/XDependencies/UDPipe/Models/Spanish-ANCORA.udpipe @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:cbf8b36290c7dcfe8074c9604ce6532478526d3097bbebe5f2298a48e5cc52fb +size 20924104 diff --git a/UDPipe/v1/XDependencies/UDPipe/Models/Spanish.udpipe b/UDPipe/v1/XDependencies/UDPipe/Models/Spanish.udpipe new file mode 100644 index 0000000000000000000000000000000000000000..c7f5ee55b520b58224e65c7dabf5c0e9ea04200b --- /dev/null +++ b/UDPipe/v1/XDependencies/UDPipe/Models/Spanish.udpipe @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5b42f4a5054a227d9d867179cb3213ae3c014f25916b0137fe54055869cd497e +size 29295124 diff --git a/UDPipe/v1/XDependencies/UDPipe/Models/Swedish-LINES.udpipe b/UDPipe/v1/XDependencies/UDPipe/Models/Swedish-LINES.udpipe new file mode 100644 index 0000000000000000000000000000000000000000..eeefa8f32c80b60997ef0a3092712d758924fbbc --- /dev/null +++ b/UDPipe/v1/XDependencies/UDPipe/Models/Swedish-LINES.udpipe @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:732e745917b8c255cc706683ef61704ceca024a6d08ecf228feb7cc91ab6e788 +size 8594513 diff --git a/UDPipe/v1/XDependencies/UDPipe/Models/Swedish.udpipe b/UDPipe/v1/XDependencies/UDPipe/Models/Swedish.udpipe new file mode 100644 index 0000000000000000000000000000000000000000..81416065ca8f9b52a2edfa0d366929fb3d03cb49 --- /dev/null +++ b/UDPipe/v1/XDependencies/UDPipe/Models/Swedish.udpipe @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:44c4af98ffbc4d4493368b5cb30f53259a0178ebe81def8a7c6e0dc0d6d032c3 +size 8048838 diff --git a/UDPipe/v1/XDependencies/UDPipe/Models/Tamil.udpipe b/UDPipe/v1/XDependencies/UDPipe/Models/Tamil.udpipe new file mode 100644 index 0000000000000000000000000000000000000000..052076468c98ef6c41e856f7976423d48c00b4c4 --- /dev/null +++ b/UDPipe/v1/XDependencies/UDPipe/Models/Tamil.udpipe @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5145455f52bbfd256dcb10e23c8229a16b513b284e78ffab75e79fb2c12f69ea +size 2797773 diff --git a/UDPipe/v1/XDependencies/UDPipe/Models/Turkish.udpipe b/UDPipe/v1/XDependencies/UDPipe/Models/Turkish.udpipe new file mode 100644 index 0000000000000000000000000000000000000000..b98332f421a87a88e2f8c084457a01cd7cdb686c --- /dev/null +++ b/UDPipe/v1/XDependencies/UDPipe/Models/Turkish.udpipe @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3546ecfb68987ac22646953873f203e65b1a19868e1f61cbf63df690b02501d5 +size 10083430 diff --git a/UDPipe/v1/XDependencies/UDPipe/Models/Ukrainian.udpipe b/UDPipe/v1/XDependencies/UDPipe/Models/Ukrainian.udpipe new file mode 100644 index 0000000000000000000000000000000000000000..5332bb5619abd15ef476c85e19fc5227905aabc8 --- /dev/null +++ b/UDPipe/v1/XDependencies/UDPipe/Models/Ukrainian.udpipe @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9232c0431aa6632f70bd8f411ddba170534bc6bf41d5f4aeb56c32b8b42ab206 +size 4894627 diff --git a/UDPipe/v1/XDependencies/UDPipe/Models/Urdu.udpipe b/UDPipe/v1/XDependencies/UDPipe/Models/Urdu.udpipe new file mode 100644 index 0000000000000000000000000000000000000000..607b2d4e17e601ac164351b69ccef4c7b7880ded --- /dev/null +++ b/UDPipe/v1/XDependencies/UDPipe/Models/Urdu.udpipe @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:253ee4b894880ecceeef64d3c5d83b72313250557658b283b9521e90a1d61121 +size 16061407 diff --git a/UDPipe/v1/XDependencies/UDPipe/Models/Uyghur.udpipe b/UDPipe/v1/XDependencies/UDPipe/Models/Uyghur.udpipe new file mode 100644 index 0000000000000000000000000000000000000000..fbb40847bd9a41ed2381668c730ad841d35055f4 --- /dev/null +++ b/UDPipe/v1/XDependencies/UDPipe/Models/Uyghur.udpipe @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:deffa786e6253bf805c0bd34cde4692e6529ad64f19e115097ef31784bf89001 +size 1912398 diff --git a/UDPipe/v1/XDependencies/UDPipe/Models/Vietnamese.udpipe b/UDPipe/v1/XDependencies/UDPipe/Models/Vietnamese.udpipe new file mode 100644 index 0000000000000000000000000000000000000000..c470d36f341b312f3dea6e69f8a044eed84edf27 --- /dev/null +++ b/UDPipe/v1/XDependencies/UDPipe/Models/Vietnamese.udpipe @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:34fea03c22fcd308eba2c4246c4fa3a9097f2ba601a448cfe03bab892fc63935 +size 4938137 diff --git a/UDPipe/v1/XDependencies/UDPipe/README b/UDPipe/v1/XDependencies/UDPipe/README new file mode 100644 index 0000000000000000000000000000000000000000..f7d4d998ec301794112dcb7caa41c444e23ab78d --- /dev/null +++ b/UDPipe/v1/XDependencies/UDPipe/README @@ -0,0 +1,27 @@ +UDPipe +======= + +UDPipe is a trainable pipeline for tokenization, tagging, lemmatization and +dependency parsing of CoNLL-U files. UDPipe is language-agnostic and can be +trained given annotated data in CoNLL-U format +(http://universaldependencies.org/format.html). Trained models are provided for +nearly all UD treebanks (http://universaldependencies.org). UDPipe is available +as a binary for Linux/Windows/OS X, as a library for C++, Python, Perl, Java, +C#, and as a web service. + +UDPipe is a free software distributed under the Mozilla Public License 2.0 +(http://www.mozilla.org/MPL/2.0/) and the linguistic models are free for +non-commercial use and distributed under the CC BY-NC-SA +(http://creativecommons.org/licenses/by-nc-sa/4.0/) license, although for some +models the original data used to create the model may impose additional +licensing conditions. UDPipe is versioned using Semantic Versioning +(http://semver.org/). + +Copyright 2017 by Institute of Formal and Applied Linguistics, Faculty of +Mathematics and Physics, Charles University, Czech Republic. + +UDPipe website http://ufal.mff.cuni.cz/udpipe contains download links of both +the released packages and trained models, hosts documentation and offers online +demo. + +UDPipe development repository http://github.com/ufal/udpipe is hosted on GitHub. diff --git a/UDPipe/v1/XDependencies/UDPipe/udpipe.exe b/UDPipe/v1/XDependencies/UDPipe/udpipe.exe new file mode 100644 index 0000000000000000000000000000000000000000..13dc8ac9e64f18760fc8182e57a9cd45b2118561 --- /dev/null +++ b/UDPipe/v1/XDependencies/UDPipe/udpipe.exe @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:fca2fdd0b983761423e4dc031640a329698b7192078f8cd473ce096eb8cea6b6 +size 1104896 diff --git a/UDPipe/v1/binary/linux32/csharp/Ufal/UDPipe/Children.cs b/UDPipe/v1/binary/linux32/csharp/Ufal/UDPipe/Children.cs new file mode 100644 index 0000000000000000000000000000000000000000..e5959f767df4f3ddb46e9dcb210f3eacd8c2237a --- /dev/null +++ b/UDPipe/v1/binary/linux32/csharp/Ufal/UDPipe/Children.cs @@ -0,0 +1,328 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +public class Children : global::System.IDisposable, global::System.Collections.IEnumerable + , global::System.Collections.Generic.IList + { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal Children(global::System.IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Children obj) { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + ~Children() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != global::System.IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + udpipe_csharpPINVOKE.delete_Children(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + global::System.GC.SuppressFinalize(this); + } + } + + public Children(global::System.Collections.ICollection c) : this() { + if (c == null) + throw new global::System.ArgumentNullException("c"); + foreach (int element in c) { + this.Add(element); + } + } + + public bool IsFixedSize { + get { + return false; + } + } + + public bool IsReadOnly { + get { + return false; + } + } + + public int this[int index] { + get { + return getitem(index); + } + set { + setitem(index, value); + } + } + + public int Capacity { + get { + return (int)capacity(); + } + set { + if (value < size()) + throw new global::System.ArgumentOutOfRangeException("Capacity"); + reserve((uint)value); + } + } + + public int Count { + get { + return (int)size(); + } + } + + public bool IsSynchronized { + get { + return false; + } + } + + public void CopyTo(int[] array) + { + CopyTo(0, array, 0, this.Count); + } + + public void CopyTo(int[] array, int arrayIndex) + { + CopyTo(0, array, arrayIndex, this.Count); + } + + public void CopyTo(int index, int[] array, int arrayIndex, int count) + { + if (array == null) + throw new global::System.ArgumentNullException("array"); + if (index < 0) + throw new global::System.ArgumentOutOfRangeException("index", "Value is less than zero"); + if (arrayIndex < 0) + throw new global::System.ArgumentOutOfRangeException("arrayIndex", "Value is less than zero"); + if (count < 0) + throw new global::System.ArgumentOutOfRangeException("count", "Value is less than zero"); + if (array.Rank > 1) + throw new global::System.ArgumentException("Multi dimensional array.", "array"); + if (index+count > this.Count || arrayIndex+count > array.Length) + throw new global::System.ArgumentException("Number of elements to copy is too large."); + for (int i=0; i global::System.Collections.Generic.IEnumerable.GetEnumerator() { + return new ChildrenEnumerator(this); + } + + global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator() { + return new ChildrenEnumerator(this); + } + + public ChildrenEnumerator GetEnumerator() { + return new ChildrenEnumerator(this); + } + + // Type-safe enumerator + /// Note that the IEnumerator documentation requires an InvalidOperationException to be thrown + /// whenever the collection is modified. This has been done for changes in the size of the + /// collection but not when one of the elements of the collection is modified as it is a bit + /// tricky to detect unmanaged code that modifies the collection under our feet. + public sealed class ChildrenEnumerator : global::System.Collections.IEnumerator + , global::System.Collections.Generic.IEnumerator + { + private Children collectionRef; + private int currentIndex; + private object currentObject; + private int currentSize; + + public ChildrenEnumerator(Children collection) { + collectionRef = collection; + currentIndex = -1; + currentObject = null; + currentSize = collectionRef.Count; + } + + // Type-safe iterator Current + public int Current { + get { + if (currentIndex == -1) + throw new global::System.InvalidOperationException("Enumeration not started."); + if (currentIndex > currentSize - 1) + throw new global::System.InvalidOperationException("Enumeration finished."); + if (currentObject == null) + throw new global::System.InvalidOperationException("Collection modified."); + return (int)currentObject; + } + } + + // Type-unsafe IEnumerator.Current + object global::System.Collections.IEnumerator.Current { + get { + return Current; + } + } + + public bool MoveNext() { + int size = collectionRef.Count; + bool moveOkay = (currentIndex+1 < size) && (size == currentSize); + if (moveOkay) { + currentIndex++; + currentObject = collectionRef[currentIndex]; + } else { + currentObject = null; + } + return moveOkay; + } + + public void Reset() { + currentIndex = -1; + currentObject = null; + if (collectionRef.Count != currentSize) { + throw new global::System.InvalidOperationException("Collection modified."); + } + } + + public void Dispose() { + currentIndex = -1; + currentObject = null; + } + } + + public void Clear() { + udpipe_csharpPINVOKE.Children_Clear(swigCPtr); + } + + public void Add(int x) { + udpipe_csharpPINVOKE.Children_Add(swigCPtr, x); + } + + private uint size() { + uint ret = udpipe_csharpPINVOKE.Children_size(swigCPtr); + return ret; + } + + private uint capacity() { + uint ret = udpipe_csharpPINVOKE.Children_capacity(swigCPtr); + return ret; + } + + private void reserve(uint n) { + udpipe_csharpPINVOKE.Children_reserve(swigCPtr, n); + } + + public Children() : this(udpipe_csharpPINVOKE.new_Children__SWIG_0(), true) { + } + + public Children(Children other) : this(udpipe_csharpPINVOKE.new_Children__SWIG_1(Children.getCPtr(other)), true) { + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public Children(int capacity) : this(udpipe_csharpPINVOKE.new_Children__SWIG_2(capacity), true) { + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + private int getitemcopy(int index) { + int ret = udpipe_csharpPINVOKE.Children_getitemcopy(swigCPtr, index); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + private int getitem(int index) { + int ret = udpipe_csharpPINVOKE.Children_getitem(swigCPtr, index); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + private void setitem(int index, int val) { + udpipe_csharpPINVOKE.Children_setitem(swigCPtr, index, val); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void AddRange(Children values) { + udpipe_csharpPINVOKE.Children_AddRange(swigCPtr, Children.getCPtr(values)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public Children GetRange(int index, int count) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.Children_GetRange(swigCPtr, index, count); + Children ret = (cPtr == global::System.IntPtr.Zero) ? null : new Children(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public void Insert(int index, int x) { + udpipe_csharpPINVOKE.Children_Insert(swigCPtr, index, x); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void InsertRange(int index, Children values) { + udpipe_csharpPINVOKE.Children_InsertRange(swigCPtr, index, Children.getCPtr(values)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void RemoveAt(int index) { + udpipe_csharpPINVOKE.Children_RemoveAt(swigCPtr, index); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void RemoveRange(int index, int count) { + udpipe_csharpPINVOKE.Children_RemoveRange(swigCPtr, index, count); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public static Children Repeat(int value, int count) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.Children_Repeat(value, count); + Children ret = (cPtr == global::System.IntPtr.Zero) ? null : new Children(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public void Reverse() { + udpipe_csharpPINVOKE.Children_Reverse__SWIG_0(swigCPtr); + } + + public void Reverse(int index, int count) { + udpipe_csharpPINVOKE.Children_Reverse__SWIG_1(swigCPtr, index, count); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void SetRange(int index, Children values) { + udpipe_csharpPINVOKE.Children_SetRange(swigCPtr, index, Children.getCPtr(values)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public bool Contains(int value) { + bool ret = udpipe_csharpPINVOKE.Children_Contains(swigCPtr, value); + return ret; + } + + public int IndexOf(int value) { + int ret = udpipe_csharpPINVOKE.Children_IndexOf(swigCPtr, value); + return ret; + } + + public int LastIndexOf(int value) { + int ret = udpipe_csharpPINVOKE.Children_LastIndexOf(swigCPtr, value); + return ret; + } + + public bool Remove(int value) { + bool ret = udpipe_csharpPINVOKE.Children_Remove(swigCPtr, value); + return ret; + } + +} + +} diff --git a/UDPipe/v1/binary/linux32/csharp/Ufal/UDPipe/Comments.cs b/UDPipe/v1/binary/linux32/csharp/Ufal/UDPipe/Comments.cs new file mode 100644 index 0000000000000000000000000000000000000000..316865d901e073812e3deda1f8ccf407a6ed93a7 --- /dev/null +++ b/UDPipe/v1/binary/linux32/csharp/Ufal/UDPipe/Comments.cs @@ -0,0 +1,333 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +public class Comments : global::System.IDisposable, global::System.Collections.IEnumerable + , global::System.Collections.Generic.IList + { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal Comments(global::System.IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Comments obj) { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + ~Comments() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != global::System.IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + udpipe_csharpPINVOKE.delete_Comments(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + global::System.GC.SuppressFinalize(this); + } + } + + public Comments(global::System.Collections.ICollection c) : this() { + if (c == null) + throw new global::System.ArgumentNullException("c"); + foreach (string element in c) { + this.Add(element); + } + } + + public bool IsFixedSize { + get { + return false; + } + } + + public bool IsReadOnly { + get { + return false; + } + } + + public string this[int index] { + get { + return getitem(index); + } + set { + setitem(index, value); + } + } + + public int Capacity { + get { + return (int)capacity(); + } + set { + if (value < size()) + throw new global::System.ArgumentOutOfRangeException("Capacity"); + reserve((uint)value); + } + } + + public int Count { + get { + return (int)size(); + } + } + + public bool IsSynchronized { + get { + return false; + } + } + + public void CopyTo(string[] array) + { + CopyTo(0, array, 0, this.Count); + } + + public void CopyTo(string[] array, int arrayIndex) + { + CopyTo(0, array, arrayIndex, this.Count); + } + + public void CopyTo(int index, string[] array, int arrayIndex, int count) + { + if (array == null) + throw new global::System.ArgumentNullException("array"); + if (index < 0) + throw new global::System.ArgumentOutOfRangeException("index", "Value is less than zero"); + if (arrayIndex < 0) + throw new global::System.ArgumentOutOfRangeException("arrayIndex", "Value is less than zero"); + if (count < 0) + throw new global::System.ArgumentOutOfRangeException("count", "Value is less than zero"); + if (array.Rank > 1) + throw new global::System.ArgumentException("Multi dimensional array.", "array"); + if (index+count > this.Count || arrayIndex+count > array.Length) + throw new global::System.ArgumentException("Number of elements to copy is too large."); + for (int i=0; i global::System.Collections.Generic.IEnumerable.GetEnumerator() { + return new CommentsEnumerator(this); + } + + global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator() { + return new CommentsEnumerator(this); + } + + public CommentsEnumerator GetEnumerator() { + return new CommentsEnumerator(this); + } + + // Type-safe enumerator + /// Note that the IEnumerator documentation requires an InvalidOperationException to be thrown + /// whenever the collection is modified. This has been done for changes in the size of the + /// collection but not when one of the elements of the collection is modified as it is a bit + /// tricky to detect unmanaged code that modifies the collection under our feet. + public sealed class CommentsEnumerator : global::System.Collections.IEnumerator + , global::System.Collections.Generic.IEnumerator + { + private Comments collectionRef; + private int currentIndex; + private object currentObject; + private int currentSize; + + public CommentsEnumerator(Comments collection) { + collectionRef = collection; + currentIndex = -1; + currentObject = null; + currentSize = collectionRef.Count; + } + + // Type-safe iterator Current + public string Current { + get { + if (currentIndex == -1) + throw new global::System.InvalidOperationException("Enumeration not started."); + if (currentIndex > currentSize - 1) + throw new global::System.InvalidOperationException("Enumeration finished."); + if (currentObject == null) + throw new global::System.InvalidOperationException("Collection modified."); + return (string)currentObject; + } + } + + // Type-unsafe IEnumerator.Current + object global::System.Collections.IEnumerator.Current { + get { + return Current; + } + } + + public bool MoveNext() { + int size = collectionRef.Count; + bool moveOkay = (currentIndex+1 < size) && (size == currentSize); + if (moveOkay) { + currentIndex++; + currentObject = collectionRef[currentIndex]; + } else { + currentObject = null; + } + return moveOkay; + } + + public void Reset() { + currentIndex = -1; + currentObject = null; + if (collectionRef.Count != currentSize) { + throw new global::System.InvalidOperationException("Collection modified."); + } + } + + public void Dispose() { + currentIndex = -1; + currentObject = null; + } + } + + public void Clear() { + udpipe_csharpPINVOKE.Comments_Clear(swigCPtr); + } + + public void Add(string x) { + udpipe_csharpPINVOKE.Comments_Add(swigCPtr, x); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + private uint size() { + uint ret = udpipe_csharpPINVOKE.Comments_size(swigCPtr); + return ret; + } + + private uint capacity() { + uint ret = udpipe_csharpPINVOKE.Comments_capacity(swigCPtr); + return ret; + } + + private void reserve(uint n) { + udpipe_csharpPINVOKE.Comments_reserve(swigCPtr, n); + } + + public Comments() : this(udpipe_csharpPINVOKE.new_Comments__SWIG_0(), true) { + } + + public Comments(Comments other) : this(udpipe_csharpPINVOKE.new_Comments__SWIG_1(Comments.getCPtr(other)), true) { + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public Comments(int capacity) : this(udpipe_csharpPINVOKE.new_Comments__SWIG_2(capacity), true) { + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + private string getitemcopy(int index) { + string ret = udpipe_csharpPINVOKE.Comments_getitemcopy(swigCPtr, index); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + private string getitem(int index) { + string ret = udpipe_csharpPINVOKE.Comments_getitem(swigCPtr, index); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + private void setitem(int index, string val) { + udpipe_csharpPINVOKE.Comments_setitem(swigCPtr, index, val); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void AddRange(Comments values) { + udpipe_csharpPINVOKE.Comments_AddRange(swigCPtr, Comments.getCPtr(values)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public Comments GetRange(int index, int count) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.Comments_GetRange(swigCPtr, index, count); + Comments ret = (cPtr == global::System.IntPtr.Zero) ? null : new Comments(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public void Insert(int index, string x) { + udpipe_csharpPINVOKE.Comments_Insert(swigCPtr, index, x); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void InsertRange(int index, Comments values) { + udpipe_csharpPINVOKE.Comments_InsertRange(swigCPtr, index, Comments.getCPtr(values)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void RemoveAt(int index) { + udpipe_csharpPINVOKE.Comments_RemoveAt(swigCPtr, index); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void RemoveRange(int index, int count) { + udpipe_csharpPINVOKE.Comments_RemoveRange(swigCPtr, index, count); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public static Comments Repeat(string value, int count) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.Comments_Repeat(value, count); + Comments ret = (cPtr == global::System.IntPtr.Zero) ? null : new Comments(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public void Reverse() { + udpipe_csharpPINVOKE.Comments_Reverse__SWIG_0(swigCPtr); + } + + public void Reverse(int index, int count) { + udpipe_csharpPINVOKE.Comments_Reverse__SWIG_1(swigCPtr, index, count); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void SetRange(int index, Comments values) { + udpipe_csharpPINVOKE.Comments_SetRange(swigCPtr, index, Comments.getCPtr(values)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public bool Contains(string value) { + bool ret = udpipe_csharpPINVOKE.Comments_Contains(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public int IndexOf(string value) { + int ret = udpipe_csharpPINVOKE.Comments_IndexOf(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public int LastIndexOf(string value) { + int ret = udpipe_csharpPINVOKE.Comments_LastIndexOf(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public bool Remove(string value) { + bool ret = udpipe_csharpPINVOKE.Comments_Remove(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + +} + +} diff --git a/UDPipe/v1/binary/linux32/csharp/Ufal/UDPipe/EmptyNode.cs b/UDPipe/v1/binary/linux32/csharp/Ufal/UDPipe/EmptyNode.cs new file mode 100644 index 0000000000000000000000000000000000000000..3d9127797fd237053078ec6db9da11cc6c9c819a --- /dev/null +++ b/UDPipe/v1/binary/linux32/csharp/Ufal/UDPipe/EmptyNode.cs @@ -0,0 +1,158 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +public class EmptyNode : global::System.IDisposable { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal EmptyNode(global::System.IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(EmptyNode obj) { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + ~EmptyNode() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != global::System.IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + udpipe_csharpPINVOKE.delete_EmptyNode(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + global::System.GC.SuppressFinalize(this); + } + } + + public int id { + set { + udpipe_csharpPINVOKE.EmptyNode_id_set(swigCPtr, value); + } + get { + int ret = udpipe_csharpPINVOKE.EmptyNode_id_get(swigCPtr); + return ret; + } + } + + public int index { + set { + udpipe_csharpPINVOKE.EmptyNode_index_set(swigCPtr, value); + } + get { + int ret = udpipe_csharpPINVOKE.EmptyNode_index_get(swigCPtr); + return ret; + } + } + + public string form { + set { + udpipe_csharpPINVOKE.EmptyNode_form_set(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + get { + string ret = udpipe_csharpPINVOKE.EmptyNode_form_get(swigCPtr); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + } + + public string lemma { + set { + udpipe_csharpPINVOKE.EmptyNode_lemma_set(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + get { + string ret = udpipe_csharpPINVOKE.EmptyNode_lemma_get(swigCPtr); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + } + + public string upostag { + set { + udpipe_csharpPINVOKE.EmptyNode_upostag_set(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + get { + string ret = udpipe_csharpPINVOKE.EmptyNode_upostag_get(swigCPtr); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + } + + public string xpostag { + set { + udpipe_csharpPINVOKE.EmptyNode_xpostag_set(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + get { + string ret = udpipe_csharpPINVOKE.EmptyNode_xpostag_get(swigCPtr); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + } + + public string feats { + set { + udpipe_csharpPINVOKE.EmptyNode_feats_set(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + get { + string ret = udpipe_csharpPINVOKE.EmptyNode_feats_get(swigCPtr); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + } + + public string deps { + set { + udpipe_csharpPINVOKE.EmptyNode_deps_set(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + get { + string ret = udpipe_csharpPINVOKE.EmptyNode_deps_get(swigCPtr); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + } + + public string misc { + set { + udpipe_csharpPINVOKE.EmptyNode_misc_set(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + get { + string ret = udpipe_csharpPINVOKE.EmptyNode_misc_get(swigCPtr); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + } + + public EmptyNode(int id, int index) : this(udpipe_csharpPINVOKE.new_EmptyNode__SWIG_0(id, index), true) { + } + + public EmptyNode(int id) : this(udpipe_csharpPINVOKE.new_EmptyNode__SWIG_1(id), true) { + } + + public EmptyNode() : this(udpipe_csharpPINVOKE.new_EmptyNode__SWIG_2(), true) { + } + +} + +} diff --git a/UDPipe/v1/binary/linux32/csharp/Ufal/UDPipe/EmptyNodes.cs b/UDPipe/v1/binary/linux32/csharp/Ufal/UDPipe/EmptyNodes.cs new file mode 100644 index 0000000000000000000000000000000000000000..2b4412bd10fdba16a486450f457720529beadb6b --- /dev/null +++ b/UDPipe/v1/binary/linux32/csharp/Ufal/UDPipe/EmptyNodes.cs @@ -0,0 +1,309 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +public class EmptyNodes : global::System.IDisposable, global::System.Collections.IEnumerable + , global::System.Collections.Generic.IEnumerable + { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal EmptyNodes(global::System.IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(EmptyNodes obj) { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + ~EmptyNodes() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != global::System.IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + udpipe_csharpPINVOKE.delete_EmptyNodes(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + global::System.GC.SuppressFinalize(this); + } + } + + public EmptyNodes(global::System.Collections.ICollection c) : this() { + if (c == null) + throw new global::System.ArgumentNullException("c"); + foreach (EmptyNode element in c) { + this.Add(element); + } + } + + public bool IsFixedSize { + get { + return false; + } + } + + public bool IsReadOnly { + get { + return false; + } + } + + public EmptyNode this[int index] { + get { + return getitem(index); + } + set { + setitem(index, value); + } + } + + public int Capacity { + get { + return (int)capacity(); + } + set { + if (value < size()) + throw new global::System.ArgumentOutOfRangeException("Capacity"); + reserve((uint)value); + } + } + + public int Count { + get { + return (int)size(); + } + } + + public bool IsSynchronized { + get { + return false; + } + } + + public void CopyTo(EmptyNode[] array) + { + CopyTo(0, array, 0, this.Count); + } + + public void CopyTo(EmptyNode[] array, int arrayIndex) + { + CopyTo(0, array, arrayIndex, this.Count); + } + + public void CopyTo(int index, EmptyNode[] array, int arrayIndex, int count) + { + if (array == null) + throw new global::System.ArgumentNullException("array"); + if (index < 0) + throw new global::System.ArgumentOutOfRangeException("index", "Value is less than zero"); + if (arrayIndex < 0) + throw new global::System.ArgumentOutOfRangeException("arrayIndex", "Value is less than zero"); + if (count < 0) + throw new global::System.ArgumentOutOfRangeException("count", "Value is less than zero"); + if (array.Rank > 1) + throw new global::System.ArgumentException("Multi dimensional array.", "array"); + if (index+count > this.Count || arrayIndex+count > array.Length) + throw new global::System.ArgumentException("Number of elements to copy is too large."); + for (int i=0; i global::System.Collections.Generic.IEnumerable.GetEnumerator() { + return new EmptyNodesEnumerator(this); + } + + global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator() { + return new EmptyNodesEnumerator(this); + } + + public EmptyNodesEnumerator GetEnumerator() { + return new EmptyNodesEnumerator(this); + } + + // Type-safe enumerator + /// Note that the IEnumerator documentation requires an InvalidOperationException to be thrown + /// whenever the collection is modified. This has been done for changes in the size of the + /// collection but not when one of the elements of the collection is modified as it is a bit + /// tricky to detect unmanaged code that modifies the collection under our feet. + public sealed class EmptyNodesEnumerator : global::System.Collections.IEnumerator + , global::System.Collections.Generic.IEnumerator + { + private EmptyNodes collectionRef; + private int currentIndex; + private object currentObject; + private int currentSize; + + public EmptyNodesEnumerator(EmptyNodes collection) { + collectionRef = collection; + currentIndex = -1; + currentObject = null; + currentSize = collectionRef.Count; + } + + // Type-safe iterator Current + public EmptyNode Current { + get { + if (currentIndex == -1) + throw new global::System.InvalidOperationException("Enumeration not started."); + if (currentIndex > currentSize - 1) + throw new global::System.InvalidOperationException("Enumeration finished."); + if (currentObject == null) + throw new global::System.InvalidOperationException("Collection modified."); + return (EmptyNode)currentObject; + } + } + + // Type-unsafe IEnumerator.Current + object global::System.Collections.IEnumerator.Current { + get { + return Current; + } + } + + public bool MoveNext() { + int size = collectionRef.Count; + bool moveOkay = (currentIndex+1 < size) && (size == currentSize); + if (moveOkay) { + currentIndex++; + currentObject = collectionRef[currentIndex]; + } else { + currentObject = null; + } + return moveOkay; + } + + public void Reset() { + currentIndex = -1; + currentObject = null; + if (collectionRef.Count != currentSize) { + throw new global::System.InvalidOperationException("Collection modified."); + } + } + + public void Dispose() { + currentIndex = -1; + currentObject = null; + } + } + + public void Clear() { + udpipe_csharpPINVOKE.EmptyNodes_Clear(swigCPtr); + } + + public void Add(EmptyNode x) { + udpipe_csharpPINVOKE.EmptyNodes_Add(swigCPtr, EmptyNode.getCPtr(x)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + private uint size() { + uint ret = udpipe_csharpPINVOKE.EmptyNodes_size(swigCPtr); + return ret; + } + + private uint capacity() { + uint ret = udpipe_csharpPINVOKE.EmptyNodes_capacity(swigCPtr); + return ret; + } + + private void reserve(uint n) { + udpipe_csharpPINVOKE.EmptyNodes_reserve(swigCPtr, n); + } + + public EmptyNodes() : this(udpipe_csharpPINVOKE.new_EmptyNodes__SWIG_0(), true) { + } + + public EmptyNodes(EmptyNodes other) : this(udpipe_csharpPINVOKE.new_EmptyNodes__SWIG_1(EmptyNodes.getCPtr(other)), true) { + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public EmptyNodes(int capacity) : this(udpipe_csharpPINVOKE.new_EmptyNodes__SWIG_2(capacity), true) { + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + private EmptyNode getitemcopy(int index) { + EmptyNode ret = new EmptyNode(udpipe_csharpPINVOKE.EmptyNodes_getitemcopy(swigCPtr, index), true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + private EmptyNode getitem(int index) { + EmptyNode ret = new EmptyNode(udpipe_csharpPINVOKE.EmptyNodes_getitem(swigCPtr, index), false); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + private void setitem(int index, EmptyNode val) { + udpipe_csharpPINVOKE.EmptyNodes_setitem(swigCPtr, index, EmptyNode.getCPtr(val)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void AddRange(EmptyNodes values) { + udpipe_csharpPINVOKE.EmptyNodes_AddRange(swigCPtr, EmptyNodes.getCPtr(values)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public EmptyNodes GetRange(int index, int count) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.EmptyNodes_GetRange(swigCPtr, index, count); + EmptyNodes ret = (cPtr == global::System.IntPtr.Zero) ? null : new EmptyNodes(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public void Insert(int index, EmptyNode x) { + udpipe_csharpPINVOKE.EmptyNodes_Insert(swigCPtr, index, EmptyNode.getCPtr(x)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void InsertRange(int index, EmptyNodes values) { + udpipe_csharpPINVOKE.EmptyNodes_InsertRange(swigCPtr, index, EmptyNodes.getCPtr(values)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void RemoveAt(int index) { + udpipe_csharpPINVOKE.EmptyNodes_RemoveAt(swigCPtr, index); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void RemoveRange(int index, int count) { + udpipe_csharpPINVOKE.EmptyNodes_RemoveRange(swigCPtr, index, count); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public static EmptyNodes Repeat(EmptyNode value, int count) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.EmptyNodes_Repeat(EmptyNode.getCPtr(value), count); + EmptyNodes ret = (cPtr == global::System.IntPtr.Zero) ? null : new EmptyNodes(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public void Reverse() { + udpipe_csharpPINVOKE.EmptyNodes_Reverse__SWIG_0(swigCPtr); + } + + public void Reverse(int index, int count) { + udpipe_csharpPINVOKE.EmptyNodes_Reverse__SWIG_1(swigCPtr, index, count); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void SetRange(int index, EmptyNodes values) { + udpipe_csharpPINVOKE.EmptyNodes_SetRange(swigCPtr, index, EmptyNodes.getCPtr(values)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + +} + +} diff --git a/UDPipe/v1/binary/linux32/csharp/Ufal/UDPipe/Evaluator.cs b/UDPipe/v1/binary/linux32/csharp/Ufal/UDPipe/Evaluator.cs new file mode 100644 index 0000000000000000000000000000000000000000..007e5ae8995f11aefe94465fed6d1d61725b6644 --- /dev/null +++ b/UDPipe/v1/binary/linux32/csharp/Ufal/UDPipe/Evaluator.cs @@ -0,0 +1,94 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +public class Evaluator : global::System.IDisposable { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal Evaluator(global::System.IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Evaluator obj) { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + ~Evaluator() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != global::System.IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + udpipe_csharpPINVOKE.delete_Evaluator(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + global::System.GC.SuppressFinalize(this); + } + } + + public Evaluator(Model m, string tokenizer, string tagger, string parser) : this(udpipe_csharpPINVOKE.new_Evaluator(Model.getCPtr(m), tokenizer, tagger, parser), true) { + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void setModel(Model m) { + udpipe_csharpPINVOKE.Evaluator_setModel(swigCPtr, Model.getCPtr(m)); + } + + public void setTokenizer(string tokenizer) { + udpipe_csharpPINVOKE.Evaluator_setTokenizer(swigCPtr, tokenizer); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void setTagger(string tagger) { + udpipe_csharpPINVOKE.Evaluator_setTagger(swigCPtr, tagger); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void setParser(string parser) { + udpipe_csharpPINVOKE.Evaluator_setParser(swigCPtr, parser); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public string evaluate(string data, ProcessingError error) { + string ret = udpipe_csharpPINVOKE.Evaluator_evaluate__SWIG_0(swigCPtr, data, ProcessingError.getCPtr(error)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public string evaluate(string data) { + string ret = udpipe_csharpPINVOKE.Evaluator_evaluate__SWIG_1(swigCPtr, data); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public static string DEFAULT { + get { + string ret = udpipe_csharpPINVOKE.Evaluator_DEFAULT_get(); + return ret; + } + } + + public static string NONE { + get { + string ret = udpipe_csharpPINVOKE.Evaluator_NONE_get(); + return ret; + } + } + +} + +} diff --git a/UDPipe/v1/binary/linux32/csharp/Ufal/UDPipe/InputFormat.cs b/UDPipe/v1/binary/linux32/csharp/Ufal/UDPipe/InputFormat.cs new file mode 100644 index 0000000000000000000000000000000000000000..4dd3bb29440658a9e5187aec1cf719180c11e798 --- /dev/null +++ b/UDPipe/v1/binary/linux32/csharp/Ufal/UDPipe/InputFormat.cs @@ -0,0 +1,175 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +public class InputFormat : global::System.IDisposable { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal InputFormat(global::System.IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(InputFormat obj) { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + ~InputFormat() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != global::System.IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + udpipe_csharpPINVOKE.delete_InputFormat(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + global::System.GC.SuppressFinalize(this); + } + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtrAndDisown(InputFormat obj) { + if (obj != null) obj.swigCMemOwn = false; + return getCPtr(obj); + } + + public virtual void resetDocument(string id) { + udpipe_csharpPINVOKE.InputFormat_resetDocument__SWIG_0(swigCPtr, id); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public virtual void resetDocument() { + udpipe_csharpPINVOKE.InputFormat_resetDocument__SWIG_1(swigCPtr); + } + + public virtual void setText(string text) { + udpipe_csharpPINVOKE.InputFormat_setText(swigCPtr, text); + } + + public virtual bool nextSentence(Sentence s, ProcessingError error) { + bool ret = udpipe_csharpPINVOKE.InputFormat_nextSentence__SWIG_0(swigCPtr, Sentence.getCPtr(s), ProcessingError.getCPtr(error)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public virtual bool nextSentence(Sentence s) { + bool ret = udpipe_csharpPINVOKE.InputFormat_nextSentence__SWIG_1(swigCPtr, Sentence.getCPtr(s)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public static InputFormat newInputFormat(string name) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.InputFormat_newInputFormat(name); + InputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new InputFormat(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public static InputFormat newConlluInputFormat(string options) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.InputFormat_newConlluInputFormat__SWIG_0(options); + InputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new InputFormat(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public static InputFormat newConlluInputFormat() { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.InputFormat_newConlluInputFormat__SWIG_1(); + InputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new InputFormat(cPtr, true); + return ret; + } + + public static InputFormat newGenericTokenizerInputFormat(string options) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.InputFormat_newGenericTokenizerInputFormat__SWIG_0(options); + InputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new InputFormat(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public static InputFormat newGenericTokenizerInputFormat() { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.InputFormat_newGenericTokenizerInputFormat__SWIG_1(); + InputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new InputFormat(cPtr, true); + return ret; + } + + public static InputFormat newHorizontalInputFormat(string options) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.InputFormat_newHorizontalInputFormat__SWIG_0(options); + InputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new InputFormat(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public static InputFormat newHorizontalInputFormat() { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.InputFormat_newHorizontalInputFormat__SWIG_1(); + InputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new InputFormat(cPtr, true); + return ret; + } + + public static InputFormat newVerticalInputFormat(string options) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.InputFormat_newVerticalInputFormat__SWIG_0(options); + InputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new InputFormat(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public static InputFormat newVerticalInputFormat() { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.InputFormat_newVerticalInputFormat__SWIG_1(); + InputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new InputFormat(cPtr, true); + return ret; + } + + public static InputFormat newPresegmentedTokenizer(InputFormat DISOWN) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.InputFormat_newPresegmentedTokenizer(InputFormat.getCPtrAndDisown(DISOWN)); + InputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new InputFormat(cPtr, true); + return ret; + } + + public static string CONLLU_V1 { + get { + string ret = udpipe_csharpPINVOKE.InputFormat_CONLLU_V1_get(); + return ret; + } + } + + public static string CONLLU_V2 { + get { + string ret = udpipe_csharpPINVOKE.InputFormat_CONLLU_V2_get(); + return ret; + } + } + + public static string GENERIC_TOKENIZER_NORMALIZED_SPACES { + get { + string ret = udpipe_csharpPINVOKE.InputFormat_GENERIC_TOKENIZER_NORMALIZED_SPACES_get(); + return ret; + } + } + + public static string GENERIC_TOKENIZER_PRESEGMENTED { + get { + string ret = udpipe_csharpPINVOKE.InputFormat_GENERIC_TOKENIZER_PRESEGMENTED_get(); + return ret; + } + } + + public static string GENERIC_TOKENIZER_RANGES { + get { + string ret = udpipe_csharpPINVOKE.InputFormat_GENERIC_TOKENIZER_RANGES_get(); + return ret; + } + } + +} + +} diff --git a/UDPipe/v1/binary/linux32/csharp/Ufal/UDPipe/Model.cs b/UDPipe/v1/binary/linux32/csharp/Ufal/UDPipe/Model.cs new file mode 100644 index 0000000000000000000000000000000000000000..c0f530c0927b5b4e91e29dd73092ab2eae73c145 --- /dev/null +++ b/UDPipe/v1/binary/linux32/csharp/Ufal/UDPipe/Model.cs @@ -0,0 +1,110 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +public class Model : global::System.IDisposable { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal Model(global::System.IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Model obj) { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + ~Model() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != global::System.IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + udpipe_csharpPINVOKE.delete_Model(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + global::System.GC.SuppressFinalize(this); + } + } + + public static Model load(string fname) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.Model_load(fname); + Model ret = (cPtr == global::System.IntPtr.Zero) ? null : new Model(cPtr, true); + return ret; + } + + public virtual InputFormat newTokenizer(string options) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.Model_newTokenizer(swigCPtr, options); + InputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new InputFormat(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public virtual bool tag(Sentence s, string options, ProcessingError error) { + bool ret = udpipe_csharpPINVOKE.Model_tag__SWIG_0(swigCPtr, Sentence.getCPtr(s), options, ProcessingError.getCPtr(error)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public virtual bool tag(Sentence s, string options) { + bool ret = udpipe_csharpPINVOKE.Model_tag__SWIG_1(swigCPtr, Sentence.getCPtr(s), options); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public virtual bool parse(Sentence s, string options, ProcessingError error) { + bool ret = udpipe_csharpPINVOKE.Model_parse__SWIG_0(swigCPtr, Sentence.getCPtr(s), options, ProcessingError.getCPtr(error)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public virtual bool parse(Sentence s, string options) { + bool ret = udpipe_csharpPINVOKE.Model_parse__SWIG_1(swigCPtr, Sentence.getCPtr(s), options); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public static string DEFAULT { + get { + string ret = udpipe_csharpPINVOKE.Model_DEFAULT_get(); + return ret; + } + } + + public static string TOKENIZER_NORMALIZED_SPACES { + get { + string ret = udpipe_csharpPINVOKE.Model_TOKENIZER_NORMALIZED_SPACES_get(); + return ret; + } + } + + public static string TOKENIZER_PRESEGMENTED { + get { + string ret = udpipe_csharpPINVOKE.Model_TOKENIZER_PRESEGMENTED_get(); + return ret; + } + } + + public static string TOKENIZER_RANGES { + get { + string ret = udpipe_csharpPINVOKE.Model_TOKENIZER_RANGES_get(); + return ret; + } + } + +} + +} diff --git a/UDPipe/v1/binary/linux32/csharp/Ufal/UDPipe/MultiwordToken.cs b/UDPipe/v1/binary/linux32/csharp/Ufal/UDPipe/MultiwordToken.cs new file mode 100644 index 0000000000000000000000000000000000000000..0c0d174d4568b275e8ccba0da645baae911f6451 --- /dev/null +++ b/UDPipe/v1/binary/linux32/csharp/Ufal/UDPipe/MultiwordToken.cs @@ -0,0 +1,81 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +public class MultiwordToken : Token { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + + internal MultiwordToken(global::System.IntPtr cPtr, bool cMemoryOwn) : base(udpipe_csharpPINVOKE.MultiwordToken_SWIGUpcast(cPtr), cMemoryOwn) { + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(MultiwordToken obj) { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + ~MultiwordToken() { + Dispose(); + } + + public override void Dispose() { + lock(this) { + if (swigCPtr.Handle != global::System.IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + udpipe_csharpPINVOKE.delete_MultiwordToken(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + global::System.GC.SuppressFinalize(this); + base.Dispose(); + } + } + + public int idFirst { + set { + udpipe_csharpPINVOKE.MultiwordToken_idFirst_set(swigCPtr, value); + } + get { + int ret = udpipe_csharpPINVOKE.MultiwordToken_idFirst_get(swigCPtr); + return ret; + } + } + + public int idLast { + set { + udpipe_csharpPINVOKE.MultiwordToken_idLast_set(swigCPtr, value); + } + get { + int ret = udpipe_csharpPINVOKE.MultiwordToken_idLast_get(swigCPtr); + return ret; + } + } + + public MultiwordToken(int id_first, int id_last, string form, string misc) : this(udpipe_csharpPINVOKE.new_MultiwordToken__SWIG_0(id_first, id_last, form, misc), true) { + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public MultiwordToken(int id_first, int id_last, string form) : this(udpipe_csharpPINVOKE.new_MultiwordToken__SWIG_1(id_first, id_last, form), true) { + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public MultiwordToken(int id_first, int id_last) : this(udpipe_csharpPINVOKE.new_MultiwordToken__SWIG_2(id_first, id_last), true) { + } + + public MultiwordToken(int id_first) : this(udpipe_csharpPINVOKE.new_MultiwordToken__SWIG_3(id_first), true) { + } + + public MultiwordToken() : this(udpipe_csharpPINVOKE.new_MultiwordToken__SWIG_4(), true) { + } + +} + +} diff --git a/UDPipe/v1/binary/linux32/csharp/Ufal/UDPipe/MultiwordTokens.cs b/UDPipe/v1/binary/linux32/csharp/Ufal/UDPipe/MultiwordTokens.cs new file mode 100644 index 0000000000000000000000000000000000000000..0e901203b8632f1636e8b5725efa90ecffbf1f7e --- /dev/null +++ b/UDPipe/v1/binary/linux32/csharp/Ufal/UDPipe/MultiwordTokens.cs @@ -0,0 +1,309 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +public class MultiwordTokens : global::System.IDisposable, global::System.Collections.IEnumerable + , global::System.Collections.Generic.IEnumerable + { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal MultiwordTokens(global::System.IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(MultiwordTokens obj) { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + ~MultiwordTokens() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != global::System.IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + udpipe_csharpPINVOKE.delete_MultiwordTokens(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + global::System.GC.SuppressFinalize(this); + } + } + + public MultiwordTokens(global::System.Collections.ICollection c) : this() { + if (c == null) + throw new global::System.ArgumentNullException("c"); + foreach (MultiwordToken element in c) { + this.Add(element); + } + } + + public bool IsFixedSize { + get { + return false; + } + } + + public bool IsReadOnly { + get { + return false; + } + } + + public MultiwordToken this[int index] { + get { + return getitem(index); + } + set { + setitem(index, value); + } + } + + public int Capacity { + get { + return (int)capacity(); + } + set { + if (value < size()) + throw new global::System.ArgumentOutOfRangeException("Capacity"); + reserve((uint)value); + } + } + + public int Count { + get { + return (int)size(); + } + } + + public bool IsSynchronized { + get { + return false; + } + } + + public void CopyTo(MultiwordToken[] array) + { + CopyTo(0, array, 0, this.Count); + } + + public void CopyTo(MultiwordToken[] array, int arrayIndex) + { + CopyTo(0, array, arrayIndex, this.Count); + } + + public void CopyTo(int index, MultiwordToken[] array, int arrayIndex, int count) + { + if (array == null) + throw new global::System.ArgumentNullException("array"); + if (index < 0) + throw new global::System.ArgumentOutOfRangeException("index", "Value is less than zero"); + if (arrayIndex < 0) + throw new global::System.ArgumentOutOfRangeException("arrayIndex", "Value is less than zero"); + if (count < 0) + throw new global::System.ArgumentOutOfRangeException("count", "Value is less than zero"); + if (array.Rank > 1) + throw new global::System.ArgumentException("Multi dimensional array.", "array"); + if (index+count > this.Count || arrayIndex+count > array.Length) + throw new global::System.ArgumentException("Number of elements to copy is too large."); + for (int i=0; i global::System.Collections.Generic.IEnumerable.GetEnumerator() { + return new MultiwordTokensEnumerator(this); + } + + global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator() { + return new MultiwordTokensEnumerator(this); + } + + public MultiwordTokensEnumerator GetEnumerator() { + return new MultiwordTokensEnumerator(this); + } + + // Type-safe enumerator + /// Note that the IEnumerator documentation requires an InvalidOperationException to be thrown + /// whenever the collection is modified. This has been done for changes in the size of the + /// collection but not when one of the elements of the collection is modified as it is a bit + /// tricky to detect unmanaged code that modifies the collection under our feet. + public sealed class MultiwordTokensEnumerator : global::System.Collections.IEnumerator + , global::System.Collections.Generic.IEnumerator + { + private MultiwordTokens collectionRef; + private int currentIndex; + private object currentObject; + private int currentSize; + + public MultiwordTokensEnumerator(MultiwordTokens collection) { + collectionRef = collection; + currentIndex = -1; + currentObject = null; + currentSize = collectionRef.Count; + } + + // Type-safe iterator Current + public MultiwordToken Current { + get { + if (currentIndex == -1) + throw new global::System.InvalidOperationException("Enumeration not started."); + if (currentIndex > currentSize - 1) + throw new global::System.InvalidOperationException("Enumeration finished."); + if (currentObject == null) + throw new global::System.InvalidOperationException("Collection modified."); + return (MultiwordToken)currentObject; + } + } + + // Type-unsafe IEnumerator.Current + object global::System.Collections.IEnumerator.Current { + get { + return Current; + } + } + + public bool MoveNext() { + int size = collectionRef.Count; + bool moveOkay = (currentIndex+1 < size) && (size == currentSize); + if (moveOkay) { + currentIndex++; + currentObject = collectionRef[currentIndex]; + } else { + currentObject = null; + } + return moveOkay; + } + + public void Reset() { + currentIndex = -1; + currentObject = null; + if (collectionRef.Count != currentSize) { + throw new global::System.InvalidOperationException("Collection modified."); + } + } + + public void Dispose() { + currentIndex = -1; + currentObject = null; + } + } + + public void Clear() { + udpipe_csharpPINVOKE.MultiwordTokens_Clear(swigCPtr); + } + + public void Add(MultiwordToken x) { + udpipe_csharpPINVOKE.MultiwordTokens_Add(swigCPtr, MultiwordToken.getCPtr(x)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + private uint size() { + uint ret = udpipe_csharpPINVOKE.MultiwordTokens_size(swigCPtr); + return ret; + } + + private uint capacity() { + uint ret = udpipe_csharpPINVOKE.MultiwordTokens_capacity(swigCPtr); + return ret; + } + + private void reserve(uint n) { + udpipe_csharpPINVOKE.MultiwordTokens_reserve(swigCPtr, n); + } + + public MultiwordTokens() : this(udpipe_csharpPINVOKE.new_MultiwordTokens__SWIG_0(), true) { + } + + public MultiwordTokens(MultiwordTokens other) : this(udpipe_csharpPINVOKE.new_MultiwordTokens__SWIG_1(MultiwordTokens.getCPtr(other)), true) { + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public MultiwordTokens(int capacity) : this(udpipe_csharpPINVOKE.new_MultiwordTokens__SWIG_2(capacity), true) { + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + private MultiwordToken getitemcopy(int index) { + MultiwordToken ret = new MultiwordToken(udpipe_csharpPINVOKE.MultiwordTokens_getitemcopy(swigCPtr, index), true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + private MultiwordToken getitem(int index) { + MultiwordToken ret = new MultiwordToken(udpipe_csharpPINVOKE.MultiwordTokens_getitem(swigCPtr, index), false); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + private void setitem(int index, MultiwordToken val) { + udpipe_csharpPINVOKE.MultiwordTokens_setitem(swigCPtr, index, MultiwordToken.getCPtr(val)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void AddRange(MultiwordTokens values) { + udpipe_csharpPINVOKE.MultiwordTokens_AddRange(swigCPtr, MultiwordTokens.getCPtr(values)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public MultiwordTokens GetRange(int index, int count) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.MultiwordTokens_GetRange(swigCPtr, index, count); + MultiwordTokens ret = (cPtr == global::System.IntPtr.Zero) ? null : new MultiwordTokens(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public void Insert(int index, MultiwordToken x) { + udpipe_csharpPINVOKE.MultiwordTokens_Insert(swigCPtr, index, MultiwordToken.getCPtr(x)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void InsertRange(int index, MultiwordTokens values) { + udpipe_csharpPINVOKE.MultiwordTokens_InsertRange(swigCPtr, index, MultiwordTokens.getCPtr(values)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void RemoveAt(int index) { + udpipe_csharpPINVOKE.MultiwordTokens_RemoveAt(swigCPtr, index); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void RemoveRange(int index, int count) { + udpipe_csharpPINVOKE.MultiwordTokens_RemoveRange(swigCPtr, index, count); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public static MultiwordTokens Repeat(MultiwordToken value, int count) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.MultiwordTokens_Repeat(MultiwordToken.getCPtr(value), count); + MultiwordTokens ret = (cPtr == global::System.IntPtr.Zero) ? null : new MultiwordTokens(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public void Reverse() { + udpipe_csharpPINVOKE.MultiwordTokens_Reverse__SWIG_0(swigCPtr); + } + + public void Reverse(int index, int count) { + udpipe_csharpPINVOKE.MultiwordTokens_Reverse__SWIG_1(swigCPtr, index, count); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void SetRange(int index, MultiwordTokens values) { + udpipe_csharpPINVOKE.MultiwordTokens_SetRange(swigCPtr, index, MultiwordTokens.getCPtr(values)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + +} + +} diff --git a/UDPipe/v1/binary/linux32/csharp/Ufal/UDPipe/OutputFormat.cs b/UDPipe/v1/binary/linux32/csharp/Ufal/UDPipe/OutputFormat.cs new file mode 100644 index 0000000000000000000000000000000000000000..e15d216ec5790ea52aa23b38a59849e151e8439c --- /dev/null +++ b/UDPipe/v1/binary/linux32/csharp/Ufal/UDPipe/OutputFormat.cs @@ -0,0 +1,176 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +public class OutputFormat : global::System.IDisposable { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal OutputFormat(global::System.IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(OutputFormat obj) { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + ~OutputFormat() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != global::System.IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + udpipe_csharpPINVOKE.delete_OutputFormat(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + global::System.GC.SuppressFinalize(this); + } + } + + public virtual string writeSentence(Sentence s) { + string ret = udpipe_csharpPINVOKE.OutputFormat_writeSentence(swigCPtr, Sentence.getCPtr(s)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public virtual string finishDocument() { + string ret = udpipe_csharpPINVOKE.OutputFormat_finishDocument(swigCPtr); + return ret; + } + + public static OutputFormat newOutputFormat(string name) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.OutputFormat_newOutputFormat(name); + OutputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new OutputFormat(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public static OutputFormat newConlluOutputFormat(string options) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.OutputFormat_newConlluOutputFormat__SWIG_0(options); + OutputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new OutputFormat(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public static OutputFormat newConlluOutputFormat() { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.OutputFormat_newConlluOutputFormat__SWIG_1(); + OutputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new OutputFormat(cPtr, true); + return ret; + } + + public static OutputFormat newEpeOutputFormat(string options) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.OutputFormat_newEpeOutputFormat__SWIG_0(options); + OutputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new OutputFormat(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public static OutputFormat newEpeOutputFormat() { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.OutputFormat_newEpeOutputFormat__SWIG_1(); + OutputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new OutputFormat(cPtr, true); + return ret; + } + + public static OutputFormat newMatxinOutputFormat(string options) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.OutputFormat_newMatxinOutputFormat__SWIG_0(options); + OutputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new OutputFormat(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public static OutputFormat newMatxinOutputFormat() { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.OutputFormat_newMatxinOutputFormat__SWIG_1(); + OutputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new OutputFormat(cPtr, true); + return ret; + } + + public static OutputFormat newHorizontalOutputFormat(string options) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.OutputFormat_newHorizontalOutputFormat__SWIG_0(options); + OutputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new OutputFormat(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public static OutputFormat newHorizontalOutputFormat() { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.OutputFormat_newHorizontalOutputFormat__SWIG_1(); + OutputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new OutputFormat(cPtr, true); + return ret; + } + + public static OutputFormat newPlaintextOutputFormat(string options) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.OutputFormat_newPlaintextOutputFormat__SWIG_0(options); + OutputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new OutputFormat(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public static OutputFormat newPlaintextOutputFormat() { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.OutputFormat_newPlaintextOutputFormat__SWIG_1(); + OutputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new OutputFormat(cPtr, true); + return ret; + } + + public static OutputFormat newVerticalOutputFormat(string options) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.OutputFormat_newVerticalOutputFormat__SWIG_0(options); + OutputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new OutputFormat(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public static OutputFormat newVerticalOutputFormat() { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.OutputFormat_newVerticalOutputFormat__SWIG_1(); + OutputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new OutputFormat(cPtr, true); + return ret; + } + + public static string CONLLU_V1 { + get { + string ret = udpipe_csharpPINVOKE.OutputFormat_CONLLU_V1_get(); + return ret; + } + } + + public static string CONLLU_V2 { + get { + string ret = udpipe_csharpPINVOKE.OutputFormat_CONLLU_V2_get(); + return ret; + } + } + + public static string HORIZONTAL_PARAGRAPHS { + get { + string ret = udpipe_csharpPINVOKE.OutputFormat_HORIZONTAL_PARAGRAPHS_get(); + return ret; + } + } + + public static string PLAINTEXT_NORMALIZED_SPACES { + get { + string ret = udpipe_csharpPINVOKE.OutputFormat_PLAINTEXT_NORMALIZED_SPACES_get(); + return ret; + } + } + + public static string VERTICAL_PARAGRAPHS { + get { + string ret = udpipe_csharpPINVOKE.OutputFormat_VERTICAL_PARAGRAPHS_get(); + return ret; + } + } + +} + +} diff --git a/UDPipe/v1/binary/linux32/csharp/Ufal/UDPipe/Pipeline.cs b/UDPipe/v1/binary/linux32/csharp/Ufal/UDPipe/Pipeline.cs new file mode 100644 index 0000000000000000000000000000000000000000..370b33368ba0c8056a906dcde9ed5478710a41c4 --- /dev/null +++ b/UDPipe/v1/binary/linux32/csharp/Ufal/UDPipe/Pipeline.cs @@ -0,0 +1,108 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +public class Pipeline : global::System.IDisposable { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal Pipeline(global::System.IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Pipeline obj) { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + ~Pipeline() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != global::System.IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + udpipe_csharpPINVOKE.delete_Pipeline(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + global::System.GC.SuppressFinalize(this); + } + } + + public Pipeline(Model m, string input, string tagger, string parser, string output) : this(udpipe_csharpPINVOKE.new_Pipeline(Model.getCPtr(m), input, tagger, parser, output), true) { + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void setModel(Model m) { + udpipe_csharpPINVOKE.Pipeline_setModel(swigCPtr, Model.getCPtr(m)); + } + + public void setInput(string input) { + udpipe_csharpPINVOKE.Pipeline_setInput(swigCPtr, input); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void setTagger(string tagger) { + udpipe_csharpPINVOKE.Pipeline_setTagger(swigCPtr, tagger); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void setParser(string parser) { + udpipe_csharpPINVOKE.Pipeline_setParser(swigCPtr, parser); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void setOutput(string output) { + udpipe_csharpPINVOKE.Pipeline_setOutput(swigCPtr, output); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void setImmediate(bool immediate) { + udpipe_csharpPINVOKE.Pipeline_setImmediate(swigCPtr, immediate); + } + + public void setDocumentId(string document_id) { + udpipe_csharpPINVOKE.Pipeline_setDocumentId(swigCPtr, document_id); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public string process(string data, ProcessingError error) { + string ret = udpipe_csharpPINVOKE.Pipeline_process__SWIG_0(swigCPtr, data, ProcessingError.getCPtr(error)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public string process(string data) { + string ret = udpipe_csharpPINVOKE.Pipeline_process__SWIG_1(swigCPtr, data); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public static string DEFAULT { + get { + string ret = udpipe_csharpPINVOKE.Pipeline_DEFAULT_get(); + return ret; + } + } + + public static string NONE { + get { + string ret = udpipe_csharpPINVOKE.Pipeline_NONE_get(); + return ret; + } + } + +} + +} diff --git a/UDPipe/v1/binary/linux32/csharp/Ufal/UDPipe/ProcessingError.cs b/UDPipe/v1/binary/linux32/csharp/Ufal/UDPipe/ProcessingError.cs new file mode 100644 index 0000000000000000000000000000000000000000..f68346cd50e55daf567824eb3cc778db1b253389 --- /dev/null +++ b/UDPipe/v1/binary/linux32/csharp/Ufal/UDPipe/ProcessingError.cs @@ -0,0 +1,65 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +public class ProcessingError : global::System.IDisposable { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal ProcessingError(global::System.IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(ProcessingError obj) { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + ~ProcessingError() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != global::System.IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + udpipe_csharpPINVOKE.delete_ProcessingError(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + global::System.GC.SuppressFinalize(this); + } + } + + public bool occurred() { + bool ret = udpipe_csharpPINVOKE.ProcessingError_occurred(swigCPtr); + return ret; + } + + public string message { + set { + udpipe_csharpPINVOKE.ProcessingError_message_set(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + get { + string ret = udpipe_csharpPINVOKE.ProcessingError_message_get(swigCPtr); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + } + + public ProcessingError() : this(udpipe_csharpPINVOKE.new_ProcessingError(), true) { + } + +} + +} diff --git a/UDPipe/v1/binary/linux32/csharp/Ufal/UDPipe/Sentence.cs b/UDPipe/v1/binary/linux32/csharp/Ufal/UDPipe/Sentence.cs new file mode 100644 index 0000000000000000000000000000000000000000..9efe884c1a7face6b7f8875411b08f95a8740c6b --- /dev/null +++ b/UDPipe/v1/binary/linux32/csharp/Ufal/UDPipe/Sentence.cs @@ -0,0 +1,180 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +public class Sentence : global::System.IDisposable { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal Sentence(global::System.IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Sentence obj) { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + ~Sentence() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != global::System.IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + udpipe_csharpPINVOKE.delete_Sentence(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + global::System.GC.SuppressFinalize(this); + } + } + + public Sentence() : this(udpipe_csharpPINVOKE.new_Sentence(), true) { + } + + public Words words { + set { + udpipe_csharpPINVOKE.Sentence_words_set(swigCPtr, Words.getCPtr(value)); + } + get { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.Sentence_words_get(swigCPtr); + Words ret = (cPtr == global::System.IntPtr.Zero) ? null : new Words(cPtr, false); + return ret; + } + } + + public MultiwordTokens multiwordTokens { + set { + udpipe_csharpPINVOKE.Sentence_multiwordTokens_set(swigCPtr, MultiwordTokens.getCPtr(value)); + } + get { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.Sentence_multiwordTokens_get(swigCPtr); + MultiwordTokens ret = (cPtr == global::System.IntPtr.Zero) ? null : new MultiwordTokens(cPtr, false); + return ret; + } + } + + public EmptyNodes emptyNodes { + set { + udpipe_csharpPINVOKE.Sentence_emptyNodes_set(swigCPtr, EmptyNodes.getCPtr(value)); + } + get { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.Sentence_emptyNodes_get(swigCPtr); + EmptyNodes ret = (cPtr == global::System.IntPtr.Zero) ? null : new EmptyNodes(cPtr, false); + return ret; + } + } + + public Comments comments { + set { + udpipe_csharpPINVOKE.Sentence_comments_set(swigCPtr, Comments.getCPtr(value)); + } + get { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.Sentence_comments_get(swigCPtr); + Comments ret = (cPtr == global::System.IntPtr.Zero) ? null : new Comments(cPtr, false); + return ret; + } + } + + public static string rootForm { + get { + string ret = udpipe_csharpPINVOKE.Sentence_rootForm_get(); + return ret; + } + } + + public bool empty() { + bool ret = udpipe_csharpPINVOKE.Sentence_empty(swigCPtr); + return ret; + } + + public void clear() { + udpipe_csharpPINVOKE.Sentence_clear(swigCPtr); + } + + public virtual Word addWord(string form) { + Word ret = new Word(udpipe_csharpPINVOKE.Sentence_addWord(swigCPtr, form), false); + return ret; + } + + public void setHead(int id, int head, string deprel) { + udpipe_csharpPINVOKE.Sentence_setHead(swigCPtr, id, head, deprel); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void unlinkAllNodes() { + udpipe_csharpPINVOKE.Sentence_unlinkAllNodes(swigCPtr); + } + + public bool getNewDoc() { + bool ret = udpipe_csharpPINVOKE.Sentence_getNewDoc(swigCPtr); + return ret; + } + + public string getNewDocId() { + string ret = udpipe_csharpPINVOKE.Sentence_getNewDocId(swigCPtr); + return ret; + } + + public void setNewDoc(bool new_doc, string id) { + udpipe_csharpPINVOKE.Sentence_setNewDoc__SWIG_0(swigCPtr, new_doc, id); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void setNewDoc(bool new_doc) { + udpipe_csharpPINVOKE.Sentence_setNewDoc__SWIG_1(swigCPtr, new_doc); + } + + public bool getNewPar() { + bool ret = udpipe_csharpPINVOKE.Sentence_getNewPar(swigCPtr); + return ret; + } + + public string getNewParId() { + string ret = udpipe_csharpPINVOKE.Sentence_getNewParId(swigCPtr); + return ret; + } + + public void setNewPar(bool new_par, string id) { + udpipe_csharpPINVOKE.Sentence_setNewPar__SWIG_0(swigCPtr, new_par, id); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void setNewPar(bool new_par) { + udpipe_csharpPINVOKE.Sentence_setNewPar__SWIG_1(swigCPtr, new_par); + } + + public string getSentId() { + string ret = udpipe_csharpPINVOKE.Sentence_getSentId(swigCPtr); + return ret; + } + + public void setSentId(string id) { + udpipe_csharpPINVOKE.Sentence_setSentId(swigCPtr, id); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public string getText() { + string ret = udpipe_csharpPINVOKE.Sentence_getText(swigCPtr); + return ret; + } + + public void setText(string id) { + udpipe_csharpPINVOKE.Sentence_setText(swigCPtr, id); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + +} + +} diff --git a/UDPipe/v1/binary/linux32/csharp/Ufal/UDPipe/Sentences.cs b/UDPipe/v1/binary/linux32/csharp/Ufal/UDPipe/Sentences.cs new file mode 100644 index 0000000000000000000000000000000000000000..4247f211a86a8e8c0e5af30d72613005a3bf4d15 --- /dev/null +++ b/UDPipe/v1/binary/linux32/csharp/Ufal/UDPipe/Sentences.cs @@ -0,0 +1,309 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +public class Sentences : global::System.IDisposable, global::System.Collections.IEnumerable + , global::System.Collections.Generic.IEnumerable + { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal Sentences(global::System.IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Sentences obj) { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + ~Sentences() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != global::System.IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + udpipe_csharpPINVOKE.delete_Sentences(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + global::System.GC.SuppressFinalize(this); + } + } + + public Sentences(global::System.Collections.ICollection c) : this() { + if (c == null) + throw new global::System.ArgumentNullException("c"); + foreach (Sentence element in c) { + this.Add(element); + } + } + + public bool IsFixedSize { + get { + return false; + } + } + + public bool IsReadOnly { + get { + return false; + } + } + + public Sentence this[int index] { + get { + return getitem(index); + } + set { + setitem(index, value); + } + } + + public int Capacity { + get { + return (int)capacity(); + } + set { + if (value < size()) + throw new global::System.ArgumentOutOfRangeException("Capacity"); + reserve((uint)value); + } + } + + public int Count { + get { + return (int)size(); + } + } + + public bool IsSynchronized { + get { + return false; + } + } + + public void CopyTo(Sentence[] array) + { + CopyTo(0, array, 0, this.Count); + } + + public void CopyTo(Sentence[] array, int arrayIndex) + { + CopyTo(0, array, arrayIndex, this.Count); + } + + public void CopyTo(int index, Sentence[] array, int arrayIndex, int count) + { + if (array == null) + throw new global::System.ArgumentNullException("array"); + if (index < 0) + throw new global::System.ArgumentOutOfRangeException("index", "Value is less than zero"); + if (arrayIndex < 0) + throw new global::System.ArgumentOutOfRangeException("arrayIndex", "Value is less than zero"); + if (count < 0) + throw new global::System.ArgumentOutOfRangeException("count", "Value is less than zero"); + if (array.Rank > 1) + throw new global::System.ArgumentException("Multi dimensional array.", "array"); + if (index+count > this.Count || arrayIndex+count > array.Length) + throw new global::System.ArgumentException("Number of elements to copy is too large."); + for (int i=0; i global::System.Collections.Generic.IEnumerable.GetEnumerator() { + return new SentencesEnumerator(this); + } + + global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator() { + return new SentencesEnumerator(this); + } + + public SentencesEnumerator GetEnumerator() { + return new SentencesEnumerator(this); + } + + // Type-safe enumerator + /// Note that the IEnumerator documentation requires an InvalidOperationException to be thrown + /// whenever the collection is modified. This has been done for changes in the size of the + /// collection but not when one of the elements of the collection is modified as it is a bit + /// tricky to detect unmanaged code that modifies the collection under our feet. + public sealed class SentencesEnumerator : global::System.Collections.IEnumerator + , global::System.Collections.Generic.IEnumerator + { + private Sentences collectionRef; + private int currentIndex; + private object currentObject; + private int currentSize; + + public SentencesEnumerator(Sentences collection) { + collectionRef = collection; + currentIndex = -1; + currentObject = null; + currentSize = collectionRef.Count; + } + + // Type-safe iterator Current + public Sentence Current { + get { + if (currentIndex == -1) + throw new global::System.InvalidOperationException("Enumeration not started."); + if (currentIndex > currentSize - 1) + throw new global::System.InvalidOperationException("Enumeration finished."); + if (currentObject == null) + throw new global::System.InvalidOperationException("Collection modified."); + return (Sentence)currentObject; + } + } + + // Type-unsafe IEnumerator.Current + object global::System.Collections.IEnumerator.Current { + get { + return Current; + } + } + + public bool MoveNext() { + int size = collectionRef.Count; + bool moveOkay = (currentIndex+1 < size) && (size == currentSize); + if (moveOkay) { + currentIndex++; + currentObject = collectionRef[currentIndex]; + } else { + currentObject = null; + } + return moveOkay; + } + + public void Reset() { + currentIndex = -1; + currentObject = null; + if (collectionRef.Count != currentSize) { + throw new global::System.InvalidOperationException("Collection modified."); + } + } + + public void Dispose() { + currentIndex = -1; + currentObject = null; + } + } + + public void Clear() { + udpipe_csharpPINVOKE.Sentences_Clear(swigCPtr); + } + + public void Add(Sentence x) { + udpipe_csharpPINVOKE.Sentences_Add(swigCPtr, Sentence.getCPtr(x)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + private uint size() { + uint ret = udpipe_csharpPINVOKE.Sentences_size(swigCPtr); + return ret; + } + + private uint capacity() { + uint ret = udpipe_csharpPINVOKE.Sentences_capacity(swigCPtr); + return ret; + } + + private void reserve(uint n) { + udpipe_csharpPINVOKE.Sentences_reserve(swigCPtr, n); + } + + public Sentences() : this(udpipe_csharpPINVOKE.new_Sentences__SWIG_0(), true) { + } + + public Sentences(Sentences other) : this(udpipe_csharpPINVOKE.new_Sentences__SWIG_1(Sentences.getCPtr(other)), true) { + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public Sentences(int capacity) : this(udpipe_csharpPINVOKE.new_Sentences__SWIG_2(capacity), true) { + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + private Sentence getitemcopy(int index) { + Sentence ret = new Sentence(udpipe_csharpPINVOKE.Sentences_getitemcopy(swigCPtr, index), true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + private Sentence getitem(int index) { + Sentence ret = new Sentence(udpipe_csharpPINVOKE.Sentences_getitem(swigCPtr, index), false); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + private void setitem(int index, Sentence val) { + udpipe_csharpPINVOKE.Sentences_setitem(swigCPtr, index, Sentence.getCPtr(val)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void AddRange(Sentences values) { + udpipe_csharpPINVOKE.Sentences_AddRange(swigCPtr, Sentences.getCPtr(values)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public Sentences GetRange(int index, int count) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.Sentences_GetRange(swigCPtr, index, count); + Sentences ret = (cPtr == global::System.IntPtr.Zero) ? null : new Sentences(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public void Insert(int index, Sentence x) { + udpipe_csharpPINVOKE.Sentences_Insert(swigCPtr, index, Sentence.getCPtr(x)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void InsertRange(int index, Sentences values) { + udpipe_csharpPINVOKE.Sentences_InsertRange(swigCPtr, index, Sentences.getCPtr(values)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void RemoveAt(int index) { + udpipe_csharpPINVOKE.Sentences_RemoveAt(swigCPtr, index); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void RemoveRange(int index, int count) { + udpipe_csharpPINVOKE.Sentences_RemoveRange(swigCPtr, index, count); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public static Sentences Repeat(Sentence value, int count) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.Sentences_Repeat(Sentence.getCPtr(value), count); + Sentences ret = (cPtr == global::System.IntPtr.Zero) ? null : new Sentences(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public void Reverse() { + udpipe_csharpPINVOKE.Sentences_Reverse__SWIG_0(swigCPtr); + } + + public void Reverse(int index, int count) { + udpipe_csharpPINVOKE.Sentences_Reverse__SWIG_1(swigCPtr, index, count); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void SetRange(int index, Sentences values) { + udpipe_csharpPINVOKE.Sentences_SetRange(swigCPtr, index, Sentences.getCPtr(values)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + +} + +} diff --git a/UDPipe/v1/binary/linux32/csharp/Ufal/UDPipe/Token.cs b/UDPipe/v1/binary/linux32/csharp/Ufal/UDPipe/Token.cs new file mode 100644 index 0000000000000000000000000000000000000000..bdeb83f9f005909bf47142481a85c7f537d63eab --- /dev/null +++ b/UDPipe/v1/binary/linux32/csharp/Ufal/UDPipe/Token.cs @@ -0,0 +1,138 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +public class Token : global::System.IDisposable { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal Token(global::System.IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Token obj) { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + ~Token() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != global::System.IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + udpipe_csharpPINVOKE.delete_Token(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + global::System.GC.SuppressFinalize(this); + } + } + + public string form { + set { + udpipe_csharpPINVOKE.Token_form_set(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + get { + string ret = udpipe_csharpPINVOKE.Token_form_get(swigCPtr); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + } + + public string misc { + set { + udpipe_csharpPINVOKE.Token_misc_set(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + get { + string ret = udpipe_csharpPINVOKE.Token_misc_get(swigCPtr); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + } + + public Token(string form, string misc) : this(udpipe_csharpPINVOKE.new_Token__SWIG_0(form, misc), true) { + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public Token(string form) : this(udpipe_csharpPINVOKE.new_Token__SWIG_1(form), true) { + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public Token() : this(udpipe_csharpPINVOKE.new_Token__SWIG_2(), true) { + } + + public bool getSpaceAfter() { + bool ret = udpipe_csharpPINVOKE.Token_getSpaceAfter(swigCPtr); + return ret; + } + + public void setSpaceAfter(bool space_after) { + udpipe_csharpPINVOKE.Token_setSpaceAfter(swigCPtr, space_after); + } + + public string getSpacesBefore() { + string ret = udpipe_csharpPINVOKE.Token_getSpacesBefore(swigCPtr); + return ret; + } + + public void setSpacesBefore(string spaces_before) { + udpipe_csharpPINVOKE.Token_setSpacesBefore(swigCPtr, spaces_before); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public string getSpacesAfter() { + string ret = udpipe_csharpPINVOKE.Token_getSpacesAfter(swigCPtr); + return ret; + } + + public void setSpacesAfter(string spaces_after) { + udpipe_csharpPINVOKE.Token_setSpacesAfter(swigCPtr, spaces_after); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public string getSpacesInToken() { + string ret = udpipe_csharpPINVOKE.Token_getSpacesInToken(swigCPtr); + return ret; + } + + public void setSpacesInToken(string spaces_in_token) { + udpipe_csharpPINVOKE.Token_setSpacesInToken(swigCPtr, spaces_in_token); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public bool getTokenRange() { + bool ret = udpipe_csharpPINVOKE.Token_getTokenRange(swigCPtr); + return ret; + } + + public uint getTokenRangeStart() { + uint ret = udpipe_csharpPINVOKE.Token_getTokenRangeStart(swigCPtr); + return ret; + } + + public uint getTokenRangeEnd() { + uint ret = udpipe_csharpPINVOKE.Token_getTokenRangeEnd(swigCPtr); + return ret; + } + + public void setTokenRange(uint start, uint end) { + udpipe_csharpPINVOKE.Token_setTokenRange(swigCPtr, start, end); + } + +} + +} diff --git a/UDPipe/v1/binary/linux32/csharp/Ufal/UDPipe/Trainer.cs b/UDPipe/v1/binary/linux32/csharp/Ufal/UDPipe/Trainer.cs new file mode 100644 index 0000000000000000000000000000000000000000..31dcaada1065b721d6e5c757087b3f7f20423273 --- /dev/null +++ b/UDPipe/v1/binary/linux32/csharp/Ufal/UDPipe/Trainer.cs @@ -0,0 +1,74 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +public class Trainer : global::System.IDisposable { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal Trainer(global::System.IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Trainer obj) { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + ~Trainer() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != global::System.IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + udpipe_csharpPINVOKE.delete_Trainer(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + global::System.GC.SuppressFinalize(this); + } + } + + public static string train(string method, Sentences train, Sentences heldout, string tokenizer, string tagger, string parser, ProcessingError error) { + string ret = udpipe_csharpPINVOKE.Trainer_train__SWIG_0(method, Sentences.getCPtr(train), Sentences.getCPtr(heldout), tokenizer, tagger, parser, ProcessingError.getCPtr(error)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public static string train(string method, Sentences train, Sentences heldout, string tokenizer, string tagger, string parser) { + string ret = udpipe_csharpPINVOKE.Trainer_train__SWIG_1(method, Sentences.getCPtr(train), Sentences.getCPtr(heldout), tokenizer, tagger, parser); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public static string DEFAULT { + get { + string ret = udpipe_csharpPINVOKE.Trainer_DEFAULT_get(); + return ret; + } + } + + public static string NONE { + get { + string ret = udpipe_csharpPINVOKE.Trainer_NONE_get(); + return ret; + } + } + + public Trainer() : this(udpipe_csharpPINVOKE.new_Trainer(), true) { + } + +} + +} diff --git a/UDPipe/v1/binary/linux32/csharp/Ufal/UDPipe/Version.cs b/UDPipe/v1/binary/linux32/csharp/Ufal/UDPipe/Version.cs new file mode 100644 index 0000000000000000000000000000000000000000..39434dd0ed3e5d35f59618ef7b418a5f4fcc4e21 --- /dev/null +++ b/UDPipe/v1/binary/linux32/csharp/Ufal/UDPipe/Version.cs @@ -0,0 +1,95 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +public class Version : global::System.IDisposable { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal Version(global::System.IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Version obj) { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + ~Version() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != global::System.IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + udpipe_csharpPINVOKE.delete_Version(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + global::System.GC.SuppressFinalize(this); + } + } + + public uint major { + set { + udpipe_csharpPINVOKE.Version_major_set(swigCPtr, value); + } + get { + uint ret = udpipe_csharpPINVOKE.Version_major_get(swigCPtr); + return ret; + } + } + + public uint minor { + set { + udpipe_csharpPINVOKE.Version_minor_set(swigCPtr, value); + } + get { + uint ret = udpipe_csharpPINVOKE.Version_minor_get(swigCPtr); + return ret; + } + } + + public uint patch { + set { + udpipe_csharpPINVOKE.Version_patch_set(swigCPtr, value); + } + get { + uint ret = udpipe_csharpPINVOKE.Version_patch_get(swigCPtr); + return ret; + } + } + + public string prerelease { + set { + udpipe_csharpPINVOKE.Version_prerelease_set(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + get { + string ret = udpipe_csharpPINVOKE.Version_prerelease_get(swigCPtr); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + } + + public static Version current() { + Version ret = new Version(udpipe_csharpPINVOKE.Version_current(), true); + return ret; + } + + public Version() : this(udpipe_csharpPINVOKE.new_Version(), true) { + } + +} + +} diff --git a/UDPipe/v1/binary/linux32/csharp/Ufal/UDPipe/Word.cs b/UDPipe/v1/binary/linux32/csharp/Ufal/UDPipe/Word.cs new file mode 100644 index 0000000000000000000000000000000000000000..e0177d90469e6240406b14abcc1e06cb56536de2 --- /dev/null +++ b/UDPipe/v1/binary/linux32/csharp/Ufal/UDPipe/Word.cs @@ -0,0 +1,157 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +public class Word : Token { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + + internal Word(global::System.IntPtr cPtr, bool cMemoryOwn) : base(udpipe_csharpPINVOKE.Word_SWIGUpcast(cPtr), cMemoryOwn) { + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Word obj) { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + ~Word() { + Dispose(); + } + + public override void Dispose() { + lock(this) { + if (swigCPtr.Handle != global::System.IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + udpipe_csharpPINVOKE.delete_Word(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + global::System.GC.SuppressFinalize(this); + base.Dispose(); + } + } + + public int id { + set { + udpipe_csharpPINVOKE.Word_id_set(swigCPtr, value); + } + get { + int ret = udpipe_csharpPINVOKE.Word_id_get(swigCPtr); + return ret; + } + } + + public string lemma { + set { + udpipe_csharpPINVOKE.Word_lemma_set(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + get { + string ret = udpipe_csharpPINVOKE.Word_lemma_get(swigCPtr); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + } + + public string upostag { + set { + udpipe_csharpPINVOKE.Word_upostag_set(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + get { + string ret = udpipe_csharpPINVOKE.Word_upostag_get(swigCPtr); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + } + + public string xpostag { + set { + udpipe_csharpPINVOKE.Word_xpostag_set(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + get { + string ret = udpipe_csharpPINVOKE.Word_xpostag_get(swigCPtr); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + } + + public string feats { + set { + udpipe_csharpPINVOKE.Word_feats_set(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + get { + string ret = udpipe_csharpPINVOKE.Word_feats_get(swigCPtr); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + } + + public int head { + set { + udpipe_csharpPINVOKE.Word_head_set(swigCPtr, value); + } + get { + int ret = udpipe_csharpPINVOKE.Word_head_get(swigCPtr); + return ret; + } + } + + public string deprel { + set { + udpipe_csharpPINVOKE.Word_deprel_set(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + get { + string ret = udpipe_csharpPINVOKE.Word_deprel_get(swigCPtr); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + } + + public string deps { + set { + udpipe_csharpPINVOKE.Word_deps_set(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + get { + string ret = udpipe_csharpPINVOKE.Word_deps_get(swigCPtr); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + } + + public Children children { + set { + udpipe_csharpPINVOKE.Word_children_set(swigCPtr, Children.getCPtr(value)); + } + get { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.Word_children_get(swigCPtr); + Children ret = (cPtr == global::System.IntPtr.Zero) ? null : new Children(cPtr, false); + return ret; + } + } + + public Word(int id, string form) : this(udpipe_csharpPINVOKE.new_Word__SWIG_0(id, form), true) { + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public Word(int id) : this(udpipe_csharpPINVOKE.new_Word__SWIG_1(id), true) { + } + + public Word() : this(udpipe_csharpPINVOKE.new_Word__SWIG_2(), true) { + } + +} + +} diff --git a/UDPipe/v1/binary/linux32/csharp/Ufal/UDPipe/Words.cs b/UDPipe/v1/binary/linux32/csharp/Ufal/UDPipe/Words.cs new file mode 100644 index 0000000000000000000000000000000000000000..01c91c83ca10a20e497356a75fcb6a266e423360 --- /dev/null +++ b/UDPipe/v1/binary/linux32/csharp/Ufal/UDPipe/Words.cs @@ -0,0 +1,309 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +public class Words : global::System.IDisposable, global::System.Collections.IEnumerable + , global::System.Collections.Generic.IEnumerable + { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal Words(global::System.IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Words obj) { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + ~Words() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != global::System.IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + udpipe_csharpPINVOKE.delete_Words(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + global::System.GC.SuppressFinalize(this); + } + } + + public Words(global::System.Collections.ICollection c) : this() { + if (c == null) + throw new global::System.ArgumentNullException("c"); + foreach (Word element in c) { + this.Add(element); + } + } + + public bool IsFixedSize { + get { + return false; + } + } + + public bool IsReadOnly { + get { + return false; + } + } + + public Word this[int index] { + get { + return getitem(index); + } + set { + setitem(index, value); + } + } + + public int Capacity { + get { + return (int)capacity(); + } + set { + if (value < size()) + throw new global::System.ArgumentOutOfRangeException("Capacity"); + reserve((uint)value); + } + } + + public int Count { + get { + return (int)size(); + } + } + + public bool IsSynchronized { + get { + return false; + } + } + + public void CopyTo(Word[] array) + { + CopyTo(0, array, 0, this.Count); + } + + public void CopyTo(Word[] array, int arrayIndex) + { + CopyTo(0, array, arrayIndex, this.Count); + } + + public void CopyTo(int index, Word[] array, int arrayIndex, int count) + { + if (array == null) + throw new global::System.ArgumentNullException("array"); + if (index < 0) + throw new global::System.ArgumentOutOfRangeException("index", "Value is less than zero"); + if (arrayIndex < 0) + throw new global::System.ArgumentOutOfRangeException("arrayIndex", "Value is less than zero"); + if (count < 0) + throw new global::System.ArgumentOutOfRangeException("count", "Value is less than zero"); + if (array.Rank > 1) + throw new global::System.ArgumentException("Multi dimensional array.", "array"); + if (index+count > this.Count || arrayIndex+count > array.Length) + throw new global::System.ArgumentException("Number of elements to copy is too large."); + for (int i=0; i global::System.Collections.Generic.IEnumerable.GetEnumerator() { + return new WordsEnumerator(this); + } + + global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator() { + return new WordsEnumerator(this); + } + + public WordsEnumerator GetEnumerator() { + return new WordsEnumerator(this); + } + + // Type-safe enumerator + /// Note that the IEnumerator documentation requires an InvalidOperationException to be thrown + /// whenever the collection is modified. This has been done for changes in the size of the + /// collection but not when one of the elements of the collection is modified as it is a bit + /// tricky to detect unmanaged code that modifies the collection under our feet. + public sealed class WordsEnumerator : global::System.Collections.IEnumerator + , global::System.Collections.Generic.IEnumerator + { + private Words collectionRef; + private int currentIndex; + private object currentObject; + private int currentSize; + + public WordsEnumerator(Words collection) { + collectionRef = collection; + currentIndex = -1; + currentObject = null; + currentSize = collectionRef.Count; + } + + // Type-safe iterator Current + public Word Current { + get { + if (currentIndex == -1) + throw new global::System.InvalidOperationException("Enumeration not started."); + if (currentIndex > currentSize - 1) + throw new global::System.InvalidOperationException("Enumeration finished."); + if (currentObject == null) + throw new global::System.InvalidOperationException("Collection modified."); + return (Word)currentObject; + } + } + + // Type-unsafe IEnumerator.Current + object global::System.Collections.IEnumerator.Current { + get { + return Current; + } + } + + public bool MoveNext() { + int size = collectionRef.Count; + bool moveOkay = (currentIndex+1 < size) && (size == currentSize); + if (moveOkay) { + currentIndex++; + currentObject = collectionRef[currentIndex]; + } else { + currentObject = null; + } + return moveOkay; + } + + public void Reset() { + currentIndex = -1; + currentObject = null; + if (collectionRef.Count != currentSize) { + throw new global::System.InvalidOperationException("Collection modified."); + } + } + + public void Dispose() { + currentIndex = -1; + currentObject = null; + } + } + + public void Clear() { + udpipe_csharpPINVOKE.Words_Clear(swigCPtr); + } + + public void Add(Word x) { + udpipe_csharpPINVOKE.Words_Add(swigCPtr, Word.getCPtr(x)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + private uint size() { + uint ret = udpipe_csharpPINVOKE.Words_size(swigCPtr); + return ret; + } + + private uint capacity() { + uint ret = udpipe_csharpPINVOKE.Words_capacity(swigCPtr); + return ret; + } + + private void reserve(uint n) { + udpipe_csharpPINVOKE.Words_reserve(swigCPtr, n); + } + + public Words() : this(udpipe_csharpPINVOKE.new_Words__SWIG_0(), true) { + } + + public Words(Words other) : this(udpipe_csharpPINVOKE.new_Words__SWIG_1(Words.getCPtr(other)), true) { + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public Words(int capacity) : this(udpipe_csharpPINVOKE.new_Words__SWIG_2(capacity), true) { + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + private Word getitemcopy(int index) { + Word ret = new Word(udpipe_csharpPINVOKE.Words_getitemcopy(swigCPtr, index), true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + private Word getitem(int index) { + Word ret = new Word(udpipe_csharpPINVOKE.Words_getitem(swigCPtr, index), false); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + private void setitem(int index, Word val) { + udpipe_csharpPINVOKE.Words_setitem(swigCPtr, index, Word.getCPtr(val)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void AddRange(Words values) { + udpipe_csharpPINVOKE.Words_AddRange(swigCPtr, Words.getCPtr(values)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public Words GetRange(int index, int count) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.Words_GetRange(swigCPtr, index, count); + Words ret = (cPtr == global::System.IntPtr.Zero) ? null : new Words(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public void Insert(int index, Word x) { + udpipe_csharpPINVOKE.Words_Insert(swigCPtr, index, Word.getCPtr(x)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void InsertRange(int index, Words values) { + udpipe_csharpPINVOKE.Words_InsertRange(swigCPtr, index, Words.getCPtr(values)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void RemoveAt(int index) { + udpipe_csharpPINVOKE.Words_RemoveAt(swigCPtr, index); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void RemoveRange(int index, int count) { + udpipe_csharpPINVOKE.Words_RemoveRange(swigCPtr, index, count); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public static Words Repeat(Word value, int count) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.Words_Repeat(Word.getCPtr(value), count); + Words ret = (cPtr == global::System.IntPtr.Zero) ? null : new Words(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public void Reverse() { + udpipe_csharpPINVOKE.Words_Reverse__SWIG_0(swigCPtr); + } + + public void Reverse(int index, int count) { + udpipe_csharpPINVOKE.Words_Reverse__SWIG_1(swigCPtr, index, count); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void SetRange(int index, Words values) { + udpipe_csharpPINVOKE.Words_SetRange(swigCPtr, index, Words.getCPtr(values)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + +} + +} diff --git a/UDPipe/v1/binary/linux32/csharp/Ufal/UDPipe/udpipe_csharp.cs b/UDPipe/v1/binary/linux32/csharp/Ufal/UDPipe/udpipe_csharp.cs new file mode 100644 index 0000000000000000000000000000000000000000..01d55de404b051d95e99a2ed6741fcdc0cefa6f7 --- /dev/null +++ b/UDPipe/v1/binary/linux32/csharp/Ufal/UDPipe/udpipe_csharp.cs @@ -0,0 +1,16 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +public class udpipe_csharp { +} + +} diff --git a/UDPipe/v1/binary/linux32/csharp/Ufal/UDPipe/udpipe_csharpPINVOKE.cs b/UDPipe/v1/binary/linux32/csharp/Ufal/UDPipe/udpipe_csharpPINVOKE.cs new file mode 100644 index 0000000000000000000000000000000000000000..08fb1041bc999961dae5278a4ac3e5df51b672ea --- /dev/null +++ b/UDPipe/v1/binary/linux32/csharp/Ufal/UDPipe/udpipe_csharpPINVOKE.cs @@ -0,0 +1,1324 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +class udpipe_csharpPINVOKE { + + protected class SWIGExceptionHelper { + + public delegate void ExceptionDelegate(string message); + public delegate void ExceptionArgumentDelegate(string message, string paramName); + + static ExceptionDelegate applicationDelegate = new ExceptionDelegate(SetPendingApplicationException); + static ExceptionDelegate arithmeticDelegate = new ExceptionDelegate(SetPendingArithmeticException); + static ExceptionDelegate divideByZeroDelegate = new ExceptionDelegate(SetPendingDivideByZeroException); + static ExceptionDelegate indexOutOfRangeDelegate = new ExceptionDelegate(SetPendingIndexOutOfRangeException); + static ExceptionDelegate invalidCastDelegate = new ExceptionDelegate(SetPendingInvalidCastException); + static ExceptionDelegate invalidOperationDelegate = new ExceptionDelegate(SetPendingInvalidOperationException); + static ExceptionDelegate ioDelegate = new ExceptionDelegate(SetPendingIOException); + static ExceptionDelegate nullReferenceDelegate = new ExceptionDelegate(SetPendingNullReferenceException); + static ExceptionDelegate outOfMemoryDelegate = new ExceptionDelegate(SetPendingOutOfMemoryException); + static ExceptionDelegate overflowDelegate = new ExceptionDelegate(SetPendingOverflowException); + static ExceptionDelegate systemDelegate = new ExceptionDelegate(SetPendingSystemException); + + static ExceptionArgumentDelegate argumentDelegate = new ExceptionArgumentDelegate(SetPendingArgumentException); + static ExceptionArgumentDelegate argumentNullDelegate = new ExceptionArgumentDelegate(SetPendingArgumentNullException); + static ExceptionArgumentDelegate argumentOutOfRangeDelegate = new ExceptionArgumentDelegate(SetPendingArgumentOutOfRangeException); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="SWIGRegisterExceptionCallbacks_udpipe_csharp")] + public static extern void SWIGRegisterExceptionCallbacks_udpipe_csharp( + ExceptionDelegate applicationDelegate, + ExceptionDelegate arithmeticDelegate, + ExceptionDelegate divideByZeroDelegate, + ExceptionDelegate indexOutOfRangeDelegate, + ExceptionDelegate invalidCastDelegate, + ExceptionDelegate invalidOperationDelegate, + ExceptionDelegate ioDelegate, + ExceptionDelegate nullReferenceDelegate, + ExceptionDelegate outOfMemoryDelegate, + ExceptionDelegate overflowDelegate, + ExceptionDelegate systemExceptionDelegate); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="SWIGRegisterExceptionArgumentCallbacks_udpipe_csharp")] + public static extern void SWIGRegisterExceptionCallbacksArgument_udpipe_csharp( + ExceptionArgumentDelegate argumentDelegate, + ExceptionArgumentDelegate argumentNullDelegate, + ExceptionArgumentDelegate argumentOutOfRangeDelegate); + + static void SetPendingApplicationException(string message) { + SWIGPendingException.Set(new global::System.ApplicationException(message, SWIGPendingException.Retrieve())); + } + static void SetPendingArithmeticException(string message) { + SWIGPendingException.Set(new global::System.ArithmeticException(message, SWIGPendingException.Retrieve())); + } + static void SetPendingDivideByZeroException(string message) { + SWIGPendingException.Set(new global::System.DivideByZeroException(message, SWIGPendingException.Retrieve())); + } + static void SetPendingIndexOutOfRangeException(string message) { + SWIGPendingException.Set(new global::System.IndexOutOfRangeException(message, SWIGPendingException.Retrieve())); + } + static void SetPendingInvalidCastException(string message) { + SWIGPendingException.Set(new global::System.InvalidCastException(message, SWIGPendingException.Retrieve())); + } + static void SetPendingInvalidOperationException(string message) { + SWIGPendingException.Set(new global::System.InvalidOperationException(message, SWIGPendingException.Retrieve())); + } + static void SetPendingIOException(string message) { + SWIGPendingException.Set(new global::System.IO.IOException(message, SWIGPendingException.Retrieve())); + } + static void SetPendingNullReferenceException(string message) { + SWIGPendingException.Set(new global::System.NullReferenceException(message, SWIGPendingException.Retrieve())); + } + static void SetPendingOutOfMemoryException(string message) { + SWIGPendingException.Set(new global::System.OutOfMemoryException(message, SWIGPendingException.Retrieve())); + } + static void SetPendingOverflowException(string message) { + SWIGPendingException.Set(new global::System.OverflowException(message, SWIGPendingException.Retrieve())); + } + static void SetPendingSystemException(string message) { + SWIGPendingException.Set(new global::System.SystemException(message, SWIGPendingException.Retrieve())); + } + + static void SetPendingArgumentException(string message, string paramName) { + SWIGPendingException.Set(new global::System.ArgumentException(message, paramName, SWIGPendingException.Retrieve())); + } + static void SetPendingArgumentNullException(string message, string paramName) { + global::System.Exception e = SWIGPendingException.Retrieve(); + if (e != null) message = message + " Inner Exception: " + e.Message; + SWIGPendingException.Set(new global::System.ArgumentNullException(paramName, message)); + } + static void SetPendingArgumentOutOfRangeException(string message, string paramName) { + global::System.Exception e = SWIGPendingException.Retrieve(); + if (e != null) message = message + " Inner Exception: " + e.Message; + SWIGPendingException.Set(new global::System.ArgumentOutOfRangeException(paramName, message)); + } + + static SWIGExceptionHelper() { + SWIGRegisterExceptionCallbacks_udpipe_csharp( + applicationDelegate, + arithmeticDelegate, + divideByZeroDelegate, + indexOutOfRangeDelegate, + invalidCastDelegate, + invalidOperationDelegate, + ioDelegate, + nullReferenceDelegate, + outOfMemoryDelegate, + overflowDelegate, + systemDelegate); + + SWIGRegisterExceptionCallbacksArgument_udpipe_csharp( + argumentDelegate, + argumentNullDelegate, + argumentOutOfRangeDelegate); + } + } + + protected static SWIGExceptionHelper swigExceptionHelper = new SWIGExceptionHelper(); + + public class SWIGPendingException { + [global::System.ThreadStatic] + private static global::System.Exception pendingException = null; + private static int numExceptionsPending = 0; + + public static bool Pending { + get { + bool pending = false; + if (numExceptionsPending > 0) + if (pendingException != null) + pending = true; + return pending; + } + } + + public static void Set(global::System.Exception e) { + if (pendingException != null) + throw new global::System.ApplicationException("FATAL: An earlier pending exception from unmanaged code was missed and thus not thrown (" + pendingException.ToString() + ")", e); + pendingException = e; + lock(typeof(udpipe_csharpPINVOKE)) { + numExceptionsPending++; + } + } + + public static global::System.Exception Retrieve() { + global::System.Exception e = null; + if (numExceptionsPending > 0) { + if (pendingException != null) { + e = pendingException; + pendingException = null; + lock(typeof(udpipe_csharpPINVOKE)) { + numExceptionsPending--; + } + } + } + return e; + } + } + + + protected class SWIGStringHelper { + + public delegate string SWIGStringDelegate(string message); + static SWIGStringDelegate stringDelegate = new SWIGStringDelegate(CreateString); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="SWIGRegisterStringCallback_udpipe_csharp")] + public static extern void SWIGRegisterStringCallback_udpipe_csharp(SWIGStringDelegate stringDelegate); + + static string CreateString(string cString) { + return cString; + } + + static SWIGStringHelper() { + SWIGRegisterStringCallback_udpipe_csharp(stringDelegate); + } + } + + static protected SWIGStringHelper swigStringHelper = new SWIGStringHelper(); + + + static udpipe_csharpPINVOKE() { + } + + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_Clear")] + public static extern void Children_Clear(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_Add")] + public static extern void Children_Add(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_size")] + public static extern uint Children_size(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_capacity")] + public static extern uint Children_capacity(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_reserve")] + public static extern void Children_reserve(global::System.Runtime.InteropServices.HandleRef jarg1, uint jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Children__SWIG_0")] + public static extern global::System.IntPtr new_Children__SWIG_0(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Children__SWIG_1")] + public static extern global::System.IntPtr new_Children__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Children__SWIG_2")] + public static extern global::System.IntPtr new_Children__SWIG_2(int jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_getitemcopy")] + public static extern int Children_getitemcopy(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_getitem")] + public static extern int Children_getitem(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_setitem")] + public static extern void Children_setitem(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_AddRange")] + public static extern void Children_AddRange(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_GetRange")] + public static extern global::System.IntPtr Children_GetRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_Insert")] + public static extern void Children_Insert(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_InsertRange")] + public static extern void Children_InsertRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_RemoveAt")] + public static extern void Children_RemoveAt(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_RemoveRange")] + public static extern void Children_RemoveRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_Repeat")] + public static extern global::System.IntPtr Children_Repeat(int jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_Reverse__SWIG_0")] + public static extern void Children_Reverse__SWIG_0(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_Reverse__SWIG_1")] + public static extern void Children_Reverse__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_SetRange")] + public static extern void Children_SetRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_Contains")] + public static extern bool Children_Contains(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_IndexOf")] + public static extern int Children_IndexOf(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_LastIndexOf")] + public static extern int Children_LastIndexOf(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_Remove")] + public static extern bool Children_Remove(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_delete_Children")] + public static extern void delete_Children(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_Clear")] + public static extern void Comments_Clear(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_Add")] + public static extern void Comments_Add(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_size")] + public static extern uint Comments_size(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_capacity")] + public static extern uint Comments_capacity(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_reserve")] + public static extern void Comments_reserve(global::System.Runtime.InteropServices.HandleRef jarg1, uint jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Comments__SWIG_0")] + public static extern global::System.IntPtr new_Comments__SWIG_0(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Comments__SWIG_1")] + public static extern global::System.IntPtr new_Comments__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Comments__SWIG_2")] + public static extern global::System.IntPtr new_Comments__SWIG_2(int jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_getitemcopy")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Comments_getitemcopy(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_getitem")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Comments_getitem(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_setitem")] + public static extern void Comments_setitem(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_AddRange")] + public static extern void Comments_AddRange(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_GetRange")] + public static extern global::System.IntPtr Comments_GetRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_Insert")] + public static extern void Comments_Insert(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_InsertRange")] + public static extern void Comments_InsertRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_RemoveAt")] + public static extern void Comments_RemoveAt(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_RemoveRange")] + public static extern void Comments_RemoveRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_Repeat")] + public static extern global::System.IntPtr Comments_Repeat([global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_Reverse__SWIG_0")] + public static extern void Comments_Reverse__SWIG_0(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_Reverse__SWIG_1")] + public static extern void Comments_Reverse__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_SetRange")] + public static extern void Comments_SetRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_Contains")] + public static extern bool Comments_Contains(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_IndexOf")] + public static extern int Comments_IndexOf(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_LastIndexOf")] + public static extern int Comments_LastIndexOf(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_Remove")] + public static extern bool Comments_Remove(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_delete_Comments")] + public static extern void delete_Comments(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_ProcessingError_occurred")] + public static extern bool ProcessingError_occurred(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_ProcessingError_message_set")] + public static extern void ProcessingError_message_set(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_ProcessingError_message_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string ProcessingError_message_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_ProcessingError")] + public static extern global::System.IntPtr new_ProcessingError(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_delete_ProcessingError")] + public static extern void delete_ProcessingError(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Token_form_set")] + public static extern void Token_form_set(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Token_form_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Token_form_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Token_misc_set")] + public static extern void Token_misc_set(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Token_misc_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Token_misc_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Token__SWIG_0")] + public static extern global::System.IntPtr new_Token__SWIG_0([global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Token__SWIG_1")] + public static extern global::System.IntPtr new_Token__SWIG_1([global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Token__SWIG_2")] + public static extern global::System.IntPtr new_Token__SWIG_2(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Token_getSpaceAfter")] + public static extern bool Token_getSpaceAfter(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Token_setSpaceAfter")] + public static extern void Token_setSpaceAfter(global::System.Runtime.InteropServices.HandleRef jarg1, bool jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Token_getSpacesBefore")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Token_getSpacesBefore(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Token_setSpacesBefore")] + public static extern void Token_setSpacesBefore(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Token_getSpacesAfter")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Token_getSpacesAfter(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Token_setSpacesAfter")] + public static extern void Token_setSpacesAfter(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Token_getSpacesInToken")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Token_getSpacesInToken(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Token_setSpacesInToken")] + public static extern void Token_setSpacesInToken(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Token_getTokenRange")] + public static extern bool Token_getTokenRange(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Token_getTokenRangeStart")] + public static extern uint Token_getTokenRangeStart(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Token_getTokenRangeEnd")] + public static extern uint Token_getTokenRangeEnd(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Token_setTokenRange")] + public static extern void Token_setTokenRange(global::System.Runtime.InteropServices.HandleRef jarg1, uint jarg2, uint jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_delete_Token")] + public static extern void delete_Token(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Word_id_set")] + public static extern void Word_id_set(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Word_id_get")] + public static extern int Word_id_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Word_lemma_set")] + public static extern void Word_lemma_set(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Word_lemma_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Word_lemma_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Word_upostag_set")] + public static extern void Word_upostag_set(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Word_upostag_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Word_upostag_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Word_xpostag_set")] + public static extern void Word_xpostag_set(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Word_xpostag_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Word_xpostag_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Word_feats_set")] + public static extern void Word_feats_set(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Word_feats_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Word_feats_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Word_head_set")] + public static extern void Word_head_set(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Word_head_get")] + public static extern int Word_head_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Word_deprel_set")] + public static extern void Word_deprel_set(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Word_deprel_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Word_deprel_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Word_deps_set")] + public static extern void Word_deps_set(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Word_deps_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Word_deps_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Word_children_set")] + public static extern void Word_children_set(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Word_children_get")] + public static extern global::System.IntPtr Word_children_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Word__SWIG_0")] + public static extern global::System.IntPtr new_Word__SWIG_0(int jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Word__SWIG_1")] + public static extern global::System.IntPtr new_Word__SWIG_1(int jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Word__SWIG_2")] + public static extern global::System.IntPtr new_Word__SWIG_2(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_delete_Word")] + public static extern void delete_Word(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Words_Clear")] + public static extern void Words_Clear(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Words_Add")] + public static extern void Words_Add(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Words_size")] + public static extern uint Words_size(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Words_capacity")] + public static extern uint Words_capacity(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Words_reserve")] + public static extern void Words_reserve(global::System.Runtime.InteropServices.HandleRef jarg1, uint jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Words__SWIG_0")] + public static extern global::System.IntPtr new_Words__SWIG_0(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Words__SWIG_1")] + public static extern global::System.IntPtr new_Words__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Words__SWIG_2")] + public static extern global::System.IntPtr new_Words__SWIG_2(int jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Words_getitemcopy")] + public static extern global::System.IntPtr Words_getitemcopy(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Words_getitem")] + public static extern global::System.IntPtr Words_getitem(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Words_setitem")] + public static extern void Words_setitem(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Words_AddRange")] + public static extern void Words_AddRange(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Words_GetRange")] + public static extern global::System.IntPtr Words_GetRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Words_Insert")] + public static extern void Words_Insert(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Words_InsertRange")] + public static extern void Words_InsertRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Words_RemoveAt")] + public static extern void Words_RemoveAt(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Words_RemoveRange")] + public static extern void Words_RemoveRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Words_Repeat")] + public static extern global::System.IntPtr Words_Repeat(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Words_Reverse__SWIG_0")] + public static extern void Words_Reverse__SWIG_0(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Words_Reverse__SWIG_1")] + public static extern void Words_Reverse__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Words_SetRange")] + public static extern void Words_SetRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_delete_Words")] + public static extern void delete_Words(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordToken_idFirst_set")] + public static extern void MultiwordToken_idFirst_set(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordToken_idFirst_get")] + public static extern int MultiwordToken_idFirst_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordToken_idLast_set")] + public static extern void MultiwordToken_idLast_set(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordToken_idLast_get")] + public static extern int MultiwordToken_idLast_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_MultiwordToken__SWIG_0")] + public static extern global::System.IntPtr new_MultiwordToken__SWIG_0(int jarg1, int jarg2, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg3, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg4); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_MultiwordToken__SWIG_1")] + public static extern global::System.IntPtr new_MultiwordToken__SWIG_1(int jarg1, int jarg2, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_MultiwordToken__SWIG_2")] + public static extern global::System.IntPtr new_MultiwordToken__SWIG_2(int jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_MultiwordToken__SWIG_3")] + public static extern global::System.IntPtr new_MultiwordToken__SWIG_3(int jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_MultiwordToken__SWIG_4")] + public static extern global::System.IntPtr new_MultiwordToken__SWIG_4(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_delete_MultiwordToken")] + public static extern void delete_MultiwordToken(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordTokens_Clear")] + public static extern void MultiwordTokens_Clear(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordTokens_Add")] + public static extern void MultiwordTokens_Add(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordTokens_size")] + public static extern uint MultiwordTokens_size(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordTokens_capacity")] + public static extern uint MultiwordTokens_capacity(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordTokens_reserve")] + public static extern void MultiwordTokens_reserve(global::System.Runtime.InteropServices.HandleRef jarg1, uint jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_MultiwordTokens__SWIG_0")] + public static extern global::System.IntPtr new_MultiwordTokens__SWIG_0(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_MultiwordTokens__SWIG_1")] + public static extern global::System.IntPtr new_MultiwordTokens__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_MultiwordTokens__SWIG_2")] + public static extern global::System.IntPtr new_MultiwordTokens__SWIG_2(int jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordTokens_getitemcopy")] + public static extern global::System.IntPtr MultiwordTokens_getitemcopy(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordTokens_getitem")] + public static extern global::System.IntPtr MultiwordTokens_getitem(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordTokens_setitem")] + public static extern void MultiwordTokens_setitem(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordTokens_AddRange")] + public static extern void MultiwordTokens_AddRange(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordTokens_GetRange")] + public static extern global::System.IntPtr MultiwordTokens_GetRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordTokens_Insert")] + public static extern void MultiwordTokens_Insert(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordTokens_InsertRange")] + public static extern void MultiwordTokens_InsertRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordTokens_RemoveAt")] + public static extern void MultiwordTokens_RemoveAt(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordTokens_RemoveRange")] + public static extern void MultiwordTokens_RemoveRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordTokens_Repeat")] + public static extern global::System.IntPtr MultiwordTokens_Repeat(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordTokens_Reverse__SWIG_0")] + public static extern void MultiwordTokens_Reverse__SWIG_0(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordTokens_Reverse__SWIG_1")] + public static extern void MultiwordTokens_Reverse__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordTokens_SetRange")] + public static extern void MultiwordTokens_SetRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_delete_MultiwordTokens")] + public static extern void delete_MultiwordTokens(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNode_id_set")] + public static extern void EmptyNode_id_set(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNode_id_get")] + public static extern int EmptyNode_id_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNode_index_set")] + public static extern void EmptyNode_index_set(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNode_index_get")] + public static extern int EmptyNode_index_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNode_form_set")] + public static extern void EmptyNode_form_set(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNode_form_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string EmptyNode_form_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNode_lemma_set")] + public static extern void EmptyNode_lemma_set(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNode_lemma_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string EmptyNode_lemma_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNode_upostag_set")] + public static extern void EmptyNode_upostag_set(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNode_upostag_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string EmptyNode_upostag_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNode_xpostag_set")] + public static extern void EmptyNode_xpostag_set(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNode_xpostag_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string EmptyNode_xpostag_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNode_feats_set")] + public static extern void EmptyNode_feats_set(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNode_feats_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string EmptyNode_feats_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNode_deps_set")] + public static extern void EmptyNode_deps_set(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNode_deps_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string EmptyNode_deps_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNode_misc_set")] + public static extern void EmptyNode_misc_set(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNode_misc_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string EmptyNode_misc_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_EmptyNode__SWIG_0")] + public static extern global::System.IntPtr new_EmptyNode__SWIG_0(int jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_EmptyNode__SWIG_1")] + public static extern global::System.IntPtr new_EmptyNode__SWIG_1(int jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_EmptyNode__SWIG_2")] + public static extern global::System.IntPtr new_EmptyNode__SWIG_2(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_delete_EmptyNode")] + public static extern void delete_EmptyNode(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNodes_Clear")] + public static extern void EmptyNodes_Clear(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNodes_Add")] + public static extern void EmptyNodes_Add(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNodes_size")] + public static extern uint EmptyNodes_size(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNodes_capacity")] + public static extern uint EmptyNodes_capacity(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNodes_reserve")] + public static extern void EmptyNodes_reserve(global::System.Runtime.InteropServices.HandleRef jarg1, uint jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_EmptyNodes__SWIG_0")] + public static extern global::System.IntPtr new_EmptyNodes__SWIG_0(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_EmptyNodes__SWIG_1")] + public static extern global::System.IntPtr new_EmptyNodes__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_EmptyNodes__SWIG_2")] + public static extern global::System.IntPtr new_EmptyNodes__SWIG_2(int jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNodes_getitemcopy")] + public static extern global::System.IntPtr EmptyNodes_getitemcopy(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNodes_getitem")] + public static extern global::System.IntPtr EmptyNodes_getitem(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNodes_setitem")] + public static extern void EmptyNodes_setitem(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNodes_AddRange")] + public static extern void EmptyNodes_AddRange(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNodes_GetRange")] + public static extern global::System.IntPtr EmptyNodes_GetRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNodes_Insert")] + public static extern void EmptyNodes_Insert(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNodes_InsertRange")] + public static extern void EmptyNodes_InsertRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNodes_RemoveAt")] + public static extern void EmptyNodes_RemoveAt(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNodes_RemoveRange")] + public static extern void EmptyNodes_RemoveRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNodes_Repeat")] + public static extern global::System.IntPtr EmptyNodes_Repeat(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNodes_Reverse__SWIG_0")] + public static extern void EmptyNodes_Reverse__SWIG_0(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNodes_Reverse__SWIG_1")] + public static extern void EmptyNodes_Reverse__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNodes_SetRange")] + public static extern void EmptyNodes_SetRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_delete_EmptyNodes")] + public static extern void delete_EmptyNodes(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Sentence")] + public static extern global::System.IntPtr new_Sentence(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_words_set")] + public static extern void Sentence_words_set(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_words_get")] + public static extern global::System.IntPtr Sentence_words_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_multiwordTokens_set")] + public static extern void Sentence_multiwordTokens_set(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_multiwordTokens_get")] + public static extern global::System.IntPtr Sentence_multiwordTokens_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_emptyNodes_set")] + public static extern void Sentence_emptyNodes_set(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_emptyNodes_get")] + public static extern global::System.IntPtr Sentence_emptyNodes_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_comments_set")] + public static extern void Sentence_comments_set(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_comments_get")] + public static extern global::System.IntPtr Sentence_comments_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_rootForm_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Sentence_rootForm_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_empty")] + public static extern bool Sentence_empty(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_clear")] + public static extern void Sentence_clear(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_addWord")] + public static extern global::System.IntPtr Sentence_addWord(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_setHead")] + public static extern void Sentence_setHead(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg4); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_unlinkAllNodes")] + public static extern void Sentence_unlinkAllNodes(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_getNewDoc")] + public static extern bool Sentence_getNewDoc(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_getNewDocId")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Sentence_getNewDocId(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_setNewDoc__SWIG_0")] + public static extern void Sentence_setNewDoc__SWIG_0(global::System.Runtime.InteropServices.HandleRef jarg1, bool jarg2, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_setNewDoc__SWIG_1")] + public static extern void Sentence_setNewDoc__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1, bool jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_getNewPar")] + public static extern bool Sentence_getNewPar(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_getNewParId")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Sentence_getNewParId(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_setNewPar__SWIG_0")] + public static extern void Sentence_setNewPar__SWIG_0(global::System.Runtime.InteropServices.HandleRef jarg1, bool jarg2, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_setNewPar__SWIG_1")] + public static extern void Sentence_setNewPar__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1, bool jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_getSentId")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Sentence_getSentId(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_setSentId")] + public static extern void Sentence_setSentId(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_getText")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Sentence_getText(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_setText")] + public static extern void Sentence_setText(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_delete_Sentence")] + public static extern void delete_Sentence(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentences_Clear")] + public static extern void Sentences_Clear(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentences_Add")] + public static extern void Sentences_Add(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentences_size")] + public static extern uint Sentences_size(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentences_capacity")] + public static extern uint Sentences_capacity(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentences_reserve")] + public static extern void Sentences_reserve(global::System.Runtime.InteropServices.HandleRef jarg1, uint jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Sentences__SWIG_0")] + public static extern global::System.IntPtr new_Sentences__SWIG_0(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Sentences__SWIG_1")] + public static extern global::System.IntPtr new_Sentences__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Sentences__SWIG_2")] + public static extern global::System.IntPtr new_Sentences__SWIG_2(int jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentences_getitemcopy")] + public static extern global::System.IntPtr Sentences_getitemcopy(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentences_getitem")] + public static extern global::System.IntPtr Sentences_getitem(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentences_setitem")] + public static extern void Sentences_setitem(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentences_AddRange")] + public static extern void Sentences_AddRange(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentences_GetRange")] + public static extern global::System.IntPtr Sentences_GetRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentences_Insert")] + public static extern void Sentences_Insert(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentences_InsertRange")] + public static extern void Sentences_InsertRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentences_RemoveAt")] + public static extern void Sentences_RemoveAt(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentences_RemoveRange")] + public static extern void Sentences_RemoveRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentences_Repeat")] + public static extern global::System.IntPtr Sentences_Repeat(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentences_Reverse__SWIG_0")] + public static extern void Sentences_Reverse__SWIG_0(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentences_Reverse__SWIG_1")] + public static extern void Sentences_Reverse__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentences_SetRange")] + public static extern void Sentences_SetRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_delete_Sentences")] + public static extern void delete_Sentences(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_delete_InputFormat")] + public static extern void delete_InputFormat(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_InputFormat_resetDocument__SWIG_0")] + public static extern void InputFormat_resetDocument__SWIG_0(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_InputFormat_resetDocument__SWIG_1")] + public static extern void InputFormat_resetDocument__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_InputFormat_setText")] + public static extern void InputFormat_setText(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_InputFormat_nextSentence__SWIG_0")] + public static extern bool InputFormat_nextSentence__SWIG_0(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_InputFormat_nextSentence__SWIG_1")] + public static extern bool InputFormat_nextSentence__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_InputFormat_newInputFormat")] + public static extern global::System.IntPtr InputFormat_newInputFormat([global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_InputFormat_newConlluInputFormat__SWIG_0")] + public static extern global::System.IntPtr InputFormat_newConlluInputFormat__SWIG_0([global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_InputFormat_newConlluInputFormat__SWIG_1")] + public static extern global::System.IntPtr InputFormat_newConlluInputFormat__SWIG_1(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_InputFormat_newGenericTokenizerInputFormat__SWIG_0")] + public static extern global::System.IntPtr InputFormat_newGenericTokenizerInputFormat__SWIG_0([global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_InputFormat_newGenericTokenizerInputFormat__SWIG_1")] + public static extern global::System.IntPtr InputFormat_newGenericTokenizerInputFormat__SWIG_1(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_InputFormat_newHorizontalInputFormat__SWIG_0")] + public static extern global::System.IntPtr InputFormat_newHorizontalInputFormat__SWIG_0([global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_InputFormat_newHorizontalInputFormat__SWIG_1")] + public static extern global::System.IntPtr InputFormat_newHorizontalInputFormat__SWIG_1(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_InputFormat_newVerticalInputFormat__SWIG_0")] + public static extern global::System.IntPtr InputFormat_newVerticalInputFormat__SWIG_0([global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_InputFormat_newVerticalInputFormat__SWIG_1")] + public static extern global::System.IntPtr InputFormat_newVerticalInputFormat__SWIG_1(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_InputFormat_newPresegmentedTokenizer")] + public static extern global::System.IntPtr InputFormat_newPresegmentedTokenizer(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_InputFormat_CONLLU_V1_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string InputFormat_CONLLU_V1_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_InputFormat_CONLLU_V2_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string InputFormat_CONLLU_V2_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_InputFormat_GENERIC_TOKENIZER_NORMALIZED_SPACES_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string InputFormat_GENERIC_TOKENIZER_NORMALIZED_SPACES_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_InputFormat_GENERIC_TOKENIZER_PRESEGMENTED_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string InputFormat_GENERIC_TOKENIZER_PRESEGMENTED_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_InputFormat_GENERIC_TOKENIZER_RANGES_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string InputFormat_GENERIC_TOKENIZER_RANGES_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_delete_OutputFormat")] + public static extern void delete_OutputFormat(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_OutputFormat_writeSentence")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string OutputFormat_writeSentence(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_OutputFormat_finishDocument")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string OutputFormat_finishDocument(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_OutputFormat_newOutputFormat")] + public static extern global::System.IntPtr OutputFormat_newOutputFormat([global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_OutputFormat_newConlluOutputFormat__SWIG_0")] + public static extern global::System.IntPtr OutputFormat_newConlluOutputFormat__SWIG_0([global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_OutputFormat_newConlluOutputFormat__SWIG_1")] + public static extern global::System.IntPtr OutputFormat_newConlluOutputFormat__SWIG_1(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_OutputFormat_newEpeOutputFormat__SWIG_0")] + public static extern global::System.IntPtr OutputFormat_newEpeOutputFormat__SWIG_0([global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_OutputFormat_newEpeOutputFormat__SWIG_1")] + public static extern global::System.IntPtr OutputFormat_newEpeOutputFormat__SWIG_1(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_OutputFormat_newMatxinOutputFormat__SWIG_0")] + public static extern global::System.IntPtr OutputFormat_newMatxinOutputFormat__SWIG_0([global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_OutputFormat_newMatxinOutputFormat__SWIG_1")] + public static extern global::System.IntPtr OutputFormat_newMatxinOutputFormat__SWIG_1(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_OutputFormat_newHorizontalOutputFormat__SWIG_0")] + public static extern global::System.IntPtr OutputFormat_newHorizontalOutputFormat__SWIG_0([global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_OutputFormat_newHorizontalOutputFormat__SWIG_1")] + public static extern global::System.IntPtr OutputFormat_newHorizontalOutputFormat__SWIG_1(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_OutputFormat_newPlaintextOutputFormat__SWIG_0")] + public static extern global::System.IntPtr OutputFormat_newPlaintextOutputFormat__SWIG_0([global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_OutputFormat_newPlaintextOutputFormat__SWIG_1")] + public static extern global::System.IntPtr OutputFormat_newPlaintextOutputFormat__SWIG_1(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_OutputFormat_newVerticalOutputFormat__SWIG_0")] + public static extern global::System.IntPtr OutputFormat_newVerticalOutputFormat__SWIG_0([global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_OutputFormat_newVerticalOutputFormat__SWIG_1")] + public static extern global::System.IntPtr OutputFormat_newVerticalOutputFormat__SWIG_1(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_OutputFormat_CONLLU_V1_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string OutputFormat_CONLLU_V1_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_OutputFormat_CONLLU_V2_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string OutputFormat_CONLLU_V2_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_OutputFormat_HORIZONTAL_PARAGRAPHS_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string OutputFormat_HORIZONTAL_PARAGRAPHS_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_OutputFormat_PLAINTEXT_NORMALIZED_SPACES_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string OutputFormat_PLAINTEXT_NORMALIZED_SPACES_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_OutputFormat_VERTICAL_PARAGRAPHS_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string OutputFormat_VERTICAL_PARAGRAPHS_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_delete_Model")] + public static extern void delete_Model(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Model_load")] + public static extern global::System.IntPtr Model_load([global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Model_newTokenizer")] + public static extern global::System.IntPtr Model_newTokenizer(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Model_tag__SWIG_0")] + public static extern bool Model_tag__SWIG_0(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg3, global::System.Runtime.InteropServices.HandleRef jarg4); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Model_tag__SWIG_1")] + public static extern bool Model_tag__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Model_parse__SWIG_0")] + public static extern bool Model_parse__SWIG_0(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg3, global::System.Runtime.InteropServices.HandleRef jarg4); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Model_parse__SWIG_1")] + public static extern bool Model_parse__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Model_DEFAULT_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Model_DEFAULT_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Model_TOKENIZER_NORMALIZED_SPACES_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Model_TOKENIZER_NORMALIZED_SPACES_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Model_TOKENIZER_PRESEGMENTED_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Model_TOKENIZER_PRESEGMENTED_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Model_TOKENIZER_RANGES_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Model_TOKENIZER_RANGES_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Pipeline")] + public static extern global::System.IntPtr new_Pipeline(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg3, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg4, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg5); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Pipeline_setModel")] + public static extern void Pipeline_setModel(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Pipeline_setInput")] + public static extern void Pipeline_setInput(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Pipeline_setTagger")] + public static extern void Pipeline_setTagger(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Pipeline_setParser")] + public static extern void Pipeline_setParser(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Pipeline_setOutput")] + public static extern void Pipeline_setOutput(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Pipeline_setImmediate")] + public static extern void Pipeline_setImmediate(global::System.Runtime.InteropServices.HandleRef jarg1, bool jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Pipeline_setDocumentId")] + public static extern void Pipeline_setDocumentId(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Pipeline_process__SWIG_0")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Pipeline_process__SWIG_0(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Pipeline_process__SWIG_1")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Pipeline_process__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Pipeline_DEFAULT_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Pipeline_DEFAULT_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Pipeline_NONE_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Pipeline_NONE_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_delete_Pipeline")] + public static extern void delete_Pipeline(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Trainer_train__SWIG_0")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Trainer_train__SWIG_0([global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg1, global::System.Runtime.InteropServices.HandleRef jarg2, global::System.Runtime.InteropServices.HandleRef jarg3, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg4, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg5, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg6, global::System.Runtime.InteropServices.HandleRef jarg7); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Trainer_train__SWIG_1")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Trainer_train__SWIG_1([global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg1, global::System.Runtime.InteropServices.HandleRef jarg2, global::System.Runtime.InteropServices.HandleRef jarg3, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg4, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg5, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg6); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Trainer_DEFAULT_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Trainer_DEFAULT_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Trainer_NONE_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Trainer_NONE_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Trainer")] + public static extern global::System.IntPtr new_Trainer(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_delete_Trainer")] + public static extern void delete_Trainer(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Evaluator")] + public static extern global::System.IntPtr new_Evaluator(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg3, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg4); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Evaluator_setModel")] + public static extern void Evaluator_setModel(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Evaluator_setTokenizer")] + public static extern void Evaluator_setTokenizer(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Evaluator_setTagger")] + public static extern void Evaluator_setTagger(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Evaluator_setParser")] + public static extern void Evaluator_setParser(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Evaluator_evaluate__SWIG_0")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Evaluator_evaluate__SWIG_0(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Evaluator_evaluate__SWIG_1")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Evaluator_evaluate__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Evaluator_DEFAULT_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Evaluator_DEFAULT_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Evaluator_NONE_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Evaluator_NONE_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_delete_Evaluator")] + public static extern void delete_Evaluator(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Version_major_set")] + public static extern void Version_major_set(global::System.Runtime.InteropServices.HandleRef jarg1, uint jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Version_major_get")] + public static extern uint Version_major_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Version_minor_set")] + public static extern void Version_minor_set(global::System.Runtime.InteropServices.HandleRef jarg1, uint jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Version_minor_get")] + public static extern uint Version_minor_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Version_patch_set")] + public static extern void Version_patch_set(global::System.Runtime.InteropServices.HandleRef jarg1, uint jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Version_patch_get")] + public static extern uint Version_patch_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Version_prerelease_set")] + public static extern void Version_prerelease_set(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Version_prerelease_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Version_prerelease_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Version_current")] + public static extern global::System.IntPtr Version_current(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Version")] + public static extern global::System.IntPtr new_Version(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_delete_Version")] + public static extern void delete_Version(global::System.Runtime.InteropServices.HandleRef jarg1); + +public class UTF8Marshaler : System.Runtime.InteropServices.ICustomMarshaler { + static UTF8Marshaler static_instance; + + public System.IntPtr MarshalManagedToNative(object managedObj) { + if (managedObj == null) + return System.IntPtr.Zero; + if (!(managedObj is string)) + throw new System.Runtime.InteropServices.MarshalDirectiveException("UTF8Marshaler must be used on a string."); + + // not null terminated + byte[] strbuf = System.Text.Encoding.UTF8.GetBytes((string)managedObj); + System.IntPtr buffer = System.Runtime.InteropServices.Marshal.AllocHGlobal(strbuf.Length + 1); + System.Runtime.InteropServices.Marshal.Copy(strbuf, 0, buffer, strbuf.Length); + + // write the terminating null + System.Runtime.InteropServices.Marshal.WriteByte(buffer + strbuf.Length, 0); + return buffer; + } + + public object MarshalNativeToManaged(System.IntPtr pNativeData) { + int length = 0; + while (System.Runtime.InteropServices.Marshal.ReadByte(pNativeData, length) != 0) + length++; + + // should not be null terminated + byte[] strbuf = new byte[length]; + // skip the trailing null + System.Runtime.InteropServices.Marshal.Copy((System.IntPtr)pNativeData, strbuf, 0, length); + string data = System.Text.Encoding.UTF8.GetString(strbuf); + return data; + } + + public void CleanUpNativeData(System.IntPtr pNativeData) { + System.Runtime.InteropServices.Marshal.FreeHGlobal(pNativeData); + } + + public void CleanUpManagedData(object managedObj) { + } + + public int GetNativeDataSize() { + return -1; + } + + public static System.Runtime.InteropServices.ICustomMarshaler GetInstance(string cookie) { + if (static_instance == null) + return static_instance = new UTF8Marshaler(); + return static_instance; + } +} + + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Word_SWIGUpcast")] + public static extern global::System.IntPtr Word_SWIGUpcast(global::System.IntPtr jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordToken_SWIGUpcast")] + public static extern global::System.IntPtr MultiwordToken_SWIGUpcast(global::System.IntPtr jarg1); +} + +} diff --git a/UDPipe/v1/binary/linux32/csharp/libudpipe_csharp.so b/UDPipe/v1/binary/linux32/csharp/libudpipe_csharp.so new file mode 100644 index 0000000000000000000000000000000000000000..7288fc23f166ca7f8cf5cefcfd4ea5aa6b0cb1c5 --- /dev/null +++ b/UDPipe/v1/binary/linux32/csharp/libudpipe_csharp.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7bfb3b71ab2164c0056ca57ba98ddb845ad4f51d011d7846485c51b0556a9de2 +size 1958272 diff --git a/UDPipe/v1/binary/linux32/java/libudpipe_java.so b/UDPipe/v1/binary/linux32/java/libudpipe_java.so new file mode 100644 index 0000000000000000000000000000000000000000..946ff0564285efacb36df811ed2c714121aec23b --- /dev/null +++ b/UDPipe/v1/binary/linux32/java/libudpipe_java.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4012e267c7444e77e599473534673f7268c05c69138735718379cb85bac47a58 +size 1893392 diff --git a/UDPipe/v1/binary/linux32/java/udpipe.jar b/UDPipe/v1/binary/linux32/java/udpipe.jar new file mode 100644 index 0000000000000000000000000000000000000000..1402eecf0486e6af3300cbad05601351d9990feb Binary files /dev/null and b/UDPipe/v1/binary/linux32/java/udpipe.jar differ diff --git a/UDPipe/v1/binary/linux32/udpipe b/UDPipe/v1/binary/linux32/udpipe new file mode 100644 index 0000000000000000000000000000000000000000..7721b8f7530dab71872b199fd2d82add266f3afd --- /dev/null +++ b/UDPipe/v1/binary/linux32/udpipe @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:73064bffa0085a0014c9e3d6394f52770a6b346731b688b2a4d3f4ea9fef9f3b +size 1521340 diff --git a/UDPipe/v1/binary/linux64/csharp/Ufal/UDPipe/Children.cs b/UDPipe/v1/binary/linux64/csharp/Ufal/UDPipe/Children.cs new file mode 100644 index 0000000000000000000000000000000000000000..e5959f767df4f3ddb46e9dcb210f3eacd8c2237a --- /dev/null +++ b/UDPipe/v1/binary/linux64/csharp/Ufal/UDPipe/Children.cs @@ -0,0 +1,328 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +public class Children : global::System.IDisposable, global::System.Collections.IEnumerable + , global::System.Collections.Generic.IList + { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal Children(global::System.IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Children obj) { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + ~Children() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != global::System.IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + udpipe_csharpPINVOKE.delete_Children(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + global::System.GC.SuppressFinalize(this); + } + } + + public Children(global::System.Collections.ICollection c) : this() { + if (c == null) + throw new global::System.ArgumentNullException("c"); + foreach (int element in c) { + this.Add(element); + } + } + + public bool IsFixedSize { + get { + return false; + } + } + + public bool IsReadOnly { + get { + return false; + } + } + + public int this[int index] { + get { + return getitem(index); + } + set { + setitem(index, value); + } + } + + public int Capacity { + get { + return (int)capacity(); + } + set { + if (value < size()) + throw new global::System.ArgumentOutOfRangeException("Capacity"); + reserve((uint)value); + } + } + + public int Count { + get { + return (int)size(); + } + } + + public bool IsSynchronized { + get { + return false; + } + } + + public void CopyTo(int[] array) + { + CopyTo(0, array, 0, this.Count); + } + + public void CopyTo(int[] array, int arrayIndex) + { + CopyTo(0, array, arrayIndex, this.Count); + } + + public void CopyTo(int index, int[] array, int arrayIndex, int count) + { + if (array == null) + throw new global::System.ArgumentNullException("array"); + if (index < 0) + throw new global::System.ArgumentOutOfRangeException("index", "Value is less than zero"); + if (arrayIndex < 0) + throw new global::System.ArgumentOutOfRangeException("arrayIndex", "Value is less than zero"); + if (count < 0) + throw new global::System.ArgumentOutOfRangeException("count", "Value is less than zero"); + if (array.Rank > 1) + throw new global::System.ArgumentException("Multi dimensional array.", "array"); + if (index+count > this.Count || arrayIndex+count > array.Length) + throw new global::System.ArgumentException("Number of elements to copy is too large."); + for (int i=0; i global::System.Collections.Generic.IEnumerable.GetEnumerator() { + return new ChildrenEnumerator(this); + } + + global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator() { + return new ChildrenEnumerator(this); + } + + public ChildrenEnumerator GetEnumerator() { + return new ChildrenEnumerator(this); + } + + // Type-safe enumerator + /// Note that the IEnumerator documentation requires an InvalidOperationException to be thrown + /// whenever the collection is modified. This has been done for changes in the size of the + /// collection but not when one of the elements of the collection is modified as it is a bit + /// tricky to detect unmanaged code that modifies the collection under our feet. + public sealed class ChildrenEnumerator : global::System.Collections.IEnumerator + , global::System.Collections.Generic.IEnumerator + { + private Children collectionRef; + private int currentIndex; + private object currentObject; + private int currentSize; + + public ChildrenEnumerator(Children collection) { + collectionRef = collection; + currentIndex = -1; + currentObject = null; + currentSize = collectionRef.Count; + } + + // Type-safe iterator Current + public int Current { + get { + if (currentIndex == -1) + throw new global::System.InvalidOperationException("Enumeration not started."); + if (currentIndex > currentSize - 1) + throw new global::System.InvalidOperationException("Enumeration finished."); + if (currentObject == null) + throw new global::System.InvalidOperationException("Collection modified."); + return (int)currentObject; + } + } + + // Type-unsafe IEnumerator.Current + object global::System.Collections.IEnumerator.Current { + get { + return Current; + } + } + + public bool MoveNext() { + int size = collectionRef.Count; + bool moveOkay = (currentIndex+1 < size) && (size == currentSize); + if (moveOkay) { + currentIndex++; + currentObject = collectionRef[currentIndex]; + } else { + currentObject = null; + } + return moveOkay; + } + + public void Reset() { + currentIndex = -1; + currentObject = null; + if (collectionRef.Count != currentSize) { + throw new global::System.InvalidOperationException("Collection modified."); + } + } + + public void Dispose() { + currentIndex = -1; + currentObject = null; + } + } + + public void Clear() { + udpipe_csharpPINVOKE.Children_Clear(swigCPtr); + } + + public void Add(int x) { + udpipe_csharpPINVOKE.Children_Add(swigCPtr, x); + } + + private uint size() { + uint ret = udpipe_csharpPINVOKE.Children_size(swigCPtr); + return ret; + } + + private uint capacity() { + uint ret = udpipe_csharpPINVOKE.Children_capacity(swigCPtr); + return ret; + } + + private void reserve(uint n) { + udpipe_csharpPINVOKE.Children_reserve(swigCPtr, n); + } + + public Children() : this(udpipe_csharpPINVOKE.new_Children__SWIG_0(), true) { + } + + public Children(Children other) : this(udpipe_csharpPINVOKE.new_Children__SWIG_1(Children.getCPtr(other)), true) { + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public Children(int capacity) : this(udpipe_csharpPINVOKE.new_Children__SWIG_2(capacity), true) { + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + private int getitemcopy(int index) { + int ret = udpipe_csharpPINVOKE.Children_getitemcopy(swigCPtr, index); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + private int getitem(int index) { + int ret = udpipe_csharpPINVOKE.Children_getitem(swigCPtr, index); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + private void setitem(int index, int val) { + udpipe_csharpPINVOKE.Children_setitem(swigCPtr, index, val); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void AddRange(Children values) { + udpipe_csharpPINVOKE.Children_AddRange(swigCPtr, Children.getCPtr(values)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public Children GetRange(int index, int count) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.Children_GetRange(swigCPtr, index, count); + Children ret = (cPtr == global::System.IntPtr.Zero) ? null : new Children(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public void Insert(int index, int x) { + udpipe_csharpPINVOKE.Children_Insert(swigCPtr, index, x); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void InsertRange(int index, Children values) { + udpipe_csharpPINVOKE.Children_InsertRange(swigCPtr, index, Children.getCPtr(values)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void RemoveAt(int index) { + udpipe_csharpPINVOKE.Children_RemoveAt(swigCPtr, index); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void RemoveRange(int index, int count) { + udpipe_csharpPINVOKE.Children_RemoveRange(swigCPtr, index, count); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public static Children Repeat(int value, int count) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.Children_Repeat(value, count); + Children ret = (cPtr == global::System.IntPtr.Zero) ? null : new Children(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public void Reverse() { + udpipe_csharpPINVOKE.Children_Reverse__SWIG_0(swigCPtr); + } + + public void Reverse(int index, int count) { + udpipe_csharpPINVOKE.Children_Reverse__SWIG_1(swigCPtr, index, count); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void SetRange(int index, Children values) { + udpipe_csharpPINVOKE.Children_SetRange(swigCPtr, index, Children.getCPtr(values)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public bool Contains(int value) { + bool ret = udpipe_csharpPINVOKE.Children_Contains(swigCPtr, value); + return ret; + } + + public int IndexOf(int value) { + int ret = udpipe_csharpPINVOKE.Children_IndexOf(swigCPtr, value); + return ret; + } + + public int LastIndexOf(int value) { + int ret = udpipe_csharpPINVOKE.Children_LastIndexOf(swigCPtr, value); + return ret; + } + + public bool Remove(int value) { + bool ret = udpipe_csharpPINVOKE.Children_Remove(swigCPtr, value); + return ret; + } + +} + +} diff --git a/UDPipe/v1/binary/linux64/csharp/Ufal/UDPipe/Comments.cs b/UDPipe/v1/binary/linux64/csharp/Ufal/UDPipe/Comments.cs new file mode 100644 index 0000000000000000000000000000000000000000..316865d901e073812e3deda1f8ccf407a6ed93a7 --- /dev/null +++ b/UDPipe/v1/binary/linux64/csharp/Ufal/UDPipe/Comments.cs @@ -0,0 +1,333 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +public class Comments : global::System.IDisposable, global::System.Collections.IEnumerable + , global::System.Collections.Generic.IList + { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal Comments(global::System.IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Comments obj) { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + ~Comments() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != global::System.IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + udpipe_csharpPINVOKE.delete_Comments(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + global::System.GC.SuppressFinalize(this); + } + } + + public Comments(global::System.Collections.ICollection c) : this() { + if (c == null) + throw new global::System.ArgumentNullException("c"); + foreach (string element in c) { + this.Add(element); + } + } + + public bool IsFixedSize { + get { + return false; + } + } + + public bool IsReadOnly { + get { + return false; + } + } + + public string this[int index] { + get { + return getitem(index); + } + set { + setitem(index, value); + } + } + + public int Capacity { + get { + return (int)capacity(); + } + set { + if (value < size()) + throw new global::System.ArgumentOutOfRangeException("Capacity"); + reserve((uint)value); + } + } + + public int Count { + get { + return (int)size(); + } + } + + public bool IsSynchronized { + get { + return false; + } + } + + public void CopyTo(string[] array) + { + CopyTo(0, array, 0, this.Count); + } + + public void CopyTo(string[] array, int arrayIndex) + { + CopyTo(0, array, arrayIndex, this.Count); + } + + public void CopyTo(int index, string[] array, int arrayIndex, int count) + { + if (array == null) + throw new global::System.ArgumentNullException("array"); + if (index < 0) + throw new global::System.ArgumentOutOfRangeException("index", "Value is less than zero"); + if (arrayIndex < 0) + throw new global::System.ArgumentOutOfRangeException("arrayIndex", "Value is less than zero"); + if (count < 0) + throw new global::System.ArgumentOutOfRangeException("count", "Value is less than zero"); + if (array.Rank > 1) + throw new global::System.ArgumentException("Multi dimensional array.", "array"); + if (index+count > this.Count || arrayIndex+count > array.Length) + throw new global::System.ArgumentException("Number of elements to copy is too large."); + for (int i=0; i global::System.Collections.Generic.IEnumerable.GetEnumerator() { + return new CommentsEnumerator(this); + } + + global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator() { + return new CommentsEnumerator(this); + } + + public CommentsEnumerator GetEnumerator() { + return new CommentsEnumerator(this); + } + + // Type-safe enumerator + /// Note that the IEnumerator documentation requires an InvalidOperationException to be thrown + /// whenever the collection is modified. This has been done for changes in the size of the + /// collection but not when one of the elements of the collection is modified as it is a bit + /// tricky to detect unmanaged code that modifies the collection under our feet. + public sealed class CommentsEnumerator : global::System.Collections.IEnumerator + , global::System.Collections.Generic.IEnumerator + { + private Comments collectionRef; + private int currentIndex; + private object currentObject; + private int currentSize; + + public CommentsEnumerator(Comments collection) { + collectionRef = collection; + currentIndex = -1; + currentObject = null; + currentSize = collectionRef.Count; + } + + // Type-safe iterator Current + public string Current { + get { + if (currentIndex == -1) + throw new global::System.InvalidOperationException("Enumeration not started."); + if (currentIndex > currentSize - 1) + throw new global::System.InvalidOperationException("Enumeration finished."); + if (currentObject == null) + throw new global::System.InvalidOperationException("Collection modified."); + return (string)currentObject; + } + } + + // Type-unsafe IEnumerator.Current + object global::System.Collections.IEnumerator.Current { + get { + return Current; + } + } + + public bool MoveNext() { + int size = collectionRef.Count; + bool moveOkay = (currentIndex+1 < size) && (size == currentSize); + if (moveOkay) { + currentIndex++; + currentObject = collectionRef[currentIndex]; + } else { + currentObject = null; + } + return moveOkay; + } + + public void Reset() { + currentIndex = -1; + currentObject = null; + if (collectionRef.Count != currentSize) { + throw new global::System.InvalidOperationException("Collection modified."); + } + } + + public void Dispose() { + currentIndex = -1; + currentObject = null; + } + } + + public void Clear() { + udpipe_csharpPINVOKE.Comments_Clear(swigCPtr); + } + + public void Add(string x) { + udpipe_csharpPINVOKE.Comments_Add(swigCPtr, x); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + private uint size() { + uint ret = udpipe_csharpPINVOKE.Comments_size(swigCPtr); + return ret; + } + + private uint capacity() { + uint ret = udpipe_csharpPINVOKE.Comments_capacity(swigCPtr); + return ret; + } + + private void reserve(uint n) { + udpipe_csharpPINVOKE.Comments_reserve(swigCPtr, n); + } + + public Comments() : this(udpipe_csharpPINVOKE.new_Comments__SWIG_0(), true) { + } + + public Comments(Comments other) : this(udpipe_csharpPINVOKE.new_Comments__SWIG_1(Comments.getCPtr(other)), true) { + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public Comments(int capacity) : this(udpipe_csharpPINVOKE.new_Comments__SWIG_2(capacity), true) { + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + private string getitemcopy(int index) { + string ret = udpipe_csharpPINVOKE.Comments_getitemcopy(swigCPtr, index); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + private string getitem(int index) { + string ret = udpipe_csharpPINVOKE.Comments_getitem(swigCPtr, index); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + private void setitem(int index, string val) { + udpipe_csharpPINVOKE.Comments_setitem(swigCPtr, index, val); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void AddRange(Comments values) { + udpipe_csharpPINVOKE.Comments_AddRange(swigCPtr, Comments.getCPtr(values)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public Comments GetRange(int index, int count) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.Comments_GetRange(swigCPtr, index, count); + Comments ret = (cPtr == global::System.IntPtr.Zero) ? null : new Comments(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public void Insert(int index, string x) { + udpipe_csharpPINVOKE.Comments_Insert(swigCPtr, index, x); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void InsertRange(int index, Comments values) { + udpipe_csharpPINVOKE.Comments_InsertRange(swigCPtr, index, Comments.getCPtr(values)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void RemoveAt(int index) { + udpipe_csharpPINVOKE.Comments_RemoveAt(swigCPtr, index); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void RemoveRange(int index, int count) { + udpipe_csharpPINVOKE.Comments_RemoveRange(swigCPtr, index, count); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public static Comments Repeat(string value, int count) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.Comments_Repeat(value, count); + Comments ret = (cPtr == global::System.IntPtr.Zero) ? null : new Comments(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public void Reverse() { + udpipe_csharpPINVOKE.Comments_Reverse__SWIG_0(swigCPtr); + } + + public void Reverse(int index, int count) { + udpipe_csharpPINVOKE.Comments_Reverse__SWIG_1(swigCPtr, index, count); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void SetRange(int index, Comments values) { + udpipe_csharpPINVOKE.Comments_SetRange(swigCPtr, index, Comments.getCPtr(values)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public bool Contains(string value) { + bool ret = udpipe_csharpPINVOKE.Comments_Contains(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public int IndexOf(string value) { + int ret = udpipe_csharpPINVOKE.Comments_IndexOf(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public int LastIndexOf(string value) { + int ret = udpipe_csharpPINVOKE.Comments_LastIndexOf(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public bool Remove(string value) { + bool ret = udpipe_csharpPINVOKE.Comments_Remove(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + +} + +} diff --git a/UDPipe/v1/binary/linux64/csharp/Ufal/UDPipe/EmptyNode.cs b/UDPipe/v1/binary/linux64/csharp/Ufal/UDPipe/EmptyNode.cs new file mode 100644 index 0000000000000000000000000000000000000000..3d9127797fd237053078ec6db9da11cc6c9c819a --- /dev/null +++ b/UDPipe/v1/binary/linux64/csharp/Ufal/UDPipe/EmptyNode.cs @@ -0,0 +1,158 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +public class EmptyNode : global::System.IDisposable { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal EmptyNode(global::System.IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(EmptyNode obj) { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + ~EmptyNode() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != global::System.IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + udpipe_csharpPINVOKE.delete_EmptyNode(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + global::System.GC.SuppressFinalize(this); + } + } + + public int id { + set { + udpipe_csharpPINVOKE.EmptyNode_id_set(swigCPtr, value); + } + get { + int ret = udpipe_csharpPINVOKE.EmptyNode_id_get(swigCPtr); + return ret; + } + } + + public int index { + set { + udpipe_csharpPINVOKE.EmptyNode_index_set(swigCPtr, value); + } + get { + int ret = udpipe_csharpPINVOKE.EmptyNode_index_get(swigCPtr); + return ret; + } + } + + public string form { + set { + udpipe_csharpPINVOKE.EmptyNode_form_set(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + get { + string ret = udpipe_csharpPINVOKE.EmptyNode_form_get(swigCPtr); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + } + + public string lemma { + set { + udpipe_csharpPINVOKE.EmptyNode_lemma_set(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + get { + string ret = udpipe_csharpPINVOKE.EmptyNode_lemma_get(swigCPtr); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + } + + public string upostag { + set { + udpipe_csharpPINVOKE.EmptyNode_upostag_set(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + get { + string ret = udpipe_csharpPINVOKE.EmptyNode_upostag_get(swigCPtr); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + } + + public string xpostag { + set { + udpipe_csharpPINVOKE.EmptyNode_xpostag_set(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + get { + string ret = udpipe_csharpPINVOKE.EmptyNode_xpostag_get(swigCPtr); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + } + + public string feats { + set { + udpipe_csharpPINVOKE.EmptyNode_feats_set(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + get { + string ret = udpipe_csharpPINVOKE.EmptyNode_feats_get(swigCPtr); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + } + + public string deps { + set { + udpipe_csharpPINVOKE.EmptyNode_deps_set(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + get { + string ret = udpipe_csharpPINVOKE.EmptyNode_deps_get(swigCPtr); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + } + + public string misc { + set { + udpipe_csharpPINVOKE.EmptyNode_misc_set(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + get { + string ret = udpipe_csharpPINVOKE.EmptyNode_misc_get(swigCPtr); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + } + + public EmptyNode(int id, int index) : this(udpipe_csharpPINVOKE.new_EmptyNode__SWIG_0(id, index), true) { + } + + public EmptyNode(int id) : this(udpipe_csharpPINVOKE.new_EmptyNode__SWIG_1(id), true) { + } + + public EmptyNode() : this(udpipe_csharpPINVOKE.new_EmptyNode__SWIG_2(), true) { + } + +} + +} diff --git a/UDPipe/v1/binary/linux64/csharp/Ufal/UDPipe/EmptyNodes.cs b/UDPipe/v1/binary/linux64/csharp/Ufal/UDPipe/EmptyNodes.cs new file mode 100644 index 0000000000000000000000000000000000000000..2b4412bd10fdba16a486450f457720529beadb6b --- /dev/null +++ b/UDPipe/v1/binary/linux64/csharp/Ufal/UDPipe/EmptyNodes.cs @@ -0,0 +1,309 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +public class EmptyNodes : global::System.IDisposable, global::System.Collections.IEnumerable + , global::System.Collections.Generic.IEnumerable + { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal EmptyNodes(global::System.IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(EmptyNodes obj) { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + ~EmptyNodes() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != global::System.IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + udpipe_csharpPINVOKE.delete_EmptyNodes(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + global::System.GC.SuppressFinalize(this); + } + } + + public EmptyNodes(global::System.Collections.ICollection c) : this() { + if (c == null) + throw new global::System.ArgumentNullException("c"); + foreach (EmptyNode element in c) { + this.Add(element); + } + } + + public bool IsFixedSize { + get { + return false; + } + } + + public bool IsReadOnly { + get { + return false; + } + } + + public EmptyNode this[int index] { + get { + return getitem(index); + } + set { + setitem(index, value); + } + } + + public int Capacity { + get { + return (int)capacity(); + } + set { + if (value < size()) + throw new global::System.ArgumentOutOfRangeException("Capacity"); + reserve((uint)value); + } + } + + public int Count { + get { + return (int)size(); + } + } + + public bool IsSynchronized { + get { + return false; + } + } + + public void CopyTo(EmptyNode[] array) + { + CopyTo(0, array, 0, this.Count); + } + + public void CopyTo(EmptyNode[] array, int arrayIndex) + { + CopyTo(0, array, arrayIndex, this.Count); + } + + public void CopyTo(int index, EmptyNode[] array, int arrayIndex, int count) + { + if (array == null) + throw new global::System.ArgumentNullException("array"); + if (index < 0) + throw new global::System.ArgumentOutOfRangeException("index", "Value is less than zero"); + if (arrayIndex < 0) + throw new global::System.ArgumentOutOfRangeException("arrayIndex", "Value is less than zero"); + if (count < 0) + throw new global::System.ArgumentOutOfRangeException("count", "Value is less than zero"); + if (array.Rank > 1) + throw new global::System.ArgumentException("Multi dimensional array.", "array"); + if (index+count > this.Count || arrayIndex+count > array.Length) + throw new global::System.ArgumentException("Number of elements to copy is too large."); + for (int i=0; i global::System.Collections.Generic.IEnumerable.GetEnumerator() { + return new EmptyNodesEnumerator(this); + } + + global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator() { + return new EmptyNodesEnumerator(this); + } + + public EmptyNodesEnumerator GetEnumerator() { + return new EmptyNodesEnumerator(this); + } + + // Type-safe enumerator + /// Note that the IEnumerator documentation requires an InvalidOperationException to be thrown + /// whenever the collection is modified. This has been done for changes in the size of the + /// collection but not when one of the elements of the collection is modified as it is a bit + /// tricky to detect unmanaged code that modifies the collection under our feet. + public sealed class EmptyNodesEnumerator : global::System.Collections.IEnumerator + , global::System.Collections.Generic.IEnumerator + { + private EmptyNodes collectionRef; + private int currentIndex; + private object currentObject; + private int currentSize; + + public EmptyNodesEnumerator(EmptyNodes collection) { + collectionRef = collection; + currentIndex = -1; + currentObject = null; + currentSize = collectionRef.Count; + } + + // Type-safe iterator Current + public EmptyNode Current { + get { + if (currentIndex == -1) + throw new global::System.InvalidOperationException("Enumeration not started."); + if (currentIndex > currentSize - 1) + throw new global::System.InvalidOperationException("Enumeration finished."); + if (currentObject == null) + throw new global::System.InvalidOperationException("Collection modified."); + return (EmptyNode)currentObject; + } + } + + // Type-unsafe IEnumerator.Current + object global::System.Collections.IEnumerator.Current { + get { + return Current; + } + } + + public bool MoveNext() { + int size = collectionRef.Count; + bool moveOkay = (currentIndex+1 < size) && (size == currentSize); + if (moveOkay) { + currentIndex++; + currentObject = collectionRef[currentIndex]; + } else { + currentObject = null; + } + return moveOkay; + } + + public void Reset() { + currentIndex = -1; + currentObject = null; + if (collectionRef.Count != currentSize) { + throw new global::System.InvalidOperationException("Collection modified."); + } + } + + public void Dispose() { + currentIndex = -1; + currentObject = null; + } + } + + public void Clear() { + udpipe_csharpPINVOKE.EmptyNodes_Clear(swigCPtr); + } + + public void Add(EmptyNode x) { + udpipe_csharpPINVOKE.EmptyNodes_Add(swigCPtr, EmptyNode.getCPtr(x)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + private uint size() { + uint ret = udpipe_csharpPINVOKE.EmptyNodes_size(swigCPtr); + return ret; + } + + private uint capacity() { + uint ret = udpipe_csharpPINVOKE.EmptyNodes_capacity(swigCPtr); + return ret; + } + + private void reserve(uint n) { + udpipe_csharpPINVOKE.EmptyNodes_reserve(swigCPtr, n); + } + + public EmptyNodes() : this(udpipe_csharpPINVOKE.new_EmptyNodes__SWIG_0(), true) { + } + + public EmptyNodes(EmptyNodes other) : this(udpipe_csharpPINVOKE.new_EmptyNodes__SWIG_1(EmptyNodes.getCPtr(other)), true) { + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public EmptyNodes(int capacity) : this(udpipe_csharpPINVOKE.new_EmptyNodes__SWIG_2(capacity), true) { + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + private EmptyNode getitemcopy(int index) { + EmptyNode ret = new EmptyNode(udpipe_csharpPINVOKE.EmptyNodes_getitemcopy(swigCPtr, index), true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + private EmptyNode getitem(int index) { + EmptyNode ret = new EmptyNode(udpipe_csharpPINVOKE.EmptyNodes_getitem(swigCPtr, index), false); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + private void setitem(int index, EmptyNode val) { + udpipe_csharpPINVOKE.EmptyNodes_setitem(swigCPtr, index, EmptyNode.getCPtr(val)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void AddRange(EmptyNodes values) { + udpipe_csharpPINVOKE.EmptyNodes_AddRange(swigCPtr, EmptyNodes.getCPtr(values)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public EmptyNodes GetRange(int index, int count) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.EmptyNodes_GetRange(swigCPtr, index, count); + EmptyNodes ret = (cPtr == global::System.IntPtr.Zero) ? null : new EmptyNodes(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public void Insert(int index, EmptyNode x) { + udpipe_csharpPINVOKE.EmptyNodes_Insert(swigCPtr, index, EmptyNode.getCPtr(x)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void InsertRange(int index, EmptyNodes values) { + udpipe_csharpPINVOKE.EmptyNodes_InsertRange(swigCPtr, index, EmptyNodes.getCPtr(values)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void RemoveAt(int index) { + udpipe_csharpPINVOKE.EmptyNodes_RemoveAt(swigCPtr, index); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void RemoveRange(int index, int count) { + udpipe_csharpPINVOKE.EmptyNodes_RemoveRange(swigCPtr, index, count); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public static EmptyNodes Repeat(EmptyNode value, int count) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.EmptyNodes_Repeat(EmptyNode.getCPtr(value), count); + EmptyNodes ret = (cPtr == global::System.IntPtr.Zero) ? null : new EmptyNodes(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public void Reverse() { + udpipe_csharpPINVOKE.EmptyNodes_Reverse__SWIG_0(swigCPtr); + } + + public void Reverse(int index, int count) { + udpipe_csharpPINVOKE.EmptyNodes_Reverse__SWIG_1(swigCPtr, index, count); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void SetRange(int index, EmptyNodes values) { + udpipe_csharpPINVOKE.EmptyNodes_SetRange(swigCPtr, index, EmptyNodes.getCPtr(values)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + +} + +} diff --git a/UDPipe/v1/binary/linux64/csharp/Ufal/UDPipe/Evaluator.cs b/UDPipe/v1/binary/linux64/csharp/Ufal/UDPipe/Evaluator.cs new file mode 100644 index 0000000000000000000000000000000000000000..007e5ae8995f11aefe94465fed6d1d61725b6644 --- /dev/null +++ b/UDPipe/v1/binary/linux64/csharp/Ufal/UDPipe/Evaluator.cs @@ -0,0 +1,94 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +public class Evaluator : global::System.IDisposable { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal Evaluator(global::System.IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Evaluator obj) { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + ~Evaluator() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != global::System.IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + udpipe_csharpPINVOKE.delete_Evaluator(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + global::System.GC.SuppressFinalize(this); + } + } + + public Evaluator(Model m, string tokenizer, string tagger, string parser) : this(udpipe_csharpPINVOKE.new_Evaluator(Model.getCPtr(m), tokenizer, tagger, parser), true) { + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void setModel(Model m) { + udpipe_csharpPINVOKE.Evaluator_setModel(swigCPtr, Model.getCPtr(m)); + } + + public void setTokenizer(string tokenizer) { + udpipe_csharpPINVOKE.Evaluator_setTokenizer(swigCPtr, tokenizer); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void setTagger(string tagger) { + udpipe_csharpPINVOKE.Evaluator_setTagger(swigCPtr, tagger); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void setParser(string parser) { + udpipe_csharpPINVOKE.Evaluator_setParser(swigCPtr, parser); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public string evaluate(string data, ProcessingError error) { + string ret = udpipe_csharpPINVOKE.Evaluator_evaluate__SWIG_0(swigCPtr, data, ProcessingError.getCPtr(error)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public string evaluate(string data) { + string ret = udpipe_csharpPINVOKE.Evaluator_evaluate__SWIG_1(swigCPtr, data); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public static string DEFAULT { + get { + string ret = udpipe_csharpPINVOKE.Evaluator_DEFAULT_get(); + return ret; + } + } + + public static string NONE { + get { + string ret = udpipe_csharpPINVOKE.Evaluator_NONE_get(); + return ret; + } + } + +} + +} diff --git a/UDPipe/v1/binary/linux64/csharp/Ufal/UDPipe/InputFormat.cs b/UDPipe/v1/binary/linux64/csharp/Ufal/UDPipe/InputFormat.cs new file mode 100644 index 0000000000000000000000000000000000000000..4dd3bb29440658a9e5187aec1cf719180c11e798 --- /dev/null +++ b/UDPipe/v1/binary/linux64/csharp/Ufal/UDPipe/InputFormat.cs @@ -0,0 +1,175 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +public class InputFormat : global::System.IDisposable { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal InputFormat(global::System.IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(InputFormat obj) { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + ~InputFormat() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != global::System.IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + udpipe_csharpPINVOKE.delete_InputFormat(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + global::System.GC.SuppressFinalize(this); + } + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtrAndDisown(InputFormat obj) { + if (obj != null) obj.swigCMemOwn = false; + return getCPtr(obj); + } + + public virtual void resetDocument(string id) { + udpipe_csharpPINVOKE.InputFormat_resetDocument__SWIG_0(swigCPtr, id); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public virtual void resetDocument() { + udpipe_csharpPINVOKE.InputFormat_resetDocument__SWIG_1(swigCPtr); + } + + public virtual void setText(string text) { + udpipe_csharpPINVOKE.InputFormat_setText(swigCPtr, text); + } + + public virtual bool nextSentence(Sentence s, ProcessingError error) { + bool ret = udpipe_csharpPINVOKE.InputFormat_nextSentence__SWIG_0(swigCPtr, Sentence.getCPtr(s), ProcessingError.getCPtr(error)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public virtual bool nextSentence(Sentence s) { + bool ret = udpipe_csharpPINVOKE.InputFormat_nextSentence__SWIG_1(swigCPtr, Sentence.getCPtr(s)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public static InputFormat newInputFormat(string name) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.InputFormat_newInputFormat(name); + InputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new InputFormat(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public static InputFormat newConlluInputFormat(string options) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.InputFormat_newConlluInputFormat__SWIG_0(options); + InputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new InputFormat(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public static InputFormat newConlluInputFormat() { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.InputFormat_newConlluInputFormat__SWIG_1(); + InputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new InputFormat(cPtr, true); + return ret; + } + + public static InputFormat newGenericTokenizerInputFormat(string options) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.InputFormat_newGenericTokenizerInputFormat__SWIG_0(options); + InputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new InputFormat(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public static InputFormat newGenericTokenizerInputFormat() { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.InputFormat_newGenericTokenizerInputFormat__SWIG_1(); + InputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new InputFormat(cPtr, true); + return ret; + } + + public static InputFormat newHorizontalInputFormat(string options) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.InputFormat_newHorizontalInputFormat__SWIG_0(options); + InputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new InputFormat(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public static InputFormat newHorizontalInputFormat() { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.InputFormat_newHorizontalInputFormat__SWIG_1(); + InputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new InputFormat(cPtr, true); + return ret; + } + + public static InputFormat newVerticalInputFormat(string options) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.InputFormat_newVerticalInputFormat__SWIG_0(options); + InputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new InputFormat(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public static InputFormat newVerticalInputFormat() { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.InputFormat_newVerticalInputFormat__SWIG_1(); + InputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new InputFormat(cPtr, true); + return ret; + } + + public static InputFormat newPresegmentedTokenizer(InputFormat DISOWN) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.InputFormat_newPresegmentedTokenizer(InputFormat.getCPtrAndDisown(DISOWN)); + InputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new InputFormat(cPtr, true); + return ret; + } + + public static string CONLLU_V1 { + get { + string ret = udpipe_csharpPINVOKE.InputFormat_CONLLU_V1_get(); + return ret; + } + } + + public static string CONLLU_V2 { + get { + string ret = udpipe_csharpPINVOKE.InputFormat_CONLLU_V2_get(); + return ret; + } + } + + public static string GENERIC_TOKENIZER_NORMALIZED_SPACES { + get { + string ret = udpipe_csharpPINVOKE.InputFormat_GENERIC_TOKENIZER_NORMALIZED_SPACES_get(); + return ret; + } + } + + public static string GENERIC_TOKENIZER_PRESEGMENTED { + get { + string ret = udpipe_csharpPINVOKE.InputFormat_GENERIC_TOKENIZER_PRESEGMENTED_get(); + return ret; + } + } + + public static string GENERIC_TOKENIZER_RANGES { + get { + string ret = udpipe_csharpPINVOKE.InputFormat_GENERIC_TOKENIZER_RANGES_get(); + return ret; + } + } + +} + +} diff --git a/UDPipe/v1/binary/linux64/csharp/Ufal/UDPipe/Model.cs b/UDPipe/v1/binary/linux64/csharp/Ufal/UDPipe/Model.cs new file mode 100644 index 0000000000000000000000000000000000000000..c0f530c0927b5b4e91e29dd73092ab2eae73c145 --- /dev/null +++ b/UDPipe/v1/binary/linux64/csharp/Ufal/UDPipe/Model.cs @@ -0,0 +1,110 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +public class Model : global::System.IDisposable { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal Model(global::System.IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Model obj) { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + ~Model() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != global::System.IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + udpipe_csharpPINVOKE.delete_Model(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + global::System.GC.SuppressFinalize(this); + } + } + + public static Model load(string fname) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.Model_load(fname); + Model ret = (cPtr == global::System.IntPtr.Zero) ? null : new Model(cPtr, true); + return ret; + } + + public virtual InputFormat newTokenizer(string options) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.Model_newTokenizer(swigCPtr, options); + InputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new InputFormat(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public virtual bool tag(Sentence s, string options, ProcessingError error) { + bool ret = udpipe_csharpPINVOKE.Model_tag__SWIG_0(swigCPtr, Sentence.getCPtr(s), options, ProcessingError.getCPtr(error)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public virtual bool tag(Sentence s, string options) { + bool ret = udpipe_csharpPINVOKE.Model_tag__SWIG_1(swigCPtr, Sentence.getCPtr(s), options); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public virtual bool parse(Sentence s, string options, ProcessingError error) { + bool ret = udpipe_csharpPINVOKE.Model_parse__SWIG_0(swigCPtr, Sentence.getCPtr(s), options, ProcessingError.getCPtr(error)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public virtual bool parse(Sentence s, string options) { + bool ret = udpipe_csharpPINVOKE.Model_parse__SWIG_1(swigCPtr, Sentence.getCPtr(s), options); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public static string DEFAULT { + get { + string ret = udpipe_csharpPINVOKE.Model_DEFAULT_get(); + return ret; + } + } + + public static string TOKENIZER_NORMALIZED_SPACES { + get { + string ret = udpipe_csharpPINVOKE.Model_TOKENIZER_NORMALIZED_SPACES_get(); + return ret; + } + } + + public static string TOKENIZER_PRESEGMENTED { + get { + string ret = udpipe_csharpPINVOKE.Model_TOKENIZER_PRESEGMENTED_get(); + return ret; + } + } + + public static string TOKENIZER_RANGES { + get { + string ret = udpipe_csharpPINVOKE.Model_TOKENIZER_RANGES_get(); + return ret; + } + } + +} + +} diff --git a/UDPipe/v1/binary/linux64/csharp/Ufal/UDPipe/MultiwordToken.cs b/UDPipe/v1/binary/linux64/csharp/Ufal/UDPipe/MultiwordToken.cs new file mode 100644 index 0000000000000000000000000000000000000000..0c0d174d4568b275e8ccba0da645baae911f6451 --- /dev/null +++ b/UDPipe/v1/binary/linux64/csharp/Ufal/UDPipe/MultiwordToken.cs @@ -0,0 +1,81 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +public class MultiwordToken : Token { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + + internal MultiwordToken(global::System.IntPtr cPtr, bool cMemoryOwn) : base(udpipe_csharpPINVOKE.MultiwordToken_SWIGUpcast(cPtr), cMemoryOwn) { + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(MultiwordToken obj) { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + ~MultiwordToken() { + Dispose(); + } + + public override void Dispose() { + lock(this) { + if (swigCPtr.Handle != global::System.IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + udpipe_csharpPINVOKE.delete_MultiwordToken(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + global::System.GC.SuppressFinalize(this); + base.Dispose(); + } + } + + public int idFirst { + set { + udpipe_csharpPINVOKE.MultiwordToken_idFirst_set(swigCPtr, value); + } + get { + int ret = udpipe_csharpPINVOKE.MultiwordToken_idFirst_get(swigCPtr); + return ret; + } + } + + public int idLast { + set { + udpipe_csharpPINVOKE.MultiwordToken_idLast_set(swigCPtr, value); + } + get { + int ret = udpipe_csharpPINVOKE.MultiwordToken_idLast_get(swigCPtr); + return ret; + } + } + + public MultiwordToken(int id_first, int id_last, string form, string misc) : this(udpipe_csharpPINVOKE.new_MultiwordToken__SWIG_0(id_first, id_last, form, misc), true) { + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public MultiwordToken(int id_first, int id_last, string form) : this(udpipe_csharpPINVOKE.new_MultiwordToken__SWIG_1(id_first, id_last, form), true) { + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public MultiwordToken(int id_first, int id_last) : this(udpipe_csharpPINVOKE.new_MultiwordToken__SWIG_2(id_first, id_last), true) { + } + + public MultiwordToken(int id_first) : this(udpipe_csharpPINVOKE.new_MultiwordToken__SWIG_3(id_first), true) { + } + + public MultiwordToken() : this(udpipe_csharpPINVOKE.new_MultiwordToken__SWIG_4(), true) { + } + +} + +} diff --git a/UDPipe/v1/binary/linux64/csharp/Ufal/UDPipe/MultiwordTokens.cs b/UDPipe/v1/binary/linux64/csharp/Ufal/UDPipe/MultiwordTokens.cs new file mode 100644 index 0000000000000000000000000000000000000000..0e901203b8632f1636e8b5725efa90ecffbf1f7e --- /dev/null +++ b/UDPipe/v1/binary/linux64/csharp/Ufal/UDPipe/MultiwordTokens.cs @@ -0,0 +1,309 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +public class MultiwordTokens : global::System.IDisposable, global::System.Collections.IEnumerable + , global::System.Collections.Generic.IEnumerable + { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal MultiwordTokens(global::System.IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(MultiwordTokens obj) { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + ~MultiwordTokens() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != global::System.IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + udpipe_csharpPINVOKE.delete_MultiwordTokens(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + global::System.GC.SuppressFinalize(this); + } + } + + public MultiwordTokens(global::System.Collections.ICollection c) : this() { + if (c == null) + throw new global::System.ArgumentNullException("c"); + foreach (MultiwordToken element in c) { + this.Add(element); + } + } + + public bool IsFixedSize { + get { + return false; + } + } + + public bool IsReadOnly { + get { + return false; + } + } + + public MultiwordToken this[int index] { + get { + return getitem(index); + } + set { + setitem(index, value); + } + } + + public int Capacity { + get { + return (int)capacity(); + } + set { + if (value < size()) + throw new global::System.ArgumentOutOfRangeException("Capacity"); + reserve((uint)value); + } + } + + public int Count { + get { + return (int)size(); + } + } + + public bool IsSynchronized { + get { + return false; + } + } + + public void CopyTo(MultiwordToken[] array) + { + CopyTo(0, array, 0, this.Count); + } + + public void CopyTo(MultiwordToken[] array, int arrayIndex) + { + CopyTo(0, array, arrayIndex, this.Count); + } + + public void CopyTo(int index, MultiwordToken[] array, int arrayIndex, int count) + { + if (array == null) + throw new global::System.ArgumentNullException("array"); + if (index < 0) + throw new global::System.ArgumentOutOfRangeException("index", "Value is less than zero"); + if (arrayIndex < 0) + throw new global::System.ArgumentOutOfRangeException("arrayIndex", "Value is less than zero"); + if (count < 0) + throw new global::System.ArgumentOutOfRangeException("count", "Value is less than zero"); + if (array.Rank > 1) + throw new global::System.ArgumentException("Multi dimensional array.", "array"); + if (index+count > this.Count || arrayIndex+count > array.Length) + throw new global::System.ArgumentException("Number of elements to copy is too large."); + for (int i=0; i global::System.Collections.Generic.IEnumerable.GetEnumerator() { + return new MultiwordTokensEnumerator(this); + } + + global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator() { + return new MultiwordTokensEnumerator(this); + } + + public MultiwordTokensEnumerator GetEnumerator() { + return new MultiwordTokensEnumerator(this); + } + + // Type-safe enumerator + /// Note that the IEnumerator documentation requires an InvalidOperationException to be thrown + /// whenever the collection is modified. This has been done for changes in the size of the + /// collection but not when one of the elements of the collection is modified as it is a bit + /// tricky to detect unmanaged code that modifies the collection under our feet. + public sealed class MultiwordTokensEnumerator : global::System.Collections.IEnumerator + , global::System.Collections.Generic.IEnumerator + { + private MultiwordTokens collectionRef; + private int currentIndex; + private object currentObject; + private int currentSize; + + public MultiwordTokensEnumerator(MultiwordTokens collection) { + collectionRef = collection; + currentIndex = -1; + currentObject = null; + currentSize = collectionRef.Count; + } + + // Type-safe iterator Current + public MultiwordToken Current { + get { + if (currentIndex == -1) + throw new global::System.InvalidOperationException("Enumeration not started."); + if (currentIndex > currentSize - 1) + throw new global::System.InvalidOperationException("Enumeration finished."); + if (currentObject == null) + throw new global::System.InvalidOperationException("Collection modified."); + return (MultiwordToken)currentObject; + } + } + + // Type-unsafe IEnumerator.Current + object global::System.Collections.IEnumerator.Current { + get { + return Current; + } + } + + public bool MoveNext() { + int size = collectionRef.Count; + bool moveOkay = (currentIndex+1 < size) && (size == currentSize); + if (moveOkay) { + currentIndex++; + currentObject = collectionRef[currentIndex]; + } else { + currentObject = null; + } + return moveOkay; + } + + public void Reset() { + currentIndex = -1; + currentObject = null; + if (collectionRef.Count != currentSize) { + throw new global::System.InvalidOperationException("Collection modified."); + } + } + + public void Dispose() { + currentIndex = -1; + currentObject = null; + } + } + + public void Clear() { + udpipe_csharpPINVOKE.MultiwordTokens_Clear(swigCPtr); + } + + public void Add(MultiwordToken x) { + udpipe_csharpPINVOKE.MultiwordTokens_Add(swigCPtr, MultiwordToken.getCPtr(x)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + private uint size() { + uint ret = udpipe_csharpPINVOKE.MultiwordTokens_size(swigCPtr); + return ret; + } + + private uint capacity() { + uint ret = udpipe_csharpPINVOKE.MultiwordTokens_capacity(swigCPtr); + return ret; + } + + private void reserve(uint n) { + udpipe_csharpPINVOKE.MultiwordTokens_reserve(swigCPtr, n); + } + + public MultiwordTokens() : this(udpipe_csharpPINVOKE.new_MultiwordTokens__SWIG_0(), true) { + } + + public MultiwordTokens(MultiwordTokens other) : this(udpipe_csharpPINVOKE.new_MultiwordTokens__SWIG_1(MultiwordTokens.getCPtr(other)), true) { + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public MultiwordTokens(int capacity) : this(udpipe_csharpPINVOKE.new_MultiwordTokens__SWIG_2(capacity), true) { + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + private MultiwordToken getitemcopy(int index) { + MultiwordToken ret = new MultiwordToken(udpipe_csharpPINVOKE.MultiwordTokens_getitemcopy(swigCPtr, index), true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + private MultiwordToken getitem(int index) { + MultiwordToken ret = new MultiwordToken(udpipe_csharpPINVOKE.MultiwordTokens_getitem(swigCPtr, index), false); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + private void setitem(int index, MultiwordToken val) { + udpipe_csharpPINVOKE.MultiwordTokens_setitem(swigCPtr, index, MultiwordToken.getCPtr(val)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void AddRange(MultiwordTokens values) { + udpipe_csharpPINVOKE.MultiwordTokens_AddRange(swigCPtr, MultiwordTokens.getCPtr(values)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public MultiwordTokens GetRange(int index, int count) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.MultiwordTokens_GetRange(swigCPtr, index, count); + MultiwordTokens ret = (cPtr == global::System.IntPtr.Zero) ? null : new MultiwordTokens(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public void Insert(int index, MultiwordToken x) { + udpipe_csharpPINVOKE.MultiwordTokens_Insert(swigCPtr, index, MultiwordToken.getCPtr(x)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void InsertRange(int index, MultiwordTokens values) { + udpipe_csharpPINVOKE.MultiwordTokens_InsertRange(swigCPtr, index, MultiwordTokens.getCPtr(values)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void RemoveAt(int index) { + udpipe_csharpPINVOKE.MultiwordTokens_RemoveAt(swigCPtr, index); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void RemoveRange(int index, int count) { + udpipe_csharpPINVOKE.MultiwordTokens_RemoveRange(swigCPtr, index, count); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public static MultiwordTokens Repeat(MultiwordToken value, int count) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.MultiwordTokens_Repeat(MultiwordToken.getCPtr(value), count); + MultiwordTokens ret = (cPtr == global::System.IntPtr.Zero) ? null : new MultiwordTokens(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public void Reverse() { + udpipe_csharpPINVOKE.MultiwordTokens_Reverse__SWIG_0(swigCPtr); + } + + public void Reverse(int index, int count) { + udpipe_csharpPINVOKE.MultiwordTokens_Reverse__SWIG_1(swigCPtr, index, count); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void SetRange(int index, MultiwordTokens values) { + udpipe_csharpPINVOKE.MultiwordTokens_SetRange(swigCPtr, index, MultiwordTokens.getCPtr(values)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + +} + +} diff --git a/UDPipe/v1/binary/linux64/csharp/Ufal/UDPipe/OutputFormat.cs b/UDPipe/v1/binary/linux64/csharp/Ufal/UDPipe/OutputFormat.cs new file mode 100644 index 0000000000000000000000000000000000000000..e15d216ec5790ea52aa23b38a59849e151e8439c --- /dev/null +++ b/UDPipe/v1/binary/linux64/csharp/Ufal/UDPipe/OutputFormat.cs @@ -0,0 +1,176 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +public class OutputFormat : global::System.IDisposable { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal OutputFormat(global::System.IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(OutputFormat obj) { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + ~OutputFormat() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != global::System.IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + udpipe_csharpPINVOKE.delete_OutputFormat(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + global::System.GC.SuppressFinalize(this); + } + } + + public virtual string writeSentence(Sentence s) { + string ret = udpipe_csharpPINVOKE.OutputFormat_writeSentence(swigCPtr, Sentence.getCPtr(s)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public virtual string finishDocument() { + string ret = udpipe_csharpPINVOKE.OutputFormat_finishDocument(swigCPtr); + return ret; + } + + public static OutputFormat newOutputFormat(string name) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.OutputFormat_newOutputFormat(name); + OutputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new OutputFormat(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public static OutputFormat newConlluOutputFormat(string options) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.OutputFormat_newConlluOutputFormat__SWIG_0(options); + OutputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new OutputFormat(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public static OutputFormat newConlluOutputFormat() { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.OutputFormat_newConlluOutputFormat__SWIG_1(); + OutputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new OutputFormat(cPtr, true); + return ret; + } + + public static OutputFormat newEpeOutputFormat(string options) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.OutputFormat_newEpeOutputFormat__SWIG_0(options); + OutputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new OutputFormat(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public static OutputFormat newEpeOutputFormat() { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.OutputFormat_newEpeOutputFormat__SWIG_1(); + OutputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new OutputFormat(cPtr, true); + return ret; + } + + public static OutputFormat newMatxinOutputFormat(string options) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.OutputFormat_newMatxinOutputFormat__SWIG_0(options); + OutputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new OutputFormat(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public static OutputFormat newMatxinOutputFormat() { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.OutputFormat_newMatxinOutputFormat__SWIG_1(); + OutputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new OutputFormat(cPtr, true); + return ret; + } + + public static OutputFormat newHorizontalOutputFormat(string options) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.OutputFormat_newHorizontalOutputFormat__SWIG_0(options); + OutputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new OutputFormat(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public static OutputFormat newHorizontalOutputFormat() { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.OutputFormat_newHorizontalOutputFormat__SWIG_1(); + OutputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new OutputFormat(cPtr, true); + return ret; + } + + public static OutputFormat newPlaintextOutputFormat(string options) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.OutputFormat_newPlaintextOutputFormat__SWIG_0(options); + OutputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new OutputFormat(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public static OutputFormat newPlaintextOutputFormat() { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.OutputFormat_newPlaintextOutputFormat__SWIG_1(); + OutputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new OutputFormat(cPtr, true); + return ret; + } + + public static OutputFormat newVerticalOutputFormat(string options) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.OutputFormat_newVerticalOutputFormat__SWIG_0(options); + OutputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new OutputFormat(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public static OutputFormat newVerticalOutputFormat() { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.OutputFormat_newVerticalOutputFormat__SWIG_1(); + OutputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new OutputFormat(cPtr, true); + return ret; + } + + public static string CONLLU_V1 { + get { + string ret = udpipe_csharpPINVOKE.OutputFormat_CONLLU_V1_get(); + return ret; + } + } + + public static string CONLLU_V2 { + get { + string ret = udpipe_csharpPINVOKE.OutputFormat_CONLLU_V2_get(); + return ret; + } + } + + public static string HORIZONTAL_PARAGRAPHS { + get { + string ret = udpipe_csharpPINVOKE.OutputFormat_HORIZONTAL_PARAGRAPHS_get(); + return ret; + } + } + + public static string PLAINTEXT_NORMALIZED_SPACES { + get { + string ret = udpipe_csharpPINVOKE.OutputFormat_PLAINTEXT_NORMALIZED_SPACES_get(); + return ret; + } + } + + public static string VERTICAL_PARAGRAPHS { + get { + string ret = udpipe_csharpPINVOKE.OutputFormat_VERTICAL_PARAGRAPHS_get(); + return ret; + } + } + +} + +} diff --git a/UDPipe/v1/binary/linux64/csharp/Ufal/UDPipe/Pipeline.cs b/UDPipe/v1/binary/linux64/csharp/Ufal/UDPipe/Pipeline.cs new file mode 100644 index 0000000000000000000000000000000000000000..370b33368ba0c8056a906dcde9ed5478710a41c4 --- /dev/null +++ b/UDPipe/v1/binary/linux64/csharp/Ufal/UDPipe/Pipeline.cs @@ -0,0 +1,108 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +public class Pipeline : global::System.IDisposable { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal Pipeline(global::System.IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Pipeline obj) { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + ~Pipeline() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != global::System.IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + udpipe_csharpPINVOKE.delete_Pipeline(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + global::System.GC.SuppressFinalize(this); + } + } + + public Pipeline(Model m, string input, string tagger, string parser, string output) : this(udpipe_csharpPINVOKE.new_Pipeline(Model.getCPtr(m), input, tagger, parser, output), true) { + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void setModel(Model m) { + udpipe_csharpPINVOKE.Pipeline_setModel(swigCPtr, Model.getCPtr(m)); + } + + public void setInput(string input) { + udpipe_csharpPINVOKE.Pipeline_setInput(swigCPtr, input); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void setTagger(string tagger) { + udpipe_csharpPINVOKE.Pipeline_setTagger(swigCPtr, tagger); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void setParser(string parser) { + udpipe_csharpPINVOKE.Pipeline_setParser(swigCPtr, parser); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void setOutput(string output) { + udpipe_csharpPINVOKE.Pipeline_setOutput(swigCPtr, output); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void setImmediate(bool immediate) { + udpipe_csharpPINVOKE.Pipeline_setImmediate(swigCPtr, immediate); + } + + public void setDocumentId(string document_id) { + udpipe_csharpPINVOKE.Pipeline_setDocumentId(swigCPtr, document_id); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public string process(string data, ProcessingError error) { + string ret = udpipe_csharpPINVOKE.Pipeline_process__SWIG_0(swigCPtr, data, ProcessingError.getCPtr(error)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public string process(string data) { + string ret = udpipe_csharpPINVOKE.Pipeline_process__SWIG_1(swigCPtr, data); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public static string DEFAULT { + get { + string ret = udpipe_csharpPINVOKE.Pipeline_DEFAULT_get(); + return ret; + } + } + + public static string NONE { + get { + string ret = udpipe_csharpPINVOKE.Pipeline_NONE_get(); + return ret; + } + } + +} + +} diff --git a/UDPipe/v1/binary/linux64/csharp/Ufal/UDPipe/ProcessingError.cs b/UDPipe/v1/binary/linux64/csharp/Ufal/UDPipe/ProcessingError.cs new file mode 100644 index 0000000000000000000000000000000000000000..f68346cd50e55daf567824eb3cc778db1b253389 --- /dev/null +++ b/UDPipe/v1/binary/linux64/csharp/Ufal/UDPipe/ProcessingError.cs @@ -0,0 +1,65 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +public class ProcessingError : global::System.IDisposable { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal ProcessingError(global::System.IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(ProcessingError obj) { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + ~ProcessingError() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != global::System.IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + udpipe_csharpPINVOKE.delete_ProcessingError(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + global::System.GC.SuppressFinalize(this); + } + } + + public bool occurred() { + bool ret = udpipe_csharpPINVOKE.ProcessingError_occurred(swigCPtr); + return ret; + } + + public string message { + set { + udpipe_csharpPINVOKE.ProcessingError_message_set(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + get { + string ret = udpipe_csharpPINVOKE.ProcessingError_message_get(swigCPtr); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + } + + public ProcessingError() : this(udpipe_csharpPINVOKE.new_ProcessingError(), true) { + } + +} + +} diff --git a/UDPipe/v1/binary/linux64/csharp/Ufal/UDPipe/Sentence.cs b/UDPipe/v1/binary/linux64/csharp/Ufal/UDPipe/Sentence.cs new file mode 100644 index 0000000000000000000000000000000000000000..9efe884c1a7face6b7f8875411b08f95a8740c6b --- /dev/null +++ b/UDPipe/v1/binary/linux64/csharp/Ufal/UDPipe/Sentence.cs @@ -0,0 +1,180 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +public class Sentence : global::System.IDisposable { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal Sentence(global::System.IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Sentence obj) { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + ~Sentence() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != global::System.IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + udpipe_csharpPINVOKE.delete_Sentence(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + global::System.GC.SuppressFinalize(this); + } + } + + public Sentence() : this(udpipe_csharpPINVOKE.new_Sentence(), true) { + } + + public Words words { + set { + udpipe_csharpPINVOKE.Sentence_words_set(swigCPtr, Words.getCPtr(value)); + } + get { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.Sentence_words_get(swigCPtr); + Words ret = (cPtr == global::System.IntPtr.Zero) ? null : new Words(cPtr, false); + return ret; + } + } + + public MultiwordTokens multiwordTokens { + set { + udpipe_csharpPINVOKE.Sentence_multiwordTokens_set(swigCPtr, MultiwordTokens.getCPtr(value)); + } + get { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.Sentence_multiwordTokens_get(swigCPtr); + MultiwordTokens ret = (cPtr == global::System.IntPtr.Zero) ? null : new MultiwordTokens(cPtr, false); + return ret; + } + } + + public EmptyNodes emptyNodes { + set { + udpipe_csharpPINVOKE.Sentence_emptyNodes_set(swigCPtr, EmptyNodes.getCPtr(value)); + } + get { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.Sentence_emptyNodes_get(swigCPtr); + EmptyNodes ret = (cPtr == global::System.IntPtr.Zero) ? null : new EmptyNodes(cPtr, false); + return ret; + } + } + + public Comments comments { + set { + udpipe_csharpPINVOKE.Sentence_comments_set(swigCPtr, Comments.getCPtr(value)); + } + get { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.Sentence_comments_get(swigCPtr); + Comments ret = (cPtr == global::System.IntPtr.Zero) ? null : new Comments(cPtr, false); + return ret; + } + } + + public static string rootForm { + get { + string ret = udpipe_csharpPINVOKE.Sentence_rootForm_get(); + return ret; + } + } + + public bool empty() { + bool ret = udpipe_csharpPINVOKE.Sentence_empty(swigCPtr); + return ret; + } + + public void clear() { + udpipe_csharpPINVOKE.Sentence_clear(swigCPtr); + } + + public virtual Word addWord(string form) { + Word ret = new Word(udpipe_csharpPINVOKE.Sentence_addWord(swigCPtr, form), false); + return ret; + } + + public void setHead(int id, int head, string deprel) { + udpipe_csharpPINVOKE.Sentence_setHead(swigCPtr, id, head, deprel); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void unlinkAllNodes() { + udpipe_csharpPINVOKE.Sentence_unlinkAllNodes(swigCPtr); + } + + public bool getNewDoc() { + bool ret = udpipe_csharpPINVOKE.Sentence_getNewDoc(swigCPtr); + return ret; + } + + public string getNewDocId() { + string ret = udpipe_csharpPINVOKE.Sentence_getNewDocId(swigCPtr); + return ret; + } + + public void setNewDoc(bool new_doc, string id) { + udpipe_csharpPINVOKE.Sentence_setNewDoc__SWIG_0(swigCPtr, new_doc, id); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void setNewDoc(bool new_doc) { + udpipe_csharpPINVOKE.Sentence_setNewDoc__SWIG_1(swigCPtr, new_doc); + } + + public bool getNewPar() { + bool ret = udpipe_csharpPINVOKE.Sentence_getNewPar(swigCPtr); + return ret; + } + + public string getNewParId() { + string ret = udpipe_csharpPINVOKE.Sentence_getNewParId(swigCPtr); + return ret; + } + + public void setNewPar(bool new_par, string id) { + udpipe_csharpPINVOKE.Sentence_setNewPar__SWIG_0(swigCPtr, new_par, id); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void setNewPar(bool new_par) { + udpipe_csharpPINVOKE.Sentence_setNewPar__SWIG_1(swigCPtr, new_par); + } + + public string getSentId() { + string ret = udpipe_csharpPINVOKE.Sentence_getSentId(swigCPtr); + return ret; + } + + public void setSentId(string id) { + udpipe_csharpPINVOKE.Sentence_setSentId(swigCPtr, id); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public string getText() { + string ret = udpipe_csharpPINVOKE.Sentence_getText(swigCPtr); + return ret; + } + + public void setText(string id) { + udpipe_csharpPINVOKE.Sentence_setText(swigCPtr, id); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + +} + +} diff --git a/UDPipe/v1/binary/linux64/csharp/Ufal/UDPipe/Sentences.cs b/UDPipe/v1/binary/linux64/csharp/Ufal/UDPipe/Sentences.cs new file mode 100644 index 0000000000000000000000000000000000000000..4247f211a86a8e8c0e5af30d72613005a3bf4d15 --- /dev/null +++ b/UDPipe/v1/binary/linux64/csharp/Ufal/UDPipe/Sentences.cs @@ -0,0 +1,309 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +public class Sentences : global::System.IDisposable, global::System.Collections.IEnumerable + , global::System.Collections.Generic.IEnumerable + { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal Sentences(global::System.IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Sentences obj) { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + ~Sentences() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != global::System.IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + udpipe_csharpPINVOKE.delete_Sentences(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + global::System.GC.SuppressFinalize(this); + } + } + + public Sentences(global::System.Collections.ICollection c) : this() { + if (c == null) + throw new global::System.ArgumentNullException("c"); + foreach (Sentence element in c) { + this.Add(element); + } + } + + public bool IsFixedSize { + get { + return false; + } + } + + public bool IsReadOnly { + get { + return false; + } + } + + public Sentence this[int index] { + get { + return getitem(index); + } + set { + setitem(index, value); + } + } + + public int Capacity { + get { + return (int)capacity(); + } + set { + if (value < size()) + throw new global::System.ArgumentOutOfRangeException("Capacity"); + reserve((uint)value); + } + } + + public int Count { + get { + return (int)size(); + } + } + + public bool IsSynchronized { + get { + return false; + } + } + + public void CopyTo(Sentence[] array) + { + CopyTo(0, array, 0, this.Count); + } + + public void CopyTo(Sentence[] array, int arrayIndex) + { + CopyTo(0, array, arrayIndex, this.Count); + } + + public void CopyTo(int index, Sentence[] array, int arrayIndex, int count) + { + if (array == null) + throw new global::System.ArgumentNullException("array"); + if (index < 0) + throw new global::System.ArgumentOutOfRangeException("index", "Value is less than zero"); + if (arrayIndex < 0) + throw new global::System.ArgumentOutOfRangeException("arrayIndex", "Value is less than zero"); + if (count < 0) + throw new global::System.ArgumentOutOfRangeException("count", "Value is less than zero"); + if (array.Rank > 1) + throw new global::System.ArgumentException("Multi dimensional array.", "array"); + if (index+count > this.Count || arrayIndex+count > array.Length) + throw new global::System.ArgumentException("Number of elements to copy is too large."); + for (int i=0; i global::System.Collections.Generic.IEnumerable.GetEnumerator() { + return new SentencesEnumerator(this); + } + + global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator() { + return new SentencesEnumerator(this); + } + + public SentencesEnumerator GetEnumerator() { + return new SentencesEnumerator(this); + } + + // Type-safe enumerator + /// Note that the IEnumerator documentation requires an InvalidOperationException to be thrown + /// whenever the collection is modified. This has been done for changes in the size of the + /// collection but not when one of the elements of the collection is modified as it is a bit + /// tricky to detect unmanaged code that modifies the collection under our feet. + public sealed class SentencesEnumerator : global::System.Collections.IEnumerator + , global::System.Collections.Generic.IEnumerator + { + private Sentences collectionRef; + private int currentIndex; + private object currentObject; + private int currentSize; + + public SentencesEnumerator(Sentences collection) { + collectionRef = collection; + currentIndex = -1; + currentObject = null; + currentSize = collectionRef.Count; + } + + // Type-safe iterator Current + public Sentence Current { + get { + if (currentIndex == -1) + throw new global::System.InvalidOperationException("Enumeration not started."); + if (currentIndex > currentSize - 1) + throw new global::System.InvalidOperationException("Enumeration finished."); + if (currentObject == null) + throw new global::System.InvalidOperationException("Collection modified."); + return (Sentence)currentObject; + } + } + + // Type-unsafe IEnumerator.Current + object global::System.Collections.IEnumerator.Current { + get { + return Current; + } + } + + public bool MoveNext() { + int size = collectionRef.Count; + bool moveOkay = (currentIndex+1 < size) && (size == currentSize); + if (moveOkay) { + currentIndex++; + currentObject = collectionRef[currentIndex]; + } else { + currentObject = null; + } + return moveOkay; + } + + public void Reset() { + currentIndex = -1; + currentObject = null; + if (collectionRef.Count != currentSize) { + throw new global::System.InvalidOperationException("Collection modified."); + } + } + + public void Dispose() { + currentIndex = -1; + currentObject = null; + } + } + + public void Clear() { + udpipe_csharpPINVOKE.Sentences_Clear(swigCPtr); + } + + public void Add(Sentence x) { + udpipe_csharpPINVOKE.Sentences_Add(swigCPtr, Sentence.getCPtr(x)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + private uint size() { + uint ret = udpipe_csharpPINVOKE.Sentences_size(swigCPtr); + return ret; + } + + private uint capacity() { + uint ret = udpipe_csharpPINVOKE.Sentences_capacity(swigCPtr); + return ret; + } + + private void reserve(uint n) { + udpipe_csharpPINVOKE.Sentences_reserve(swigCPtr, n); + } + + public Sentences() : this(udpipe_csharpPINVOKE.new_Sentences__SWIG_0(), true) { + } + + public Sentences(Sentences other) : this(udpipe_csharpPINVOKE.new_Sentences__SWIG_1(Sentences.getCPtr(other)), true) { + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public Sentences(int capacity) : this(udpipe_csharpPINVOKE.new_Sentences__SWIG_2(capacity), true) { + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + private Sentence getitemcopy(int index) { + Sentence ret = new Sentence(udpipe_csharpPINVOKE.Sentences_getitemcopy(swigCPtr, index), true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + private Sentence getitem(int index) { + Sentence ret = new Sentence(udpipe_csharpPINVOKE.Sentences_getitem(swigCPtr, index), false); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + private void setitem(int index, Sentence val) { + udpipe_csharpPINVOKE.Sentences_setitem(swigCPtr, index, Sentence.getCPtr(val)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void AddRange(Sentences values) { + udpipe_csharpPINVOKE.Sentences_AddRange(swigCPtr, Sentences.getCPtr(values)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public Sentences GetRange(int index, int count) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.Sentences_GetRange(swigCPtr, index, count); + Sentences ret = (cPtr == global::System.IntPtr.Zero) ? null : new Sentences(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public void Insert(int index, Sentence x) { + udpipe_csharpPINVOKE.Sentences_Insert(swigCPtr, index, Sentence.getCPtr(x)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void InsertRange(int index, Sentences values) { + udpipe_csharpPINVOKE.Sentences_InsertRange(swigCPtr, index, Sentences.getCPtr(values)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void RemoveAt(int index) { + udpipe_csharpPINVOKE.Sentences_RemoveAt(swigCPtr, index); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void RemoveRange(int index, int count) { + udpipe_csharpPINVOKE.Sentences_RemoveRange(swigCPtr, index, count); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public static Sentences Repeat(Sentence value, int count) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.Sentences_Repeat(Sentence.getCPtr(value), count); + Sentences ret = (cPtr == global::System.IntPtr.Zero) ? null : new Sentences(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public void Reverse() { + udpipe_csharpPINVOKE.Sentences_Reverse__SWIG_0(swigCPtr); + } + + public void Reverse(int index, int count) { + udpipe_csharpPINVOKE.Sentences_Reverse__SWIG_1(swigCPtr, index, count); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void SetRange(int index, Sentences values) { + udpipe_csharpPINVOKE.Sentences_SetRange(swigCPtr, index, Sentences.getCPtr(values)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + +} + +} diff --git a/UDPipe/v1/binary/linux64/csharp/Ufal/UDPipe/Token.cs b/UDPipe/v1/binary/linux64/csharp/Ufal/UDPipe/Token.cs new file mode 100644 index 0000000000000000000000000000000000000000..bdeb83f9f005909bf47142481a85c7f537d63eab --- /dev/null +++ b/UDPipe/v1/binary/linux64/csharp/Ufal/UDPipe/Token.cs @@ -0,0 +1,138 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +public class Token : global::System.IDisposable { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal Token(global::System.IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Token obj) { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + ~Token() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != global::System.IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + udpipe_csharpPINVOKE.delete_Token(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + global::System.GC.SuppressFinalize(this); + } + } + + public string form { + set { + udpipe_csharpPINVOKE.Token_form_set(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + get { + string ret = udpipe_csharpPINVOKE.Token_form_get(swigCPtr); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + } + + public string misc { + set { + udpipe_csharpPINVOKE.Token_misc_set(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + get { + string ret = udpipe_csharpPINVOKE.Token_misc_get(swigCPtr); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + } + + public Token(string form, string misc) : this(udpipe_csharpPINVOKE.new_Token__SWIG_0(form, misc), true) { + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public Token(string form) : this(udpipe_csharpPINVOKE.new_Token__SWIG_1(form), true) { + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public Token() : this(udpipe_csharpPINVOKE.new_Token__SWIG_2(), true) { + } + + public bool getSpaceAfter() { + bool ret = udpipe_csharpPINVOKE.Token_getSpaceAfter(swigCPtr); + return ret; + } + + public void setSpaceAfter(bool space_after) { + udpipe_csharpPINVOKE.Token_setSpaceAfter(swigCPtr, space_after); + } + + public string getSpacesBefore() { + string ret = udpipe_csharpPINVOKE.Token_getSpacesBefore(swigCPtr); + return ret; + } + + public void setSpacesBefore(string spaces_before) { + udpipe_csharpPINVOKE.Token_setSpacesBefore(swigCPtr, spaces_before); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public string getSpacesAfter() { + string ret = udpipe_csharpPINVOKE.Token_getSpacesAfter(swigCPtr); + return ret; + } + + public void setSpacesAfter(string spaces_after) { + udpipe_csharpPINVOKE.Token_setSpacesAfter(swigCPtr, spaces_after); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public string getSpacesInToken() { + string ret = udpipe_csharpPINVOKE.Token_getSpacesInToken(swigCPtr); + return ret; + } + + public void setSpacesInToken(string spaces_in_token) { + udpipe_csharpPINVOKE.Token_setSpacesInToken(swigCPtr, spaces_in_token); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public bool getTokenRange() { + bool ret = udpipe_csharpPINVOKE.Token_getTokenRange(swigCPtr); + return ret; + } + + public uint getTokenRangeStart() { + uint ret = udpipe_csharpPINVOKE.Token_getTokenRangeStart(swigCPtr); + return ret; + } + + public uint getTokenRangeEnd() { + uint ret = udpipe_csharpPINVOKE.Token_getTokenRangeEnd(swigCPtr); + return ret; + } + + public void setTokenRange(uint start, uint end) { + udpipe_csharpPINVOKE.Token_setTokenRange(swigCPtr, start, end); + } + +} + +} diff --git a/UDPipe/v1/binary/linux64/csharp/Ufal/UDPipe/Trainer.cs b/UDPipe/v1/binary/linux64/csharp/Ufal/UDPipe/Trainer.cs new file mode 100644 index 0000000000000000000000000000000000000000..31dcaada1065b721d6e5c757087b3f7f20423273 --- /dev/null +++ b/UDPipe/v1/binary/linux64/csharp/Ufal/UDPipe/Trainer.cs @@ -0,0 +1,74 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +public class Trainer : global::System.IDisposable { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal Trainer(global::System.IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Trainer obj) { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + ~Trainer() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != global::System.IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + udpipe_csharpPINVOKE.delete_Trainer(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + global::System.GC.SuppressFinalize(this); + } + } + + public static string train(string method, Sentences train, Sentences heldout, string tokenizer, string tagger, string parser, ProcessingError error) { + string ret = udpipe_csharpPINVOKE.Trainer_train__SWIG_0(method, Sentences.getCPtr(train), Sentences.getCPtr(heldout), tokenizer, tagger, parser, ProcessingError.getCPtr(error)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public static string train(string method, Sentences train, Sentences heldout, string tokenizer, string tagger, string parser) { + string ret = udpipe_csharpPINVOKE.Trainer_train__SWIG_1(method, Sentences.getCPtr(train), Sentences.getCPtr(heldout), tokenizer, tagger, parser); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public static string DEFAULT { + get { + string ret = udpipe_csharpPINVOKE.Trainer_DEFAULT_get(); + return ret; + } + } + + public static string NONE { + get { + string ret = udpipe_csharpPINVOKE.Trainer_NONE_get(); + return ret; + } + } + + public Trainer() : this(udpipe_csharpPINVOKE.new_Trainer(), true) { + } + +} + +} diff --git a/UDPipe/v1/binary/linux64/csharp/Ufal/UDPipe/Version.cs b/UDPipe/v1/binary/linux64/csharp/Ufal/UDPipe/Version.cs new file mode 100644 index 0000000000000000000000000000000000000000..39434dd0ed3e5d35f59618ef7b418a5f4fcc4e21 --- /dev/null +++ b/UDPipe/v1/binary/linux64/csharp/Ufal/UDPipe/Version.cs @@ -0,0 +1,95 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +public class Version : global::System.IDisposable { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal Version(global::System.IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Version obj) { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + ~Version() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != global::System.IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + udpipe_csharpPINVOKE.delete_Version(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + global::System.GC.SuppressFinalize(this); + } + } + + public uint major { + set { + udpipe_csharpPINVOKE.Version_major_set(swigCPtr, value); + } + get { + uint ret = udpipe_csharpPINVOKE.Version_major_get(swigCPtr); + return ret; + } + } + + public uint minor { + set { + udpipe_csharpPINVOKE.Version_minor_set(swigCPtr, value); + } + get { + uint ret = udpipe_csharpPINVOKE.Version_minor_get(swigCPtr); + return ret; + } + } + + public uint patch { + set { + udpipe_csharpPINVOKE.Version_patch_set(swigCPtr, value); + } + get { + uint ret = udpipe_csharpPINVOKE.Version_patch_get(swigCPtr); + return ret; + } + } + + public string prerelease { + set { + udpipe_csharpPINVOKE.Version_prerelease_set(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + get { + string ret = udpipe_csharpPINVOKE.Version_prerelease_get(swigCPtr); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + } + + public static Version current() { + Version ret = new Version(udpipe_csharpPINVOKE.Version_current(), true); + return ret; + } + + public Version() : this(udpipe_csharpPINVOKE.new_Version(), true) { + } + +} + +} diff --git a/UDPipe/v1/binary/linux64/csharp/Ufal/UDPipe/Word.cs b/UDPipe/v1/binary/linux64/csharp/Ufal/UDPipe/Word.cs new file mode 100644 index 0000000000000000000000000000000000000000..e0177d90469e6240406b14abcc1e06cb56536de2 --- /dev/null +++ b/UDPipe/v1/binary/linux64/csharp/Ufal/UDPipe/Word.cs @@ -0,0 +1,157 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +public class Word : Token { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + + internal Word(global::System.IntPtr cPtr, bool cMemoryOwn) : base(udpipe_csharpPINVOKE.Word_SWIGUpcast(cPtr), cMemoryOwn) { + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Word obj) { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + ~Word() { + Dispose(); + } + + public override void Dispose() { + lock(this) { + if (swigCPtr.Handle != global::System.IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + udpipe_csharpPINVOKE.delete_Word(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + global::System.GC.SuppressFinalize(this); + base.Dispose(); + } + } + + public int id { + set { + udpipe_csharpPINVOKE.Word_id_set(swigCPtr, value); + } + get { + int ret = udpipe_csharpPINVOKE.Word_id_get(swigCPtr); + return ret; + } + } + + public string lemma { + set { + udpipe_csharpPINVOKE.Word_lemma_set(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + get { + string ret = udpipe_csharpPINVOKE.Word_lemma_get(swigCPtr); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + } + + public string upostag { + set { + udpipe_csharpPINVOKE.Word_upostag_set(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + get { + string ret = udpipe_csharpPINVOKE.Word_upostag_get(swigCPtr); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + } + + public string xpostag { + set { + udpipe_csharpPINVOKE.Word_xpostag_set(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + get { + string ret = udpipe_csharpPINVOKE.Word_xpostag_get(swigCPtr); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + } + + public string feats { + set { + udpipe_csharpPINVOKE.Word_feats_set(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + get { + string ret = udpipe_csharpPINVOKE.Word_feats_get(swigCPtr); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + } + + public int head { + set { + udpipe_csharpPINVOKE.Word_head_set(swigCPtr, value); + } + get { + int ret = udpipe_csharpPINVOKE.Word_head_get(swigCPtr); + return ret; + } + } + + public string deprel { + set { + udpipe_csharpPINVOKE.Word_deprel_set(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + get { + string ret = udpipe_csharpPINVOKE.Word_deprel_get(swigCPtr); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + } + + public string deps { + set { + udpipe_csharpPINVOKE.Word_deps_set(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + get { + string ret = udpipe_csharpPINVOKE.Word_deps_get(swigCPtr); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + } + + public Children children { + set { + udpipe_csharpPINVOKE.Word_children_set(swigCPtr, Children.getCPtr(value)); + } + get { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.Word_children_get(swigCPtr); + Children ret = (cPtr == global::System.IntPtr.Zero) ? null : new Children(cPtr, false); + return ret; + } + } + + public Word(int id, string form) : this(udpipe_csharpPINVOKE.new_Word__SWIG_0(id, form), true) { + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public Word(int id) : this(udpipe_csharpPINVOKE.new_Word__SWIG_1(id), true) { + } + + public Word() : this(udpipe_csharpPINVOKE.new_Word__SWIG_2(), true) { + } + +} + +} diff --git a/UDPipe/v1/binary/linux64/csharp/Ufal/UDPipe/Words.cs b/UDPipe/v1/binary/linux64/csharp/Ufal/UDPipe/Words.cs new file mode 100644 index 0000000000000000000000000000000000000000..01c91c83ca10a20e497356a75fcb6a266e423360 --- /dev/null +++ b/UDPipe/v1/binary/linux64/csharp/Ufal/UDPipe/Words.cs @@ -0,0 +1,309 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +public class Words : global::System.IDisposable, global::System.Collections.IEnumerable + , global::System.Collections.Generic.IEnumerable + { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal Words(global::System.IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Words obj) { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + ~Words() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != global::System.IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + udpipe_csharpPINVOKE.delete_Words(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + global::System.GC.SuppressFinalize(this); + } + } + + public Words(global::System.Collections.ICollection c) : this() { + if (c == null) + throw new global::System.ArgumentNullException("c"); + foreach (Word element in c) { + this.Add(element); + } + } + + public bool IsFixedSize { + get { + return false; + } + } + + public bool IsReadOnly { + get { + return false; + } + } + + public Word this[int index] { + get { + return getitem(index); + } + set { + setitem(index, value); + } + } + + public int Capacity { + get { + return (int)capacity(); + } + set { + if (value < size()) + throw new global::System.ArgumentOutOfRangeException("Capacity"); + reserve((uint)value); + } + } + + public int Count { + get { + return (int)size(); + } + } + + public bool IsSynchronized { + get { + return false; + } + } + + public void CopyTo(Word[] array) + { + CopyTo(0, array, 0, this.Count); + } + + public void CopyTo(Word[] array, int arrayIndex) + { + CopyTo(0, array, arrayIndex, this.Count); + } + + public void CopyTo(int index, Word[] array, int arrayIndex, int count) + { + if (array == null) + throw new global::System.ArgumentNullException("array"); + if (index < 0) + throw new global::System.ArgumentOutOfRangeException("index", "Value is less than zero"); + if (arrayIndex < 0) + throw new global::System.ArgumentOutOfRangeException("arrayIndex", "Value is less than zero"); + if (count < 0) + throw new global::System.ArgumentOutOfRangeException("count", "Value is less than zero"); + if (array.Rank > 1) + throw new global::System.ArgumentException("Multi dimensional array.", "array"); + if (index+count > this.Count || arrayIndex+count > array.Length) + throw new global::System.ArgumentException("Number of elements to copy is too large."); + for (int i=0; i global::System.Collections.Generic.IEnumerable.GetEnumerator() { + return new WordsEnumerator(this); + } + + global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator() { + return new WordsEnumerator(this); + } + + public WordsEnumerator GetEnumerator() { + return new WordsEnumerator(this); + } + + // Type-safe enumerator + /// Note that the IEnumerator documentation requires an InvalidOperationException to be thrown + /// whenever the collection is modified. This has been done for changes in the size of the + /// collection but not when one of the elements of the collection is modified as it is a bit + /// tricky to detect unmanaged code that modifies the collection under our feet. + public sealed class WordsEnumerator : global::System.Collections.IEnumerator + , global::System.Collections.Generic.IEnumerator + { + private Words collectionRef; + private int currentIndex; + private object currentObject; + private int currentSize; + + public WordsEnumerator(Words collection) { + collectionRef = collection; + currentIndex = -1; + currentObject = null; + currentSize = collectionRef.Count; + } + + // Type-safe iterator Current + public Word Current { + get { + if (currentIndex == -1) + throw new global::System.InvalidOperationException("Enumeration not started."); + if (currentIndex > currentSize - 1) + throw new global::System.InvalidOperationException("Enumeration finished."); + if (currentObject == null) + throw new global::System.InvalidOperationException("Collection modified."); + return (Word)currentObject; + } + } + + // Type-unsafe IEnumerator.Current + object global::System.Collections.IEnumerator.Current { + get { + return Current; + } + } + + public bool MoveNext() { + int size = collectionRef.Count; + bool moveOkay = (currentIndex+1 < size) && (size == currentSize); + if (moveOkay) { + currentIndex++; + currentObject = collectionRef[currentIndex]; + } else { + currentObject = null; + } + return moveOkay; + } + + public void Reset() { + currentIndex = -1; + currentObject = null; + if (collectionRef.Count != currentSize) { + throw new global::System.InvalidOperationException("Collection modified."); + } + } + + public void Dispose() { + currentIndex = -1; + currentObject = null; + } + } + + public void Clear() { + udpipe_csharpPINVOKE.Words_Clear(swigCPtr); + } + + public void Add(Word x) { + udpipe_csharpPINVOKE.Words_Add(swigCPtr, Word.getCPtr(x)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + private uint size() { + uint ret = udpipe_csharpPINVOKE.Words_size(swigCPtr); + return ret; + } + + private uint capacity() { + uint ret = udpipe_csharpPINVOKE.Words_capacity(swigCPtr); + return ret; + } + + private void reserve(uint n) { + udpipe_csharpPINVOKE.Words_reserve(swigCPtr, n); + } + + public Words() : this(udpipe_csharpPINVOKE.new_Words__SWIG_0(), true) { + } + + public Words(Words other) : this(udpipe_csharpPINVOKE.new_Words__SWIG_1(Words.getCPtr(other)), true) { + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public Words(int capacity) : this(udpipe_csharpPINVOKE.new_Words__SWIG_2(capacity), true) { + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + private Word getitemcopy(int index) { + Word ret = new Word(udpipe_csharpPINVOKE.Words_getitemcopy(swigCPtr, index), true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + private Word getitem(int index) { + Word ret = new Word(udpipe_csharpPINVOKE.Words_getitem(swigCPtr, index), false); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + private void setitem(int index, Word val) { + udpipe_csharpPINVOKE.Words_setitem(swigCPtr, index, Word.getCPtr(val)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void AddRange(Words values) { + udpipe_csharpPINVOKE.Words_AddRange(swigCPtr, Words.getCPtr(values)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public Words GetRange(int index, int count) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.Words_GetRange(swigCPtr, index, count); + Words ret = (cPtr == global::System.IntPtr.Zero) ? null : new Words(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public void Insert(int index, Word x) { + udpipe_csharpPINVOKE.Words_Insert(swigCPtr, index, Word.getCPtr(x)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void InsertRange(int index, Words values) { + udpipe_csharpPINVOKE.Words_InsertRange(swigCPtr, index, Words.getCPtr(values)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void RemoveAt(int index) { + udpipe_csharpPINVOKE.Words_RemoveAt(swigCPtr, index); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void RemoveRange(int index, int count) { + udpipe_csharpPINVOKE.Words_RemoveRange(swigCPtr, index, count); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public static Words Repeat(Word value, int count) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.Words_Repeat(Word.getCPtr(value), count); + Words ret = (cPtr == global::System.IntPtr.Zero) ? null : new Words(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public void Reverse() { + udpipe_csharpPINVOKE.Words_Reverse__SWIG_0(swigCPtr); + } + + public void Reverse(int index, int count) { + udpipe_csharpPINVOKE.Words_Reverse__SWIG_1(swigCPtr, index, count); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void SetRange(int index, Words values) { + udpipe_csharpPINVOKE.Words_SetRange(swigCPtr, index, Words.getCPtr(values)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + +} + +} diff --git a/UDPipe/v1/binary/linux64/csharp/Ufal/UDPipe/udpipe_csharp.cs b/UDPipe/v1/binary/linux64/csharp/Ufal/UDPipe/udpipe_csharp.cs new file mode 100644 index 0000000000000000000000000000000000000000..01d55de404b051d95e99a2ed6741fcdc0cefa6f7 --- /dev/null +++ b/UDPipe/v1/binary/linux64/csharp/Ufal/UDPipe/udpipe_csharp.cs @@ -0,0 +1,16 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +public class udpipe_csharp { +} + +} diff --git a/UDPipe/v1/binary/linux64/csharp/Ufal/UDPipe/udpipe_csharpPINVOKE.cs b/UDPipe/v1/binary/linux64/csharp/Ufal/UDPipe/udpipe_csharpPINVOKE.cs new file mode 100644 index 0000000000000000000000000000000000000000..08fb1041bc999961dae5278a4ac3e5df51b672ea --- /dev/null +++ b/UDPipe/v1/binary/linux64/csharp/Ufal/UDPipe/udpipe_csharpPINVOKE.cs @@ -0,0 +1,1324 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +class udpipe_csharpPINVOKE { + + protected class SWIGExceptionHelper { + + public delegate void ExceptionDelegate(string message); + public delegate void ExceptionArgumentDelegate(string message, string paramName); + + static ExceptionDelegate applicationDelegate = new ExceptionDelegate(SetPendingApplicationException); + static ExceptionDelegate arithmeticDelegate = new ExceptionDelegate(SetPendingArithmeticException); + static ExceptionDelegate divideByZeroDelegate = new ExceptionDelegate(SetPendingDivideByZeroException); + static ExceptionDelegate indexOutOfRangeDelegate = new ExceptionDelegate(SetPendingIndexOutOfRangeException); + static ExceptionDelegate invalidCastDelegate = new ExceptionDelegate(SetPendingInvalidCastException); + static ExceptionDelegate invalidOperationDelegate = new ExceptionDelegate(SetPendingInvalidOperationException); + static ExceptionDelegate ioDelegate = new ExceptionDelegate(SetPendingIOException); + static ExceptionDelegate nullReferenceDelegate = new ExceptionDelegate(SetPendingNullReferenceException); + static ExceptionDelegate outOfMemoryDelegate = new ExceptionDelegate(SetPendingOutOfMemoryException); + static ExceptionDelegate overflowDelegate = new ExceptionDelegate(SetPendingOverflowException); + static ExceptionDelegate systemDelegate = new ExceptionDelegate(SetPendingSystemException); + + static ExceptionArgumentDelegate argumentDelegate = new ExceptionArgumentDelegate(SetPendingArgumentException); + static ExceptionArgumentDelegate argumentNullDelegate = new ExceptionArgumentDelegate(SetPendingArgumentNullException); + static ExceptionArgumentDelegate argumentOutOfRangeDelegate = new ExceptionArgumentDelegate(SetPendingArgumentOutOfRangeException); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="SWIGRegisterExceptionCallbacks_udpipe_csharp")] + public static extern void SWIGRegisterExceptionCallbacks_udpipe_csharp( + ExceptionDelegate applicationDelegate, + ExceptionDelegate arithmeticDelegate, + ExceptionDelegate divideByZeroDelegate, + ExceptionDelegate indexOutOfRangeDelegate, + ExceptionDelegate invalidCastDelegate, + ExceptionDelegate invalidOperationDelegate, + ExceptionDelegate ioDelegate, + ExceptionDelegate nullReferenceDelegate, + ExceptionDelegate outOfMemoryDelegate, + ExceptionDelegate overflowDelegate, + ExceptionDelegate systemExceptionDelegate); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="SWIGRegisterExceptionArgumentCallbacks_udpipe_csharp")] + public static extern void SWIGRegisterExceptionCallbacksArgument_udpipe_csharp( + ExceptionArgumentDelegate argumentDelegate, + ExceptionArgumentDelegate argumentNullDelegate, + ExceptionArgumentDelegate argumentOutOfRangeDelegate); + + static void SetPendingApplicationException(string message) { + SWIGPendingException.Set(new global::System.ApplicationException(message, SWIGPendingException.Retrieve())); + } + static void SetPendingArithmeticException(string message) { + SWIGPendingException.Set(new global::System.ArithmeticException(message, SWIGPendingException.Retrieve())); + } + static void SetPendingDivideByZeroException(string message) { + SWIGPendingException.Set(new global::System.DivideByZeroException(message, SWIGPendingException.Retrieve())); + } + static void SetPendingIndexOutOfRangeException(string message) { + SWIGPendingException.Set(new global::System.IndexOutOfRangeException(message, SWIGPendingException.Retrieve())); + } + static void SetPendingInvalidCastException(string message) { + SWIGPendingException.Set(new global::System.InvalidCastException(message, SWIGPendingException.Retrieve())); + } + static void SetPendingInvalidOperationException(string message) { + SWIGPendingException.Set(new global::System.InvalidOperationException(message, SWIGPendingException.Retrieve())); + } + static void SetPendingIOException(string message) { + SWIGPendingException.Set(new global::System.IO.IOException(message, SWIGPendingException.Retrieve())); + } + static void SetPendingNullReferenceException(string message) { + SWIGPendingException.Set(new global::System.NullReferenceException(message, SWIGPendingException.Retrieve())); + } + static void SetPendingOutOfMemoryException(string message) { + SWIGPendingException.Set(new global::System.OutOfMemoryException(message, SWIGPendingException.Retrieve())); + } + static void SetPendingOverflowException(string message) { + SWIGPendingException.Set(new global::System.OverflowException(message, SWIGPendingException.Retrieve())); + } + static void SetPendingSystemException(string message) { + SWIGPendingException.Set(new global::System.SystemException(message, SWIGPendingException.Retrieve())); + } + + static void SetPendingArgumentException(string message, string paramName) { + SWIGPendingException.Set(new global::System.ArgumentException(message, paramName, SWIGPendingException.Retrieve())); + } + static void SetPendingArgumentNullException(string message, string paramName) { + global::System.Exception e = SWIGPendingException.Retrieve(); + if (e != null) message = message + " Inner Exception: " + e.Message; + SWIGPendingException.Set(new global::System.ArgumentNullException(paramName, message)); + } + static void SetPendingArgumentOutOfRangeException(string message, string paramName) { + global::System.Exception e = SWIGPendingException.Retrieve(); + if (e != null) message = message + " Inner Exception: " + e.Message; + SWIGPendingException.Set(new global::System.ArgumentOutOfRangeException(paramName, message)); + } + + static SWIGExceptionHelper() { + SWIGRegisterExceptionCallbacks_udpipe_csharp( + applicationDelegate, + arithmeticDelegate, + divideByZeroDelegate, + indexOutOfRangeDelegate, + invalidCastDelegate, + invalidOperationDelegate, + ioDelegate, + nullReferenceDelegate, + outOfMemoryDelegate, + overflowDelegate, + systemDelegate); + + SWIGRegisterExceptionCallbacksArgument_udpipe_csharp( + argumentDelegate, + argumentNullDelegate, + argumentOutOfRangeDelegate); + } + } + + protected static SWIGExceptionHelper swigExceptionHelper = new SWIGExceptionHelper(); + + public class SWIGPendingException { + [global::System.ThreadStatic] + private static global::System.Exception pendingException = null; + private static int numExceptionsPending = 0; + + public static bool Pending { + get { + bool pending = false; + if (numExceptionsPending > 0) + if (pendingException != null) + pending = true; + return pending; + } + } + + public static void Set(global::System.Exception e) { + if (pendingException != null) + throw new global::System.ApplicationException("FATAL: An earlier pending exception from unmanaged code was missed and thus not thrown (" + pendingException.ToString() + ")", e); + pendingException = e; + lock(typeof(udpipe_csharpPINVOKE)) { + numExceptionsPending++; + } + } + + public static global::System.Exception Retrieve() { + global::System.Exception e = null; + if (numExceptionsPending > 0) { + if (pendingException != null) { + e = pendingException; + pendingException = null; + lock(typeof(udpipe_csharpPINVOKE)) { + numExceptionsPending--; + } + } + } + return e; + } + } + + + protected class SWIGStringHelper { + + public delegate string SWIGStringDelegate(string message); + static SWIGStringDelegate stringDelegate = new SWIGStringDelegate(CreateString); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="SWIGRegisterStringCallback_udpipe_csharp")] + public static extern void SWIGRegisterStringCallback_udpipe_csharp(SWIGStringDelegate stringDelegate); + + static string CreateString(string cString) { + return cString; + } + + static SWIGStringHelper() { + SWIGRegisterStringCallback_udpipe_csharp(stringDelegate); + } + } + + static protected SWIGStringHelper swigStringHelper = new SWIGStringHelper(); + + + static udpipe_csharpPINVOKE() { + } + + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_Clear")] + public static extern void Children_Clear(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_Add")] + public static extern void Children_Add(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_size")] + public static extern uint Children_size(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_capacity")] + public static extern uint Children_capacity(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_reserve")] + public static extern void Children_reserve(global::System.Runtime.InteropServices.HandleRef jarg1, uint jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Children__SWIG_0")] + public static extern global::System.IntPtr new_Children__SWIG_0(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Children__SWIG_1")] + public static extern global::System.IntPtr new_Children__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Children__SWIG_2")] + public static extern global::System.IntPtr new_Children__SWIG_2(int jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_getitemcopy")] + public static extern int Children_getitemcopy(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_getitem")] + public static extern int Children_getitem(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_setitem")] + public static extern void Children_setitem(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_AddRange")] + public static extern void Children_AddRange(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_GetRange")] + public static extern global::System.IntPtr Children_GetRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_Insert")] + public static extern void Children_Insert(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_InsertRange")] + public static extern void Children_InsertRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_RemoveAt")] + public static extern void Children_RemoveAt(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_RemoveRange")] + public static extern void Children_RemoveRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_Repeat")] + public static extern global::System.IntPtr Children_Repeat(int jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_Reverse__SWIG_0")] + public static extern void Children_Reverse__SWIG_0(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_Reverse__SWIG_1")] + public static extern void Children_Reverse__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_SetRange")] + public static extern void Children_SetRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_Contains")] + public static extern bool Children_Contains(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_IndexOf")] + public static extern int Children_IndexOf(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_LastIndexOf")] + public static extern int Children_LastIndexOf(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_Remove")] + public static extern bool Children_Remove(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_delete_Children")] + public static extern void delete_Children(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_Clear")] + public static extern void Comments_Clear(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_Add")] + public static extern void Comments_Add(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_size")] + public static extern uint Comments_size(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_capacity")] + public static extern uint Comments_capacity(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_reserve")] + public static extern void Comments_reserve(global::System.Runtime.InteropServices.HandleRef jarg1, uint jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Comments__SWIG_0")] + public static extern global::System.IntPtr new_Comments__SWIG_0(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Comments__SWIG_1")] + public static extern global::System.IntPtr new_Comments__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Comments__SWIG_2")] + public static extern global::System.IntPtr new_Comments__SWIG_2(int jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_getitemcopy")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Comments_getitemcopy(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_getitem")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Comments_getitem(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_setitem")] + public static extern void Comments_setitem(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_AddRange")] + public static extern void Comments_AddRange(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_GetRange")] + public static extern global::System.IntPtr Comments_GetRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_Insert")] + public static extern void Comments_Insert(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_InsertRange")] + public static extern void Comments_InsertRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_RemoveAt")] + public static extern void Comments_RemoveAt(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_RemoveRange")] + public static extern void Comments_RemoveRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_Repeat")] + public static extern global::System.IntPtr Comments_Repeat([global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_Reverse__SWIG_0")] + public static extern void Comments_Reverse__SWIG_0(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_Reverse__SWIG_1")] + public static extern void Comments_Reverse__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_SetRange")] + public static extern void Comments_SetRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_Contains")] + public static extern bool Comments_Contains(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_IndexOf")] + public static extern int Comments_IndexOf(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_LastIndexOf")] + public static extern int Comments_LastIndexOf(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_Remove")] + public static extern bool Comments_Remove(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_delete_Comments")] + public static extern void delete_Comments(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_ProcessingError_occurred")] + public static extern bool ProcessingError_occurred(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_ProcessingError_message_set")] + public static extern void ProcessingError_message_set(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_ProcessingError_message_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string ProcessingError_message_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_ProcessingError")] + public static extern global::System.IntPtr new_ProcessingError(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_delete_ProcessingError")] + public static extern void delete_ProcessingError(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Token_form_set")] + public static extern void Token_form_set(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Token_form_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Token_form_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Token_misc_set")] + public static extern void Token_misc_set(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Token_misc_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Token_misc_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Token__SWIG_0")] + public static extern global::System.IntPtr new_Token__SWIG_0([global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Token__SWIG_1")] + public static extern global::System.IntPtr new_Token__SWIG_1([global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Token__SWIG_2")] + public static extern global::System.IntPtr new_Token__SWIG_2(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Token_getSpaceAfter")] + public static extern bool Token_getSpaceAfter(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Token_setSpaceAfter")] + public static extern void Token_setSpaceAfter(global::System.Runtime.InteropServices.HandleRef jarg1, bool jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Token_getSpacesBefore")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Token_getSpacesBefore(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Token_setSpacesBefore")] + public static extern void Token_setSpacesBefore(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Token_getSpacesAfter")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Token_getSpacesAfter(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Token_setSpacesAfter")] + public static extern void Token_setSpacesAfter(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Token_getSpacesInToken")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Token_getSpacesInToken(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Token_setSpacesInToken")] + public static extern void Token_setSpacesInToken(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Token_getTokenRange")] + public static extern bool Token_getTokenRange(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Token_getTokenRangeStart")] + public static extern uint Token_getTokenRangeStart(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Token_getTokenRangeEnd")] + public static extern uint Token_getTokenRangeEnd(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Token_setTokenRange")] + public static extern void Token_setTokenRange(global::System.Runtime.InteropServices.HandleRef jarg1, uint jarg2, uint jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_delete_Token")] + public static extern void delete_Token(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Word_id_set")] + public static extern void Word_id_set(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Word_id_get")] + public static extern int Word_id_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Word_lemma_set")] + public static extern void Word_lemma_set(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Word_lemma_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Word_lemma_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Word_upostag_set")] + public static extern void Word_upostag_set(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Word_upostag_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Word_upostag_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Word_xpostag_set")] + public static extern void Word_xpostag_set(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Word_xpostag_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Word_xpostag_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Word_feats_set")] + public static extern void Word_feats_set(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Word_feats_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Word_feats_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Word_head_set")] + public static extern void Word_head_set(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Word_head_get")] + public static extern int Word_head_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Word_deprel_set")] + public static extern void Word_deprel_set(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Word_deprel_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Word_deprel_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Word_deps_set")] + public static extern void Word_deps_set(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Word_deps_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Word_deps_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Word_children_set")] + public static extern void Word_children_set(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Word_children_get")] + public static extern global::System.IntPtr Word_children_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Word__SWIG_0")] + public static extern global::System.IntPtr new_Word__SWIG_0(int jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Word__SWIG_1")] + public static extern global::System.IntPtr new_Word__SWIG_1(int jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Word__SWIG_2")] + public static extern global::System.IntPtr new_Word__SWIG_2(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_delete_Word")] + public static extern void delete_Word(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Words_Clear")] + public static extern void Words_Clear(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Words_Add")] + public static extern void Words_Add(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Words_size")] + public static extern uint Words_size(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Words_capacity")] + public static extern uint Words_capacity(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Words_reserve")] + public static extern void Words_reserve(global::System.Runtime.InteropServices.HandleRef jarg1, uint jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Words__SWIG_0")] + public static extern global::System.IntPtr new_Words__SWIG_0(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Words__SWIG_1")] + public static extern global::System.IntPtr new_Words__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Words__SWIG_2")] + public static extern global::System.IntPtr new_Words__SWIG_2(int jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Words_getitemcopy")] + public static extern global::System.IntPtr Words_getitemcopy(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Words_getitem")] + public static extern global::System.IntPtr Words_getitem(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Words_setitem")] + public static extern void Words_setitem(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Words_AddRange")] + public static extern void Words_AddRange(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Words_GetRange")] + public static extern global::System.IntPtr Words_GetRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Words_Insert")] + public static extern void Words_Insert(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Words_InsertRange")] + public static extern void Words_InsertRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Words_RemoveAt")] + public static extern void Words_RemoveAt(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Words_RemoveRange")] + public static extern void Words_RemoveRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Words_Repeat")] + public static extern global::System.IntPtr Words_Repeat(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Words_Reverse__SWIG_0")] + public static extern void Words_Reverse__SWIG_0(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Words_Reverse__SWIG_1")] + public static extern void Words_Reverse__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Words_SetRange")] + public static extern void Words_SetRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_delete_Words")] + public static extern void delete_Words(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordToken_idFirst_set")] + public static extern void MultiwordToken_idFirst_set(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordToken_idFirst_get")] + public static extern int MultiwordToken_idFirst_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordToken_idLast_set")] + public static extern void MultiwordToken_idLast_set(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordToken_idLast_get")] + public static extern int MultiwordToken_idLast_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_MultiwordToken__SWIG_0")] + public static extern global::System.IntPtr new_MultiwordToken__SWIG_0(int jarg1, int jarg2, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg3, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg4); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_MultiwordToken__SWIG_1")] + public static extern global::System.IntPtr new_MultiwordToken__SWIG_1(int jarg1, int jarg2, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_MultiwordToken__SWIG_2")] + public static extern global::System.IntPtr new_MultiwordToken__SWIG_2(int jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_MultiwordToken__SWIG_3")] + public static extern global::System.IntPtr new_MultiwordToken__SWIG_3(int jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_MultiwordToken__SWIG_4")] + public static extern global::System.IntPtr new_MultiwordToken__SWIG_4(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_delete_MultiwordToken")] + public static extern void delete_MultiwordToken(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordTokens_Clear")] + public static extern void MultiwordTokens_Clear(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordTokens_Add")] + public static extern void MultiwordTokens_Add(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordTokens_size")] + public static extern uint MultiwordTokens_size(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordTokens_capacity")] + public static extern uint MultiwordTokens_capacity(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordTokens_reserve")] + public static extern void MultiwordTokens_reserve(global::System.Runtime.InteropServices.HandleRef jarg1, uint jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_MultiwordTokens__SWIG_0")] + public static extern global::System.IntPtr new_MultiwordTokens__SWIG_0(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_MultiwordTokens__SWIG_1")] + public static extern global::System.IntPtr new_MultiwordTokens__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_MultiwordTokens__SWIG_2")] + public static extern global::System.IntPtr new_MultiwordTokens__SWIG_2(int jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordTokens_getitemcopy")] + public static extern global::System.IntPtr MultiwordTokens_getitemcopy(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordTokens_getitem")] + public static extern global::System.IntPtr MultiwordTokens_getitem(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordTokens_setitem")] + public static extern void MultiwordTokens_setitem(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordTokens_AddRange")] + public static extern void MultiwordTokens_AddRange(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordTokens_GetRange")] + public static extern global::System.IntPtr MultiwordTokens_GetRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordTokens_Insert")] + public static extern void MultiwordTokens_Insert(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordTokens_InsertRange")] + public static extern void MultiwordTokens_InsertRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordTokens_RemoveAt")] + public static extern void MultiwordTokens_RemoveAt(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordTokens_RemoveRange")] + public static extern void MultiwordTokens_RemoveRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordTokens_Repeat")] + public static extern global::System.IntPtr MultiwordTokens_Repeat(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordTokens_Reverse__SWIG_0")] + public static extern void MultiwordTokens_Reverse__SWIG_0(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordTokens_Reverse__SWIG_1")] + public static extern void MultiwordTokens_Reverse__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordTokens_SetRange")] + public static extern void MultiwordTokens_SetRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_delete_MultiwordTokens")] + public static extern void delete_MultiwordTokens(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNode_id_set")] + public static extern void EmptyNode_id_set(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNode_id_get")] + public static extern int EmptyNode_id_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNode_index_set")] + public static extern void EmptyNode_index_set(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNode_index_get")] + public static extern int EmptyNode_index_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNode_form_set")] + public static extern void EmptyNode_form_set(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNode_form_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string EmptyNode_form_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNode_lemma_set")] + public static extern void EmptyNode_lemma_set(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNode_lemma_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string EmptyNode_lemma_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNode_upostag_set")] + public static extern void EmptyNode_upostag_set(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNode_upostag_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string EmptyNode_upostag_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNode_xpostag_set")] + public static extern void EmptyNode_xpostag_set(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNode_xpostag_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string EmptyNode_xpostag_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNode_feats_set")] + public static extern void EmptyNode_feats_set(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNode_feats_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string EmptyNode_feats_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNode_deps_set")] + public static extern void EmptyNode_deps_set(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNode_deps_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string EmptyNode_deps_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNode_misc_set")] + public static extern void EmptyNode_misc_set(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNode_misc_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string EmptyNode_misc_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_EmptyNode__SWIG_0")] + public static extern global::System.IntPtr new_EmptyNode__SWIG_0(int jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_EmptyNode__SWIG_1")] + public static extern global::System.IntPtr new_EmptyNode__SWIG_1(int jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_EmptyNode__SWIG_2")] + public static extern global::System.IntPtr new_EmptyNode__SWIG_2(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_delete_EmptyNode")] + public static extern void delete_EmptyNode(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNodes_Clear")] + public static extern void EmptyNodes_Clear(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNodes_Add")] + public static extern void EmptyNodes_Add(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNodes_size")] + public static extern uint EmptyNodes_size(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNodes_capacity")] + public static extern uint EmptyNodes_capacity(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNodes_reserve")] + public static extern void EmptyNodes_reserve(global::System.Runtime.InteropServices.HandleRef jarg1, uint jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_EmptyNodes__SWIG_0")] + public static extern global::System.IntPtr new_EmptyNodes__SWIG_0(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_EmptyNodes__SWIG_1")] + public static extern global::System.IntPtr new_EmptyNodes__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_EmptyNodes__SWIG_2")] + public static extern global::System.IntPtr new_EmptyNodes__SWIG_2(int jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNodes_getitemcopy")] + public static extern global::System.IntPtr EmptyNodes_getitemcopy(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNodes_getitem")] + public static extern global::System.IntPtr EmptyNodes_getitem(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNodes_setitem")] + public static extern void EmptyNodes_setitem(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNodes_AddRange")] + public static extern void EmptyNodes_AddRange(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNodes_GetRange")] + public static extern global::System.IntPtr EmptyNodes_GetRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNodes_Insert")] + public static extern void EmptyNodes_Insert(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNodes_InsertRange")] + public static extern void EmptyNodes_InsertRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNodes_RemoveAt")] + public static extern void EmptyNodes_RemoveAt(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNodes_RemoveRange")] + public static extern void EmptyNodes_RemoveRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNodes_Repeat")] + public static extern global::System.IntPtr EmptyNodes_Repeat(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNodes_Reverse__SWIG_0")] + public static extern void EmptyNodes_Reverse__SWIG_0(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNodes_Reverse__SWIG_1")] + public static extern void EmptyNodes_Reverse__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNodes_SetRange")] + public static extern void EmptyNodes_SetRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_delete_EmptyNodes")] + public static extern void delete_EmptyNodes(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Sentence")] + public static extern global::System.IntPtr new_Sentence(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_words_set")] + public static extern void Sentence_words_set(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_words_get")] + public static extern global::System.IntPtr Sentence_words_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_multiwordTokens_set")] + public static extern void Sentence_multiwordTokens_set(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_multiwordTokens_get")] + public static extern global::System.IntPtr Sentence_multiwordTokens_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_emptyNodes_set")] + public static extern void Sentence_emptyNodes_set(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_emptyNodes_get")] + public static extern global::System.IntPtr Sentence_emptyNodes_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_comments_set")] + public static extern void Sentence_comments_set(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_comments_get")] + public static extern global::System.IntPtr Sentence_comments_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_rootForm_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Sentence_rootForm_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_empty")] + public static extern bool Sentence_empty(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_clear")] + public static extern void Sentence_clear(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_addWord")] + public static extern global::System.IntPtr Sentence_addWord(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_setHead")] + public static extern void Sentence_setHead(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg4); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_unlinkAllNodes")] + public static extern void Sentence_unlinkAllNodes(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_getNewDoc")] + public static extern bool Sentence_getNewDoc(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_getNewDocId")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Sentence_getNewDocId(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_setNewDoc__SWIG_0")] + public static extern void Sentence_setNewDoc__SWIG_0(global::System.Runtime.InteropServices.HandleRef jarg1, bool jarg2, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_setNewDoc__SWIG_1")] + public static extern void Sentence_setNewDoc__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1, bool jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_getNewPar")] + public static extern bool Sentence_getNewPar(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_getNewParId")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Sentence_getNewParId(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_setNewPar__SWIG_0")] + public static extern void Sentence_setNewPar__SWIG_0(global::System.Runtime.InteropServices.HandleRef jarg1, bool jarg2, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_setNewPar__SWIG_1")] + public static extern void Sentence_setNewPar__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1, bool jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_getSentId")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Sentence_getSentId(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_setSentId")] + public static extern void Sentence_setSentId(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_getText")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Sentence_getText(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_setText")] + public static extern void Sentence_setText(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_delete_Sentence")] + public static extern void delete_Sentence(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentences_Clear")] + public static extern void Sentences_Clear(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentences_Add")] + public static extern void Sentences_Add(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentences_size")] + public static extern uint Sentences_size(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentences_capacity")] + public static extern uint Sentences_capacity(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentences_reserve")] + public static extern void Sentences_reserve(global::System.Runtime.InteropServices.HandleRef jarg1, uint jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Sentences__SWIG_0")] + public static extern global::System.IntPtr new_Sentences__SWIG_0(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Sentences__SWIG_1")] + public static extern global::System.IntPtr new_Sentences__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Sentences__SWIG_2")] + public static extern global::System.IntPtr new_Sentences__SWIG_2(int jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentences_getitemcopy")] + public static extern global::System.IntPtr Sentences_getitemcopy(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentences_getitem")] + public static extern global::System.IntPtr Sentences_getitem(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentences_setitem")] + public static extern void Sentences_setitem(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentences_AddRange")] + public static extern void Sentences_AddRange(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentences_GetRange")] + public static extern global::System.IntPtr Sentences_GetRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentences_Insert")] + public static extern void Sentences_Insert(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentences_InsertRange")] + public static extern void Sentences_InsertRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentences_RemoveAt")] + public static extern void Sentences_RemoveAt(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentences_RemoveRange")] + public static extern void Sentences_RemoveRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentences_Repeat")] + public static extern global::System.IntPtr Sentences_Repeat(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentences_Reverse__SWIG_0")] + public static extern void Sentences_Reverse__SWIG_0(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentences_Reverse__SWIG_1")] + public static extern void Sentences_Reverse__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentences_SetRange")] + public static extern void Sentences_SetRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_delete_Sentences")] + public static extern void delete_Sentences(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_delete_InputFormat")] + public static extern void delete_InputFormat(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_InputFormat_resetDocument__SWIG_0")] + public static extern void InputFormat_resetDocument__SWIG_0(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_InputFormat_resetDocument__SWIG_1")] + public static extern void InputFormat_resetDocument__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_InputFormat_setText")] + public static extern void InputFormat_setText(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_InputFormat_nextSentence__SWIG_0")] + public static extern bool InputFormat_nextSentence__SWIG_0(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_InputFormat_nextSentence__SWIG_1")] + public static extern bool InputFormat_nextSentence__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_InputFormat_newInputFormat")] + public static extern global::System.IntPtr InputFormat_newInputFormat([global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_InputFormat_newConlluInputFormat__SWIG_0")] + public static extern global::System.IntPtr InputFormat_newConlluInputFormat__SWIG_0([global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_InputFormat_newConlluInputFormat__SWIG_1")] + public static extern global::System.IntPtr InputFormat_newConlluInputFormat__SWIG_1(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_InputFormat_newGenericTokenizerInputFormat__SWIG_0")] + public static extern global::System.IntPtr InputFormat_newGenericTokenizerInputFormat__SWIG_0([global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_InputFormat_newGenericTokenizerInputFormat__SWIG_1")] + public static extern global::System.IntPtr InputFormat_newGenericTokenizerInputFormat__SWIG_1(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_InputFormat_newHorizontalInputFormat__SWIG_0")] + public static extern global::System.IntPtr InputFormat_newHorizontalInputFormat__SWIG_0([global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_InputFormat_newHorizontalInputFormat__SWIG_1")] + public static extern global::System.IntPtr InputFormat_newHorizontalInputFormat__SWIG_1(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_InputFormat_newVerticalInputFormat__SWIG_0")] + public static extern global::System.IntPtr InputFormat_newVerticalInputFormat__SWIG_0([global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_InputFormat_newVerticalInputFormat__SWIG_1")] + public static extern global::System.IntPtr InputFormat_newVerticalInputFormat__SWIG_1(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_InputFormat_newPresegmentedTokenizer")] + public static extern global::System.IntPtr InputFormat_newPresegmentedTokenizer(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_InputFormat_CONLLU_V1_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string InputFormat_CONLLU_V1_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_InputFormat_CONLLU_V2_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string InputFormat_CONLLU_V2_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_InputFormat_GENERIC_TOKENIZER_NORMALIZED_SPACES_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string InputFormat_GENERIC_TOKENIZER_NORMALIZED_SPACES_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_InputFormat_GENERIC_TOKENIZER_PRESEGMENTED_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string InputFormat_GENERIC_TOKENIZER_PRESEGMENTED_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_InputFormat_GENERIC_TOKENIZER_RANGES_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string InputFormat_GENERIC_TOKENIZER_RANGES_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_delete_OutputFormat")] + public static extern void delete_OutputFormat(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_OutputFormat_writeSentence")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string OutputFormat_writeSentence(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_OutputFormat_finishDocument")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string OutputFormat_finishDocument(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_OutputFormat_newOutputFormat")] + public static extern global::System.IntPtr OutputFormat_newOutputFormat([global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_OutputFormat_newConlluOutputFormat__SWIG_0")] + public static extern global::System.IntPtr OutputFormat_newConlluOutputFormat__SWIG_0([global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_OutputFormat_newConlluOutputFormat__SWIG_1")] + public static extern global::System.IntPtr OutputFormat_newConlluOutputFormat__SWIG_1(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_OutputFormat_newEpeOutputFormat__SWIG_0")] + public static extern global::System.IntPtr OutputFormat_newEpeOutputFormat__SWIG_0([global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_OutputFormat_newEpeOutputFormat__SWIG_1")] + public static extern global::System.IntPtr OutputFormat_newEpeOutputFormat__SWIG_1(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_OutputFormat_newMatxinOutputFormat__SWIG_0")] + public static extern global::System.IntPtr OutputFormat_newMatxinOutputFormat__SWIG_0([global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_OutputFormat_newMatxinOutputFormat__SWIG_1")] + public static extern global::System.IntPtr OutputFormat_newMatxinOutputFormat__SWIG_1(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_OutputFormat_newHorizontalOutputFormat__SWIG_0")] + public static extern global::System.IntPtr OutputFormat_newHorizontalOutputFormat__SWIG_0([global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_OutputFormat_newHorizontalOutputFormat__SWIG_1")] + public static extern global::System.IntPtr OutputFormat_newHorizontalOutputFormat__SWIG_1(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_OutputFormat_newPlaintextOutputFormat__SWIG_0")] + public static extern global::System.IntPtr OutputFormat_newPlaintextOutputFormat__SWIG_0([global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_OutputFormat_newPlaintextOutputFormat__SWIG_1")] + public static extern global::System.IntPtr OutputFormat_newPlaintextOutputFormat__SWIG_1(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_OutputFormat_newVerticalOutputFormat__SWIG_0")] + public static extern global::System.IntPtr OutputFormat_newVerticalOutputFormat__SWIG_0([global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_OutputFormat_newVerticalOutputFormat__SWIG_1")] + public static extern global::System.IntPtr OutputFormat_newVerticalOutputFormat__SWIG_1(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_OutputFormat_CONLLU_V1_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string OutputFormat_CONLLU_V1_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_OutputFormat_CONLLU_V2_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string OutputFormat_CONLLU_V2_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_OutputFormat_HORIZONTAL_PARAGRAPHS_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string OutputFormat_HORIZONTAL_PARAGRAPHS_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_OutputFormat_PLAINTEXT_NORMALIZED_SPACES_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string OutputFormat_PLAINTEXT_NORMALIZED_SPACES_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_OutputFormat_VERTICAL_PARAGRAPHS_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string OutputFormat_VERTICAL_PARAGRAPHS_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_delete_Model")] + public static extern void delete_Model(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Model_load")] + public static extern global::System.IntPtr Model_load([global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Model_newTokenizer")] + public static extern global::System.IntPtr Model_newTokenizer(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Model_tag__SWIG_0")] + public static extern bool Model_tag__SWIG_0(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg3, global::System.Runtime.InteropServices.HandleRef jarg4); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Model_tag__SWIG_1")] + public static extern bool Model_tag__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Model_parse__SWIG_0")] + public static extern bool Model_parse__SWIG_0(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg3, global::System.Runtime.InteropServices.HandleRef jarg4); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Model_parse__SWIG_1")] + public static extern bool Model_parse__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Model_DEFAULT_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Model_DEFAULT_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Model_TOKENIZER_NORMALIZED_SPACES_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Model_TOKENIZER_NORMALIZED_SPACES_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Model_TOKENIZER_PRESEGMENTED_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Model_TOKENIZER_PRESEGMENTED_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Model_TOKENIZER_RANGES_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Model_TOKENIZER_RANGES_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Pipeline")] + public static extern global::System.IntPtr new_Pipeline(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg3, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg4, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg5); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Pipeline_setModel")] + public static extern void Pipeline_setModel(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Pipeline_setInput")] + public static extern void Pipeline_setInput(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Pipeline_setTagger")] + public static extern void Pipeline_setTagger(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Pipeline_setParser")] + public static extern void Pipeline_setParser(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Pipeline_setOutput")] + public static extern void Pipeline_setOutput(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Pipeline_setImmediate")] + public static extern void Pipeline_setImmediate(global::System.Runtime.InteropServices.HandleRef jarg1, bool jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Pipeline_setDocumentId")] + public static extern void Pipeline_setDocumentId(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Pipeline_process__SWIG_0")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Pipeline_process__SWIG_0(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Pipeline_process__SWIG_1")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Pipeline_process__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Pipeline_DEFAULT_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Pipeline_DEFAULT_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Pipeline_NONE_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Pipeline_NONE_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_delete_Pipeline")] + public static extern void delete_Pipeline(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Trainer_train__SWIG_0")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Trainer_train__SWIG_0([global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg1, global::System.Runtime.InteropServices.HandleRef jarg2, global::System.Runtime.InteropServices.HandleRef jarg3, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg4, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg5, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg6, global::System.Runtime.InteropServices.HandleRef jarg7); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Trainer_train__SWIG_1")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Trainer_train__SWIG_1([global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg1, global::System.Runtime.InteropServices.HandleRef jarg2, global::System.Runtime.InteropServices.HandleRef jarg3, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg4, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg5, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg6); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Trainer_DEFAULT_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Trainer_DEFAULT_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Trainer_NONE_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Trainer_NONE_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Trainer")] + public static extern global::System.IntPtr new_Trainer(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_delete_Trainer")] + public static extern void delete_Trainer(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Evaluator")] + public static extern global::System.IntPtr new_Evaluator(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg3, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg4); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Evaluator_setModel")] + public static extern void Evaluator_setModel(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Evaluator_setTokenizer")] + public static extern void Evaluator_setTokenizer(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Evaluator_setTagger")] + public static extern void Evaluator_setTagger(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Evaluator_setParser")] + public static extern void Evaluator_setParser(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Evaluator_evaluate__SWIG_0")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Evaluator_evaluate__SWIG_0(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Evaluator_evaluate__SWIG_1")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Evaluator_evaluate__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Evaluator_DEFAULT_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Evaluator_DEFAULT_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Evaluator_NONE_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Evaluator_NONE_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_delete_Evaluator")] + public static extern void delete_Evaluator(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Version_major_set")] + public static extern void Version_major_set(global::System.Runtime.InteropServices.HandleRef jarg1, uint jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Version_major_get")] + public static extern uint Version_major_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Version_minor_set")] + public static extern void Version_minor_set(global::System.Runtime.InteropServices.HandleRef jarg1, uint jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Version_minor_get")] + public static extern uint Version_minor_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Version_patch_set")] + public static extern void Version_patch_set(global::System.Runtime.InteropServices.HandleRef jarg1, uint jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Version_patch_get")] + public static extern uint Version_patch_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Version_prerelease_set")] + public static extern void Version_prerelease_set(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Version_prerelease_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Version_prerelease_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Version_current")] + public static extern global::System.IntPtr Version_current(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Version")] + public static extern global::System.IntPtr new_Version(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_delete_Version")] + public static extern void delete_Version(global::System.Runtime.InteropServices.HandleRef jarg1); + +public class UTF8Marshaler : System.Runtime.InteropServices.ICustomMarshaler { + static UTF8Marshaler static_instance; + + public System.IntPtr MarshalManagedToNative(object managedObj) { + if (managedObj == null) + return System.IntPtr.Zero; + if (!(managedObj is string)) + throw new System.Runtime.InteropServices.MarshalDirectiveException("UTF8Marshaler must be used on a string."); + + // not null terminated + byte[] strbuf = System.Text.Encoding.UTF8.GetBytes((string)managedObj); + System.IntPtr buffer = System.Runtime.InteropServices.Marshal.AllocHGlobal(strbuf.Length + 1); + System.Runtime.InteropServices.Marshal.Copy(strbuf, 0, buffer, strbuf.Length); + + // write the terminating null + System.Runtime.InteropServices.Marshal.WriteByte(buffer + strbuf.Length, 0); + return buffer; + } + + public object MarshalNativeToManaged(System.IntPtr pNativeData) { + int length = 0; + while (System.Runtime.InteropServices.Marshal.ReadByte(pNativeData, length) != 0) + length++; + + // should not be null terminated + byte[] strbuf = new byte[length]; + // skip the trailing null + System.Runtime.InteropServices.Marshal.Copy((System.IntPtr)pNativeData, strbuf, 0, length); + string data = System.Text.Encoding.UTF8.GetString(strbuf); + return data; + } + + public void CleanUpNativeData(System.IntPtr pNativeData) { + System.Runtime.InteropServices.Marshal.FreeHGlobal(pNativeData); + } + + public void CleanUpManagedData(object managedObj) { + } + + public int GetNativeDataSize() { + return -1; + } + + public static System.Runtime.InteropServices.ICustomMarshaler GetInstance(string cookie) { + if (static_instance == null) + return static_instance = new UTF8Marshaler(); + return static_instance; + } +} + + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Word_SWIGUpcast")] + public static extern global::System.IntPtr Word_SWIGUpcast(global::System.IntPtr jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordToken_SWIGUpcast")] + public static extern global::System.IntPtr MultiwordToken_SWIGUpcast(global::System.IntPtr jarg1); +} + +} diff --git a/UDPipe/v1/binary/linux64/csharp/libudpipe_csharp.so b/UDPipe/v1/binary/linux64/csharp/libudpipe_csharp.so new file mode 100644 index 0000000000000000000000000000000000000000..11e4522f97a10f76cbbfc8fa7d0c316a9b6bd8c6 --- /dev/null +++ b/UDPipe/v1/binary/linux64/csharp/libudpipe_csharp.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4f40c3844ec7841668985c71c41f9a7ff1b88275dca6c3a6d2f1278b3cc77565 +size 1981824 diff --git a/UDPipe/v1/binary/linux64/java/libudpipe_java.so b/UDPipe/v1/binary/linux64/java/libudpipe_java.so new file mode 100644 index 0000000000000000000000000000000000000000..02d884d36804d5ab0be44f80c4d08d30d5ceb2aa --- /dev/null +++ b/UDPipe/v1/binary/linux64/java/libudpipe_java.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0535daa921fd95a8f4da794c4d070ceb28763bdfcb2c9c196d34c86f408e7d0a +size 1910144 diff --git a/UDPipe/v1/binary/linux64/java/udpipe.jar b/UDPipe/v1/binary/linux64/java/udpipe.jar new file mode 100644 index 0000000000000000000000000000000000000000..1402eecf0486e6af3300cbad05601351d9990feb Binary files /dev/null and b/UDPipe/v1/binary/linux64/java/udpipe.jar differ diff --git a/UDPipe/v1/binary/linux64/udpipe b/UDPipe/v1/binary/linux64/udpipe new file mode 100644 index 0000000000000000000000000000000000000000..21826f5bb3318ab2ab11f10a812cdb91625e2764 --- /dev/null +++ b/UDPipe/v1/binary/linux64/udpipe @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:88180da109fbfef6823cf806ffd093d2263475792ad679f93163573b9ca3e380 +size 1512216 diff --git a/UDPipe/v1/binary/linuxArmv7/libudpipe.a b/UDPipe/v1/binary/linuxArmv7/libudpipe.a new file mode 100644 index 0000000000000000000000000000000000000000..d1522e25f58384e58d4afd39f96f86f182e400ff --- /dev/null +++ b/UDPipe/v1/binary/linuxArmv7/libudpipe.a @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:db50cc8abdfedbea36c429529d8066405c16468551a45af03239745f7c74aded +size 3489636 diff --git a/UDPipe/v1/binary/linuxArmv7/rest_server/udpipe_server b/UDPipe/v1/binary/linuxArmv7/rest_server/udpipe_server new file mode 100644 index 0000000000000000000000000000000000000000..8fd117212d46f6bc4517d183d0b02b3be6aa27f3 --- /dev/null +++ b/UDPipe/v1/binary/linuxArmv7/rest_server/udpipe_server @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7650d1415a57f0725aac010d7bc94876c6e283c7e8e3c56a9a935ff9e1da02b8 +size 1985660 diff --git a/UDPipe/v1/binary/linuxArmv7/udpipe b/UDPipe/v1/binary/linuxArmv7/udpipe new file mode 100644 index 0000000000000000000000000000000000000000..dbf82024fd0c1971932a0b13bd786a9cec1891d9 --- /dev/null +++ b/UDPipe/v1/binary/linuxArmv7/udpipe @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:116c09068ede781cadba1684eaba410c8f3e61ea7ef960773f4753abaf16d06b +size 1738136 diff --git a/UDPipe/v1/binary/osx/csharp/Ufal/UDPipe/Children.cs b/UDPipe/v1/binary/osx/csharp/Ufal/UDPipe/Children.cs new file mode 100644 index 0000000000000000000000000000000000000000..e5959f767df4f3ddb46e9dcb210f3eacd8c2237a --- /dev/null +++ b/UDPipe/v1/binary/osx/csharp/Ufal/UDPipe/Children.cs @@ -0,0 +1,328 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +public class Children : global::System.IDisposable, global::System.Collections.IEnumerable + , global::System.Collections.Generic.IList + { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal Children(global::System.IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Children obj) { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + ~Children() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != global::System.IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + udpipe_csharpPINVOKE.delete_Children(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + global::System.GC.SuppressFinalize(this); + } + } + + public Children(global::System.Collections.ICollection c) : this() { + if (c == null) + throw new global::System.ArgumentNullException("c"); + foreach (int element in c) { + this.Add(element); + } + } + + public bool IsFixedSize { + get { + return false; + } + } + + public bool IsReadOnly { + get { + return false; + } + } + + public int this[int index] { + get { + return getitem(index); + } + set { + setitem(index, value); + } + } + + public int Capacity { + get { + return (int)capacity(); + } + set { + if (value < size()) + throw new global::System.ArgumentOutOfRangeException("Capacity"); + reserve((uint)value); + } + } + + public int Count { + get { + return (int)size(); + } + } + + public bool IsSynchronized { + get { + return false; + } + } + + public void CopyTo(int[] array) + { + CopyTo(0, array, 0, this.Count); + } + + public void CopyTo(int[] array, int arrayIndex) + { + CopyTo(0, array, arrayIndex, this.Count); + } + + public void CopyTo(int index, int[] array, int arrayIndex, int count) + { + if (array == null) + throw new global::System.ArgumentNullException("array"); + if (index < 0) + throw new global::System.ArgumentOutOfRangeException("index", "Value is less than zero"); + if (arrayIndex < 0) + throw new global::System.ArgumentOutOfRangeException("arrayIndex", "Value is less than zero"); + if (count < 0) + throw new global::System.ArgumentOutOfRangeException("count", "Value is less than zero"); + if (array.Rank > 1) + throw new global::System.ArgumentException("Multi dimensional array.", "array"); + if (index+count > this.Count || arrayIndex+count > array.Length) + throw new global::System.ArgumentException("Number of elements to copy is too large."); + for (int i=0; i global::System.Collections.Generic.IEnumerable.GetEnumerator() { + return new ChildrenEnumerator(this); + } + + global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator() { + return new ChildrenEnumerator(this); + } + + public ChildrenEnumerator GetEnumerator() { + return new ChildrenEnumerator(this); + } + + // Type-safe enumerator + /// Note that the IEnumerator documentation requires an InvalidOperationException to be thrown + /// whenever the collection is modified. This has been done for changes in the size of the + /// collection but not when one of the elements of the collection is modified as it is a bit + /// tricky to detect unmanaged code that modifies the collection under our feet. + public sealed class ChildrenEnumerator : global::System.Collections.IEnumerator + , global::System.Collections.Generic.IEnumerator + { + private Children collectionRef; + private int currentIndex; + private object currentObject; + private int currentSize; + + public ChildrenEnumerator(Children collection) { + collectionRef = collection; + currentIndex = -1; + currentObject = null; + currentSize = collectionRef.Count; + } + + // Type-safe iterator Current + public int Current { + get { + if (currentIndex == -1) + throw new global::System.InvalidOperationException("Enumeration not started."); + if (currentIndex > currentSize - 1) + throw new global::System.InvalidOperationException("Enumeration finished."); + if (currentObject == null) + throw new global::System.InvalidOperationException("Collection modified."); + return (int)currentObject; + } + } + + // Type-unsafe IEnumerator.Current + object global::System.Collections.IEnumerator.Current { + get { + return Current; + } + } + + public bool MoveNext() { + int size = collectionRef.Count; + bool moveOkay = (currentIndex+1 < size) && (size == currentSize); + if (moveOkay) { + currentIndex++; + currentObject = collectionRef[currentIndex]; + } else { + currentObject = null; + } + return moveOkay; + } + + public void Reset() { + currentIndex = -1; + currentObject = null; + if (collectionRef.Count != currentSize) { + throw new global::System.InvalidOperationException("Collection modified."); + } + } + + public void Dispose() { + currentIndex = -1; + currentObject = null; + } + } + + public void Clear() { + udpipe_csharpPINVOKE.Children_Clear(swigCPtr); + } + + public void Add(int x) { + udpipe_csharpPINVOKE.Children_Add(swigCPtr, x); + } + + private uint size() { + uint ret = udpipe_csharpPINVOKE.Children_size(swigCPtr); + return ret; + } + + private uint capacity() { + uint ret = udpipe_csharpPINVOKE.Children_capacity(swigCPtr); + return ret; + } + + private void reserve(uint n) { + udpipe_csharpPINVOKE.Children_reserve(swigCPtr, n); + } + + public Children() : this(udpipe_csharpPINVOKE.new_Children__SWIG_0(), true) { + } + + public Children(Children other) : this(udpipe_csharpPINVOKE.new_Children__SWIG_1(Children.getCPtr(other)), true) { + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public Children(int capacity) : this(udpipe_csharpPINVOKE.new_Children__SWIG_2(capacity), true) { + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + private int getitemcopy(int index) { + int ret = udpipe_csharpPINVOKE.Children_getitemcopy(swigCPtr, index); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + private int getitem(int index) { + int ret = udpipe_csharpPINVOKE.Children_getitem(swigCPtr, index); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + private void setitem(int index, int val) { + udpipe_csharpPINVOKE.Children_setitem(swigCPtr, index, val); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void AddRange(Children values) { + udpipe_csharpPINVOKE.Children_AddRange(swigCPtr, Children.getCPtr(values)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public Children GetRange(int index, int count) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.Children_GetRange(swigCPtr, index, count); + Children ret = (cPtr == global::System.IntPtr.Zero) ? null : new Children(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public void Insert(int index, int x) { + udpipe_csharpPINVOKE.Children_Insert(swigCPtr, index, x); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void InsertRange(int index, Children values) { + udpipe_csharpPINVOKE.Children_InsertRange(swigCPtr, index, Children.getCPtr(values)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void RemoveAt(int index) { + udpipe_csharpPINVOKE.Children_RemoveAt(swigCPtr, index); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void RemoveRange(int index, int count) { + udpipe_csharpPINVOKE.Children_RemoveRange(swigCPtr, index, count); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public static Children Repeat(int value, int count) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.Children_Repeat(value, count); + Children ret = (cPtr == global::System.IntPtr.Zero) ? null : new Children(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public void Reverse() { + udpipe_csharpPINVOKE.Children_Reverse__SWIG_0(swigCPtr); + } + + public void Reverse(int index, int count) { + udpipe_csharpPINVOKE.Children_Reverse__SWIG_1(swigCPtr, index, count); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void SetRange(int index, Children values) { + udpipe_csharpPINVOKE.Children_SetRange(swigCPtr, index, Children.getCPtr(values)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public bool Contains(int value) { + bool ret = udpipe_csharpPINVOKE.Children_Contains(swigCPtr, value); + return ret; + } + + public int IndexOf(int value) { + int ret = udpipe_csharpPINVOKE.Children_IndexOf(swigCPtr, value); + return ret; + } + + public int LastIndexOf(int value) { + int ret = udpipe_csharpPINVOKE.Children_LastIndexOf(swigCPtr, value); + return ret; + } + + public bool Remove(int value) { + bool ret = udpipe_csharpPINVOKE.Children_Remove(swigCPtr, value); + return ret; + } + +} + +} diff --git a/UDPipe/v1/binary/osx/csharp/Ufal/UDPipe/Comments.cs b/UDPipe/v1/binary/osx/csharp/Ufal/UDPipe/Comments.cs new file mode 100644 index 0000000000000000000000000000000000000000..316865d901e073812e3deda1f8ccf407a6ed93a7 --- /dev/null +++ b/UDPipe/v1/binary/osx/csharp/Ufal/UDPipe/Comments.cs @@ -0,0 +1,333 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +public class Comments : global::System.IDisposable, global::System.Collections.IEnumerable + , global::System.Collections.Generic.IList + { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal Comments(global::System.IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Comments obj) { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + ~Comments() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != global::System.IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + udpipe_csharpPINVOKE.delete_Comments(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + global::System.GC.SuppressFinalize(this); + } + } + + public Comments(global::System.Collections.ICollection c) : this() { + if (c == null) + throw new global::System.ArgumentNullException("c"); + foreach (string element in c) { + this.Add(element); + } + } + + public bool IsFixedSize { + get { + return false; + } + } + + public bool IsReadOnly { + get { + return false; + } + } + + public string this[int index] { + get { + return getitem(index); + } + set { + setitem(index, value); + } + } + + public int Capacity { + get { + return (int)capacity(); + } + set { + if (value < size()) + throw new global::System.ArgumentOutOfRangeException("Capacity"); + reserve((uint)value); + } + } + + public int Count { + get { + return (int)size(); + } + } + + public bool IsSynchronized { + get { + return false; + } + } + + public void CopyTo(string[] array) + { + CopyTo(0, array, 0, this.Count); + } + + public void CopyTo(string[] array, int arrayIndex) + { + CopyTo(0, array, arrayIndex, this.Count); + } + + public void CopyTo(int index, string[] array, int arrayIndex, int count) + { + if (array == null) + throw new global::System.ArgumentNullException("array"); + if (index < 0) + throw new global::System.ArgumentOutOfRangeException("index", "Value is less than zero"); + if (arrayIndex < 0) + throw new global::System.ArgumentOutOfRangeException("arrayIndex", "Value is less than zero"); + if (count < 0) + throw new global::System.ArgumentOutOfRangeException("count", "Value is less than zero"); + if (array.Rank > 1) + throw new global::System.ArgumentException("Multi dimensional array.", "array"); + if (index+count > this.Count || arrayIndex+count > array.Length) + throw new global::System.ArgumentException("Number of elements to copy is too large."); + for (int i=0; i global::System.Collections.Generic.IEnumerable.GetEnumerator() { + return new CommentsEnumerator(this); + } + + global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator() { + return new CommentsEnumerator(this); + } + + public CommentsEnumerator GetEnumerator() { + return new CommentsEnumerator(this); + } + + // Type-safe enumerator + /// Note that the IEnumerator documentation requires an InvalidOperationException to be thrown + /// whenever the collection is modified. This has been done for changes in the size of the + /// collection but not when one of the elements of the collection is modified as it is a bit + /// tricky to detect unmanaged code that modifies the collection under our feet. + public sealed class CommentsEnumerator : global::System.Collections.IEnumerator + , global::System.Collections.Generic.IEnumerator + { + private Comments collectionRef; + private int currentIndex; + private object currentObject; + private int currentSize; + + public CommentsEnumerator(Comments collection) { + collectionRef = collection; + currentIndex = -1; + currentObject = null; + currentSize = collectionRef.Count; + } + + // Type-safe iterator Current + public string Current { + get { + if (currentIndex == -1) + throw new global::System.InvalidOperationException("Enumeration not started."); + if (currentIndex > currentSize - 1) + throw new global::System.InvalidOperationException("Enumeration finished."); + if (currentObject == null) + throw new global::System.InvalidOperationException("Collection modified."); + return (string)currentObject; + } + } + + // Type-unsafe IEnumerator.Current + object global::System.Collections.IEnumerator.Current { + get { + return Current; + } + } + + public bool MoveNext() { + int size = collectionRef.Count; + bool moveOkay = (currentIndex+1 < size) && (size == currentSize); + if (moveOkay) { + currentIndex++; + currentObject = collectionRef[currentIndex]; + } else { + currentObject = null; + } + return moveOkay; + } + + public void Reset() { + currentIndex = -1; + currentObject = null; + if (collectionRef.Count != currentSize) { + throw new global::System.InvalidOperationException("Collection modified."); + } + } + + public void Dispose() { + currentIndex = -1; + currentObject = null; + } + } + + public void Clear() { + udpipe_csharpPINVOKE.Comments_Clear(swigCPtr); + } + + public void Add(string x) { + udpipe_csharpPINVOKE.Comments_Add(swigCPtr, x); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + private uint size() { + uint ret = udpipe_csharpPINVOKE.Comments_size(swigCPtr); + return ret; + } + + private uint capacity() { + uint ret = udpipe_csharpPINVOKE.Comments_capacity(swigCPtr); + return ret; + } + + private void reserve(uint n) { + udpipe_csharpPINVOKE.Comments_reserve(swigCPtr, n); + } + + public Comments() : this(udpipe_csharpPINVOKE.new_Comments__SWIG_0(), true) { + } + + public Comments(Comments other) : this(udpipe_csharpPINVOKE.new_Comments__SWIG_1(Comments.getCPtr(other)), true) { + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public Comments(int capacity) : this(udpipe_csharpPINVOKE.new_Comments__SWIG_2(capacity), true) { + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + private string getitemcopy(int index) { + string ret = udpipe_csharpPINVOKE.Comments_getitemcopy(swigCPtr, index); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + private string getitem(int index) { + string ret = udpipe_csharpPINVOKE.Comments_getitem(swigCPtr, index); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + private void setitem(int index, string val) { + udpipe_csharpPINVOKE.Comments_setitem(swigCPtr, index, val); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void AddRange(Comments values) { + udpipe_csharpPINVOKE.Comments_AddRange(swigCPtr, Comments.getCPtr(values)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public Comments GetRange(int index, int count) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.Comments_GetRange(swigCPtr, index, count); + Comments ret = (cPtr == global::System.IntPtr.Zero) ? null : new Comments(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public void Insert(int index, string x) { + udpipe_csharpPINVOKE.Comments_Insert(swigCPtr, index, x); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void InsertRange(int index, Comments values) { + udpipe_csharpPINVOKE.Comments_InsertRange(swigCPtr, index, Comments.getCPtr(values)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void RemoveAt(int index) { + udpipe_csharpPINVOKE.Comments_RemoveAt(swigCPtr, index); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void RemoveRange(int index, int count) { + udpipe_csharpPINVOKE.Comments_RemoveRange(swigCPtr, index, count); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public static Comments Repeat(string value, int count) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.Comments_Repeat(value, count); + Comments ret = (cPtr == global::System.IntPtr.Zero) ? null : new Comments(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public void Reverse() { + udpipe_csharpPINVOKE.Comments_Reverse__SWIG_0(swigCPtr); + } + + public void Reverse(int index, int count) { + udpipe_csharpPINVOKE.Comments_Reverse__SWIG_1(swigCPtr, index, count); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void SetRange(int index, Comments values) { + udpipe_csharpPINVOKE.Comments_SetRange(swigCPtr, index, Comments.getCPtr(values)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public bool Contains(string value) { + bool ret = udpipe_csharpPINVOKE.Comments_Contains(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public int IndexOf(string value) { + int ret = udpipe_csharpPINVOKE.Comments_IndexOf(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public int LastIndexOf(string value) { + int ret = udpipe_csharpPINVOKE.Comments_LastIndexOf(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public bool Remove(string value) { + bool ret = udpipe_csharpPINVOKE.Comments_Remove(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + +} + +} diff --git a/UDPipe/v1/binary/osx/csharp/Ufal/UDPipe/EmptyNode.cs b/UDPipe/v1/binary/osx/csharp/Ufal/UDPipe/EmptyNode.cs new file mode 100644 index 0000000000000000000000000000000000000000..3d9127797fd237053078ec6db9da11cc6c9c819a --- /dev/null +++ b/UDPipe/v1/binary/osx/csharp/Ufal/UDPipe/EmptyNode.cs @@ -0,0 +1,158 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +public class EmptyNode : global::System.IDisposable { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal EmptyNode(global::System.IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(EmptyNode obj) { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + ~EmptyNode() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != global::System.IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + udpipe_csharpPINVOKE.delete_EmptyNode(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + global::System.GC.SuppressFinalize(this); + } + } + + public int id { + set { + udpipe_csharpPINVOKE.EmptyNode_id_set(swigCPtr, value); + } + get { + int ret = udpipe_csharpPINVOKE.EmptyNode_id_get(swigCPtr); + return ret; + } + } + + public int index { + set { + udpipe_csharpPINVOKE.EmptyNode_index_set(swigCPtr, value); + } + get { + int ret = udpipe_csharpPINVOKE.EmptyNode_index_get(swigCPtr); + return ret; + } + } + + public string form { + set { + udpipe_csharpPINVOKE.EmptyNode_form_set(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + get { + string ret = udpipe_csharpPINVOKE.EmptyNode_form_get(swigCPtr); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + } + + public string lemma { + set { + udpipe_csharpPINVOKE.EmptyNode_lemma_set(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + get { + string ret = udpipe_csharpPINVOKE.EmptyNode_lemma_get(swigCPtr); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + } + + public string upostag { + set { + udpipe_csharpPINVOKE.EmptyNode_upostag_set(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + get { + string ret = udpipe_csharpPINVOKE.EmptyNode_upostag_get(swigCPtr); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + } + + public string xpostag { + set { + udpipe_csharpPINVOKE.EmptyNode_xpostag_set(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + get { + string ret = udpipe_csharpPINVOKE.EmptyNode_xpostag_get(swigCPtr); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + } + + public string feats { + set { + udpipe_csharpPINVOKE.EmptyNode_feats_set(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + get { + string ret = udpipe_csharpPINVOKE.EmptyNode_feats_get(swigCPtr); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + } + + public string deps { + set { + udpipe_csharpPINVOKE.EmptyNode_deps_set(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + get { + string ret = udpipe_csharpPINVOKE.EmptyNode_deps_get(swigCPtr); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + } + + public string misc { + set { + udpipe_csharpPINVOKE.EmptyNode_misc_set(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + get { + string ret = udpipe_csharpPINVOKE.EmptyNode_misc_get(swigCPtr); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + } + + public EmptyNode(int id, int index) : this(udpipe_csharpPINVOKE.new_EmptyNode__SWIG_0(id, index), true) { + } + + public EmptyNode(int id) : this(udpipe_csharpPINVOKE.new_EmptyNode__SWIG_1(id), true) { + } + + public EmptyNode() : this(udpipe_csharpPINVOKE.new_EmptyNode__SWIG_2(), true) { + } + +} + +} diff --git a/UDPipe/v1/binary/osx/csharp/Ufal/UDPipe/EmptyNodes.cs b/UDPipe/v1/binary/osx/csharp/Ufal/UDPipe/EmptyNodes.cs new file mode 100644 index 0000000000000000000000000000000000000000..2b4412bd10fdba16a486450f457720529beadb6b --- /dev/null +++ b/UDPipe/v1/binary/osx/csharp/Ufal/UDPipe/EmptyNodes.cs @@ -0,0 +1,309 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +public class EmptyNodes : global::System.IDisposable, global::System.Collections.IEnumerable + , global::System.Collections.Generic.IEnumerable + { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal EmptyNodes(global::System.IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(EmptyNodes obj) { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + ~EmptyNodes() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != global::System.IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + udpipe_csharpPINVOKE.delete_EmptyNodes(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + global::System.GC.SuppressFinalize(this); + } + } + + public EmptyNodes(global::System.Collections.ICollection c) : this() { + if (c == null) + throw new global::System.ArgumentNullException("c"); + foreach (EmptyNode element in c) { + this.Add(element); + } + } + + public bool IsFixedSize { + get { + return false; + } + } + + public bool IsReadOnly { + get { + return false; + } + } + + public EmptyNode this[int index] { + get { + return getitem(index); + } + set { + setitem(index, value); + } + } + + public int Capacity { + get { + return (int)capacity(); + } + set { + if (value < size()) + throw new global::System.ArgumentOutOfRangeException("Capacity"); + reserve((uint)value); + } + } + + public int Count { + get { + return (int)size(); + } + } + + public bool IsSynchronized { + get { + return false; + } + } + + public void CopyTo(EmptyNode[] array) + { + CopyTo(0, array, 0, this.Count); + } + + public void CopyTo(EmptyNode[] array, int arrayIndex) + { + CopyTo(0, array, arrayIndex, this.Count); + } + + public void CopyTo(int index, EmptyNode[] array, int arrayIndex, int count) + { + if (array == null) + throw new global::System.ArgumentNullException("array"); + if (index < 0) + throw new global::System.ArgumentOutOfRangeException("index", "Value is less than zero"); + if (arrayIndex < 0) + throw new global::System.ArgumentOutOfRangeException("arrayIndex", "Value is less than zero"); + if (count < 0) + throw new global::System.ArgumentOutOfRangeException("count", "Value is less than zero"); + if (array.Rank > 1) + throw new global::System.ArgumentException("Multi dimensional array.", "array"); + if (index+count > this.Count || arrayIndex+count > array.Length) + throw new global::System.ArgumentException("Number of elements to copy is too large."); + for (int i=0; i global::System.Collections.Generic.IEnumerable.GetEnumerator() { + return new EmptyNodesEnumerator(this); + } + + global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator() { + return new EmptyNodesEnumerator(this); + } + + public EmptyNodesEnumerator GetEnumerator() { + return new EmptyNodesEnumerator(this); + } + + // Type-safe enumerator + /// Note that the IEnumerator documentation requires an InvalidOperationException to be thrown + /// whenever the collection is modified. This has been done for changes in the size of the + /// collection but not when one of the elements of the collection is modified as it is a bit + /// tricky to detect unmanaged code that modifies the collection under our feet. + public sealed class EmptyNodesEnumerator : global::System.Collections.IEnumerator + , global::System.Collections.Generic.IEnumerator + { + private EmptyNodes collectionRef; + private int currentIndex; + private object currentObject; + private int currentSize; + + public EmptyNodesEnumerator(EmptyNodes collection) { + collectionRef = collection; + currentIndex = -1; + currentObject = null; + currentSize = collectionRef.Count; + } + + // Type-safe iterator Current + public EmptyNode Current { + get { + if (currentIndex == -1) + throw new global::System.InvalidOperationException("Enumeration not started."); + if (currentIndex > currentSize - 1) + throw new global::System.InvalidOperationException("Enumeration finished."); + if (currentObject == null) + throw new global::System.InvalidOperationException("Collection modified."); + return (EmptyNode)currentObject; + } + } + + // Type-unsafe IEnumerator.Current + object global::System.Collections.IEnumerator.Current { + get { + return Current; + } + } + + public bool MoveNext() { + int size = collectionRef.Count; + bool moveOkay = (currentIndex+1 < size) && (size == currentSize); + if (moveOkay) { + currentIndex++; + currentObject = collectionRef[currentIndex]; + } else { + currentObject = null; + } + return moveOkay; + } + + public void Reset() { + currentIndex = -1; + currentObject = null; + if (collectionRef.Count != currentSize) { + throw new global::System.InvalidOperationException("Collection modified."); + } + } + + public void Dispose() { + currentIndex = -1; + currentObject = null; + } + } + + public void Clear() { + udpipe_csharpPINVOKE.EmptyNodes_Clear(swigCPtr); + } + + public void Add(EmptyNode x) { + udpipe_csharpPINVOKE.EmptyNodes_Add(swigCPtr, EmptyNode.getCPtr(x)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + private uint size() { + uint ret = udpipe_csharpPINVOKE.EmptyNodes_size(swigCPtr); + return ret; + } + + private uint capacity() { + uint ret = udpipe_csharpPINVOKE.EmptyNodes_capacity(swigCPtr); + return ret; + } + + private void reserve(uint n) { + udpipe_csharpPINVOKE.EmptyNodes_reserve(swigCPtr, n); + } + + public EmptyNodes() : this(udpipe_csharpPINVOKE.new_EmptyNodes__SWIG_0(), true) { + } + + public EmptyNodes(EmptyNodes other) : this(udpipe_csharpPINVOKE.new_EmptyNodes__SWIG_1(EmptyNodes.getCPtr(other)), true) { + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public EmptyNodes(int capacity) : this(udpipe_csharpPINVOKE.new_EmptyNodes__SWIG_2(capacity), true) { + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + private EmptyNode getitemcopy(int index) { + EmptyNode ret = new EmptyNode(udpipe_csharpPINVOKE.EmptyNodes_getitemcopy(swigCPtr, index), true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + private EmptyNode getitem(int index) { + EmptyNode ret = new EmptyNode(udpipe_csharpPINVOKE.EmptyNodes_getitem(swigCPtr, index), false); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + private void setitem(int index, EmptyNode val) { + udpipe_csharpPINVOKE.EmptyNodes_setitem(swigCPtr, index, EmptyNode.getCPtr(val)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void AddRange(EmptyNodes values) { + udpipe_csharpPINVOKE.EmptyNodes_AddRange(swigCPtr, EmptyNodes.getCPtr(values)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public EmptyNodes GetRange(int index, int count) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.EmptyNodes_GetRange(swigCPtr, index, count); + EmptyNodes ret = (cPtr == global::System.IntPtr.Zero) ? null : new EmptyNodes(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public void Insert(int index, EmptyNode x) { + udpipe_csharpPINVOKE.EmptyNodes_Insert(swigCPtr, index, EmptyNode.getCPtr(x)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void InsertRange(int index, EmptyNodes values) { + udpipe_csharpPINVOKE.EmptyNodes_InsertRange(swigCPtr, index, EmptyNodes.getCPtr(values)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void RemoveAt(int index) { + udpipe_csharpPINVOKE.EmptyNodes_RemoveAt(swigCPtr, index); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void RemoveRange(int index, int count) { + udpipe_csharpPINVOKE.EmptyNodes_RemoveRange(swigCPtr, index, count); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public static EmptyNodes Repeat(EmptyNode value, int count) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.EmptyNodes_Repeat(EmptyNode.getCPtr(value), count); + EmptyNodes ret = (cPtr == global::System.IntPtr.Zero) ? null : new EmptyNodes(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public void Reverse() { + udpipe_csharpPINVOKE.EmptyNodes_Reverse__SWIG_0(swigCPtr); + } + + public void Reverse(int index, int count) { + udpipe_csharpPINVOKE.EmptyNodes_Reverse__SWIG_1(swigCPtr, index, count); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void SetRange(int index, EmptyNodes values) { + udpipe_csharpPINVOKE.EmptyNodes_SetRange(swigCPtr, index, EmptyNodes.getCPtr(values)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + +} + +} diff --git a/UDPipe/v1/binary/osx/csharp/Ufal/UDPipe/Evaluator.cs b/UDPipe/v1/binary/osx/csharp/Ufal/UDPipe/Evaluator.cs new file mode 100644 index 0000000000000000000000000000000000000000..007e5ae8995f11aefe94465fed6d1d61725b6644 --- /dev/null +++ b/UDPipe/v1/binary/osx/csharp/Ufal/UDPipe/Evaluator.cs @@ -0,0 +1,94 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +public class Evaluator : global::System.IDisposable { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal Evaluator(global::System.IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Evaluator obj) { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + ~Evaluator() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != global::System.IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + udpipe_csharpPINVOKE.delete_Evaluator(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + global::System.GC.SuppressFinalize(this); + } + } + + public Evaluator(Model m, string tokenizer, string tagger, string parser) : this(udpipe_csharpPINVOKE.new_Evaluator(Model.getCPtr(m), tokenizer, tagger, parser), true) { + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void setModel(Model m) { + udpipe_csharpPINVOKE.Evaluator_setModel(swigCPtr, Model.getCPtr(m)); + } + + public void setTokenizer(string tokenizer) { + udpipe_csharpPINVOKE.Evaluator_setTokenizer(swigCPtr, tokenizer); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void setTagger(string tagger) { + udpipe_csharpPINVOKE.Evaluator_setTagger(swigCPtr, tagger); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void setParser(string parser) { + udpipe_csharpPINVOKE.Evaluator_setParser(swigCPtr, parser); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public string evaluate(string data, ProcessingError error) { + string ret = udpipe_csharpPINVOKE.Evaluator_evaluate__SWIG_0(swigCPtr, data, ProcessingError.getCPtr(error)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public string evaluate(string data) { + string ret = udpipe_csharpPINVOKE.Evaluator_evaluate__SWIG_1(swigCPtr, data); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public static string DEFAULT { + get { + string ret = udpipe_csharpPINVOKE.Evaluator_DEFAULT_get(); + return ret; + } + } + + public static string NONE { + get { + string ret = udpipe_csharpPINVOKE.Evaluator_NONE_get(); + return ret; + } + } + +} + +} diff --git a/UDPipe/v1/binary/osx/csharp/Ufal/UDPipe/InputFormat.cs b/UDPipe/v1/binary/osx/csharp/Ufal/UDPipe/InputFormat.cs new file mode 100644 index 0000000000000000000000000000000000000000..4dd3bb29440658a9e5187aec1cf719180c11e798 --- /dev/null +++ b/UDPipe/v1/binary/osx/csharp/Ufal/UDPipe/InputFormat.cs @@ -0,0 +1,175 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +public class InputFormat : global::System.IDisposable { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal InputFormat(global::System.IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(InputFormat obj) { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + ~InputFormat() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != global::System.IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + udpipe_csharpPINVOKE.delete_InputFormat(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + global::System.GC.SuppressFinalize(this); + } + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtrAndDisown(InputFormat obj) { + if (obj != null) obj.swigCMemOwn = false; + return getCPtr(obj); + } + + public virtual void resetDocument(string id) { + udpipe_csharpPINVOKE.InputFormat_resetDocument__SWIG_0(swigCPtr, id); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public virtual void resetDocument() { + udpipe_csharpPINVOKE.InputFormat_resetDocument__SWIG_1(swigCPtr); + } + + public virtual void setText(string text) { + udpipe_csharpPINVOKE.InputFormat_setText(swigCPtr, text); + } + + public virtual bool nextSentence(Sentence s, ProcessingError error) { + bool ret = udpipe_csharpPINVOKE.InputFormat_nextSentence__SWIG_0(swigCPtr, Sentence.getCPtr(s), ProcessingError.getCPtr(error)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public virtual bool nextSentence(Sentence s) { + bool ret = udpipe_csharpPINVOKE.InputFormat_nextSentence__SWIG_1(swigCPtr, Sentence.getCPtr(s)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public static InputFormat newInputFormat(string name) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.InputFormat_newInputFormat(name); + InputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new InputFormat(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public static InputFormat newConlluInputFormat(string options) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.InputFormat_newConlluInputFormat__SWIG_0(options); + InputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new InputFormat(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public static InputFormat newConlluInputFormat() { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.InputFormat_newConlluInputFormat__SWIG_1(); + InputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new InputFormat(cPtr, true); + return ret; + } + + public static InputFormat newGenericTokenizerInputFormat(string options) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.InputFormat_newGenericTokenizerInputFormat__SWIG_0(options); + InputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new InputFormat(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public static InputFormat newGenericTokenizerInputFormat() { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.InputFormat_newGenericTokenizerInputFormat__SWIG_1(); + InputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new InputFormat(cPtr, true); + return ret; + } + + public static InputFormat newHorizontalInputFormat(string options) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.InputFormat_newHorizontalInputFormat__SWIG_0(options); + InputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new InputFormat(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public static InputFormat newHorizontalInputFormat() { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.InputFormat_newHorizontalInputFormat__SWIG_1(); + InputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new InputFormat(cPtr, true); + return ret; + } + + public static InputFormat newVerticalInputFormat(string options) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.InputFormat_newVerticalInputFormat__SWIG_0(options); + InputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new InputFormat(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public static InputFormat newVerticalInputFormat() { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.InputFormat_newVerticalInputFormat__SWIG_1(); + InputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new InputFormat(cPtr, true); + return ret; + } + + public static InputFormat newPresegmentedTokenizer(InputFormat DISOWN) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.InputFormat_newPresegmentedTokenizer(InputFormat.getCPtrAndDisown(DISOWN)); + InputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new InputFormat(cPtr, true); + return ret; + } + + public static string CONLLU_V1 { + get { + string ret = udpipe_csharpPINVOKE.InputFormat_CONLLU_V1_get(); + return ret; + } + } + + public static string CONLLU_V2 { + get { + string ret = udpipe_csharpPINVOKE.InputFormat_CONLLU_V2_get(); + return ret; + } + } + + public static string GENERIC_TOKENIZER_NORMALIZED_SPACES { + get { + string ret = udpipe_csharpPINVOKE.InputFormat_GENERIC_TOKENIZER_NORMALIZED_SPACES_get(); + return ret; + } + } + + public static string GENERIC_TOKENIZER_PRESEGMENTED { + get { + string ret = udpipe_csharpPINVOKE.InputFormat_GENERIC_TOKENIZER_PRESEGMENTED_get(); + return ret; + } + } + + public static string GENERIC_TOKENIZER_RANGES { + get { + string ret = udpipe_csharpPINVOKE.InputFormat_GENERIC_TOKENIZER_RANGES_get(); + return ret; + } + } + +} + +} diff --git a/UDPipe/v1/binary/osx/csharp/Ufal/UDPipe/Model.cs b/UDPipe/v1/binary/osx/csharp/Ufal/UDPipe/Model.cs new file mode 100644 index 0000000000000000000000000000000000000000..c0f530c0927b5b4e91e29dd73092ab2eae73c145 --- /dev/null +++ b/UDPipe/v1/binary/osx/csharp/Ufal/UDPipe/Model.cs @@ -0,0 +1,110 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +public class Model : global::System.IDisposable { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal Model(global::System.IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Model obj) { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + ~Model() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != global::System.IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + udpipe_csharpPINVOKE.delete_Model(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + global::System.GC.SuppressFinalize(this); + } + } + + public static Model load(string fname) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.Model_load(fname); + Model ret = (cPtr == global::System.IntPtr.Zero) ? null : new Model(cPtr, true); + return ret; + } + + public virtual InputFormat newTokenizer(string options) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.Model_newTokenizer(swigCPtr, options); + InputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new InputFormat(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public virtual bool tag(Sentence s, string options, ProcessingError error) { + bool ret = udpipe_csharpPINVOKE.Model_tag__SWIG_0(swigCPtr, Sentence.getCPtr(s), options, ProcessingError.getCPtr(error)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public virtual bool tag(Sentence s, string options) { + bool ret = udpipe_csharpPINVOKE.Model_tag__SWIG_1(swigCPtr, Sentence.getCPtr(s), options); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public virtual bool parse(Sentence s, string options, ProcessingError error) { + bool ret = udpipe_csharpPINVOKE.Model_parse__SWIG_0(swigCPtr, Sentence.getCPtr(s), options, ProcessingError.getCPtr(error)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public virtual bool parse(Sentence s, string options) { + bool ret = udpipe_csharpPINVOKE.Model_parse__SWIG_1(swigCPtr, Sentence.getCPtr(s), options); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public static string DEFAULT { + get { + string ret = udpipe_csharpPINVOKE.Model_DEFAULT_get(); + return ret; + } + } + + public static string TOKENIZER_NORMALIZED_SPACES { + get { + string ret = udpipe_csharpPINVOKE.Model_TOKENIZER_NORMALIZED_SPACES_get(); + return ret; + } + } + + public static string TOKENIZER_PRESEGMENTED { + get { + string ret = udpipe_csharpPINVOKE.Model_TOKENIZER_PRESEGMENTED_get(); + return ret; + } + } + + public static string TOKENIZER_RANGES { + get { + string ret = udpipe_csharpPINVOKE.Model_TOKENIZER_RANGES_get(); + return ret; + } + } + +} + +} diff --git a/UDPipe/v1/binary/osx/csharp/Ufal/UDPipe/MultiwordToken.cs b/UDPipe/v1/binary/osx/csharp/Ufal/UDPipe/MultiwordToken.cs new file mode 100644 index 0000000000000000000000000000000000000000..0c0d174d4568b275e8ccba0da645baae911f6451 --- /dev/null +++ b/UDPipe/v1/binary/osx/csharp/Ufal/UDPipe/MultiwordToken.cs @@ -0,0 +1,81 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +public class MultiwordToken : Token { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + + internal MultiwordToken(global::System.IntPtr cPtr, bool cMemoryOwn) : base(udpipe_csharpPINVOKE.MultiwordToken_SWIGUpcast(cPtr), cMemoryOwn) { + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(MultiwordToken obj) { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + ~MultiwordToken() { + Dispose(); + } + + public override void Dispose() { + lock(this) { + if (swigCPtr.Handle != global::System.IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + udpipe_csharpPINVOKE.delete_MultiwordToken(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + global::System.GC.SuppressFinalize(this); + base.Dispose(); + } + } + + public int idFirst { + set { + udpipe_csharpPINVOKE.MultiwordToken_idFirst_set(swigCPtr, value); + } + get { + int ret = udpipe_csharpPINVOKE.MultiwordToken_idFirst_get(swigCPtr); + return ret; + } + } + + public int idLast { + set { + udpipe_csharpPINVOKE.MultiwordToken_idLast_set(swigCPtr, value); + } + get { + int ret = udpipe_csharpPINVOKE.MultiwordToken_idLast_get(swigCPtr); + return ret; + } + } + + public MultiwordToken(int id_first, int id_last, string form, string misc) : this(udpipe_csharpPINVOKE.new_MultiwordToken__SWIG_0(id_first, id_last, form, misc), true) { + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public MultiwordToken(int id_first, int id_last, string form) : this(udpipe_csharpPINVOKE.new_MultiwordToken__SWIG_1(id_first, id_last, form), true) { + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public MultiwordToken(int id_first, int id_last) : this(udpipe_csharpPINVOKE.new_MultiwordToken__SWIG_2(id_first, id_last), true) { + } + + public MultiwordToken(int id_first) : this(udpipe_csharpPINVOKE.new_MultiwordToken__SWIG_3(id_first), true) { + } + + public MultiwordToken() : this(udpipe_csharpPINVOKE.new_MultiwordToken__SWIG_4(), true) { + } + +} + +} diff --git a/UDPipe/v1/binary/osx/csharp/Ufal/UDPipe/MultiwordTokens.cs b/UDPipe/v1/binary/osx/csharp/Ufal/UDPipe/MultiwordTokens.cs new file mode 100644 index 0000000000000000000000000000000000000000..0e901203b8632f1636e8b5725efa90ecffbf1f7e --- /dev/null +++ b/UDPipe/v1/binary/osx/csharp/Ufal/UDPipe/MultiwordTokens.cs @@ -0,0 +1,309 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +public class MultiwordTokens : global::System.IDisposable, global::System.Collections.IEnumerable + , global::System.Collections.Generic.IEnumerable + { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal MultiwordTokens(global::System.IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(MultiwordTokens obj) { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + ~MultiwordTokens() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != global::System.IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + udpipe_csharpPINVOKE.delete_MultiwordTokens(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + global::System.GC.SuppressFinalize(this); + } + } + + public MultiwordTokens(global::System.Collections.ICollection c) : this() { + if (c == null) + throw new global::System.ArgumentNullException("c"); + foreach (MultiwordToken element in c) { + this.Add(element); + } + } + + public bool IsFixedSize { + get { + return false; + } + } + + public bool IsReadOnly { + get { + return false; + } + } + + public MultiwordToken this[int index] { + get { + return getitem(index); + } + set { + setitem(index, value); + } + } + + public int Capacity { + get { + return (int)capacity(); + } + set { + if (value < size()) + throw new global::System.ArgumentOutOfRangeException("Capacity"); + reserve((uint)value); + } + } + + public int Count { + get { + return (int)size(); + } + } + + public bool IsSynchronized { + get { + return false; + } + } + + public void CopyTo(MultiwordToken[] array) + { + CopyTo(0, array, 0, this.Count); + } + + public void CopyTo(MultiwordToken[] array, int arrayIndex) + { + CopyTo(0, array, arrayIndex, this.Count); + } + + public void CopyTo(int index, MultiwordToken[] array, int arrayIndex, int count) + { + if (array == null) + throw new global::System.ArgumentNullException("array"); + if (index < 0) + throw new global::System.ArgumentOutOfRangeException("index", "Value is less than zero"); + if (arrayIndex < 0) + throw new global::System.ArgumentOutOfRangeException("arrayIndex", "Value is less than zero"); + if (count < 0) + throw new global::System.ArgumentOutOfRangeException("count", "Value is less than zero"); + if (array.Rank > 1) + throw new global::System.ArgumentException("Multi dimensional array.", "array"); + if (index+count > this.Count || arrayIndex+count > array.Length) + throw new global::System.ArgumentException("Number of elements to copy is too large."); + for (int i=0; i global::System.Collections.Generic.IEnumerable.GetEnumerator() { + return new MultiwordTokensEnumerator(this); + } + + global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator() { + return new MultiwordTokensEnumerator(this); + } + + public MultiwordTokensEnumerator GetEnumerator() { + return new MultiwordTokensEnumerator(this); + } + + // Type-safe enumerator + /// Note that the IEnumerator documentation requires an InvalidOperationException to be thrown + /// whenever the collection is modified. This has been done for changes in the size of the + /// collection but not when one of the elements of the collection is modified as it is a bit + /// tricky to detect unmanaged code that modifies the collection under our feet. + public sealed class MultiwordTokensEnumerator : global::System.Collections.IEnumerator + , global::System.Collections.Generic.IEnumerator + { + private MultiwordTokens collectionRef; + private int currentIndex; + private object currentObject; + private int currentSize; + + public MultiwordTokensEnumerator(MultiwordTokens collection) { + collectionRef = collection; + currentIndex = -1; + currentObject = null; + currentSize = collectionRef.Count; + } + + // Type-safe iterator Current + public MultiwordToken Current { + get { + if (currentIndex == -1) + throw new global::System.InvalidOperationException("Enumeration not started."); + if (currentIndex > currentSize - 1) + throw new global::System.InvalidOperationException("Enumeration finished."); + if (currentObject == null) + throw new global::System.InvalidOperationException("Collection modified."); + return (MultiwordToken)currentObject; + } + } + + // Type-unsafe IEnumerator.Current + object global::System.Collections.IEnumerator.Current { + get { + return Current; + } + } + + public bool MoveNext() { + int size = collectionRef.Count; + bool moveOkay = (currentIndex+1 < size) && (size == currentSize); + if (moveOkay) { + currentIndex++; + currentObject = collectionRef[currentIndex]; + } else { + currentObject = null; + } + return moveOkay; + } + + public void Reset() { + currentIndex = -1; + currentObject = null; + if (collectionRef.Count != currentSize) { + throw new global::System.InvalidOperationException("Collection modified."); + } + } + + public void Dispose() { + currentIndex = -1; + currentObject = null; + } + } + + public void Clear() { + udpipe_csharpPINVOKE.MultiwordTokens_Clear(swigCPtr); + } + + public void Add(MultiwordToken x) { + udpipe_csharpPINVOKE.MultiwordTokens_Add(swigCPtr, MultiwordToken.getCPtr(x)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + private uint size() { + uint ret = udpipe_csharpPINVOKE.MultiwordTokens_size(swigCPtr); + return ret; + } + + private uint capacity() { + uint ret = udpipe_csharpPINVOKE.MultiwordTokens_capacity(swigCPtr); + return ret; + } + + private void reserve(uint n) { + udpipe_csharpPINVOKE.MultiwordTokens_reserve(swigCPtr, n); + } + + public MultiwordTokens() : this(udpipe_csharpPINVOKE.new_MultiwordTokens__SWIG_0(), true) { + } + + public MultiwordTokens(MultiwordTokens other) : this(udpipe_csharpPINVOKE.new_MultiwordTokens__SWIG_1(MultiwordTokens.getCPtr(other)), true) { + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public MultiwordTokens(int capacity) : this(udpipe_csharpPINVOKE.new_MultiwordTokens__SWIG_2(capacity), true) { + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + private MultiwordToken getitemcopy(int index) { + MultiwordToken ret = new MultiwordToken(udpipe_csharpPINVOKE.MultiwordTokens_getitemcopy(swigCPtr, index), true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + private MultiwordToken getitem(int index) { + MultiwordToken ret = new MultiwordToken(udpipe_csharpPINVOKE.MultiwordTokens_getitem(swigCPtr, index), false); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + private void setitem(int index, MultiwordToken val) { + udpipe_csharpPINVOKE.MultiwordTokens_setitem(swigCPtr, index, MultiwordToken.getCPtr(val)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void AddRange(MultiwordTokens values) { + udpipe_csharpPINVOKE.MultiwordTokens_AddRange(swigCPtr, MultiwordTokens.getCPtr(values)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public MultiwordTokens GetRange(int index, int count) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.MultiwordTokens_GetRange(swigCPtr, index, count); + MultiwordTokens ret = (cPtr == global::System.IntPtr.Zero) ? null : new MultiwordTokens(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public void Insert(int index, MultiwordToken x) { + udpipe_csharpPINVOKE.MultiwordTokens_Insert(swigCPtr, index, MultiwordToken.getCPtr(x)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void InsertRange(int index, MultiwordTokens values) { + udpipe_csharpPINVOKE.MultiwordTokens_InsertRange(swigCPtr, index, MultiwordTokens.getCPtr(values)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void RemoveAt(int index) { + udpipe_csharpPINVOKE.MultiwordTokens_RemoveAt(swigCPtr, index); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void RemoveRange(int index, int count) { + udpipe_csharpPINVOKE.MultiwordTokens_RemoveRange(swigCPtr, index, count); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public static MultiwordTokens Repeat(MultiwordToken value, int count) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.MultiwordTokens_Repeat(MultiwordToken.getCPtr(value), count); + MultiwordTokens ret = (cPtr == global::System.IntPtr.Zero) ? null : new MultiwordTokens(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public void Reverse() { + udpipe_csharpPINVOKE.MultiwordTokens_Reverse__SWIG_0(swigCPtr); + } + + public void Reverse(int index, int count) { + udpipe_csharpPINVOKE.MultiwordTokens_Reverse__SWIG_1(swigCPtr, index, count); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void SetRange(int index, MultiwordTokens values) { + udpipe_csharpPINVOKE.MultiwordTokens_SetRange(swigCPtr, index, MultiwordTokens.getCPtr(values)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + +} + +} diff --git a/UDPipe/v1/binary/osx/csharp/Ufal/UDPipe/OutputFormat.cs b/UDPipe/v1/binary/osx/csharp/Ufal/UDPipe/OutputFormat.cs new file mode 100644 index 0000000000000000000000000000000000000000..e15d216ec5790ea52aa23b38a59849e151e8439c --- /dev/null +++ b/UDPipe/v1/binary/osx/csharp/Ufal/UDPipe/OutputFormat.cs @@ -0,0 +1,176 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +public class OutputFormat : global::System.IDisposable { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal OutputFormat(global::System.IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(OutputFormat obj) { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + ~OutputFormat() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != global::System.IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + udpipe_csharpPINVOKE.delete_OutputFormat(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + global::System.GC.SuppressFinalize(this); + } + } + + public virtual string writeSentence(Sentence s) { + string ret = udpipe_csharpPINVOKE.OutputFormat_writeSentence(swigCPtr, Sentence.getCPtr(s)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public virtual string finishDocument() { + string ret = udpipe_csharpPINVOKE.OutputFormat_finishDocument(swigCPtr); + return ret; + } + + public static OutputFormat newOutputFormat(string name) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.OutputFormat_newOutputFormat(name); + OutputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new OutputFormat(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public static OutputFormat newConlluOutputFormat(string options) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.OutputFormat_newConlluOutputFormat__SWIG_0(options); + OutputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new OutputFormat(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public static OutputFormat newConlluOutputFormat() { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.OutputFormat_newConlluOutputFormat__SWIG_1(); + OutputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new OutputFormat(cPtr, true); + return ret; + } + + public static OutputFormat newEpeOutputFormat(string options) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.OutputFormat_newEpeOutputFormat__SWIG_0(options); + OutputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new OutputFormat(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public static OutputFormat newEpeOutputFormat() { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.OutputFormat_newEpeOutputFormat__SWIG_1(); + OutputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new OutputFormat(cPtr, true); + return ret; + } + + public static OutputFormat newMatxinOutputFormat(string options) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.OutputFormat_newMatxinOutputFormat__SWIG_0(options); + OutputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new OutputFormat(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public static OutputFormat newMatxinOutputFormat() { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.OutputFormat_newMatxinOutputFormat__SWIG_1(); + OutputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new OutputFormat(cPtr, true); + return ret; + } + + public static OutputFormat newHorizontalOutputFormat(string options) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.OutputFormat_newHorizontalOutputFormat__SWIG_0(options); + OutputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new OutputFormat(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public static OutputFormat newHorizontalOutputFormat() { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.OutputFormat_newHorizontalOutputFormat__SWIG_1(); + OutputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new OutputFormat(cPtr, true); + return ret; + } + + public static OutputFormat newPlaintextOutputFormat(string options) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.OutputFormat_newPlaintextOutputFormat__SWIG_0(options); + OutputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new OutputFormat(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public static OutputFormat newPlaintextOutputFormat() { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.OutputFormat_newPlaintextOutputFormat__SWIG_1(); + OutputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new OutputFormat(cPtr, true); + return ret; + } + + public static OutputFormat newVerticalOutputFormat(string options) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.OutputFormat_newVerticalOutputFormat__SWIG_0(options); + OutputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new OutputFormat(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public static OutputFormat newVerticalOutputFormat() { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.OutputFormat_newVerticalOutputFormat__SWIG_1(); + OutputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new OutputFormat(cPtr, true); + return ret; + } + + public static string CONLLU_V1 { + get { + string ret = udpipe_csharpPINVOKE.OutputFormat_CONLLU_V1_get(); + return ret; + } + } + + public static string CONLLU_V2 { + get { + string ret = udpipe_csharpPINVOKE.OutputFormat_CONLLU_V2_get(); + return ret; + } + } + + public static string HORIZONTAL_PARAGRAPHS { + get { + string ret = udpipe_csharpPINVOKE.OutputFormat_HORIZONTAL_PARAGRAPHS_get(); + return ret; + } + } + + public static string PLAINTEXT_NORMALIZED_SPACES { + get { + string ret = udpipe_csharpPINVOKE.OutputFormat_PLAINTEXT_NORMALIZED_SPACES_get(); + return ret; + } + } + + public static string VERTICAL_PARAGRAPHS { + get { + string ret = udpipe_csharpPINVOKE.OutputFormat_VERTICAL_PARAGRAPHS_get(); + return ret; + } + } + +} + +} diff --git a/UDPipe/v1/binary/osx/csharp/Ufal/UDPipe/Pipeline.cs b/UDPipe/v1/binary/osx/csharp/Ufal/UDPipe/Pipeline.cs new file mode 100644 index 0000000000000000000000000000000000000000..370b33368ba0c8056a906dcde9ed5478710a41c4 --- /dev/null +++ b/UDPipe/v1/binary/osx/csharp/Ufal/UDPipe/Pipeline.cs @@ -0,0 +1,108 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +public class Pipeline : global::System.IDisposable { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal Pipeline(global::System.IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Pipeline obj) { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + ~Pipeline() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != global::System.IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + udpipe_csharpPINVOKE.delete_Pipeline(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + global::System.GC.SuppressFinalize(this); + } + } + + public Pipeline(Model m, string input, string tagger, string parser, string output) : this(udpipe_csharpPINVOKE.new_Pipeline(Model.getCPtr(m), input, tagger, parser, output), true) { + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void setModel(Model m) { + udpipe_csharpPINVOKE.Pipeline_setModel(swigCPtr, Model.getCPtr(m)); + } + + public void setInput(string input) { + udpipe_csharpPINVOKE.Pipeline_setInput(swigCPtr, input); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void setTagger(string tagger) { + udpipe_csharpPINVOKE.Pipeline_setTagger(swigCPtr, tagger); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void setParser(string parser) { + udpipe_csharpPINVOKE.Pipeline_setParser(swigCPtr, parser); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void setOutput(string output) { + udpipe_csharpPINVOKE.Pipeline_setOutput(swigCPtr, output); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void setImmediate(bool immediate) { + udpipe_csharpPINVOKE.Pipeline_setImmediate(swigCPtr, immediate); + } + + public void setDocumentId(string document_id) { + udpipe_csharpPINVOKE.Pipeline_setDocumentId(swigCPtr, document_id); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public string process(string data, ProcessingError error) { + string ret = udpipe_csharpPINVOKE.Pipeline_process__SWIG_0(swigCPtr, data, ProcessingError.getCPtr(error)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public string process(string data) { + string ret = udpipe_csharpPINVOKE.Pipeline_process__SWIG_1(swigCPtr, data); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public static string DEFAULT { + get { + string ret = udpipe_csharpPINVOKE.Pipeline_DEFAULT_get(); + return ret; + } + } + + public static string NONE { + get { + string ret = udpipe_csharpPINVOKE.Pipeline_NONE_get(); + return ret; + } + } + +} + +} diff --git a/UDPipe/v1/binary/osx/csharp/Ufal/UDPipe/ProcessingError.cs b/UDPipe/v1/binary/osx/csharp/Ufal/UDPipe/ProcessingError.cs new file mode 100644 index 0000000000000000000000000000000000000000..f68346cd50e55daf567824eb3cc778db1b253389 --- /dev/null +++ b/UDPipe/v1/binary/osx/csharp/Ufal/UDPipe/ProcessingError.cs @@ -0,0 +1,65 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +public class ProcessingError : global::System.IDisposable { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal ProcessingError(global::System.IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(ProcessingError obj) { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + ~ProcessingError() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != global::System.IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + udpipe_csharpPINVOKE.delete_ProcessingError(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + global::System.GC.SuppressFinalize(this); + } + } + + public bool occurred() { + bool ret = udpipe_csharpPINVOKE.ProcessingError_occurred(swigCPtr); + return ret; + } + + public string message { + set { + udpipe_csharpPINVOKE.ProcessingError_message_set(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + get { + string ret = udpipe_csharpPINVOKE.ProcessingError_message_get(swigCPtr); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + } + + public ProcessingError() : this(udpipe_csharpPINVOKE.new_ProcessingError(), true) { + } + +} + +} diff --git a/UDPipe/v1/binary/osx/csharp/Ufal/UDPipe/Sentence.cs b/UDPipe/v1/binary/osx/csharp/Ufal/UDPipe/Sentence.cs new file mode 100644 index 0000000000000000000000000000000000000000..9efe884c1a7face6b7f8875411b08f95a8740c6b --- /dev/null +++ b/UDPipe/v1/binary/osx/csharp/Ufal/UDPipe/Sentence.cs @@ -0,0 +1,180 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +public class Sentence : global::System.IDisposable { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal Sentence(global::System.IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Sentence obj) { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + ~Sentence() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != global::System.IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + udpipe_csharpPINVOKE.delete_Sentence(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + global::System.GC.SuppressFinalize(this); + } + } + + public Sentence() : this(udpipe_csharpPINVOKE.new_Sentence(), true) { + } + + public Words words { + set { + udpipe_csharpPINVOKE.Sentence_words_set(swigCPtr, Words.getCPtr(value)); + } + get { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.Sentence_words_get(swigCPtr); + Words ret = (cPtr == global::System.IntPtr.Zero) ? null : new Words(cPtr, false); + return ret; + } + } + + public MultiwordTokens multiwordTokens { + set { + udpipe_csharpPINVOKE.Sentence_multiwordTokens_set(swigCPtr, MultiwordTokens.getCPtr(value)); + } + get { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.Sentence_multiwordTokens_get(swigCPtr); + MultiwordTokens ret = (cPtr == global::System.IntPtr.Zero) ? null : new MultiwordTokens(cPtr, false); + return ret; + } + } + + public EmptyNodes emptyNodes { + set { + udpipe_csharpPINVOKE.Sentence_emptyNodes_set(swigCPtr, EmptyNodes.getCPtr(value)); + } + get { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.Sentence_emptyNodes_get(swigCPtr); + EmptyNodes ret = (cPtr == global::System.IntPtr.Zero) ? null : new EmptyNodes(cPtr, false); + return ret; + } + } + + public Comments comments { + set { + udpipe_csharpPINVOKE.Sentence_comments_set(swigCPtr, Comments.getCPtr(value)); + } + get { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.Sentence_comments_get(swigCPtr); + Comments ret = (cPtr == global::System.IntPtr.Zero) ? null : new Comments(cPtr, false); + return ret; + } + } + + public static string rootForm { + get { + string ret = udpipe_csharpPINVOKE.Sentence_rootForm_get(); + return ret; + } + } + + public bool empty() { + bool ret = udpipe_csharpPINVOKE.Sentence_empty(swigCPtr); + return ret; + } + + public void clear() { + udpipe_csharpPINVOKE.Sentence_clear(swigCPtr); + } + + public virtual Word addWord(string form) { + Word ret = new Word(udpipe_csharpPINVOKE.Sentence_addWord(swigCPtr, form), false); + return ret; + } + + public void setHead(int id, int head, string deprel) { + udpipe_csharpPINVOKE.Sentence_setHead(swigCPtr, id, head, deprel); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void unlinkAllNodes() { + udpipe_csharpPINVOKE.Sentence_unlinkAllNodes(swigCPtr); + } + + public bool getNewDoc() { + bool ret = udpipe_csharpPINVOKE.Sentence_getNewDoc(swigCPtr); + return ret; + } + + public string getNewDocId() { + string ret = udpipe_csharpPINVOKE.Sentence_getNewDocId(swigCPtr); + return ret; + } + + public void setNewDoc(bool new_doc, string id) { + udpipe_csharpPINVOKE.Sentence_setNewDoc__SWIG_0(swigCPtr, new_doc, id); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void setNewDoc(bool new_doc) { + udpipe_csharpPINVOKE.Sentence_setNewDoc__SWIG_1(swigCPtr, new_doc); + } + + public bool getNewPar() { + bool ret = udpipe_csharpPINVOKE.Sentence_getNewPar(swigCPtr); + return ret; + } + + public string getNewParId() { + string ret = udpipe_csharpPINVOKE.Sentence_getNewParId(swigCPtr); + return ret; + } + + public void setNewPar(bool new_par, string id) { + udpipe_csharpPINVOKE.Sentence_setNewPar__SWIG_0(swigCPtr, new_par, id); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void setNewPar(bool new_par) { + udpipe_csharpPINVOKE.Sentence_setNewPar__SWIG_1(swigCPtr, new_par); + } + + public string getSentId() { + string ret = udpipe_csharpPINVOKE.Sentence_getSentId(swigCPtr); + return ret; + } + + public void setSentId(string id) { + udpipe_csharpPINVOKE.Sentence_setSentId(swigCPtr, id); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public string getText() { + string ret = udpipe_csharpPINVOKE.Sentence_getText(swigCPtr); + return ret; + } + + public void setText(string id) { + udpipe_csharpPINVOKE.Sentence_setText(swigCPtr, id); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + +} + +} diff --git a/UDPipe/v1/binary/osx/csharp/Ufal/UDPipe/Sentences.cs b/UDPipe/v1/binary/osx/csharp/Ufal/UDPipe/Sentences.cs new file mode 100644 index 0000000000000000000000000000000000000000..4247f211a86a8e8c0e5af30d72613005a3bf4d15 --- /dev/null +++ b/UDPipe/v1/binary/osx/csharp/Ufal/UDPipe/Sentences.cs @@ -0,0 +1,309 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +public class Sentences : global::System.IDisposable, global::System.Collections.IEnumerable + , global::System.Collections.Generic.IEnumerable + { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal Sentences(global::System.IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Sentences obj) { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + ~Sentences() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != global::System.IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + udpipe_csharpPINVOKE.delete_Sentences(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + global::System.GC.SuppressFinalize(this); + } + } + + public Sentences(global::System.Collections.ICollection c) : this() { + if (c == null) + throw new global::System.ArgumentNullException("c"); + foreach (Sentence element in c) { + this.Add(element); + } + } + + public bool IsFixedSize { + get { + return false; + } + } + + public bool IsReadOnly { + get { + return false; + } + } + + public Sentence this[int index] { + get { + return getitem(index); + } + set { + setitem(index, value); + } + } + + public int Capacity { + get { + return (int)capacity(); + } + set { + if (value < size()) + throw new global::System.ArgumentOutOfRangeException("Capacity"); + reserve((uint)value); + } + } + + public int Count { + get { + return (int)size(); + } + } + + public bool IsSynchronized { + get { + return false; + } + } + + public void CopyTo(Sentence[] array) + { + CopyTo(0, array, 0, this.Count); + } + + public void CopyTo(Sentence[] array, int arrayIndex) + { + CopyTo(0, array, arrayIndex, this.Count); + } + + public void CopyTo(int index, Sentence[] array, int arrayIndex, int count) + { + if (array == null) + throw new global::System.ArgumentNullException("array"); + if (index < 0) + throw new global::System.ArgumentOutOfRangeException("index", "Value is less than zero"); + if (arrayIndex < 0) + throw new global::System.ArgumentOutOfRangeException("arrayIndex", "Value is less than zero"); + if (count < 0) + throw new global::System.ArgumentOutOfRangeException("count", "Value is less than zero"); + if (array.Rank > 1) + throw new global::System.ArgumentException("Multi dimensional array.", "array"); + if (index+count > this.Count || arrayIndex+count > array.Length) + throw new global::System.ArgumentException("Number of elements to copy is too large."); + for (int i=0; i global::System.Collections.Generic.IEnumerable.GetEnumerator() { + return new SentencesEnumerator(this); + } + + global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator() { + return new SentencesEnumerator(this); + } + + public SentencesEnumerator GetEnumerator() { + return new SentencesEnumerator(this); + } + + // Type-safe enumerator + /// Note that the IEnumerator documentation requires an InvalidOperationException to be thrown + /// whenever the collection is modified. This has been done for changes in the size of the + /// collection but not when one of the elements of the collection is modified as it is a bit + /// tricky to detect unmanaged code that modifies the collection under our feet. + public sealed class SentencesEnumerator : global::System.Collections.IEnumerator + , global::System.Collections.Generic.IEnumerator + { + private Sentences collectionRef; + private int currentIndex; + private object currentObject; + private int currentSize; + + public SentencesEnumerator(Sentences collection) { + collectionRef = collection; + currentIndex = -1; + currentObject = null; + currentSize = collectionRef.Count; + } + + // Type-safe iterator Current + public Sentence Current { + get { + if (currentIndex == -1) + throw new global::System.InvalidOperationException("Enumeration not started."); + if (currentIndex > currentSize - 1) + throw new global::System.InvalidOperationException("Enumeration finished."); + if (currentObject == null) + throw new global::System.InvalidOperationException("Collection modified."); + return (Sentence)currentObject; + } + } + + // Type-unsafe IEnumerator.Current + object global::System.Collections.IEnumerator.Current { + get { + return Current; + } + } + + public bool MoveNext() { + int size = collectionRef.Count; + bool moveOkay = (currentIndex+1 < size) && (size == currentSize); + if (moveOkay) { + currentIndex++; + currentObject = collectionRef[currentIndex]; + } else { + currentObject = null; + } + return moveOkay; + } + + public void Reset() { + currentIndex = -1; + currentObject = null; + if (collectionRef.Count != currentSize) { + throw new global::System.InvalidOperationException("Collection modified."); + } + } + + public void Dispose() { + currentIndex = -1; + currentObject = null; + } + } + + public void Clear() { + udpipe_csharpPINVOKE.Sentences_Clear(swigCPtr); + } + + public void Add(Sentence x) { + udpipe_csharpPINVOKE.Sentences_Add(swigCPtr, Sentence.getCPtr(x)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + private uint size() { + uint ret = udpipe_csharpPINVOKE.Sentences_size(swigCPtr); + return ret; + } + + private uint capacity() { + uint ret = udpipe_csharpPINVOKE.Sentences_capacity(swigCPtr); + return ret; + } + + private void reserve(uint n) { + udpipe_csharpPINVOKE.Sentences_reserve(swigCPtr, n); + } + + public Sentences() : this(udpipe_csharpPINVOKE.new_Sentences__SWIG_0(), true) { + } + + public Sentences(Sentences other) : this(udpipe_csharpPINVOKE.new_Sentences__SWIG_1(Sentences.getCPtr(other)), true) { + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public Sentences(int capacity) : this(udpipe_csharpPINVOKE.new_Sentences__SWIG_2(capacity), true) { + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + private Sentence getitemcopy(int index) { + Sentence ret = new Sentence(udpipe_csharpPINVOKE.Sentences_getitemcopy(swigCPtr, index), true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + private Sentence getitem(int index) { + Sentence ret = new Sentence(udpipe_csharpPINVOKE.Sentences_getitem(swigCPtr, index), false); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + private void setitem(int index, Sentence val) { + udpipe_csharpPINVOKE.Sentences_setitem(swigCPtr, index, Sentence.getCPtr(val)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void AddRange(Sentences values) { + udpipe_csharpPINVOKE.Sentences_AddRange(swigCPtr, Sentences.getCPtr(values)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public Sentences GetRange(int index, int count) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.Sentences_GetRange(swigCPtr, index, count); + Sentences ret = (cPtr == global::System.IntPtr.Zero) ? null : new Sentences(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public void Insert(int index, Sentence x) { + udpipe_csharpPINVOKE.Sentences_Insert(swigCPtr, index, Sentence.getCPtr(x)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void InsertRange(int index, Sentences values) { + udpipe_csharpPINVOKE.Sentences_InsertRange(swigCPtr, index, Sentences.getCPtr(values)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void RemoveAt(int index) { + udpipe_csharpPINVOKE.Sentences_RemoveAt(swigCPtr, index); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void RemoveRange(int index, int count) { + udpipe_csharpPINVOKE.Sentences_RemoveRange(swigCPtr, index, count); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public static Sentences Repeat(Sentence value, int count) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.Sentences_Repeat(Sentence.getCPtr(value), count); + Sentences ret = (cPtr == global::System.IntPtr.Zero) ? null : new Sentences(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public void Reverse() { + udpipe_csharpPINVOKE.Sentences_Reverse__SWIG_0(swigCPtr); + } + + public void Reverse(int index, int count) { + udpipe_csharpPINVOKE.Sentences_Reverse__SWIG_1(swigCPtr, index, count); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void SetRange(int index, Sentences values) { + udpipe_csharpPINVOKE.Sentences_SetRange(swigCPtr, index, Sentences.getCPtr(values)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + +} + +} diff --git a/UDPipe/v1/binary/osx/csharp/Ufal/UDPipe/Token.cs b/UDPipe/v1/binary/osx/csharp/Ufal/UDPipe/Token.cs new file mode 100644 index 0000000000000000000000000000000000000000..bdeb83f9f005909bf47142481a85c7f537d63eab --- /dev/null +++ b/UDPipe/v1/binary/osx/csharp/Ufal/UDPipe/Token.cs @@ -0,0 +1,138 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +public class Token : global::System.IDisposable { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal Token(global::System.IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Token obj) { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + ~Token() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != global::System.IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + udpipe_csharpPINVOKE.delete_Token(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + global::System.GC.SuppressFinalize(this); + } + } + + public string form { + set { + udpipe_csharpPINVOKE.Token_form_set(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + get { + string ret = udpipe_csharpPINVOKE.Token_form_get(swigCPtr); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + } + + public string misc { + set { + udpipe_csharpPINVOKE.Token_misc_set(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + get { + string ret = udpipe_csharpPINVOKE.Token_misc_get(swigCPtr); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + } + + public Token(string form, string misc) : this(udpipe_csharpPINVOKE.new_Token__SWIG_0(form, misc), true) { + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public Token(string form) : this(udpipe_csharpPINVOKE.new_Token__SWIG_1(form), true) { + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public Token() : this(udpipe_csharpPINVOKE.new_Token__SWIG_2(), true) { + } + + public bool getSpaceAfter() { + bool ret = udpipe_csharpPINVOKE.Token_getSpaceAfter(swigCPtr); + return ret; + } + + public void setSpaceAfter(bool space_after) { + udpipe_csharpPINVOKE.Token_setSpaceAfter(swigCPtr, space_after); + } + + public string getSpacesBefore() { + string ret = udpipe_csharpPINVOKE.Token_getSpacesBefore(swigCPtr); + return ret; + } + + public void setSpacesBefore(string spaces_before) { + udpipe_csharpPINVOKE.Token_setSpacesBefore(swigCPtr, spaces_before); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public string getSpacesAfter() { + string ret = udpipe_csharpPINVOKE.Token_getSpacesAfter(swigCPtr); + return ret; + } + + public void setSpacesAfter(string spaces_after) { + udpipe_csharpPINVOKE.Token_setSpacesAfter(swigCPtr, spaces_after); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public string getSpacesInToken() { + string ret = udpipe_csharpPINVOKE.Token_getSpacesInToken(swigCPtr); + return ret; + } + + public void setSpacesInToken(string spaces_in_token) { + udpipe_csharpPINVOKE.Token_setSpacesInToken(swigCPtr, spaces_in_token); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public bool getTokenRange() { + bool ret = udpipe_csharpPINVOKE.Token_getTokenRange(swigCPtr); + return ret; + } + + public uint getTokenRangeStart() { + uint ret = udpipe_csharpPINVOKE.Token_getTokenRangeStart(swigCPtr); + return ret; + } + + public uint getTokenRangeEnd() { + uint ret = udpipe_csharpPINVOKE.Token_getTokenRangeEnd(swigCPtr); + return ret; + } + + public void setTokenRange(uint start, uint end) { + udpipe_csharpPINVOKE.Token_setTokenRange(swigCPtr, start, end); + } + +} + +} diff --git a/UDPipe/v1/binary/osx/csharp/Ufal/UDPipe/Trainer.cs b/UDPipe/v1/binary/osx/csharp/Ufal/UDPipe/Trainer.cs new file mode 100644 index 0000000000000000000000000000000000000000..31dcaada1065b721d6e5c757087b3f7f20423273 --- /dev/null +++ b/UDPipe/v1/binary/osx/csharp/Ufal/UDPipe/Trainer.cs @@ -0,0 +1,74 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +public class Trainer : global::System.IDisposable { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal Trainer(global::System.IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Trainer obj) { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + ~Trainer() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != global::System.IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + udpipe_csharpPINVOKE.delete_Trainer(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + global::System.GC.SuppressFinalize(this); + } + } + + public static string train(string method, Sentences train, Sentences heldout, string tokenizer, string tagger, string parser, ProcessingError error) { + string ret = udpipe_csharpPINVOKE.Trainer_train__SWIG_0(method, Sentences.getCPtr(train), Sentences.getCPtr(heldout), tokenizer, tagger, parser, ProcessingError.getCPtr(error)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public static string train(string method, Sentences train, Sentences heldout, string tokenizer, string tagger, string parser) { + string ret = udpipe_csharpPINVOKE.Trainer_train__SWIG_1(method, Sentences.getCPtr(train), Sentences.getCPtr(heldout), tokenizer, tagger, parser); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public static string DEFAULT { + get { + string ret = udpipe_csharpPINVOKE.Trainer_DEFAULT_get(); + return ret; + } + } + + public static string NONE { + get { + string ret = udpipe_csharpPINVOKE.Trainer_NONE_get(); + return ret; + } + } + + public Trainer() : this(udpipe_csharpPINVOKE.new_Trainer(), true) { + } + +} + +} diff --git a/UDPipe/v1/binary/osx/csharp/Ufal/UDPipe/Version.cs b/UDPipe/v1/binary/osx/csharp/Ufal/UDPipe/Version.cs new file mode 100644 index 0000000000000000000000000000000000000000..39434dd0ed3e5d35f59618ef7b418a5f4fcc4e21 --- /dev/null +++ b/UDPipe/v1/binary/osx/csharp/Ufal/UDPipe/Version.cs @@ -0,0 +1,95 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +public class Version : global::System.IDisposable { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal Version(global::System.IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Version obj) { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + ~Version() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != global::System.IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + udpipe_csharpPINVOKE.delete_Version(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + global::System.GC.SuppressFinalize(this); + } + } + + public uint major { + set { + udpipe_csharpPINVOKE.Version_major_set(swigCPtr, value); + } + get { + uint ret = udpipe_csharpPINVOKE.Version_major_get(swigCPtr); + return ret; + } + } + + public uint minor { + set { + udpipe_csharpPINVOKE.Version_minor_set(swigCPtr, value); + } + get { + uint ret = udpipe_csharpPINVOKE.Version_minor_get(swigCPtr); + return ret; + } + } + + public uint patch { + set { + udpipe_csharpPINVOKE.Version_patch_set(swigCPtr, value); + } + get { + uint ret = udpipe_csharpPINVOKE.Version_patch_get(swigCPtr); + return ret; + } + } + + public string prerelease { + set { + udpipe_csharpPINVOKE.Version_prerelease_set(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + get { + string ret = udpipe_csharpPINVOKE.Version_prerelease_get(swigCPtr); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + } + + public static Version current() { + Version ret = new Version(udpipe_csharpPINVOKE.Version_current(), true); + return ret; + } + + public Version() : this(udpipe_csharpPINVOKE.new_Version(), true) { + } + +} + +} diff --git a/UDPipe/v1/binary/osx/csharp/Ufal/UDPipe/Word.cs b/UDPipe/v1/binary/osx/csharp/Ufal/UDPipe/Word.cs new file mode 100644 index 0000000000000000000000000000000000000000..e0177d90469e6240406b14abcc1e06cb56536de2 --- /dev/null +++ b/UDPipe/v1/binary/osx/csharp/Ufal/UDPipe/Word.cs @@ -0,0 +1,157 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +public class Word : Token { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + + internal Word(global::System.IntPtr cPtr, bool cMemoryOwn) : base(udpipe_csharpPINVOKE.Word_SWIGUpcast(cPtr), cMemoryOwn) { + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Word obj) { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + ~Word() { + Dispose(); + } + + public override void Dispose() { + lock(this) { + if (swigCPtr.Handle != global::System.IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + udpipe_csharpPINVOKE.delete_Word(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + global::System.GC.SuppressFinalize(this); + base.Dispose(); + } + } + + public int id { + set { + udpipe_csharpPINVOKE.Word_id_set(swigCPtr, value); + } + get { + int ret = udpipe_csharpPINVOKE.Word_id_get(swigCPtr); + return ret; + } + } + + public string lemma { + set { + udpipe_csharpPINVOKE.Word_lemma_set(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + get { + string ret = udpipe_csharpPINVOKE.Word_lemma_get(swigCPtr); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + } + + public string upostag { + set { + udpipe_csharpPINVOKE.Word_upostag_set(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + get { + string ret = udpipe_csharpPINVOKE.Word_upostag_get(swigCPtr); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + } + + public string xpostag { + set { + udpipe_csharpPINVOKE.Word_xpostag_set(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + get { + string ret = udpipe_csharpPINVOKE.Word_xpostag_get(swigCPtr); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + } + + public string feats { + set { + udpipe_csharpPINVOKE.Word_feats_set(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + get { + string ret = udpipe_csharpPINVOKE.Word_feats_get(swigCPtr); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + } + + public int head { + set { + udpipe_csharpPINVOKE.Word_head_set(swigCPtr, value); + } + get { + int ret = udpipe_csharpPINVOKE.Word_head_get(swigCPtr); + return ret; + } + } + + public string deprel { + set { + udpipe_csharpPINVOKE.Word_deprel_set(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + get { + string ret = udpipe_csharpPINVOKE.Word_deprel_get(swigCPtr); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + } + + public string deps { + set { + udpipe_csharpPINVOKE.Word_deps_set(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + get { + string ret = udpipe_csharpPINVOKE.Word_deps_get(swigCPtr); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + } + + public Children children { + set { + udpipe_csharpPINVOKE.Word_children_set(swigCPtr, Children.getCPtr(value)); + } + get { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.Word_children_get(swigCPtr); + Children ret = (cPtr == global::System.IntPtr.Zero) ? null : new Children(cPtr, false); + return ret; + } + } + + public Word(int id, string form) : this(udpipe_csharpPINVOKE.new_Word__SWIG_0(id, form), true) { + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public Word(int id) : this(udpipe_csharpPINVOKE.new_Word__SWIG_1(id), true) { + } + + public Word() : this(udpipe_csharpPINVOKE.new_Word__SWIG_2(), true) { + } + +} + +} diff --git a/UDPipe/v1/binary/osx/csharp/Ufal/UDPipe/Words.cs b/UDPipe/v1/binary/osx/csharp/Ufal/UDPipe/Words.cs new file mode 100644 index 0000000000000000000000000000000000000000..01c91c83ca10a20e497356a75fcb6a266e423360 --- /dev/null +++ b/UDPipe/v1/binary/osx/csharp/Ufal/UDPipe/Words.cs @@ -0,0 +1,309 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +public class Words : global::System.IDisposable, global::System.Collections.IEnumerable + , global::System.Collections.Generic.IEnumerable + { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal Words(global::System.IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Words obj) { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + ~Words() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != global::System.IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + udpipe_csharpPINVOKE.delete_Words(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + global::System.GC.SuppressFinalize(this); + } + } + + public Words(global::System.Collections.ICollection c) : this() { + if (c == null) + throw new global::System.ArgumentNullException("c"); + foreach (Word element in c) { + this.Add(element); + } + } + + public bool IsFixedSize { + get { + return false; + } + } + + public bool IsReadOnly { + get { + return false; + } + } + + public Word this[int index] { + get { + return getitem(index); + } + set { + setitem(index, value); + } + } + + public int Capacity { + get { + return (int)capacity(); + } + set { + if (value < size()) + throw new global::System.ArgumentOutOfRangeException("Capacity"); + reserve((uint)value); + } + } + + public int Count { + get { + return (int)size(); + } + } + + public bool IsSynchronized { + get { + return false; + } + } + + public void CopyTo(Word[] array) + { + CopyTo(0, array, 0, this.Count); + } + + public void CopyTo(Word[] array, int arrayIndex) + { + CopyTo(0, array, arrayIndex, this.Count); + } + + public void CopyTo(int index, Word[] array, int arrayIndex, int count) + { + if (array == null) + throw new global::System.ArgumentNullException("array"); + if (index < 0) + throw new global::System.ArgumentOutOfRangeException("index", "Value is less than zero"); + if (arrayIndex < 0) + throw new global::System.ArgumentOutOfRangeException("arrayIndex", "Value is less than zero"); + if (count < 0) + throw new global::System.ArgumentOutOfRangeException("count", "Value is less than zero"); + if (array.Rank > 1) + throw new global::System.ArgumentException("Multi dimensional array.", "array"); + if (index+count > this.Count || arrayIndex+count > array.Length) + throw new global::System.ArgumentException("Number of elements to copy is too large."); + for (int i=0; i global::System.Collections.Generic.IEnumerable.GetEnumerator() { + return new WordsEnumerator(this); + } + + global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator() { + return new WordsEnumerator(this); + } + + public WordsEnumerator GetEnumerator() { + return new WordsEnumerator(this); + } + + // Type-safe enumerator + /// Note that the IEnumerator documentation requires an InvalidOperationException to be thrown + /// whenever the collection is modified. This has been done for changes in the size of the + /// collection but not when one of the elements of the collection is modified as it is a bit + /// tricky to detect unmanaged code that modifies the collection under our feet. + public sealed class WordsEnumerator : global::System.Collections.IEnumerator + , global::System.Collections.Generic.IEnumerator + { + private Words collectionRef; + private int currentIndex; + private object currentObject; + private int currentSize; + + public WordsEnumerator(Words collection) { + collectionRef = collection; + currentIndex = -1; + currentObject = null; + currentSize = collectionRef.Count; + } + + // Type-safe iterator Current + public Word Current { + get { + if (currentIndex == -1) + throw new global::System.InvalidOperationException("Enumeration not started."); + if (currentIndex > currentSize - 1) + throw new global::System.InvalidOperationException("Enumeration finished."); + if (currentObject == null) + throw new global::System.InvalidOperationException("Collection modified."); + return (Word)currentObject; + } + } + + // Type-unsafe IEnumerator.Current + object global::System.Collections.IEnumerator.Current { + get { + return Current; + } + } + + public bool MoveNext() { + int size = collectionRef.Count; + bool moveOkay = (currentIndex+1 < size) && (size == currentSize); + if (moveOkay) { + currentIndex++; + currentObject = collectionRef[currentIndex]; + } else { + currentObject = null; + } + return moveOkay; + } + + public void Reset() { + currentIndex = -1; + currentObject = null; + if (collectionRef.Count != currentSize) { + throw new global::System.InvalidOperationException("Collection modified."); + } + } + + public void Dispose() { + currentIndex = -1; + currentObject = null; + } + } + + public void Clear() { + udpipe_csharpPINVOKE.Words_Clear(swigCPtr); + } + + public void Add(Word x) { + udpipe_csharpPINVOKE.Words_Add(swigCPtr, Word.getCPtr(x)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + private uint size() { + uint ret = udpipe_csharpPINVOKE.Words_size(swigCPtr); + return ret; + } + + private uint capacity() { + uint ret = udpipe_csharpPINVOKE.Words_capacity(swigCPtr); + return ret; + } + + private void reserve(uint n) { + udpipe_csharpPINVOKE.Words_reserve(swigCPtr, n); + } + + public Words() : this(udpipe_csharpPINVOKE.new_Words__SWIG_0(), true) { + } + + public Words(Words other) : this(udpipe_csharpPINVOKE.new_Words__SWIG_1(Words.getCPtr(other)), true) { + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public Words(int capacity) : this(udpipe_csharpPINVOKE.new_Words__SWIG_2(capacity), true) { + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + private Word getitemcopy(int index) { + Word ret = new Word(udpipe_csharpPINVOKE.Words_getitemcopy(swigCPtr, index), true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + private Word getitem(int index) { + Word ret = new Word(udpipe_csharpPINVOKE.Words_getitem(swigCPtr, index), false); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + private void setitem(int index, Word val) { + udpipe_csharpPINVOKE.Words_setitem(swigCPtr, index, Word.getCPtr(val)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void AddRange(Words values) { + udpipe_csharpPINVOKE.Words_AddRange(swigCPtr, Words.getCPtr(values)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public Words GetRange(int index, int count) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.Words_GetRange(swigCPtr, index, count); + Words ret = (cPtr == global::System.IntPtr.Zero) ? null : new Words(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public void Insert(int index, Word x) { + udpipe_csharpPINVOKE.Words_Insert(swigCPtr, index, Word.getCPtr(x)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void InsertRange(int index, Words values) { + udpipe_csharpPINVOKE.Words_InsertRange(swigCPtr, index, Words.getCPtr(values)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void RemoveAt(int index) { + udpipe_csharpPINVOKE.Words_RemoveAt(swigCPtr, index); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void RemoveRange(int index, int count) { + udpipe_csharpPINVOKE.Words_RemoveRange(swigCPtr, index, count); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public static Words Repeat(Word value, int count) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.Words_Repeat(Word.getCPtr(value), count); + Words ret = (cPtr == global::System.IntPtr.Zero) ? null : new Words(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public void Reverse() { + udpipe_csharpPINVOKE.Words_Reverse__SWIG_0(swigCPtr); + } + + public void Reverse(int index, int count) { + udpipe_csharpPINVOKE.Words_Reverse__SWIG_1(swigCPtr, index, count); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void SetRange(int index, Words values) { + udpipe_csharpPINVOKE.Words_SetRange(swigCPtr, index, Words.getCPtr(values)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + +} + +} diff --git a/UDPipe/v1/binary/osx/csharp/Ufal/UDPipe/udpipe_csharp.cs b/UDPipe/v1/binary/osx/csharp/Ufal/UDPipe/udpipe_csharp.cs new file mode 100644 index 0000000000000000000000000000000000000000..01d55de404b051d95e99a2ed6741fcdc0cefa6f7 --- /dev/null +++ b/UDPipe/v1/binary/osx/csharp/Ufal/UDPipe/udpipe_csharp.cs @@ -0,0 +1,16 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +public class udpipe_csharp { +} + +} diff --git a/UDPipe/v1/binary/osx/csharp/Ufal/UDPipe/udpipe_csharpPINVOKE.cs b/UDPipe/v1/binary/osx/csharp/Ufal/UDPipe/udpipe_csharpPINVOKE.cs new file mode 100644 index 0000000000000000000000000000000000000000..08fb1041bc999961dae5278a4ac3e5df51b672ea --- /dev/null +++ b/UDPipe/v1/binary/osx/csharp/Ufal/UDPipe/udpipe_csharpPINVOKE.cs @@ -0,0 +1,1324 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +class udpipe_csharpPINVOKE { + + protected class SWIGExceptionHelper { + + public delegate void ExceptionDelegate(string message); + public delegate void ExceptionArgumentDelegate(string message, string paramName); + + static ExceptionDelegate applicationDelegate = new ExceptionDelegate(SetPendingApplicationException); + static ExceptionDelegate arithmeticDelegate = new ExceptionDelegate(SetPendingArithmeticException); + static ExceptionDelegate divideByZeroDelegate = new ExceptionDelegate(SetPendingDivideByZeroException); + static ExceptionDelegate indexOutOfRangeDelegate = new ExceptionDelegate(SetPendingIndexOutOfRangeException); + static ExceptionDelegate invalidCastDelegate = new ExceptionDelegate(SetPendingInvalidCastException); + static ExceptionDelegate invalidOperationDelegate = new ExceptionDelegate(SetPendingInvalidOperationException); + static ExceptionDelegate ioDelegate = new ExceptionDelegate(SetPendingIOException); + static ExceptionDelegate nullReferenceDelegate = new ExceptionDelegate(SetPendingNullReferenceException); + static ExceptionDelegate outOfMemoryDelegate = new ExceptionDelegate(SetPendingOutOfMemoryException); + static ExceptionDelegate overflowDelegate = new ExceptionDelegate(SetPendingOverflowException); + static ExceptionDelegate systemDelegate = new ExceptionDelegate(SetPendingSystemException); + + static ExceptionArgumentDelegate argumentDelegate = new ExceptionArgumentDelegate(SetPendingArgumentException); + static ExceptionArgumentDelegate argumentNullDelegate = new ExceptionArgumentDelegate(SetPendingArgumentNullException); + static ExceptionArgumentDelegate argumentOutOfRangeDelegate = new ExceptionArgumentDelegate(SetPendingArgumentOutOfRangeException); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="SWIGRegisterExceptionCallbacks_udpipe_csharp")] + public static extern void SWIGRegisterExceptionCallbacks_udpipe_csharp( + ExceptionDelegate applicationDelegate, + ExceptionDelegate arithmeticDelegate, + ExceptionDelegate divideByZeroDelegate, + ExceptionDelegate indexOutOfRangeDelegate, + ExceptionDelegate invalidCastDelegate, + ExceptionDelegate invalidOperationDelegate, + ExceptionDelegate ioDelegate, + ExceptionDelegate nullReferenceDelegate, + ExceptionDelegate outOfMemoryDelegate, + ExceptionDelegate overflowDelegate, + ExceptionDelegate systemExceptionDelegate); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="SWIGRegisterExceptionArgumentCallbacks_udpipe_csharp")] + public static extern void SWIGRegisterExceptionCallbacksArgument_udpipe_csharp( + ExceptionArgumentDelegate argumentDelegate, + ExceptionArgumentDelegate argumentNullDelegate, + ExceptionArgumentDelegate argumentOutOfRangeDelegate); + + static void SetPendingApplicationException(string message) { + SWIGPendingException.Set(new global::System.ApplicationException(message, SWIGPendingException.Retrieve())); + } + static void SetPendingArithmeticException(string message) { + SWIGPendingException.Set(new global::System.ArithmeticException(message, SWIGPendingException.Retrieve())); + } + static void SetPendingDivideByZeroException(string message) { + SWIGPendingException.Set(new global::System.DivideByZeroException(message, SWIGPendingException.Retrieve())); + } + static void SetPendingIndexOutOfRangeException(string message) { + SWIGPendingException.Set(new global::System.IndexOutOfRangeException(message, SWIGPendingException.Retrieve())); + } + static void SetPendingInvalidCastException(string message) { + SWIGPendingException.Set(new global::System.InvalidCastException(message, SWIGPendingException.Retrieve())); + } + static void SetPendingInvalidOperationException(string message) { + SWIGPendingException.Set(new global::System.InvalidOperationException(message, SWIGPendingException.Retrieve())); + } + static void SetPendingIOException(string message) { + SWIGPendingException.Set(new global::System.IO.IOException(message, SWIGPendingException.Retrieve())); + } + static void SetPendingNullReferenceException(string message) { + SWIGPendingException.Set(new global::System.NullReferenceException(message, SWIGPendingException.Retrieve())); + } + static void SetPendingOutOfMemoryException(string message) { + SWIGPendingException.Set(new global::System.OutOfMemoryException(message, SWIGPendingException.Retrieve())); + } + static void SetPendingOverflowException(string message) { + SWIGPendingException.Set(new global::System.OverflowException(message, SWIGPendingException.Retrieve())); + } + static void SetPendingSystemException(string message) { + SWIGPendingException.Set(new global::System.SystemException(message, SWIGPendingException.Retrieve())); + } + + static void SetPendingArgumentException(string message, string paramName) { + SWIGPendingException.Set(new global::System.ArgumentException(message, paramName, SWIGPendingException.Retrieve())); + } + static void SetPendingArgumentNullException(string message, string paramName) { + global::System.Exception e = SWIGPendingException.Retrieve(); + if (e != null) message = message + " Inner Exception: " + e.Message; + SWIGPendingException.Set(new global::System.ArgumentNullException(paramName, message)); + } + static void SetPendingArgumentOutOfRangeException(string message, string paramName) { + global::System.Exception e = SWIGPendingException.Retrieve(); + if (e != null) message = message + " Inner Exception: " + e.Message; + SWIGPendingException.Set(new global::System.ArgumentOutOfRangeException(paramName, message)); + } + + static SWIGExceptionHelper() { + SWIGRegisterExceptionCallbacks_udpipe_csharp( + applicationDelegate, + arithmeticDelegate, + divideByZeroDelegate, + indexOutOfRangeDelegate, + invalidCastDelegate, + invalidOperationDelegate, + ioDelegate, + nullReferenceDelegate, + outOfMemoryDelegate, + overflowDelegate, + systemDelegate); + + SWIGRegisterExceptionCallbacksArgument_udpipe_csharp( + argumentDelegate, + argumentNullDelegate, + argumentOutOfRangeDelegate); + } + } + + protected static SWIGExceptionHelper swigExceptionHelper = new SWIGExceptionHelper(); + + public class SWIGPendingException { + [global::System.ThreadStatic] + private static global::System.Exception pendingException = null; + private static int numExceptionsPending = 0; + + public static bool Pending { + get { + bool pending = false; + if (numExceptionsPending > 0) + if (pendingException != null) + pending = true; + return pending; + } + } + + public static void Set(global::System.Exception e) { + if (pendingException != null) + throw new global::System.ApplicationException("FATAL: An earlier pending exception from unmanaged code was missed and thus not thrown (" + pendingException.ToString() + ")", e); + pendingException = e; + lock(typeof(udpipe_csharpPINVOKE)) { + numExceptionsPending++; + } + } + + public static global::System.Exception Retrieve() { + global::System.Exception e = null; + if (numExceptionsPending > 0) { + if (pendingException != null) { + e = pendingException; + pendingException = null; + lock(typeof(udpipe_csharpPINVOKE)) { + numExceptionsPending--; + } + } + } + return e; + } + } + + + protected class SWIGStringHelper { + + public delegate string SWIGStringDelegate(string message); + static SWIGStringDelegate stringDelegate = new SWIGStringDelegate(CreateString); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="SWIGRegisterStringCallback_udpipe_csharp")] + public static extern void SWIGRegisterStringCallback_udpipe_csharp(SWIGStringDelegate stringDelegate); + + static string CreateString(string cString) { + return cString; + } + + static SWIGStringHelper() { + SWIGRegisterStringCallback_udpipe_csharp(stringDelegate); + } + } + + static protected SWIGStringHelper swigStringHelper = new SWIGStringHelper(); + + + static udpipe_csharpPINVOKE() { + } + + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_Clear")] + public static extern void Children_Clear(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_Add")] + public static extern void Children_Add(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_size")] + public static extern uint Children_size(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_capacity")] + public static extern uint Children_capacity(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_reserve")] + public static extern void Children_reserve(global::System.Runtime.InteropServices.HandleRef jarg1, uint jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Children__SWIG_0")] + public static extern global::System.IntPtr new_Children__SWIG_0(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Children__SWIG_1")] + public static extern global::System.IntPtr new_Children__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Children__SWIG_2")] + public static extern global::System.IntPtr new_Children__SWIG_2(int jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_getitemcopy")] + public static extern int Children_getitemcopy(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_getitem")] + public static extern int Children_getitem(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_setitem")] + public static extern void Children_setitem(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_AddRange")] + public static extern void Children_AddRange(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_GetRange")] + public static extern global::System.IntPtr Children_GetRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_Insert")] + public static extern void Children_Insert(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_InsertRange")] + public static extern void Children_InsertRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_RemoveAt")] + public static extern void Children_RemoveAt(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_RemoveRange")] + public static extern void Children_RemoveRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_Repeat")] + public static extern global::System.IntPtr Children_Repeat(int jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_Reverse__SWIG_0")] + public static extern void Children_Reverse__SWIG_0(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_Reverse__SWIG_1")] + public static extern void Children_Reverse__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_SetRange")] + public static extern void Children_SetRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_Contains")] + public static extern bool Children_Contains(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_IndexOf")] + public static extern int Children_IndexOf(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_LastIndexOf")] + public static extern int Children_LastIndexOf(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_Remove")] + public static extern bool Children_Remove(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_delete_Children")] + public static extern void delete_Children(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_Clear")] + public static extern void Comments_Clear(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_Add")] + public static extern void Comments_Add(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_size")] + public static extern uint Comments_size(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_capacity")] + public static extern uint Comments_capacity(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_reserve")] + public static extern void Comments_reserve(global::System.Runtime.InteropServices.HandleRef jarg1, uint jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Comments__SWIG_0")] + public static extern global::System.IntPtr new_Comments__SWIG_0(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Comments__SWIG_1")] + public static extern global::System.IntPtr new_Comments__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Comments__SWIG_2")] + public static extern global::System.IntPtr new_Comments__SWIG_2(int jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_getitemcopy")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Comments_getitemcopy(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_getitem")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Comments_getitem(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_setitem")] + public static extern void Comments_setitem(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_AddRange")] + public static extern void Comments_AddRange(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_GetRange")] + public static extern global::System.IntPtr Comments_GetRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_Insert")] + public static extern void Comments_Insert(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_InsertRange")] + public static extern void Comments_InsertRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_RemoveAt")] + public static extern void Comments_RemoveAt(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_RemoveRange")] + public static extern void Comments_RemoveRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_Repeat")] + public static extern global::System.IntPtr Comments_Repeat([global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_Reverse__SWIG_0")] + public static extern void Comments_Reverse__SWIG_0(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_Reverse__SWIG_1")] + public static extern void Comments_Reverse__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_SetRange")] + public static extern void Comments_SetRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_Contains")] + public static extern bool Comments_Contains(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_IndexOf")] + public static extern int Comments_IndexOf(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_LastIndexOf")] + public static extern int Comments_LastIndexOf(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_Remove")] + public static extern bool Comments_Remove(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_delete_Comments")] + public static extern void delete_Comments(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_ProcessingError_occurred")] + public static extern bool ProcessingError_occurred(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_ProcessingError_message_set")] + public static extern void ProcessingError_message_set(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_ProcessingError_message_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string ProcessingError_message_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_ProcessingError")] + public static extern global::System.IntPtr new_ProcessingError(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_delete_ProcessingError")] + public static extern void delete_ProcessingError(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Token_form_set")] + public static extern void Token_form_set(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Token_form_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Token_form_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Token_misc_set")] + public static extern void Token_misc_set(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Token_misc_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Token_misc_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Token__SWIG_0")] + public static extern global::System.IntPtr new_Token__SWIG_0([global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Token__SWIG_1")] + public static extern global::System.IntPtr new_Token__SWIG_1([global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Token__SWIG_2")] + public static extern global::System.IntPtr new_Token__SWIG_2(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Token_getSpaceAfter")] + public static extern bool Token_getSpaceAfter(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Token_setSpaceAfter")] + public static extern void Token_setSpaceAfter(global::System.Runtime.InteropServices.HandleRef jarg1, bool jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Token_getSpacesBefore")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Token_getSpacesBefore(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Token_setSpacesBefore")] + public static extern void Token_setSpacesBefore(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Token_getSpacesAfter")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Token_getSpacesAfter(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Token_setSpacesAfter")] + public static extern void Token_setSpacesAfter(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Token_getSpacesInToken")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Token_getSpacesInToken(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Token_setSpacesInToken")] + public static extern void Token_setSpacesInToken(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Token_getTokenRange")] + public static extern bool Token_getTokenRange(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Token_getTokenRangeStart")] + public static extern uint Token_getTokenRangeStart(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Token_getTokenRangeEnd")] + public static extern uint Token_getTokenRangeEnd(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Token_setTokenRange")] + public static extern void Token_setTokenRange(global::System.Runtime.InteropServices.HandleRef jarg1, uint jarg2, uint jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_delete_Token")] + public static extern void delete_Token(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Word_id_set")] + public static extern void Word_id_set(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Word_id_get")] + public static extern int Word_id_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Word_lemma_set")] + public static extern void Word_lemma_set(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Word_lemma_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Word_lemma_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Word_upostag_set")] + public static extern void Word_upostag_set(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Word_upostag_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Word_upostag_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Word_xpostag_set")] + public static extern void Word_xpostag_set(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Word_xpostag_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Word_xpostag_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Word_feats_set")] + public static extern void Word_feats_set(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Word_feats_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Word_feats_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Word_head_set")] + public static extern void Word_head_set(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Word_head_get")] + public static extern int Word_head_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Word_deprel_set")] + public static extern void Word_deprel_set(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Word_deprel_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Word_deprel_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Word_deps_set")] + public static extern void Word_deps_set(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Word_deps_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Word_deps_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Word_children_set")] + public static extern void Word_children_set(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Word_children_get")] + public static extern global::System.IntPtr Word_children_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Word__SWIG_0")] + public static extern global::System.IntPtr new_Word__SWIG_0(int jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Word__SWIG_1")] + public static extern global::System.IntPtr new_Word__SWIG_1(int jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Word__SWIG_2")] + public static extern global::System.IntPtr new_Word__SWIG_2(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_delete_Word")] + public static extern void delete_Word(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Words_Clear")] + public static extern void Words_Clear(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Words_Add")] + public static extern void Words_Add(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Words_size")] + public static extern uint Words_size(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Words_capacity")] + public static extern uint Words_capacity(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Words_reserve")] + public static extern void Words_reserve(global::System.Runtime.InteropServices.HandleRef jarg1, uint jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Words__SWIG_0")] + public static extern global::System.IntPtr new_Words__SWIG_0(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Words__SWIG_1")] + public static extern global::System.IntPtr new_Words__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Words__SWIG_2")] + public static extern global::System.IntPtr new_Words__SWIG_2(int jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Words_getitemcopy")] + public static extern global::System.IntPtr Words_getitemcopy(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Words_getitem")] + public static extern global::System.IntPtr Words_getitem(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Words_setitem")] + public static extern void Words_setitem(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Words_AddRange")] + public static extern void Words_AddRange(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Words_GetRange")] + public static extern global::System.IntPtr Words_GetRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Words_Insert")] + public static extern void Words_Insert(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Words_InsertRange")] + public static extern void Words_InsertRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Words_RemoveAt")] + public static extern void Words_RemoveAt(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Words_RemoveRange")] + public static extern void Words_RemoveRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Words_Repeat")] + public static extern global::System.IntPtr Words_Repeat(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Words_Reverse__SWIG_0")] + public static extern void Words_Reverse__SWIG_0(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Words_Reverse__SWIG_1")] + public static extern void Words_Reverse__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Words_SetRange")] + public static extern void Words_SetRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_delete_Words")] + public static extern void delete_Words(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordToken_idFirst_set")] + public static extern void MultiwordToken_idFirst_set(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordToken_idFirst_get")] + public static extern int MultiwordToken_idFirst_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordToken_idLast_set")] + public static extern void MultiwordToken_idLast_set(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordToken_idLast_get")] + public static extern int MultiwordToken_idLast_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_MultiwordToken__SWIG_0")] + public static extern global::System.IntPtr new_MultiwordToken__SWIG_0(int jarg1, int jarg2, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg3, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg4); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_MultiwordToken__SWIG_1")] + public static extern global::System.IntPtr new_MultiwordToken__SWIG_1(int jarg1, int jarg2, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_MultiwordToken__SWIG_2")] + public static extern global::System.IntPtr new_MultiwordToken__SWIG_2(int jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_MultiwordToken__SWIG_3")] + public static extern global::System.IntPtr new_MultiwordToken__SWIG_3(int jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_MultiwordToken__SWIG_4")] + public static extern global::System.IntPtr new_MultiwordToken__SWIG_4(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_delete_MultiwordToken")] + public static extern void delete_MultiwordToken(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordTokens_Clear")] + public static extern void MultiwordTokens_Clear(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordTokens_Add")] + public static extern void MultiwordTokens_Add(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordTokens_size")] + public static extern uint MultiwordTokens_size(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordTokens_capacity")] + public static extern uint MultiwordTokens_capacity(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordTokens_reserve")] + public static extern void MultiwordTokens_reserve(global::System.Runtime.InteropServices.HandleRef jarg1, uint jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_MultiwordTokens__SWIG_0")] + public static extern global::System.IntPtr new_MultiwordTokens__SWIG_0(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_MultiwordTokens__SWIG_1")] + public static extern global::System.IntPtr new_MultiwordTokens__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_MultiwordTokens__SWIG_2")] + public static extern global::System.IntPtr new_MultiwordTokens__SWIG_2(int jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordTokens_getitemcopy")] + public static extern global::System.IntPtr MultiwordTokens_getitemcopy(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordTokens_getitem")] + public static extern global::System.IntPtr MultiwordTokens_getitem(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordTokens_setitem")] + public static extern void MultiwordTokens_setitem(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordTokens_AddRange")] + public static extern void MultiwordTokens_AddRange(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordTokens_GetRange")] + public static extern global::System.IntPtr MultiwordTokens_GetRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordTokens_Insert")] + public static extern void MultiwordTokens_Insert(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordTokens_InsertRange")] + public static extern void MultiwordTokens_InsertRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordTokens_RemoveAt")] + public static extern void MultiwordTokens_RemoveAt(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordTokens_RemoveRange")] + public static extern void MultiwordTokens_RemoveRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordTokens_Repeat")] + public static extern global::System.IntPtr MultiwordTokens_Repeat(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordTokens_Reverse__SWIG_0")] + public static extern void MultiwordTokens_Reverse__SWIG_0(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordTokens_Reverse__SWIG_1")] + public static extern void MultiwordTokens_Reverse__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordTokens_SetRange")] + public static extern void MultiwordTokens_SetRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_delete_MultiwordTokens")] + public static extern void delete_MultiwordTokens(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNode_id_set")] + public static extern void EmptyNode_id_set(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNode_id_get")] + public static extern int EmptyNode_id_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNode_index_set")] + public static extern void EmptyNode_index_set(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNode_index_get")] + public static extern int EmptyNode_index_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNode_form_set")] + public static extern void EmptyNode_form_set(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNode_form_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string EmptyNode_form_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNode_lemma_set")] + public static extern void EmptyNode_lemma_set(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNode_lemma_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string EmptyNode_lemma_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNode_upostag_set")] + public static extern void EmptyNode_upostag_set(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNode_upostag_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string EmptyNode_upostag_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNode_xpostag_set")] + public static extern void EmptyNode_xpostag_set(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNode_xpostag_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string EmptyNode_xpostag_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNode_feats_set")] + public static extern void EmptyNode_feats_set(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNode_feats_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string EmptyNode_feats_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNode_deps_set")] + public static extern void EmptyNode_deps_set(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNode_deps_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string EmptyNode_deps_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNode_misc_set")] + public static extern void EmptyNode_misc_set(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNode_misc_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string EmptyNode_misc_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_EmptyNode__SWIG_0")] + public static extern global::System.IntPtr new_EmptyNode__SWIG_0(int jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_EmptyNode__SWIG_1")] + public static extern global::System.IntPtr new_EmptyNode__SWIG_1(int jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_EmptyNode__SWIG_2")] + public static extern global::System.IntPtr new_EmptyNode__SWIG_2(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_delete_EmptyNode")] + public static extern void delete_EmptyNode(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNodes_Clear")] + public static extern void EmptyNodes_Clear(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNodes_Add")] + public static extern void EmptyNodes_Add(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNodes_size")] + public static extern uint EmptyNodes_size(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNodes_capacity")] + public static extern uint EmptyNodes_capacity(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNodes_reserve")] + public static extern void EmptyNodes_reserve(global::System.Runtime.InteropServices.HandleRef jarg1, uint jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_EmptyNodes__SWIG_0")] + public static extern global::System.IntPtr new_EmptyNodes__SWIG_0(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_EmptyNodes__SWIG_1")] + public static extern global::System.IntPtr new_EmptyNodes__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_EmptyNodes__SWIG_2")] + public static extern global::System.IntPtr new_EmptyNodes__SWIG_2(int jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNodes_getitemcopy")] + public static extern global::System.IntPtr EmptyNodes_getitemcopy(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNodes_getitem")] + public static extern global::System.IntPtr EmptyNodes_getitem(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNodes_setitem")] + public static extern void EmptyNodes_setitem(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNodes_AddRange")] + public static extern void EmptyNodes_AddRange(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNodes_GetRange")] + public static extern global::System.IntPtr EmptyNodes_GetRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNodes_Insert")] + public static extern void EmptyNodes_Insert(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNodes_InsertRange")] + public static extern void EmptyNodes_InsertRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNodes_RemoveAt")] + public static extern void EmptyNodes_RemoveAt(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNodes_RemoveRange")] + public static extern void EmptyNodes_RemoveRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNodes_Repeat")] + public static extern global::System.IntPtr EmptyNodes_Repeat(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNodes_Reverse__SWIG_0")] + public static extern void EmptyNodes_Reverse__SWIG_0(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNodes_Reverse__SWIG_1")] + public static extern void EmptyNodes_Reverse__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNodes_SetRange")] + public static extern void EmptyNodes_SetRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_delete_EmptyNodes")] + public static extern void delete_EmptyNodes(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Sentence")] + public static extern global::System.IntPtr new_Sentence(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_words_set")] + public static extern void Sentence_words_set(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_words_get")] + public static extern global::System.IntPtr Sentence_words_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_multiwordTokens_set")] + public static extern void Sentence_multiwordTokens_set(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_multiwordTokens_get")] + public static extern global::System.IntPtr Sentence_multiwordTokens_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_emptyNodes_set")] + public static extern void Sentence_emptyNodes_set(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_emptyNodes_get")] + public static extern global::System.IntPtr Sentence_emptyNodes_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_comments_set")] + public static extern void Sentence_comments_set(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_comments_get")] + public static extern global::System.IntPtr Sentence_comments_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_rootForm_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Sentence_rootForm_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_empty")] + public static extern bool Sentence_empty(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_clear")] + public static extern void Sentence_clear(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_addWord")] + public static extern global::System.IntPtr Sentence_addWord(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_setHead")] + public static extern void Sentence_setHead(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg4); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_unlinkAllNodes")] + public static extern void Sentence_unlinkAllNodes(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_getNewDoc")] + public static extern bool Sentence_getNewDoc(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_getNewDocId")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Sentence_getNewDocId(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_setNewDoc__SWIG_0")] + public static extern void Sentence_setNewDoc__SWIG_0(global::System.Runtime.InteropServices.HandleRef jarg1, bool jarg2, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_setNewDoc__SWIG_1")] + public static extern void Sentence_setNewDoc__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1, bool jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_getNewPar")] + public static extern bool Sentence_getNewPar(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_getNewParId")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Sentence_getNewParId(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_setNewPar__SWIG_0")] + public static extern void Sentence_setNewPar__SWIG_0(global::System.Runtime.InteropServices.HandleRef jarg1, bool jarg2, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_setNewPar__SWIG_1")] + public static extern void Sentence_setNewPar__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1, bool jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_getSentId")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Sentence_getSentId(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_setSentId")] + public static extern void Sentence_setSentId(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_getText")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Sentence_getText(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_setText")] + public static extern void Sentence_setText(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_delete_Sentence")] + public static extern void delete_Sentence(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentences_Clear")] + public static extern void Sentences_Clear(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentences_Add")] + public static extern void Sentences_Add(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentences_size")] + public static extern uint Sentences_size(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentences_capacity")] + public static extern uint Sentences_capacity(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentences_reserve")] + public static extern void Sentences_reserve(global::System.Runtime.InteropServices.HandleRef jarg1, uint jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Sentences__SWIG_0")] + public static extern global::System.IntPtr new_Sentences__SWIG_0(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Sentences__SWIG_1")] + public static extern global::System.IntPtr new_Sentences__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Sentences__SWIG_2")] + public static extern global::System.IntPtr new_Sentences__SWIG_2(int jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentences_getitemcopy")] + public static extern global::System.IntPtr Sentences_getitemcopy(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentences_getitem")] + public static extern global::System.IntPtr Sentences_getitem(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentences_setitem")] + public static extern void Sentences_setitem(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentences_AddRange")] + public static extern void Sentences_AddRange(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentences_GetRange")] + public static extern global::System.IntPtr Sentences_GetRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentences_Insert")] + public static extern void Sentences_Insert(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentences_InsertRange")] + public static extern void Sentences_InsertRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentences_RemoveAt")] + public static extern void Sentences_RemoveAt(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentences_RemoveRange")] + public static extern void Sentences_RemoveRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentences_Repeat")] + public static extern global::System.IntPtr Sentences_Repeat(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentences_Reverse__SWIG_0")] + public static extern void Sentences_Reverse__SWIG_0(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentences_Reverse__SWIG_1")] + public static extern void Sentences_Reverse__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentences_SetRange")] + public static extern void Sentences_SetRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_delete_Sentences")] + public static extern void delete_Sentences(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_delete_InputFormat")] + public static extern void delete_InputFormat(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_InputFormat_resetDocument__SWIG_0")] + public static extern void InputFormat_resetDocument__SWIG_0(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_InputFormat_resetDocument__SWIG_1")] + public static extern void InputFormat_resetDocument__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_InputFormat_setText")] + public static extern void InputFormat_setText(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_InputFormat_nextSentence__SWIG_0")] + public static extern bool InputFormat_nextSentence__SWIG_0(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_InputFormat_nextSentence__SWIG_1")] + public static extern bool InputFormat_nextSentence__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_InputFormat_newInputFormat")] + public static extern global::System.IntPtr InputFormat_newInputFormat([global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_InputFormat_newConlluInputFormat__SWIG_0")] + public static extern global::System.IntPtr InputFormat_newConlluInputFormat__SWIG_0([global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_InputFormat_newConlluInputFormat__SWIG_1")] + public static extern global::System.IntPtr InputFormat_newConlluInputFormat__SWIG_1(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_InputFormat_newGenericTokenizerInputFormat__SWIG_0")] + public static extern global::System.IntPtr InputFormat_newGenericTokenizerInputFormat__SWIG_0([global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_InputFormat_newGenericTokenizerInputFormat__SWIG_1")] + public static extern global::System.IntPtr InputFormat_newGenericTokenizerInputFormat__SWIG_1(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_InputFormat_newHorizontalInputFormat__SWIG_0")] + public static extern global::System.IntPtr InputFormat_newHorizontalInputFormat__SWIG_0([global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_InputFormat_newHorizontalInputFormat__SWIG_1")] + public static extern global::System.IntPtr InputFormat_newHorizontalInputFormat__SWIG_1(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_InputFormat_newVerticalInputFormat__SWIG_0")] + public static extern global::System.IntPtr InputFormat_newVerticalInputFormat__SWIG_0([global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_InputFormat_newVerticalInputFormat__SWIG_1")] + public static extern global::System.IntPtr InputFormat_newVerticalInputFormat__SWIG_1(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_InputFormat_newPresegmentedTokenizer")] + public static extern global::System.IntPtr InputFormat_newPresegmentedTokenizer(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_InputFormat_CONLLU_V1_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string InputFormat_CONLLU_V1_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_InputFormat_CONLLU_V2_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string InputFormat_CONLLU_V2_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_InputFormat_GENERIC_TOKENIZER_NORMALIZED_SPACES_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string InputFormat_GENERIC_TOKENIZER_NORMALIZED_SPACES_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_InputFormat_GENERIC_TOKENIZER_PRESEGMENTED_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string InputFormat_GENERIC_TOKENIZER_PRESEGMENTED_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_InputFormat_GENERIC_TOKENIZER_RANGES_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string InputFormat_GENERIC_TOKENIZER_RANGES_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_delete_OutputFormat")] + public static extern void delete_OutputFormat(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_OutputFormat_writeSentence")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string OutputFormat_writeSentence(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_OutputFormat_finishDocument")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string OutputFormat_finishDocument(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_OutputFormat_newOutputFormat")] + public static extern global::System.IntPtr OutputFormat_newOutputFormat([global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_OutputFormat_newConlluOutputFormat__SWIG_0")] + public static extern global::System.IntPtr OutputFormat_newConlluOutputFormat__SWIG_0([global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_OutputFormat_newConlluOutputFormat__SWIG_1")] + public static extern global::System.IntPtr OutputFormat_newConlluOutputFormat__SWIG_1(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_OutputFormat_newEpeOutputFormat__SWIG_0")] + public static extern global::System.IntPtr OutputFormat_newEpeOutputFormat__SWIG_0([global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_OutputFormat_newEpeOutputFormat__SWIG_1")] + public static extern global::System.IntPtr OutputFormat_newEpeOutputFormat__SWIG_1(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_OutputFormat_newMatxinOutputFormat__SWIG_0")] + public static extern global::System.IntPtr OutputFormat_newMatxinOutputFormat__SWIG_0([global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_OutputFormat_newMatxinOutputFormat__SWIG_1")] + public static extern global::System.IntPtr OutputFormat_newMatxinOutputFormat__SWIG_1(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_OutputFormat_newHorizontalOutputFormat__SWIG_0")] + public static extern global::System.IntPtr OutputFormat_newHorizontalOutputFormat__SWIG_0([global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_OutputFormat_newHorizontalOutputFormat__SWIG_1")] + public static extern global::System.IntPtr OutputFormat_newHorizontalOutputFormat__SWIG_1(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_OutputFormat_newPlaintextOutputFormat__SWIG_0")] + public static extern global::System.IntPtr OutputFormat_newPlaintextOutputFormat__SWIG_0([global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_OutputFormat_newPlaintextOutputFormat__SWIG_1")] + public static extern global::System.IntPtr OutputFormat_newPlaintextOutputFormat__SWIG_1(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_OutputFormat_newVerticalOutputFormat__SWIG_0")] + public static extern global::System.IntPtr OutputFormat_newVerticalOutputFormat__SWIG_0([global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_OutputFormat_newVerticalOutputFormat__SWIG_1")] + public static extern global::System.IntPtr OutputFormat_newVerticalOutputFormat__SWIG_1(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_OutputFormat_CONLLU_V1_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string OutputFormat_CONLLU_V1_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_OutputFormat_CONLLU_V2_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string OutputFormat_CONLLU_V2_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_OutputFormat_HORIZONTAL_PARAGRAPHS_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string OutputFormat_HORIZONTAL_PARAGRAPHS_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_OutputFormat_PLAINTEXT_NORMALIZED_SPACES_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string OutputFormat_PLAINTEXT_NORMALIZED_SPACES_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_OutputFormat_VERTICAL_PARAGRAPHS_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string OutputFormat_VERTICAL_PARAGRAPHS_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_delete_Model")] + public static extern void delete_Model(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Model_load")] + public static extern global::System.IntPtr Model_load([global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Model_newTokenizer")] + public static extern global::System.IntPtr Model_newTokenizer(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Model_tag__SWIG_0")] + public static extern bool Model_tag__SWIG_0(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg3, global::System.Runtime.InteropServices.HandleRef jarg4); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Model_tag__SWIG_1")] + public static extern bool Model_tag__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Model_parse__SWIG_0")] + public static extern bool Model_parse__SWIG_0(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg3, global::System.Runtime.InteropServices.HandleRef jarg4); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Model_parse__SWIG_1")] + public static extern bool Model_parse__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Model_DEFAULT_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Model_DEFAULT_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Model_TOKENIZER_NORMALIZED_SPACES_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Model_TOKENIZER_NORMALIZED_SPACES_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Model_TOKENIZER_PRESEGMENTED_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Model_TOKENIZER_PRESEGMENTED_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Model_TOKENIZER_RANGES_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Model_TOKENIZER_RANGES_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Pipeline")] + public static extern global::System.IntPtr new_Pipeline(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg3, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg4, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg5); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Pipeline_setModel")] + public static extern void Pipeline_setModel(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Pipeline_setInput")] + public static extern void Pipeline_setInput(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Pipeline_setTagger")] + public static extern void Pipeline_setTagger(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Pipeline_setParser")] + public static extern void Pipeline_setParser(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Pipeline_setOutput")] + public static extern void Pipeline_setOutput(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Pipeline_setImmediate")] + public static extern void Pipeline_setImmediate(global::System.Runtime.InteropServices.HandleRef jarg1, bool jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Pipeline_setDocumentId")] + public static extern void Pipeline_setDocumentId(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Pipeline_process__SWIG_0")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Pipeline_process__SWIG_0(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Pipeline_process__SWIG_1")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Pipeline_process__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Pipeline_DEFAULT_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Pipeline_DEFAULT_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Pipeline_NONE_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Pipeline_NONE_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_delete_Pipeline")] + public static extern void delete_Pipeline(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Trainer_train__SWIG_0")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Trainer_train__SWIG_0([global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg1, global::System.Runtime.InteropServices.HandleRef jarg2, global::System.Runtime.InteropServices.HandleRef jarg3, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg4, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg5, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg6, global::System.Runtime.InteropServices.HandleRef jarg7); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Trainer_train__SWIG_1")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Trainer_train__SWIG_1([global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg1, global::System.Runtime.InteropServices.HandleRef jarg2, global::System.Runtime.InteropServices.HandleRef jarg3, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg4, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg5, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg6); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Trainer_DEFAULT_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Trainer_DEFAULT_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Trainer_NONE_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Trainer_NONE_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Trainer")] + public static extern global::System.IntPtr new_Trainer(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_delete_Trainer")] + public static extern void delete_Trainer(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Evaluator")] + public static extern global::System.IntPtr new_Evaluator(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg3, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg4); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Evaluator_setModel")] + public static extern void Evaluator_setModel(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Evaluator_setTokenizer")] + public static extern void Evaluator_setTokenizer(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Evaluator_setTagger")] + public static extern void Evaluator_setTagger(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Evaluator_setParser")] + public static extern void Evaluator_setParser(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Evaluator_evaluate__SWIG_0")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Evaluator_evaluate__SWIG_0(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Evaluator_evaluate__SWIG_1")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Evaluator_evaluate__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Evaluator_DEFAULT_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Evaluator_DEFAULT_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Evaluator_NONE_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Evaluator_NONE_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_delete_Evaluator")] + public static extern void delete_Evaluator(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Version_major_set")] + public static extern void Version_major_set(global::System.Runtime.InteropServices.HandleRef jarg1, uint jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Version_major_get")] + public static extern uint Version_major_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Version_minor_set")] + public static extern void Version_minor_set(global::System.Runtime.InteropServices.HandleRef jarg1, uint jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Version_minor_get")] + public static extern uint Version_minor_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Version_patch_set")] + public static extern void Version_patch_set(global::System.Runtime.InteropServices.HandleRef jarg1, uint jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Version_patch_get")] + public static extern uint Version_patch_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Version_prerelease_set")] + public static extern void Version_prerelease_set(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Version_prerelease_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Version_prerelease_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Version_current")] + public static extern global::System.IntPtr Version_current(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Version")] + public static extern global::System.IntPtr new_Version(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_delete_Version")] + public static extern void delete_Version(global::System.Runtime.InteropServices.HandleRef jarg1); + +public class UTF8Marshaler : System.Runtime.InteropServices.ICustomMarshaler { + static UTF8Marshaler static_instance; + + public System.IntPtr MarshalManagedToNative(object managedObj) { + if (managedObj == null) + return System.IntPtr.Zero; + if (!(managedObj is string)) + throw new System.Runtime.InteropServices.MarshalDirectiveException("UTF8Marshaler must be used on a string."); + + // not null terminated + byte[] strbuf = System.Text.Encoding.UTF8.GetBytes((string)managedObj); + System.IntPtr buffer = System.Runtime.InteropServices.Marshal.AllocHGlobal(strbuf.Length + 1); + System.Runtime.InteropServices.Marshal.Copy(strbuf, 0, buffer, strbuf.Length); + + // write the terminating null + System.Runtime.InteropServices.Marshal.WriteByte(buffer + strbuf.Length, 0); + return buffer; + } + + public object MarshalNativeToManaged(System.IntPtr pNativeData) { + int length = 0; + while (System.Runtime.InteropServices.Marshal.ReadByte(pNativeData, length) != 0) + length++; + + // should not be null terminated + byte[] strbuf = new byte[length]; + // skip the trailing null + System.Runtime.InteropServices.Marshal.Copy((System.IntPtr)pNativeData, strbuf, 0, length); + string data = System.Text.Encoding.UTF8.GetString(strbuf); + return data; + } + + public void CleanUpNativeData(System.IntPtr pNativeData) { + System.Runtime.InteropServices.Marshal.FreeHGlobal(pNativeData); + } + + public void CleanUpManagedData(object managedObj) { + } + + public int GetNativeDataSize() { + return -1; + } + + public static System.Runtime.InteropServices.ICustomMarshaler GetInstance(string cookie) { + if (static_instance == null) + return static_instance = new UTF8Marshaler(); + return static_instance; + } +} + + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Word_SWIGUpcast")] + public static extern global::System.IntPtr Word_SWIGUpcast(global::System.IntPtr jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordToken_SWIGUpcast")] + public static extern global::System.IntPtr MultiwordToken_SWIGUpcast(global::System.IntPtr jarg1); +} + +} diff --git a/UDPipe/v1/binary/osx/csharp/libudpipe_csharp.dylib b/UDPipe/v1/binary/osx/csharp/libudpipe_csharp.dylib new file mode 100644 index 0000000000000000000000000000000000000000..039d98a48b6feeaade0ac2e01607094521506d96 --- /dev/null +++ b/UDPipe/v1/binary/osx/csharp/libudpipe_csharp.dylib @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:bbef9ed04cbdcf308a887be1d119d2b6f37a56141c8486132f71fb6f4f27801c +size 2913244 diff --git a/UDPipe/v1/binary/osx/java/libudpipe_java.dylib b/UDPipe/v1/binary/osx/java/libudpipe_java.dylib new file mode 100644 index 0000000000000000000000000000000000000000..f06d6b75f8f3eb37eaab8d82215005a54b4faac0 --- /dev/null +++ b/UDPipe/v1/binary/osx/java/libudpipe_java.dylib @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b86c2582f215edb1f5d1ec3b66cb87d490a0610b52ea35bf63d92f5bbb03c82e +size 2812256 diff --git a/UDPipe/v1/binary/osx/java/udpipe.jar b/UDPipe/v1/binary/osx/java/udpipe.jar new file mode 100644 index 0000000000000000000000000000000000000000..1402eecf0486e6af3300cbad05601351d9990feb Binary files /dev/null and b/UDPipe/v1/binary/osx/java/udpipe.jar differ diff --git a/UDPipe/v1/binary/osx/udpipe b/UDPipe/v1/binary/osx/udpipe new file mode 100644 index 0000000000000000000000000000000000000000..16f27f776dba1b29e5039834c8856914c284bc28 --- /dev/null +++ b/UDPipe/v1/binary/osx/udpipe @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ed5238f9a415c1c046c2cdff64088eaae007b8859223d57042bdc927316b0a2c +size 2693568 diff --git a/UDPipe/v1/binary/win64/csharp/Ufal/UDPipe/Children.cs b/UDPipe/v1/binary/win64/csharp/Ufal/UDPipe/Children.cs new file mode 100644 index 0000000000000000000000000000000000000000..e5959f767df4f3ddb46e9dcb210f3eacd8c2237a --- /dev/null +++ b/UDPipe/v1/binary/win64/csharp/Ufal/UDPipe/Children.cs @@ -0,0 +1,328 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +public class Children : global::System.IDisposable, global::System.Collections.IEnumerable + , global::System.Collections.Generic.IList + { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal Children(global::System.IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Children obj) { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + ~Children() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != global::System.IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + udpipe_csharpPINVOKE.delete_Children(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + global::System.GC.SuppressFinalize(this); + } + } + + public Children(global::System.Collections.ICollection c) : this() { + if (c == null) + throw new global::System.ArgumentNullException("c"); + foreach (int element in c) { + this.Add(element); + } + } + + public bool IsFixedSize { + get { + return false; + } + } + + public bool IsReadOnly { + get { + return false; + } + } + + public int this[int index] { + get { + return getitem(index); + } + set { + setitem(index, value); + } + } + + public int Capacity { + get { + return (int)capacity(); + } + set { + if (value < size()) + throw new global::System.ArgumentOutOfRangeException("Capacity"); + reserve((uint)value); + } + } + + public int Count { + get { + return (int)size(); + } + } + + public bool IsSynchronized { + get { + return false; + } + } + + public void CopyTo(int[] array) + { + CopyTo(0, array, 0, this.Count); + } + + public void CopyTo(int[] array, int arrayIndex) + { + CopyTo(0, array, arrayIndex, this.Count); + } + + public void CopyTo(int index, int[] array, int arrayIndex, int count) + { + if (array == null) + throw new global::System.ArgumentNullException("array"); + if (index < 0) + throw new global::System.ArgumentOutOfRangeException("index", "Value is less than zero"); + if (arrayIndex < 0) + throw new global::System.ArgumentOutOfRangeException("arrayIndex", "Value is less than zero"); + if (count < 0) + throw new global::System.ArgumentOutOfRangeException("count", "Value is less than zero"); + if (array.Rank > 1) + throw new global::System.ArgumentException("Multi dimensional array.", "array"); + if (index+count > this.Count || arrayIndex+count > array.Length) + throw new global::System.ArgumentException("Number of elements to copy is too large."); + for (int i=0; i global::System.Collections.Generic.IEnumerable.GetEnumerator() { + return new ChildrenEnumerator(this); + } + + global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator() { + return new ChildrenEnumerator(this); + } + + public ChildrenEnumerator GetEnumerator() { + return new ChildrenEnumerator(this); + } + + // Type-safe enumerator + /// Note that the IEnumerator documentation requires an InvalidOperationException to be thrown + /// whenever the collection is modified. This has been done for changes in the size of the + /// collection but not when one of the elements of the collection is modified as it is a bit + /// tricky to detect unmanaged code that modifies the collection under our feet. + public sealed class ChildrenEnumerator : global::System.Collections.IEnumerator + , global::System.Collections.Generic.IEnumerator + { + private Children collectionRef; + private int currentIndex; + private object currentObject; + private int currentSize; + + public ChildrenEnumerator(Children collection) { + collectionRef = collection; + currentIndex = -1; + currentObject = null; + currentSize = collectionRef.Count; + } + + // Type-safe iterator Current + public int Current { + get { + if (currentIndex == -1) + throw new global::System.InvalidOperationException("Enumeration not started."); + if (currentIndex > currentSize - 1) + throw new global::System.InvalidOperationException("Enumeration finished."); + if (currentObject == null) + throw new global::System.InvalidOperationException("Collection modified."); + return (int)currentObject; + } + } + + // Type-unsafe IEnumerator.Current + object global::System.Collections.IEnumerator.Current { + get { + return Current; + } + } + + public bool MoveNext() { + int size = collectionRef.Count; + bool moveOkay = (currentIndex+1 < size) && (size == currentSize); + if (moveOkay) { + currentIndex++; + currentObject = collectionRef[currentIndex]; + } else { + currentObject = null; + } + return moveOkay; + } + + public void Reset() { + currentIndex = -1; + currentObject = null; + if (collectionRef.Count != currentSize) { + throw new global::System.InvalidOperationException("Collection modified."); + } + } + + public void Dispose() { + currentIndex = -1; + currentObject = null; + } + } + + public void Clear() { + udpipe_csharpPINVOKE.Children_Clear(swigCPtr); + } + + public void Add(int x) { + udpipe_csharpPINVOKE.Children_Add(swigCPtr, x); + } + + private uint size() { + uint ret = udpipe_csharpPINVOKE.Children_size(swigCPtr); + return ret; + } + + private uint capacity() { + uint ret = udpipe_csharpPINVOKE.Children_capacity(swigCPtr); + return ret; + } + + private void reserve(uint n) { + udpipe_csharpPINVOKE.Children_reserve(swigCPtr, n); + } + + public Children() : this(udpipe_csharpPINVOKE.new_Children__SWIG_0(), true) { + } + + public Children(Children other) : this(udpipe_csharpPINVOKE.new_Children__SWIG_1(Children.getCPtr(other)), true) { + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public Children(int capacity) : this(udpipe_csharpPINVOKE.new_Children__SWIG_2(capacity), true) { + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + private int getitemcopy(int index) { + int ret = udpipe_csharpPINVOKE.Children_getitemcopy(swigCPtr, index); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + private int getitem(int index) { + int ret = udpipe_csharpPINVOKE.Children_getitem(swigCPtr, index); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + private void setitem(int index, int val) { + udpipe_csharpPINVOKE.Children_setitem(swigCPtr, index, val); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void AddRange(Children values) { + udpipe_csharpPINVOKE.Children_AddRange(swigCPtr, Children.getCPtr(values)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public Children GetRange(int index, int count) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.Children_GetRange(swigCPtr, index, count); + Children ret = (cPtr == global::System.IntPtr.Zero) ? null : new Children(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public void Insert(int index, int x) { + udpipe_csharpPINVOKE.Children_Insert(swigCPtr, index, x); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void InsertRange(int index, Children values) { + udpipe_csharpPINVOKE.Children_InsertRange(swigCPtr, index, Children.getCPtr(values)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void RemoveAt(int index) { + udpipe_csharpPINVOKE.Children_RemoveAt(swigCPtr, index); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void RemoveRange(int index, int count) { + udpipe_csharpPINVOKE.Children_RemoveRange(swigCPtr, index, count); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public static Children Repeat(int value, int count) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.Children_Repeat(value, count); + Children ret = (cPtr == global::System.IntPtr.Zero) ? null : new Children(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public void Reverse() { + udpipe_csharpPINVOKE.Children_Reverse__SWIG_0(swigCPtr); + } + + public void Reverse(int index, int count) { + udpipe_csharpPINVOKE.Children_Reverse__SWIG_1(swigCPtr, index, count); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void SetRange(int index, Children values) { + udpipe_csharpPINVOKE.Children_SetRange(swigCPtr, index, Children.getCPtr(values)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public bool Contains(int value) { + bool ret = udpipe_csharpPINVOKE.Children_Contains(swigCPtr, value); + return ret; + } + + public int IndexOf(int value) { + int ret = udpipe_csharpPINVOKE.Children_IndexOf(swigCPtr, value); + return ret; + } + + public int LastIndexOf(int value) { + int ret = udpipe_csharpPINVOKE.Children_LastIndexOf(swigCPtr, value); + return ret; + } + + public bool Remove(int value) { + bool ret = udpipe_csharpPINVOKE.Children_Remove(swigCPtr, value); + return ret; + } + +} + +} diff --git a/UDPipe/v1/binary/win64/csharp/Ufal/UDPipe/Comments.cs b/UDPipe/v1/binary/win64/csharp/Ufal/UDPipe/Comments.cs new file mode 100644 index 0000000000000000000000000000000000000000..316865d901e073812e3deda1f8ccf407a6ed93a7 --- /dev/null +++ b/UDPipe/v1/binary/win64/csharp/Ufal/UDPipe/Comments.cs @@ -0,0 +1,333 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +public class Comments : global::System.IDisposable, global::System.Collections.IEnumerable + , global::System.Collections.Generic.IList + { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal Comments(global::System.IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Comments obj) { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + ~Comments() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != global::System.IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + udpipe_csharpPINVOKE.delete_Comments(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + global::System.GC.SuppressFinalize(this); + } + } + + public Comments(global::System.Collections.ICollection c) : this() { + if (c == null) + throw new global::System.ArgumentNullException("c"); + foreach (string element in c) { + this.Add(element); + } + } + + public bool IsFixedSize { + get { + return false; + } + } + + public bool IsReadOnly { + get { + return false; + } + } + + public string this[int index] { + get { + return getitem(index); + } + set { + setitem(index, value); + } + } + + public int Capacity { + get { + return (int)capacity(); + } + set { + if (value < size()) + throw new global::System.ArgumentOutOfRangeException("Capacity"); + reserve((uint)value); + } + } + + public int Count { + get { + return (int)size(); + } + } + + public bool IsSynchronized { + get { + return false; + } + } + + public void CopyTo(string[] array) + { + CopyTo(0, array, 0, this.Count); + } + + public void CopyTo(string[] array, int arrayIndex) + { + CopyTo(0, array, arrayIndex, this.Count); + } + + public void CopyTo(int index, string[] array, int arrayIndex, int count) + { + if (array == null) + throw new global::System.ArgumentNullException("array"); + if (index < 0) + throw new global::System.ArgumentOutOfRangeException("index", "Value is less than zero"); + if (arrayIndex < 0) + throw new global::System.ArgumentOutOfRangeException("arrayIndex", "Value is less than zero"); + if (count < 0) + throw new global::System.ArgumentOutOfRangeException("count", "Value is less than zero"); + if (array.Rank > 1) + throw new global::System.ArgumentException("Multi dimensional array.", "array"); + if (index+count > this.Count || arrayIndex+count > array.Length) + throw new global::System.ArgumentException("Number of elements to copy is too large."); + for (int i=0; i global::System.Collections.Generic.IEnumerable.GetEnumerator() { + return new CommentsEnumerator(this); + } + + global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator() { + return new CommentsEnumerator(this); + } + + public CommentsEnumerator GetEnumerator() { + return new CommentsEnumerator(this); + } + + // Type-safe enumerator + /// Note that the IEnumerator documentation requires an InvalidOperationException to be thrown + /// whenever the collection is modified. This has been done for changes in the size of the + /// collection but not when one of the elements of the collection is modified as it is a bit + /// tricky to detect unmanaged code that modifies the collection under our feet. + public sealed class CommentsEnumerator : global::System.Collections.IEnumerator + , global::System.Collections.Generic.IEnumerator + { + private Comments collectionRef; + private int currentIndex; + private object currentObject; + private int currentSize; + + public CommentsEnumerator(Comments collection) { + collectionRef = collection; + currentIndex = -1; + currentObject = null; + currentSize = collectionRef.Count; + } + + // Type-safe iterator Current + public string Current { + get { + if (currentIndex == -1) + throw new global::System.InvalidOperationException("Enumeration not started."); + if (currentIndex > currentSize - 1) + throw new global::System.InvalidOperationException("Enumeration finished."); + if (currentObject == null) + throw new global::System.InvalidOperationException("Collection modified."); + return (string)currentObject; + } + } + + // Type-unsafe IEnumerator.Current + object global::System.Collections.IEnumerator.Current { + get { + return Current; + } + } + + public bool MoveNext() { + int size = collectionRef.Count; + bool moveOkay = (currentIndex+1 < size) && (size == currentSize); + if (moveOkay) { + currentIndex++; + currentObject = collectionRef[currentIndex]; + } else { + currentObject = null; + } + return moveOkay; + } + + public void Reset() { + currentIndex = -1; + currentObject = null; + if (collectionRef.Count != currentSize) { + throw new global::System.InvalidOperationException("Collection modified."); + } + } + + public void Dispose() { + currentIndex = -1; + currentObject = null; + } + } + + public void Clear() { + udpipe_csharpPINVOKE.Comments_Clear(swigCPtr); + } + + public void Add(string x) { + udpipe_csharpPINVOKE.Comments_Add(swigCPtr, x); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + private uint size() { + uint ret = udpipe_csharpPINVOKE.Comments_size(swigCPtr); + return ret; + } + + private uint capacity() { + uint ret = udpipe_csharpPINVOKE.Comments_capacity(swigCPtr); + return ret; + } + + private void reserve(uint n) { + udpipe_csharpPINVOKE.Comments_reserve(swigCPtr, n); + } + + public Comments() : this(udpipe_csharpPINVOKE.new_Comments__SWIG_0(), true) { + } + + public Comments(Comments other) : this(udpipe_csharpPINVOKE.new_Comments__SWIG_1(Comments.getCPtr(other)), true) { + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public Comments(int capacity) : this(udpipe_csharpPINVOKE.new_Comments__SWIG_2(capacity), true) { + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + private string getitemcopy(int index) { + string ret = udpipe_csharpPINVOKE.Comments_getitemcopy(swigCPtr, index); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + private string getitem(int index) { + string ret = udpipe_csharpPINVOKE.Comments_getitem(swigCPtr, index); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + private void setitem(int index, string val) { + udpipe_csharpPINVOKE.Comments_setitem(swigCPtr, index, val); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void AddRange(Comments values) { + udpipe_csharpPINVOKE.Comments_AddRange(swigCPtr, Comments.getCPtr(values)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public Comments GetRange(int index, int count) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.Comments_GetRange(swigCPtr, index, count); + Comments ret = (cPtr == global::System.IntPtr.Zero) ? null : new Comments(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public void Insert(int index, string x) { + udpipe_csharpPINVOKE.Comments_Insert(swigCPtr, index, x); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void InsertRange(int index, Comments values) { + udpipe_csharpPINVOKE.Comments_InsertRange(swigCPtr, index, Comments.getCPtr(values)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void RemoveAt(int index) { + udpipe_csharpPINVOKE.Comments_RemoveAt(swigCPtr, index); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void RemoveRange(int index, int count) { + udpipe_csharpPINVOKE.Comments_RemoveRange(swigCPtr, index, count); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public static Comments Repeat(string value, int count) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.Comments_Repeat(value, count); + Comments ret = (cPtr == global::System.IntPtr.Zero) ? null : new Comments(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public void Reverse() { + udpipe_csharpPINVOKE.Comments_Reverse__SWIG_0(swigCPtr); + } + + public void Reverse(int index, int count) { + udpipe_csharpPINVOKE.Comments_Reverse__SWIG_1(swigCPtr, index, count); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void SetRange(int index, Comments values) { + udpipe_csharpPINVOKE.Comments_SetRange(swigCPtr, index, Comments.getCPtr(values)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public bool Contains(string value) { + bool ret = udpipe_csharpPINVOKE.Comments_Contains(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public int IndexOf(string value) { + int ret = udpipe_csharpPINVOKE.Comments_IndexOf(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public int LastIndexOf(string value) { + int ret = udpipe_csharpPINVOKE.Comments_LastIndexOf(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public bool Remove(string value) { + bool ret = udpipe_csharpPINVOKE.Comments_Remove(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + +} + +} diff --git a/UDPipe/v1/binary/win64/csharp/Ufal/UDPipe/EmptyNode.cs b/UDPipe/v1/binary/win64/csharp/Ufal/UDPipe/EmptyNode.cs new file mode 100644 index 0000000000000000000000000000000000000000..3d9127797fd237053078ec6db9da11cc6c9c819a --- /dev/null +++ b/UDPipe/v1/binary/win64/csharp/Ufal/UDPipe/EmptyNode.cs @@ -0,0 +1,158 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +public class EmptyNode : global::System.IDisposable { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal EmptyNode(global::System.IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(EmptyNode obj) { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + ~EmptyNode() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != global::System.IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + udpipe_csharpPINVOKE.delete_EmptyNode(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + global::System.GC.SuppressFinalize(this); + } + } + + public int id { + set { + udpipe_csharpPINVOKE.EmptyNode_id_set(swigCPtr, value); + } + get { + int ret = udpipe_csharpPINVOKE.EmptyNode_id_get(swigCPtr); + return ret; + } + } + + public int index { + set { + udpipe_csharpPINVOKE.EmptyNode_index_set(swigCPtr, value); + } + get { + int ret = udpipe_csharpPINVOKE.EmptyNode_index_get(swigCPtr); + return ret; + } + } + + public string form { + set { + udpipe_csharpPINVOKE.EmptyNode_form_set(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + get { + string ret = udpipe_csharpPINVOKE.EmptyNode_form_get(swigCPtr); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + } + + public string lemma { + set { + udpipe_csharpPINVOKE.EmptyNode_lemma_set(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + get { + string ret = udpipe_csharpPINVOKE.EmptyNode_lemma_get(swigCPtr); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + } + + public string upostag { + set { + udpipe_csharpPINVOKE.EmptyNode_upostag_set(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + get { + string ret = udpipe_csharpPINVOKE.EmptyNode_upostag_get(swigCPtr); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + } + + public string xpostag { + set { + udpipe_csharpPINVOKE.EmptyNode_xpostag_set(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + get { + string ret = udpipe_csharpPINVOKE.EmptyNode_xpostag_get(swigCPtr); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + } + + public string feats { + set { + udpipe_csharpPINVOKE.EmptyNode_feats_set(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + get { + string ret = udpipe_csharpPINVOKE.EmptyNode_feats_get(swigCPtr); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + } + + public string deps { + set { + udpipe_csharpPINVOKE.EmptyNode_deps_set(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + get { + string ret = udpipe_csharpPINVOKE.EmptyNode_deps_get(swigCPtr); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + } + + public string misc { + set { + udpipe_csharpPINVOKE.EmptyNode_misc_set(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + get { + string ret = udpipe_csharpPINVOKE.EmptyNode_misc_get(swigCPtr); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + } + + public EmptyNode(int id, int index) : this(udpipe_csharpPINVOKE.new_EmptyNode__SWIG_0(id, index), true) { + } + + public EmptyNode(int id) : this(udpipe_csharpPINVOKE.new_EmptyNode__SWIG_1(id), true) { + } + + public EmptyNode() : this(udpipe_csharpPINVOKE.new_EmptyNode__SWIG_2(), true) { + } + +} + +} diff --git a/UDPipe/v1/binary/win64/csharp/Ufal/UDPipe/EmptyNodes.cs b/UDPipe/v1/binary/win64/csharp/Ufal/UDPipe/EmptyNodes.cs new file mode 100644 index 0000000000000000000000000000000000000000..2b4412bd10fdba16a486450f457720529beadb6b --- /dev/null +++ b/UDPipe/v1/binary/win64/csharp/Ufal/UDPipe/EmptyNodes.cs @@ -0,0 +1,309 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +public class EmptyNodes : global::System.IDisposable, global::System.Collections.IEnumerable + , global::System.Collections.Generic.IEnumerable + { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal EmptyNodes(global::System.IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(EmptyNodes obj) { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + ~EmptyNodes() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != global::System.IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + udpipe_csharpPINVOKE.delete_EmptyNodes(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + global::System.GC.SuppressFinalize(this); + } + } + + public EmptyNodes(global::System.Collections.ICollection c) : this() { + if (c == null) + throw new global::System.ArgumentNullException("c"); + foreach (EmptyNode element in c) { + this.Add(element); + } + } + + public bool IsFixedSize { + get { + return false; + } + } + + public bool IsReadOnly { + get { + return false; + } + } + + public EmptyNode this[int index] { + get { + return getitem(index); + } + set { + setitem(index, value); + } + } + + public int Capacity { + get { + return (int)capacity(); + } + set { + if (value < size()) + throw new global::System.ArgumentOutOfRangeException("Capacity"); + reserve((uint)value); + } + } + + public int Count { + get { + return (int)size(); + } + } + + public bool IsSynchronized { + get { + return false; + } + } + + public void CopyTo(EmptyNode[] array) + { + CopyTo(0, array, 0, this.Count); + } + + public void CopyTo(EmptyNode[] array, int arrayIndex) + { + CopyTo(0, array, arrayIndex, this.Count); + } + + public void CopyTo(int index, EmptyNode[] array, int arrayIndex, int count) + { + if (array == null) + throw new global::System.ArgumentNullException("array"); + if (index < 0) + throw new global::System.ArgumentOutOfRangeException("index", "Value is less than zero"); + if (arrayIndex < 0) + throw new global::System.ArgumentOutOfRangeException("arrayIndex", "Value is less than zero"); + if (count < 0) + throw new global::System.ArgumentOutOfRangeException("count", "Value is less than zero"); + if (array.Rank > 1) + throw new global::System.ArgumentException("Multi dimensional array.", "array"); + if (index+count > this.Count || arrayIndex+count > array.Length) + throw new global::System.ArgumentException("Number of elements to copy is too large."); + for (int i=0; i global::System.Collections.Generic.IEnumerable.GetEnumerator() { + return new EmptyNodesEnumerator(this); + } + + global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator() { + return new EmptyNodesEnumerator(this); + } + + public EmptyNodesEnumerator GetEnumerator() { + return new EmptyNodesEnumerator(this); + } + + // Type-safe enumerator + /// Note that the IEnumerator documentation requires an InvalidOperationException to be thrown + /// whenever the collection is modified. This has been done for changes in the size of the + /// collection but not when one of the elements of the collection is modified as it is a bit + /// tricky to detect unmanaged code that modifies the collection under our feet. + public sealed class EmptyNodesEnumerator : global::System.Collections.IEnumerator + , global::System.Collections.Generic.IEnumerator + { + private EmptyNodes collectionRef; + private int currentIndex; + private object currentObject; + private int currentSize; + + public EmptyNodesEnumerator(EmptyNodes collection) { + collectionRef = collection; + currentIndex = -1; + currentObject = null; + currentSize = collectionRef.Count; + } + + // Type-safe iterator Current + public EmptyNode Current { + get { + if (currentIndex == -1) + throw new global::System.InvalidOperationException("Enumeration not started."); + if (currentIndex > currentSize - 1) + throw new global::System.InvalidOperationException("Enumeration finished."); + if (currentObject == null) + throw new global::System.InvalidOperationException("Collection modified."); + return (EmptyNode)currentObject; + } + } + + // Type-unsafe IEnumerator.Current + object global::System.Collections.IEnumerator.Current { + get { + return Current; + } + } + + public bool MoveNext() { + int size = collectionRef.Count; + bool moveOkay = (currentIndex+1 < size) && (size == currentSize); + if (moveOkay) { + currentIndex++; + currentObject = collectionRef[currentIndex]; + } else { + currentObject = null; + } + return moveOkay; + } + + public void Reset() { + currentIndex = -1; + currentObject = null; + if (collectionRef.Count != currentSize) { + throw new global::System.InvalidOperationException("Collection modified."); + } + } + + public void Dispose() { + currentIndex = -1; + currentObject = null; + } + } + + public void Clear() { + udpipe_csharpPINVOKE.EmptyNodes_Clear(swigCPtr); + } + + public void Add(EmptyNode x) { + udpipe_csharpPINVOKE.EmptyNodes_Add(swigCPtr, EmptyNode.getCPtr(x)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + private uint size() { + uint ret = udpipe_csharpPINVOKE.EmptyNodes_size(swigCPtr); + return ret; + } + + private uint capacity() { + uint ret = udpipe_csharpPINVOKE.EmptyNodes_capacity(swigCPtr); + return ret; + } + + private void reserve(uint n) { + udpipe_csharpPINVOKE.EmptyNodes_reserve(swigCPtr, n); + } + + public EmptyNodes() : this(udpipe_csharpPINVOKE.new_EmptyNodes__SWIG_0(), true) { + } + + public EmptyNodes(EmptyNodes other) : this(udpipe_csharpPINVOKE.new_EmptyNodes__SWIG_1(EmptyNodes.getCPtr(other)), true) { + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public EmptyNodes(int capacity) : this(udpipe_csharpPINVOKE.new_EmptyNodes__SWIG_2(capacity), true) { + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + private EmptyNode getitemcopy(int index) { + EmptyNode ret = new EmptyNode(udpipe_csharpPINVOKE.EmptyNodes_getitemcopy(swigCPtr, index), true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + private EmptyNode getitem(int index) { + EmptyNode ret = new EmptyNode(udpipe_csharpPINVOKE.EmptyNodes_getitem(swigCPtr, index), false); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + private void setitem(int index, EmptyNode val) { + udpipe_csharpPINVOKE.EmptyNodes_setitem(swigCPtr, index, EmptyNode.getCPtr(val)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void AddRange(EmptyNodes values) { + udpipe_csharpPINVOKE.EmptyNodes_AddRange(swigCPtr, EmptyNodes.getCPtr(values)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public EmptyNodes GetRange(int index, int count) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.EmptyNodes_GetRange(swigCPtr, index, count); + EmptyNodes ret = (cPtr == global::System.IntPtr.Zero) ? null : new EmptyNodes(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public void Insert(int index, EmptyNode x) { + udpipe_csharpPINVOKE.EmptyNodes_Insert(swigCPtr, index, EmptyNode.getCPtr(x)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void InsertRange(int index, EmptyNodes values) { + udpipe_csharpPINVOKE.EmptyNodes_InsertRange(swigCPtr, index, EmptyNodes.getCPtr(values)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void RemoveAt(int index) { + udpipe_csharpPINVOKE.EmptyNodes_RemoveAt(swigCPtr, index); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void RemoveRange(int index, int count) { + udpipe_csharpPINVOKE.EmptyNodes_RemoveRange(swigCPtr, index, count); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public static EmptyNodes Repeat(EmptyNode value, int count) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.EmptyNodes_Repeat(EmptyNode.getCPtr(value), count); + EmptyNodes ret = (cPtr == global::System.IntPtr.Zero) ? null : new EmptyNodes(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public void Reverse() { + udpipe_csharpPINVOKE.EmptyNodes_Reverse__SWIG_0(swigCPtr); + } + + public void Reverse(int index, int count) { + udpipe_csharpPINVOKE.EmptyNodes_Reverse__SWIG_1(swigCPtr, index, count); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void SetRange(int index, EmptyNodes values) { + udpipe_csharpPINVOKE.EmptyNodes_SetRange(swigCPtr, index, EmptyNodes.getCPtr(values)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + +} + +} diff --git a/UDPipe/v1/binary/win64/csharp/Ufal/UDPipe/Evaluator.cs b/UDPipe/v1/binary/win64/csharp/Ufal/UDPipe/Evaluator.cs new file mode 100644 index 0000000000000000000000000000000000000000..007e5ae8995f11aefe94465fed6d1d61725b6644 --- /dev/null +++ b/UDPipe/v1/binary/win64/csharp/Ufal/UDPipe/Evaluator.cs @@ -0,0 +1,94 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +public class Evaluator : global::System.IDisposable { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal Evaluator(global::System.IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Evaluator obj) { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + ~Evaluator() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != global::System.IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + udpipe_csharpPINVOKE.delete_Evaluator(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + global::System.GC.SuppressFinalize(this); + } + } + + public Evaluator(Model m, string tokenizer, string tagger, string parser) : this(udpipe_csharpPINVOKE.new_Evaluator(Model.getCPtr(m), tokenizer, tagger, parser), true) { + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void setModel(Model m) { + udpipe_csharpPINVOKE.Evaluator_setModel(swigCPtr, Model.getCPtr(m)); + } + + public void setTokenizer(string tokenizer) { + udpipe_csharpPINVOKE.Evaluator_setTokenizer(swigCPtr, tokenizer); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void setTagger(string tagger) { + udpipe_csharpPINVOKE.Evaluator_setTagger(swigCPtr, tagger); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void setParser(string parser) { + udpipe_csharpPINVOKE.Evaluator_setParser(swigCPtr, parser); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public string evaluate(string data, ProcessingError error) { + string ret = udpipe_csharpPINVOKE.Evaluator_evaluate__SWIG_0(swigCPtr, data, ProcessingError.getCPtr(error)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public string evaluate(string data) { + string ret = udpipe_csharpPINVOKE.Evaluator_evaluate__SWIG_1(swigCPtr, data); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public static string DEFAULT { + get { + string ret = udpipe_csharpPINVOKE.Evaluator_DEFAULT_get(); + return ret; + } + } + + public static string NONE { + get { + string ret = udpipe_csharpPINVOKE.Evaluator_NONE_get(); + return ret; + } + } + +} + +} diff --git a/UDPipe/v1/binary/win64/csharp/Ufal/UDPipe/InputFormat.cs b/UDPipe/v1/binary/win64/csharp/Ufal/UDPipe/InputFormat.cs new file mode 100644 index 0000000000000000000000000000000000000000..4dd3bb29440658a9e5187aec1cf719180c11e798 --- /dev/null +++ b/UDPipe/v1/binary/win64/csharp/Ufal/UDPipe/InputFormat.cs @@ -0,0 +1,175 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +public class InputFormat : global::System.IDisposable { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal InputFormat(global::System.IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(InputFormat obj) { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + ~InputFormat() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != global::System.IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + udpipe_csharpPINVOKE.delete_InputFormat(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + global::System.GC.SuppressFinalize(this); + } + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtrAndDisown(InputFormat obj) { + if (obj != null) obj.swigCMemOwn = false; + return getCPtr(obj); + } + + public virtual void resetDocument(string id) { + udpipe_csharpPINVOKE.InputFormat_resetDocument__SWIG_0(swigCPtr, id); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public virtual void resetDocument() { + udpipe_csharpPINVOKE.InputFormat_resetDocument__SWIG_1(swigCPtr); + } + + public virtual void setText(string text) { + udpipe_csharpPINVOKE.InputFormat_setText(swigCPtr, text); + } + + public virtual bool nextSentence(Sentence s, ProcessingError error) { + bool ret = udpipe_csharpPINVOKE.InputFormat_nextSentence__SWIG_0(swigCPtr, Sentence.getCPtr(s), ProcessingError.getCPtr(error)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public virtual bool nextSentence(Sentence s) { + bool ret = udpipe_csharpPINVOKE.InputFormat_nextSentence__SWIG_1(swigCPtr, Sentence.getCPtr(s)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public static InputFormat newInputFormat(string name) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.InputFormat_newInputFormat(name); + InputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new InputFormat(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public static InputFormat newConlluInputFormat(string options) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.InputFormat_newConlluInputFormat__SWIG_0(options); + InputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new InputFormat(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public static InputFormat newConlluInputFormat() { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.InputFormat_newConlluInputFormat__SWIG_1(); + InputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new InputFormat(cPtr, true); + return ret; + } + + public static InputFormat newGenericTokenizerInputFormat(string options) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.InputFormat_newGenericTokenizerInputFormat__SWIG_0(options); + InputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new InputFormat(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public static InputFormat newGenericTokenizerInputFormat() { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.InputFormat_newGenericTokenizerInputFormat__SWIG_1(); + InputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new InputFormat(cPtr, true); + return ret; + } + + public static InputFormat newHorizontalInputFormat(string options) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.InputFormat_newHorizontalInputFormat__SWIG_0(options); + InputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new InputFormat(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public static InputFormat newHorizontalInputFormat() { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.InputFormat_newHorizontalInputFormat__SWIG_1(); + InputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new InputFormat(cPtr, true); + return ret; + } + + public static InputFormat newVerticalInputFormat(string options) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.InputFormat_newVerticalInputFormat__SWIG_0(options); + InputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new InputFormat(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public static InputFormat newVerticalInputFormat() { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.InputFormat_newVerticalInputFormat__SWIG_1(); + InputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new InputFormat(cPtr, true); + return ret; + } + + public static InputFormat newPresegmentedTokenizer(InputFormat DISOWN) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.InputFormat_newPresegmentedTokenizer(InputFormat.getCPtrAndDisown(DISOWN)); + InputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new InputFormat(cPtr, true); + return ret; + } + + public static string CONLLU_V1 { + get { + string ret = udpipe_csharpPINVOKE.InputFormat_CONLLU_V1_get(); + return ret; + } + } + + public static string CONLLU_V2 { + get { + string ret = udpipe_csharpPINVOKE.InputFormat_CONLLU_V2_get(); + return ret; + } + } + + public static string GENERIC_TOKENIZER_NORMALIZED_SPACES { + get { + string ret = udpipe_csharpPINVOKE.InputFormat_GENERIC_TOKENIZER_NORMALIZED_SPACES_get(); + return ret; + } + } + + public static string GENERIC_TOKENIZER_PRESEGMENTED { + get { + string ret = udpipe_csharpPINVOKE.InputFormat_GENERIC_TOKENIZER_PRESEGMENTED_get(); + return ret; + } + } + + public static string GENERIC_TOKENIZER_RANGES { + get { + string ret = udpipe_csharpPINVOKE.InputFormat_GENERIC_TOKENIZER_RANGES_get(); + return ret; + } + } + +} + +} diff --git a/UDPipe/v1/binary/win64/csharp/Ufal/UDPipe/Model.cs b/UDPipe/v1/binary/win64/csharp/Ufal/UDPipe/Model.cs new file mode 100644 index 0000000000000000000000000000000000000000..c0f530c0927b5b4e91e29dd73092ab2eae73c145 --- /dev/null +++ b/UDPipe/v1/binary/win64/csharp/Ufal/UDPipe/Model.cs @@ -0,0 +1,110 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +public class Model : global::System.IDisposable { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal Model(global::System.IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Model obj) { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + ~Model() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != global::System.IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + udpipe_csharpPINVOKE.delete_Model(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + global::System.GC.SuppressFinalize(this); + } + } + + public static Model load(string fname) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.Model_load(fname); + Model ret = (cPtr == global::System.IntPtr.Zero) ? null : new Model(cPtr, true); + return ret; + } + + public virtual InputFormat newTokenizer(string options) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.Model_newTokenizer(swigCPtr, options); + InputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new InputFormat(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public virtual bool tag(Sentence s, string options, ProcessingError error) { + bool ret = udpipe_csharpPINVOKE.Model_tag__SWIG_0(swigCPtr, Sentence.getCPtr(s), options, ProcessingError.getCPtr(error)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public virtual bool tag(Sentence s, string options) { + bool ret = udpipe_csharpPINVOKE.Model_tag__SWIG_1(swigCPtr, Sentence.getCPtr(s), options); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public virtual bool parse(Sentence s, string options, ProcessingError error) { + bool ret = udpipe_csharpPINVOKE.Model_parse__SWIG_0(swigCPtr, Sentence.getCPtr(s), options, ProcessingError.getCPtr(error)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public virtual bool parse(Sentence s, string options) { + bool ret = udpipe_csharpPINVOKE.Model_parse__SWIG_1(swigCPtr, Sentence.getCPtr(s), options); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public static string DEFAULT { + get { + string ret = udpipe_csharpPINVOKE.Model_DEFAULT_get(); + return ret; + } + } + + public static string TOKENIZER_NORMALIZED_SPACES { + get { + string ret = udpipe_csharpPINVOKE.Model_TOKENIZER_NORMALIZED_SPACES_get(); + return ret; + } + } + + public static string TOKENIZER_PRESEGMENTED { + get { + string ret = udpipe_csharpPINVOKE.Model_TOKENIZER_PRESEGMENTED_get(); + return ret; + } + } + + public static string TOKENIZER_RANGES { + get { + string ret = udpipe_csharpPINVOKE.Model_TOKENIZER_RANGES_get(); + return ret; + } + } + +} + +} diff --git a/UDPipe/v1/binary/win64/csharp/Ufal/UDPipe/MultiwordToken.cs b/UDPipe/v1/binary/win64/csharp/Ufal/UDPipe/MultiwordToken.cs new file mode 100644 index 0000000000000000000000000000000000000000..0c0d174d4568b275e8ccba0da645baae911f6451 --- /dev/null +++ b/UDPipe/v1/binary/win64/csharp/Ufal/UDPipe/MultiwordToken.cs @@ -0,0 +1,81 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +public class MultiwordToken : Token { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + + internal MultiwordToken(global::System.IntPtr cPtr, bool cMemoryOwn) : base(udpipe_csharpPINVOKE.MultiwordToken_SWIGUpcast(cPtr), cMemoryOwn) { + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(MultiwordToken obj) { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + ~MultiwordToken() { + Dispose(); + } + + public override void Dispose() { + lock(this) { + if (swigCPtr.Handle != global::System.IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + udpipe_csharpPINVOKE.delete_MultiwordToken(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + global::System.GC.SuppressFinalize(this); + base.Dispose(); + } + } + + public int idFirst { + set { + udpipe_csharpPINVOKE.MultiwordToken_idFirst_set(swigCPtr, value); + } + get { + int ret = udpipe_csharpPINVOKE.MultiwordToken_idFirst_get(swigCPtr); + return ret; + } + } + + public int idLast { + set { + udpipe_csharpPINVOKE.MultiwordToken_idLast_set(swigCPtr, value); + } + get { + int ret = udpipe_csharpPINVOKE.MultiwordToken_idLast_get(swigCPtr); + return ret; + } + } + + public MultiwordToken(int id_first, int id_last, string form, string misc) : this(udpipe_csharpPINVOKE.new_MultiwordToken__SWIG_0(id_first, id_last, form, misc), true) { + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public MultiwordToken(int id_first, int id_last, string form) : this(udpipe_csharpPINVOKE.new_MultiwordToken__SWIG_1(id_first, id_last, form), true) { + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public MultiwordToken(int id_first, int id_last) : this(udpipe_csharpPINVOKE.new_MultiwordToken__SWIG_2(id_first, id_last), true) { + } + + public MultiwordToken(int id_first) : this(udpipe_csharpPINVOKE.new_MultiwordToken__SWIG_3(id_first), true) { + } + + public MultiwordToken() : this(udpipe_csharpPINVOKE.new_MultiwordToken__SWIG_4(), true) { + } + +} + +} diff --git a/UDPipe/v1/binary/win64/csharp/Ufal/UDPipe/MultiwordTokens.cs b/UDPipe/v1/binary/win64/csharp/Ufal/UDPipe/MultiwordTokens.cs new file mode 100644 index 0000000000000000000000000000000000000000..0e901203b8632f1636e8b5725efa90ecffbf1f7e --- /dev/null +++ b/UDPipe/v1/binary/win64/csharp/Ufal/UDPipe/MultiwordTokens.cs @@ -0,0 +1,309 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +public class MultiwordTokens : global::System.IDisposable, global::System.Collections.IEnumerable + , global::System.Collections.Generic.IEnumerable + { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal MultiwordTokens(global::System.IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(MultiwordTokens obj) { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + ~MultiwordTokens() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != global::System.IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + udpipe_csharpPINVOKE.delete_MultiwordTokens(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + global::System.GC.SuppressFinalize(this); + } + } + + public MultiwordTokens(global::System.Collections.ICollection c) : this() { + if (c == null) + throw new global::System.ArgumentNullException("c"); + foreach (MultiwordToken element in c) { + this.Add(element); + } + } + + public bool IsFixedSize { + get { + return false; + } + } + + public bool IsReadOnly { + get { + return false; + } + } + + public MultiwordToken this[int index] { + get { + return getitem(index); + } + set { + setitem(index, value); + } + } + + public int Capacity { + get { + return (int)capacity(); + } + set { + if (value < size()) + throw new global::System.ArgumentOutOfRangeException("Capacity"); + reserve((uint)value); + } + } + + public int Count { + get { + return (int)size(); + } + } + + public bool IsSynchronized { + get { + return false; + } + } + + public void CopyTo(MultiwordToken[] array) + { + CopyTo(0, array, 0, this.Count); + } + + public void CopyTo(MultiwordToken[] array, int arrayIndex) + { + CopyTo(0, array, arrayIndex, this.Count); + } + + public void CopyTo(int index, MultiwordToken[] array, int arrayIndex, int count) + { + if (array == null) + throw new global::System.ArgumentNullException("array"); + if (index < 0) + throw new global::System.ArgumentOutOfRangeException("index", "Value is less than zero"); + if (arrayIndex < 0) + throw new global::System.ArgumentOutOfRangeException("arrayIndex", "Value is less than zero"); + if (count < 0) + throw new global::System.ArgumentOutOfRangeException("count", "Value is less than zero"); + if (array.Rank > 1) + throw new global::System.ArgumentException("Multi dimensional array.", "array"); + if (index+count > this.Count || arrayIndex+count > array.Length) + throw new global::System.ArgumentException("Number of elements to copy is too large."); + for (int i=0; i global::System.Collections.Generic.IEnumerable.GetEnumerator() { + return new MultiwordTokensEnumerator(this); + } + + global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator() { + return new MultiwordTokensEnumerator(this); + } + + public MultiwordTokensEnumerator GetEnumerator() { + return new MultiwordTokensEnumerator(this); + } + + // Type-safe enumerator + /// Note that the IEnumerator documentation requires an InvalidOperationException to be thrown + /// whenever the collection is modified. This has been done for changes in the size of the + /// collection but not when one of the elements of the collection is modified as it is a bit + /// tricky to detect unmanaged code that modifies the collection under our feet. + public sealed class MultiwordTokensEnumerator : global::System.Collections.IEnumerator + , global::System.Collections.Generic.IEnumerator + { + private MultiwordTokens collectionRef; + private int currentIndex; + private object currentObject; + private int currentSize; + + public MultiwordTokensEnumerator(MultiwordTokens collection) { + collectionRef = collection; + currentIndex = -1; + currentObject = null; + currentSize = collectionRef.Count; + } + + // Type-safe iterator Current + public MultiwordToken Current { + get { + if (currentIndex == -1) + throw new global::System.InvalidOperationException("Enumeration not started."); + if (currentIndex > currentSize - 1) + throw new global::System.InvalidOperationException("Enumeration finished."); + if (currentObject == null) + throw new global::System.InvalidOperationException("Collection modified."); + return (MultiwordToken)currentObject; + } + } + + // Type-unsafe IEnumerator.Current + object global::System.Collections.IEnumerator.Current { + get { + return Current; + } + } + + public bool MoveNext() { + int size = collectionRef.Count; + bool moveOkay = (currentIndex+1 < size) && (size == currentSize); + if (moveOkay) { + currentIndex++; + currentObject = collectionRef[currentIndex]; + } else { + currentObject = null; + } + return moveOkay; + } + + public void Reset() { + currentIndex = -1; + currentObject = null; + if (collectionRef.Count != currentSize) { + throw new global::System.InvalidOperationException("Collection modified."); + } + } + + public void Dispose() { + currentIndex = -1; + currentObject = null; + } + } + + public void Clear() { + udpipe_csharpPINVOKE.MultiwordTokens_Clear(swigCPtr); + } + + public void Add(MultiwordToken x) { + udpipe_csharpPINVOKE.MultiwordTokens_Add(swigCPtr, MultiwordToken.getCPtr(x)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + private uint size() { + uint ret = udpipe_csharpPINVOKE.MultiwordTokens_size(swigCPtr); + return ret; + } + + private uint capacity() { + uint ret = udpipe_csharpPINVOKE.MultiwordTokens_capacity(swigCPtr); + return ret; + } + + private void reserve(uint n) { + udpipe_csharpPINVOKE.MultiwordTokens_reserve(swigCPtr, n); + } + + public MultiwordTokens() : this(udpipe_csharpPINVOKE.new_MultiwordTokens__SWIG_0(), true) { + } + + public MultiwordTokens(MultiwordTokens other) : this(udpipe_csharpPINVOKE.new_MultiwordTokens__SWIG_1(MultiwordTokens.getCPtr(other)), true) { + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public MultiwordTokens(int capacity) : this(udpipe_csharpPINVOKE.new_MultiwordTokens__SWIG_2(capacity), true) { + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + private MultiwordToken getitemcopy(int index) { + MultiwordToken ret = new MultiwordToken(udpipe_csharpPINVOKE.MultiwordTokens_getitemcopy(swigCPtr, index), true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + private MultiwordToken getitem(int index) { + MultiwordToken ret = new MultiwordToken(udpipe_csharpPINVOKE.MultiwordTokens_getitem(swigCPtr, index), false); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + private void setitem(int index, MultiwordToken val) { + udpipe_csharpPINVOKE.MultiwordTokens_setitem(swigCPtr, index, MultiwordToken.getCPtr(val)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void AddRange(MultiwordTokens values) { + udpipe_csharpPINVOKE.MultiwordTokens_AddRange(swigCPtr, MultiwordTokens.getCPtr(values)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public MultiwordTokens GetRange(int index, int count) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.MultiwordTokens_GetRange(swigCPtr, index, count); + MultiwordTokens ret = (cPtr == global::System.IntPtr.Zero) ? null : new MultiwordTokens(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public void Insert(int index, MultiwordToken x) { + udpipe_csharpPINVOKE.MultiwordTokens_Insert(swigCPtr, index, MultiwordToken.getCPtr(x)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void InsertRange(int index, MultiwordTokens values) { + udpipe_csharpPINVOKE.MultiwordTokens_InsertRange(swigCPtr, index, MultiwordTokens.getCPtr(values)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void RemoveAt(int index) { + udpipe_csharpPINVOKE.MultiwordTokens_RemoveAt(swigCPtr, index); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void RemoveRange(int index, int count) { + udpipe_csharpPINVOKE.MultiwordTokens_RemoveRange(swigCPtr, index, count); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public static MultiwordTokens Repeat(MultiwordToken value, int count) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.MultiwordTokens_Repeat(MultiwordToken.getCPtr(value), count); + MultiwordTokens ret = (cPtr == global::System.IntPtr.Zero) ? null : new MultiwordTokens(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public void Reverse() { + udpipe_csharpPINVOKE.MultiwordTokens_Reverse__SWIG_0(swigCPtr); + } + + public void Reverse(int index, int count) { + udpipe_csharpPINVOKE.MultiwordTokens_Reverse__SWIG_1(swigCPtr, index, count); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void SetRange(int index, MultiwordTokens values) { + udpipe_csharpPINVOKE.MultiwordTokens_SetRange(swigCPtr, index, MultiwordTokens.getCPtr(values)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + +} + +} diff --git a/UDPipe/v1/binary/win64/csharp/Ufal/UDPipe/OutputFormat.cs b/UDPipe/v1/binary/win64/csharp/Ufal/UDPipe/OutputFormat.cs new file mode 100644 index 0000000000000000000000000000000000000000..e15d216ec5790ea52aa23b38a59849e151e8439c --- /dev/null +++ b/UDPipe/v1/binary/win64/csharp/Ufal/UDPipe/OutputFormat.cs @@ -0,0 +1,176 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +public class OutputFormat : global::System.IDisposable { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal OutputFormat(global::System.IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(OutputFormat obj) { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + ~OutputFormat() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != global::System.IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + udpipe_csharpPINVOKE.delete_OutputFormat(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + global::System.GC.SuppressFinalize(this); + } + } + + public virtual string writeSentence(Sentence s) { + string ret = udpipe_csharpPINVOKE.OutputFormat_writeSentence(swigCPtr, Sentence.getCPtr(s)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public virtual string finishDocument() { + string ret = udpipe_csharpPINVOKE.OutputFormat_finishDocument(swigCPtr); + return ret; + } + + public static OutputFormat newOutputFormat(string name) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.OutputFormat_newOutputFormat(name); + OutputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new OutputFormat(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public static OutputFormat newConlluOutputFormat(string options) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.OutputFormat_newConlluOutputFormat__SWIG_0(options); + OutputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new OutputFormat(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public static OutputFormat newConlluOutputFormat() { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.OutputFormat_newConlluOutputFormat__SWIG_1(); + OutputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new OutputFormat(cPtr, true); + return ret; + } + + public static OutputFormat newEpeOutputFormat(string options) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.OutputFormat_newEpeOutputFormat__SWIG_0(options); + OutputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new OutputFormat(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public static OutputFormat newEpeOutputFormat() { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.OutputFormat_newEpeOutputFormat__SWIG_1(); + OutputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new OutputFormat(cPtr, true); + return ret; + } + + public static OutputFormat newMatxinOutputFormat(string options) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.OutputFormat_newMatxinOutputFormat__SWIG_0(options); + OutputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new OutputFormat(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public static OutputFormat newMatxinOutputFormat() { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.OutputFormat_newMatxinOutputFormat__SWIG_1(); + OutputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new OutputFormat(cPtr, true); + return ret; + } + + public static OutputFormat newHorizontalOutputFormat(string options) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.OutputFormat_newHorizontalOutputFormat__SWIG_0(options); + OutputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new OutputFormat(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public static OutputFormat newHorizontalOutputFormat() { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.OutputFormat_newHorizontalOutputFormat__SWIG_1(); + OutputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new OutputFormat(cPtr, true); + return ret; + } + + public static OutputFormat newPlaintextOutputFormat(string options) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.OutputFormat_newPlaintextOutputFormat__SWIG_0(options); + OutputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new OutputFormat(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public static OutputFormat newPlaintextOutputFormat() { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.OutputFormat_newPlaintextOutputFormat__SWIG_1(); + OutputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new OutputFormat(cPtr, true); + return ret; + } + + public static OutputFormat newVerticalOutputFormat(string options) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.OutputFormat_newVerticalOutputFormat__SWIG_0(options); + OutputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new OutputFormat(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public static OutputFormat newVerticalOutputFormat() { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.OutputFormat_newVerticalOutputFormat__SWIG_1(); + OutputFormat ret = (cPtr == global::System.IntPtr.Zero) ? null : new OutputFormat(cPtr, true); + return ret; + } + + public static string CONLLU_V1 { + get { + string ret = udpipe_csharpPINVOKE.OutputFormat_CONLLU_V1_get(); + return ret; + } + } + + public static string CONLLU_V2 { + get { + string ret = udpipe_csharpPINVOKE.OutputFormat_CONLLU_V2_get(); + return ret; + } + } + + public static string HORIZONTAL_PARAGRAPHS { + get { + string ret = udpipe_csharpPINVOKE.OutputFormat_HORIZONTAL_PARAGRAPHS_get(); + return ret; + } + } + + public static string PLAINTEXT_NORMALIZED_SPACES { + get { + string ret = udpipe_csharpPINVOKE.OutputFormat_PLAINTEXT_NORMALIZED_SPACES_get(); + return ret; + } + } + + public static string VERTICAL_PARAGRAPHS { + get { + string ret = udpipe_csharpPINVOKE.OutputFormat_VERTICAL_PARAGRAPHS_get(); + return ret; + } + } + +} + +} diff --git a/UDPipe/v1/binary/win64/csharp/Ufal/UDPipe/Pipeline.cs b/UDPipe/v1/binary/win64/csharp/Ufal/UDPipe/Pipeline.cs new file mode 100644 index 0000000000000000000000000000000000000000..370b33368ba0c8056a906dcde9ed5478710a41c4 --- /dev/null +++ b/UDPipe/v1/binary/win64/csharp/Ufal/UDPipe/Pipeline.cs @@ -0,0 +1,108 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +public class Pipeline : global::System.IDisposable { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal Pipeline(global::System.IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Pipeline obj) { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + ~Pipeline() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != global::System.IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + udpipe_csharpPINVOKE.delete_Pipeline(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + global::System.GC.SuppressFinalize(this); + } + } + + public Pipeline(Model m, string input, string tagger, string parser, string output) : this(udpipe_csharpPINVOKE.new_Pipeline(Model.getCPtr(m), input, tagger, parser, output), true) { + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void setModel(Model m) { + udpipe_csharpPINVOKE.Pipeline_setModel(swigCPtr, Model.getCPtr(m)); + } + + public void setInput(string input) { + udpipe_csharpPINVOKE.Pipeline_setInput(swigCPtr, input); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void setTagger(string tagger) { + udpipe_csharpPINVOKE.Pipeline_setTagger(swigCPtr, tagger); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void setParser(string parser) { + udpipe_csharpPINVOKE.Pipeline_setParser(swigCPtr, parser); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void setOutput(string output) { + udpipe_csharpPINVOKE.Pipeline_setOutput(swigCPtr, output); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void setImmediate(bool immediate) { + udpipe_csharpPINVOKE.Pipeline_setImmediate(swigCPtr, immediate); + } + + public void setDocumentId(string document_id) { + udpipe_csharpPINVOKE.Pipeline_setDocumentId(swigCPtr, document_id); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public string process(string data, ProcessingError error) { + string ret = udpipe_csharpPINVOKE.Pipeline_process__SWIG_0(swigCPtr, data, ProcessingError.getCPtr(error)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public string process(string data) { + string ret = udpipe_csharpPINVOKE.Pipeline_process__SWIG_1(swigCPtr, data); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public static string DEFAULT { + get { + string ret = udpipe_csharpPINVOKE.Pipeline_DEFAULT_get(); + return ret; + } + } + + public static string NONE { + get { + string ret = udpipe_csharpPINVOKE.Pipeline_NONE_get(); + return ret; + } + } + +} + +} diff --git a/UDPipe/v1/binary/win64/csharp/Ufal/UDPipe/ProcessingError.cs b/UDPipe/v1/binary/win64/csharp/Ufal/UDPipe/ProcessingError.cs new file mode 100644 index 0000000000000000000000000000000000000000..f68346cd50e55daf567824eb3cc778db1b253389 --- /dev/null +++ b/UDPipe/v1/binary/win64/csharp/Ufal/UDPipe/ProcessingError.cs @@ -0,0 +1,65 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +public class ProcessingError : global::System.IDisposable { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal ProcessingError(global::System.IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(ProcessingError obj) { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + ~ProcessingError() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != global::System.IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + udpipe_csharpPINVOKE.delete_ProcessingError(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + global::System.GC.SuppressFinalize(this); + } + } + + public bool occurred() { + bool ret = udpipe_csharpPINVOKE.ProcessingError_occurred(swigCPtr); + return ret; + } + + public string message { + set { + udpipe_csharpPINVOKE.ProcessingError_message_set(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + get { + string ret = udpipe_csharpPINVOKE.ProcessingError_message_get(swigCPtr); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + } + + public ProcessingError() : this(udpipe_csharpPINVOKE.new_ProcessingError(), true) { + } + +} + +} diff --git a/UDPipe/v1/binary/win64/csharp/Ufal/UDPipe/Sentence.cs b/UDPipe/v1/binary/win64/csharp/Ufal/UDPipe/Sentence.cs new file mode 100644 index 0000000000000000000000000000000000000000..9efe884c1a7face6b7f8875411b08f95a8740c6b --- /dev/null +++ b/UDPipe/v1/binary/win64/csharp/Ufal/UDPipe/Sentence.cs @@ -0,0 +1,180 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +public class Sentence : global::System.IDisposable { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal Sentence(global::System.IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Sentence obj) { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + ~Sentence() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != global::System.IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + udpipe_csharpPINVOKE.delete_Sentence(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + global::System.GC.SuppressFinalize(this); + } + } + + public Sentence() : this(udpipe_csharpPINVOKE.new_Sentence(), true) { + } + + public Words words { + set { + udpipe_csharpPINVOKE.Sentence_words_set(swigCPtr, Words.getCPtr(value)); + } + get { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.Sentence_words_get(swigCPtr); + Words ret = (cPtr == global::System.IntPtr.Zero) ? null : new Words(cPtr, false); + return ret; + } + } + + public MultiwordTokens multiwordTokens { + set { + udpipe_csharpPINVOKE.Sentence_multiwordTokens_set(swigCPtr, MultiwordTokens.getCPtr(value)); + } + get { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.Sentence_multiwordTokens_get(swigCPtr); + MultiwordTokens ret = (cPtr == global::System.IntPtr.Zero) ? null : new MultiwordTokens(cPtr, false); + return ret; + } + } + + public EmptyNodes emptyNodes { + set { + udpipe_csharpPINVOKE.Sentence_emptyNodes_set(swigCPtr, EmptyNodes.getCPtr(value)); + } + get { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.Sentence_emptyNodes_get(swigCPtr); + EmptyNodes ret = (cPtr == global::System.IntPtr.Zero) ? null : new EmptyNodes(cPtr, false); + return ret; + } + } + + public Comments comments { + set { + udpipe_csharpPINVOKE.Sentence_comments_set(swigCPtr, Comments.getCPtr(value)); + } + get { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.Sentence_comments_get(swigCPtr); + Comments ret = (cPtr == global::System.IntPtr.Zero) ? null : new Comments(cPtr, false); + return ret; + } + } + + public static string rootForm { + get { + string ret = udpipe_csharpPINVOKE.Sentence_rootForm_get(); + return ret; + } + } + + public bool empty() { + bool ret = udpipe_csharpPINVOKE.Sentence_empty(swigCPtr); + return ret; + } + + public void clear() { + udpipe_csharpPINVOKE.Sentence_clear(swigCPtr); + } + + public virtual Word addWord(string form) { + Word ret = new Word(udpipe_csharpPINVOKE.Sentence_addWord(swigCPtr, form), false); + return ret; + } + + public void setHead(int id, int head, string deprel) { + udpipe_csharpPINVOKE.Sentence_setHead(swigCPtr, id, head, deprel); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void unlinkAllNodes() { + udpipe_csharpPINVOKE.Sentence_unlinkAllNodes(swigCPtr); + } + + public bool getNewDoc() { + bool ret = udpipe_csharpPINVOKE.Sentence_getNewDoc(swigCPtr); + return ret; + } + + public string getNewDocId() { + string ret = udpipe_csharpPINVOKE.Sentence_getNewDocId(swigCPtr); + return ret; + } + + public void setNewDoc(bool new_doc, string id) { + udpipe_csharpPINVOKE.Sentence_setNewDoc__SWIG_0(swigCPtr, new_doc, id); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void setNewDoc(bool new_doc) { + udpipe_csharpPINVOKE.Sentence_setNewDoc__SWIG_1(swigCPtr, new_doc); + } + + public bool getNewPar() { + bool ret = udpipe_csharpPINVOKE.Sentence_getNewPar(swigCPtr); + return ret; + } + + public string getNewParId() { + string ret = udpipe_csharpPINVOKE.Sentence_getNewParId(swigCPtr); + return ret; + } + + public void setNewPar(bool new_par, string id) { + udpipe_csharpPINVOKE.Sentence_setNewPar__SWIG_0(swigCPtr, new_par, id); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void setNewPar(bool new_par) { + udpipe_csharpPINVOKE.Sentence_setNewPar__SWIG_1(swigCPtr, new_par); + } + + public string getSentId() { + string ret = udpipe_csharpPINVOKE.Sentence_getSentId(swigCPtr); + return ret; + } + + public void setSentId(string id) { + udpipe_csharpPINVOKE.Sentence_setSentId(swigCPtr, id); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public string getText() { + string ret = udpipe_csharpPINVOKE.Sentence_getText(swigCPtr); + return ret; + } + + public void setText(string id) { + udpipe_csharpPINVOKE.Sentence_setText(swigCPtr, id); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + +} + +} diff --git a/UDPipe/v1/binary/win64/csharp/Ufal/UDPipe/Sentences.cs b/UDPipe/v1/binary/win64/csharp/Ufal/UDPipe/Sentences.cs new file mode 100644 index 0000000000000000000000000000000000000000..4247f211a86a8e8c0e5af30d72613005a3bf4d15 --- /dev/null +++ b/UDPipe/v1/binary/win64/csharp/Ufal/UDPipe/Sentences.cs @@ -0,0 +1,309 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +public class Sentences : global::System.IDisposable, global::System.Collections.IEnumerable + , global::System.Collections.Generic.IEnumerable + { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal Sentences(global::System.IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Sentences obj) { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + ~Sentences() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != global::System.IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + udpipe_csharpPINVOKE.delete_Sentences(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + global::System.GC.SuppressFinalize(this); + } + } + + public Sentences(global::System.Collections.ICollection c) : this() { + if (c == null) + throw new global::System.ArgumentNullException("c"); + foreach (Sentence element in c) { + this.Add(element); + } + } + + public bool IsFixedSize { + get { + return false; + } + } + + public bool IsReadOnly { + get { + return false; + } + } + + public Sentence this[int index] { + get { + return getitem(index); + } + set { + setitem(index, value); + } + } + + public int Capacity { + get { + return (int)capacity(); + } + set { + if (value < size()) + throw new global::System.ArgumentOutOfRangeException("Capacity"); + reserve((uint)value); + } + } + + public int Count { + get { + return (int)size(); + } + } + + public bool IsSynchronized { + get { + return false; + } + } + + public void CopyTo(Sentence[] array) + { + CopyTo(0, array, 0, this.Count); + } + + public void CopyTo(Sentence[] array, int arrayIndex) + { + CopyTo(0, array, arrayIndex, this.Count); + } + + public void CopyTo(int index, Sentence[] array, int arrayIndex, int count) + { + if (array == null) + throw new global::System.ArgumentNullException("array"); + if (index < 0) + throw new global::System.ArgumentOutOfRangeException("index", "Value is less than zero"); + if (arrayIndex < 0) + throw new global::System.ArgumentOutOfRangeException("arrayIndex", "Value is less than zero"); + if (count < 0) + throw new global::System.ArgumentOutOfRangeException("count", "Value is less than zero"); + if (array.Rank > 1) + throw new global::System.ArgumentException("Multi dimensional array.", "array"); + if (index+count > this.Count || arrayIndex+count > array.Length) + throw new global::System.ArgumentException("Number of elements to copy is too large."); + for (int i=0; i global::System.Collections.Generic.IEnumerable.GetEnumerator() { + return new SentencesEnumerator(this); + } + + global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator() { + return new SentencesEnumerator(this); + } + + public SentencesEnumerator GetEnumerator() { + return new SentencesEnumerator(this); + } + + // Type-safe enumerator + /// Note that the IEnumerator documentation requires an InvalidOperationException to be thrown + /// whenever the collection is modified. This has been done for changes in the size of the + /// collection but not when one of the elements of the collection is modified as it is a bit + /// tricky to detect unmanaged code that modifies the collection under our feet. + public sealed class SentencesEnumerator : global::System.Collections.IEnumerator + , global::System.Collections.Generic.IEnumerator + { + private Sentences collectionRef; + private int currentIndex; + private object currentObject; + private int currentSize; + + public SentencesEnumerator(Sentences collection) { + collectionRef = collection; + currentIndex = -1; + currentObject = null; + currentSize = collectionRef.Count; + } + + // Type-safe iterator Current + public Sentence Current { + get { + if (currentIndex == -1) + throw new global::System.InvalidOperationException("Enumeration not started."); + if (currentIndex > currentSize - 1) + throw new global::System.InvalidOperationException("Enumeration finished."); + if (currentObject == null) + throw new global::System.InvalidOperationException("Collection modified."); + return (Sentence)currentObject; + } + } + + // Type-unsafe IEnumerator.Current + object global::System.Collections.IEnumerator.Current { + get { + return Current; + } + } + + public bool MoveNext() { + int size = collectionRef.Count; + bool moveOkay = (currentIndex+1 < size) && (size == currentSize); + if (moveOkay) { + currentIndex++; + currentObject = collectionRef[currentIndex]; + } else { + currentObject = null; + } + return moveOkay; + } + + public void Reset() { + currentIndex = -1; + currentObject = null; + if (collectionRef.Count != currentSize) { + throw new global::System.InvalidOperationException("Collection modified."); + } + } + + public void Dispose() { + currentIndex = -1; + currentObject = null; + } + } + + public void Clear() { + udpipe_csharpPINVOKE.Sentences_Clear(swigCPtr); + } + + public void Add(Sentence x) { + udpipe_csharpPINVOKE.Sentences_Add(swigCPtr, Sentence.getCPtr(x)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + private uint size() { + uint ret = udpipe_csharpPINVOKE.Sentences_size(swigCPtr); + return ret; + } + + private uint capacity() { + uint ret = udpipe_csharpPINVOKE.Sentences_capacity(swigCPtr); + return ret; + } + + private void reserve(uint n) { + udpipe_csharpPINVOKE.Sentences_reserve(swigCPtr, n); + } + + public Sentences() : this(udpipe_csharpPINVOKE.new_Sentences__SWIG_0(), true) { + } + + public Sentences(Sentences other) : this(udpipe_csharpPINVOKE.new_Sentences__SWIG_1(Sentences.getCPtr(other)), true) { + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public Sentences(int capacity) : this(udpipe_csharpPINVOKE.new_Sentences__SWIG_2(capacity), true) { + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + private Sentence getitemcopy(int index) { + Sentence ret = new Sentence(udpipe_csharpPINVOKE.Sentences_getitemcopy(swigCPtr, index), true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + private Sentence getitem(int index) { + Sentence ret = new Sentence(udpipe_csharpPINVOKE.Sentences_getitem(swigCPtr, index), false); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + private void setitem(int index, Sentence val) { + udpipe_csharpPINVOKE.Sentences_setitem(swigCPtr, index, Sentence.getCPtr(val)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void AddRange(Sentences values) { + udpipe_csharpPINVOKE.Sentences_AddRange(swigCPtr, Sentences.getCPtr(values)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public Sentences GetRange(int index, int count) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.Sentences_GetRange(swigCPtr, index, count); + Sentences ret = (cPtr == global::System.IntPtr.Zero) ? null : new Sentences(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public void Insert(int index, Sentence x) { + udpipe_csharpPINVOKE.Sentences_Insert(swigCPtr, index, Sentence.getCPtr(x)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void InsertRange(int index, Sentences values) { + udpipe_csharpPINVOKE.Sentences_InsertRange(swigCPtr, index, Sentences.getCPtr(values)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void RemoveAt(int index) { + udpipe_csharpPINVOKE.Sentences_RemoveAt(swigCPtr, index); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void RemoveRange(int index, int count) { + udpipe_csharpPINVOKE.Sentences_RemoveRange(swigCPtr, index, count); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public static Sentences Repeat(Sentence value, int count) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.Sentences_Repeat(Sentence.getCPtr(value), count); + Sentences ret = (cPtr == global::System.IntPtr.Zero) ? null : new Sentences(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public void Reverse() { + udpipe_csharpPINVOKE.Sentences_Reverse__SWIG_0(swigCPtr); + } + + public void Reverse(int index, int count) { + udpipe_csharpPINVOKE.Sentences_Reverse__SWIG_1(swigCPtr, index, count); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void SetRange(int index, Sentences values) { + udpipe_csharpPINVOKE.Sentences_SetRange(swigCPtr, index, Sentences.getCPtr(values)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + +} + +} diff --git a/UDPipe/v1/binary/win64/csharp/Ufal/UDPipe/Token.cs b/UDPipe/v1/binary/win64/csharp/Ufal/UDPipe/Token.cs new file mode 100644 index 0000000000000000000000000000000000000000..bdeb83f9f005909bf47142481a85c7f537d63eab --- /dev/null +++ b/UDPipe/v1/binary/win64/csharp/Ufal/UDPipe/Token.cs @@ -0,0 +1,138 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +public class Token : global::System.IDisposable { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal Token(global::System.IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Token obj) { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + ~Token() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != global::System.IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + udpipe_csharpPINVOKE.delete_Token(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + global::System.GC.SuppressFinalize(this); + } + } + + public string form { + set { + udpipe_csharpPINVOKE.Token_form_set(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + get { + string ret = udpipe_csharpPINVOKE.Token_form_get(swigCPtr); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + } + + public string misc { + set { + udpipe_csharpPINVOKE.Token_misc_set(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + get { + string ret = udpipe_csharpPINVOKE.Token_misc_get(swigCPtr); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + } + + public Token(string form, string misc) : this(udpipe_csharpPINVOKE.new_Token__SWIG_0(form, misc), true) { + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public Token(string form) : this(udpipe_csharpPINVOKE.new_Token__SWIG_1(form), true) { + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public Token() : this(udpipe_csharpPINVOKE.new_Token__SWIG_2(), true) { + } + + public bool getSpaceAfter() { + bool ret = udpipe_csharpPINVOKE.Token_getSpaceAfter(swigCPtr); + return ret; + } + + public void setSpaceAfter(bool space_after) { + udpipe_csharpPINVOKE.Token_setSpaceAfter(swigCPtr, space_after); + } + + public string getSpacesBefore() { + string ret = udpipe_csharpPINVOKE.Token_getSpacesBefore(swigCPtr); + return ret; + } + + public void setSpacesBefore(string spaces_before) { + udpipe_csharpPINVOKE.Token_setSpacesBefore(swigCPtr, spaces_before); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public string getSpacesAfter() { + string ret = udpipe_csharpPINVOKE.Token_getSpacesAfter(swigCPtr); + return ret; + } + + public void setSpacesAfter(string spaces_after) { + udpipe_csharpPINVOKE.Token_setSpacesAfter(swigCPtr, spaces_after); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public string getSpacesInToken() { + string ret = udpipe_csharpPINVOKE.Token_getSpacesInToken(swigCPtr); + return ret; + } + + public void setSpacesInToken(string spaces_in_token) { + udpipe_csharpPINVOKE.Token_setSpacesInToken(swigCPtr, spaces_in_token); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public bool getTokenRange() { + bool ret = udpipe_csharpPINVOKE.Token_getTokenRange(swigCPtr); + return ret; + } + + public uint getTokenRangeStart() { + uint ret = udpipe_csharpPINVOKE.Token_getTokenRangeStart(swigCPtr); + return ret; + } + + public uint getTokenRangeEnd() { + uint ret = udpipe_csharpPINVOKE.Token_getTokenRangeEnd(swigCPtr); + return ret; + } + + public void setTokenRange(uint start, uint end) { + udpipe_csharpPINVOKE.Token_setTokenRange(swigCPtr, start, end); + } + +} + +} diff --git a/UDPipe/v1/binary/win64/csharp/Ufal/UDPipe/Trainer.cs b/UDPipe/v1/binary/win64/csharp/Ufal/UDPipe/Trainer.cs new file mode 100644 index 0000000000000000000000000000000000000000..31dcaada1065b721d6e5c757087b3f7f20423273 --- /dev/null +++ b/UDPipe/v1/binary/win64/csharp/Ufal/UDPipe/Trainer.cs @@ -0,0 +1,74 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +public class Trainer : global::System.IDisposable { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal Trainer(global::System.IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Trainer obj) { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + ~Trainer() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != global::System.IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + udpipe_csharpPINVOKE.delete_Trainer(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + global::System.GC.SuppressFinalize(this); + } + } + + public static string train(string method, Sentences train, Sentences heldout, string tokenizer, string tagger, string parser, ProcessingError error) { + string ret = udpipe_csharpPINVOKE.Trainer_train__SWIG_0(method, Sentences.getCPtr(train), Sentences.getCPtr(heldout), tokenizer, tagger, parser, ProcessingError.getCPtr(error)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public static string train(string method, Sentences train, Sentences heldout, string tokenizer, string tagger, string parser) { + string ret = udpipe_csharpPINVOKE.Trainer_train__SWIG_1(method, Sentences.getCPtr(train), Sentences.getCPtr(heldout), tokenizer, tagger, parser); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public static string DEFAULT { + get { + string ret = udpipe_csharpPINVOKE.Trainer_DEFAULT_get(); + return ret; + } + } + + public static string NONE { + get { + string ret = udpipe_csharpPINVOKE.Trainer_NONE_get(); + return ret; + } + } + + public Trainer() : this(udpipe_csharpPINVOKE.new_Trainer(), true) { + } + +} + +} diff --git a/UDPipe/v1/binary/win64/csharp/Ufal/UDPipe/Version.cs b/UDPipe/v1/binary/win64/csharp/Ufal/UDPipe/Version.cs new file mode 100644 index 0000000000000000000000000000000000000000..39434dd0ed3e5d35f59618ef7b418a5f4fcc4e21 --- /dev/null +++ b/UDPipe/v1/binary/win64/csharp/Ufal/UDPipe/Version.cs @@ -0,0 +1,95 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +public class Version : global::System.IDisposable { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal Version(global::System.IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Version obj) { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + ~Version() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != global::System.IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + udpipe_csharpPINVOKE.delete_Version(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + global::System.GC.SuppressFinalize(this); + } + } + + public uint major { + set { + udpipe_csharpPINVOKE.Version_major_set(swigCPtr, value); + } + get { + uint ret = udpipe_csharpPINVOKE.Version_major_get(swigCPtr); + return ret; + } + } + + public uint minor { + set { + udpipe_csharpPINVOKE.Version_minor_set(swigCPtr, value); + } + get { + uint ret = udpipe_csharpPINVOKE.Version_minor_get(swigCPtr); + return ret; + } + } + + public uint patch { + set { + udpipe_csharpPINVOKE.Version_patch_set(swigCPtr, value); + } + get { + uint ret = udpipe_csharpPINVOKE.Version_patch_get(swigCPtr); + return ret; + } + } + + public string prerelease { + set { + udpipe_csharpPINVOKE.Version_prerelease_set(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + get { + string ret = udpipe_csharpPINVOKE.Version_prerelease_get(swigCPtr); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + } + + public static Version current() { + Version ret = new Version(udpipe_csharpPINVOKE.Version_current(), true); + return ret; + } + + public Version() : this(udpipe_csharpPINVOKE.new_Version(), true) { + } + +} + +} diff --git a/UDPipe/v1/binary/win64/csharp/Ufal/UDPipe/Word.cs b/UDPipe/v1/binary/win64/csharp/Ufal/UDPipe/Word.cs new file mode 100644 index 0000000000000000000000000000000000000000..e0177d90469e6240406b14abcc1e06cb56536de2 --- /dev/null +++ b/UDPipe/v1/binary/win64/csharp/Ufal/UDPipe/Word.cs @@ -0,0 +1,157 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +public class Word : Token { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + + internal Word(global::System.IntPtr cPtr, bool cMemoryOwn) : base(udpipe_csharpPINVOKE.Word_SWIGUpcast(cPtr), cMemoryOwn) { + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Word obj) { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + ~Word() { + Dispose(); + } + + public override void Dispose() { + lock(this) { + if (swigCPtr.Handle != global::System.IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + udpipe_csharpPINVOKE.delete_Word(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + global::System.GC.SuppressFinalize(this); + base.Dispose(); + } + } + + public int id { + set { + udpipe_csharpPINVOKE.Word_id_set(swigCPtr, value); + } + get { + int ret = udpipe_csharpPINVOKE.Word_id_get(swigCPtr); + return ret; + } + } + + public string lemma { + set { + udpipe_csharpPINVOKE.Word_lemma_set(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + get { + string ret = udpipe_csharpPINVOKE.Word_lemma_get(swigCPtr); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + } + + public string upostag { + set { + udpipe_csharpPINVOKE.Word_upostag_set(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + get { + string ret = udpipe_csharpPINVOKE.Word_upostag_get(swigCPtr); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + } + + public string xpostag { + set { + udpipe_csharpPINVOKE.Word_xpostag_set(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + get { + string ret = udpipe_csharpPINVOKE.Word_xpostag_get(swigCPtr); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + } + + public string feats { + set { + udpipe_csharpPINVOKE.Word_feats_set(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + get { + string ret = udpipe_csharpPINVOKE.Word_feats_get(swigCPtr); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + } + + public int head { + set { + udpipe_csharpPINVOKE.Word_head_set(swigCPtr, value); + } + get { + int ret = udpipe_csharpPINVOKE.Word_head_get(swigCPtr); + return ret; + } + } + + public string deprel { + set { + udpipe_csharpPINVOKE.Word_deprel_set(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + get { + string ret = udpipe_csharpPINVOKE.Word_deprel_get(swigCPtr); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + } + + public string deps { + set { + udpipe_csharpPINVOKE.Word_deps_set(swigCPtr, value); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + get { + string ret = udpipe_csharpPINVOKE.Word_deps_get(swigCPtr); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + } + + public Children children { + set { + udpipe_csharpPINVOKE.Word_children_set(swigCPtr, Children.getCPtr(value)); + } + get { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.Word_children_get(swigCPtr); + Children ret = (cPtr == global::System.IntPtr.Zero) ? null : new Children(cPtr, false); + return ret; + } + } + + public Word(int id, string form) : this(udpipe_csharpPINVOKE.new_Word__SWIG_0(id, form), true) { + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public Word(int id) : this(udpipe_csharpPINVOKE.new_Word__SWIG_1(id), true) { + } + + public Word() : this(udpipe_csharpPINVOKE.new_Word__SWIG_2(), true) { + } + +} + +} diff --git a/UDPipe/v1/binary/win64/csharp/Ufal/UDPipe/Words.cs b/UDPipe/v1/binary/win64/csharp/Ufal/UDPipe/Words.cs new file mode 100644 index 0000000000000000000000000000000000000000..01c91c83ca10a20e497356a75fcb6a266e423360 --- /dev/null +++ b/UDPipe/v1/binary/win64/csharp/Ufal/UDPipe/Words.cs @@ -0,0 +1,309 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +public class Words : global::System.IDisposable, global::System.Collections.IEnumerable + , global::System.Collections.Generic.IEnumerable + { + private global::System.Runtime.InteropServices.HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal Words(global::System.IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr); + } + + internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Words obj) { + return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr; + } + + ~Words() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != global::System.IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + udpipe_csharpPINVOKE.delete_Words(swigCPtr); + } + swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero); + } + global::System.GC.SuppressFinalize(this); + } + } + + public Words(global::System.Collections.ICollection c) : this() { + if (c == null) + throw new global::System.ArgumentNullException("c"); + foreach (Word element in c) { + this.Add(element); + } + } + + public bool IsFixedSize { + get { + return false; + } + } + + public bool IsReadOnly { + get { + return false; + } + } + + public Word this[int index] { + get { + return getitem(index); + } + set { + setitem(index, value); + } + } + + public int Capacity { + get { + return (int)capacity(); + } + set { + if (value < size()) + throw new global::System.ArgumentOutOfRangeException("Capacity"); + reserve((uint)value); + } + } + + public int Count { + get { + return (int)size(); + } + } + + public bool IsSynchronized { + get { + return false; + } + } + + public void CopyTo(Word[] array) + { + CopyTo(0, array, 0, this.Count); + } + + public void CopyTo(Word[] array, int arrayIndex) + { + CopyTo(0, array, arrayIndex, this.Count); + } + + public void CopyTo(int index, Word[] array, int arrayIndex, int count) + { + if (array == null) + throw new global::System.ArgumentNullException("array"); + if (index < 0) + throw new global::System.ArgumentOutOfRangeException("index", "Value is less than zero"); + if (arrayIndex < 0) + throw new global::System.ArgumentOutOfRangeException("arrayIndex", "Value is less than zero"); + if (count < 0) + throw new global::System.ArgumentOutOfRangeException("count", "Value is less than zero"); + if (array.Rank > 1) + throw new global::System.ArgumentException("Multi dimensional array.", "array"); + if (index+count > this.Count || arrayIndex+count > array.Length) + throw new global::System.ArgumentException("Number of elements to copy is too large."); + for (int i=0; i global::System.Collections.Generic.IEnumerable.GetEnumerator() { + return new WordsEnumerator(this); + } + + global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator() { + return new WordsEnumerator(this); + } + + public WordsEnumerator GetEnumerator() { + return new WordsEnumerator(this); + } + + // Type-safe enumerator + /// Note that the IEnumerator documentation requires an InvalidOperationException to be thrown + /// whenever the collection is modified. This has been done for changes in the size of the + /// collection but not when one of the elements of the collection is modified as it is a bit + /// tricky to detect unmanaged code that modifies the collection under our feet. + public sealed class WordsEnumerator : global::System.Collections.IEnumerator + , global::System.Collections.Generic.IEnumerator + { + private Words collectionRef; + private int currentIndex; + private object currentObject; + private int currentSize; + + public WordsEnumerator(Words collection) { + collectionRef = collection; + currentIndex = -1; + currentObject = null; + currentSize = collectionRef.Count; + } + + // Type-safe iterator Current + public Word Current { + get { + if (currentIndex == -1) + throw new global::System.InvalidOperationException("Enumeration not started."); + if (currentIndex > currentSize - 1) + throw new global::System.InvalidOperationException("Enumeration finished."); + if (currentObject == null) + throw new global::System.InvalidOperationException("Collection modified."); + return (Word)currentObject; + } + } + + // Type-unsafe IEnumerator.Current + object global::System.Collections.IEnumerator.Current { + get { + return Current; + } + } + + public bool MoveNext() { + int size = collectionRef.Count; + bool moveOkay = (currentIndex+1 < size) && (size == currentSize); + if (moveOkay) { + currentIndex++; + currentObject = collectionRef[currentIndex]; + } else { + currentObject = null; + } + return moveOkay; + } + + public void Reset() { + currentIndex = -1; + currentObject = null; + if (collectionRef.Count != currentSize) { + throw new global::System.InvalidOperationException("Collection modified."); + } + } + + public void Dispose() { + currentIndex = -1; + currentObject = null; + } + } + + public void Clear() { + udpipe_csharpPINVOKE.Words_Clear(swigCPtr); + } + + public void Add(Word x) { + udpipe_csharpPINVOKE.Words_Add(swigCPtr, Word.getCPtr(x)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + private uint size() { + uint ret = udpipe_csharpPINVOKE.Words_size(swigCPtr); + return ret; + } + + private uint capacity() { + uint ret = udpipe_csharpPINVOKE.Words_capacity(swigCPtr); + return ret; + } + + private void reserve(uint n) { + udpipe_csharpPINVOKE.Words_reserve(swigCPtr, n); + } + + public Words() : this(udpipe_csharpPINVOKE.new_Words__SWIG_0(), true) { + } + + public Words(Words other) : this(udpipe_csharpPINVOKE.new_Words__SWIG_1(Words.getCPtr(other)), true) { + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public Words(int capacity) : this(udpipe_csharpPINVOKE.new_Words__SWIG_2(capacity), true) { + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + private Word getitemcopy(int index) { + Word ret = new Word(udpipe_csharpPINVOKE.Words_getitemcopy(swigCPtr, index), true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + private Word getitem(int index) { + Word ret = new Word(udpipe_csharpPINVOKE.Words_getitem(swigCPtr, index), false); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + private void setitem(int index, Word val) { + udpipe_csharpPINVOKE.Words_setitem(swigCPtr, index, Word.getCPtr(val)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void AddRange(Words values) { + udpipe_csharpPINVOKE.Words_AddRange(swigCPtr, Words.getCPtr(values)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public Words GetRange(int index, int count) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.Words_GetRange(swigCPtr, index, count); + Words ret = (cPtr == global::System.IntPtr.Zero) ? null : new Words(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public void Insert(int index, Word x) { + udpipe_csharpPINVOKE.Words_Insert(swigCPtr, index, Word.getCPtr(x)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void InsertRange(int index, Words values) { + udpipe_csharpPINVOKE.Words_InsertRange(swigCPtr, index, Words.getCPtr(values)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void RemoveAt(int index) { + udpipe_csharpPINVOKE.Words_RemoveAt(swigCPtr, index); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void RemoveRange(int index, int count) { + udpipe_csharpPINVOKE.Words_RemoveRange(swigCPtr, index, count); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public static Words Repeat(Word value, int count) { + global::System.IntPtr cPtr = udpipe_csharpPINVOKE.Words_Repeat(Word.getCPtr(value), count); + Words ret = (cPtr == global::System.IntPtr.Zero) ? null : new Words(cPtr, true); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public void Reverse() { + udpipe_csharpPINVOKE.Words_Reverse__SWIG_0(swigCPtr); + } + + public void Reverse(int index, int count) { + udpipe_csharpPINVOKE.Words_Reverse__SWIG_1(swigCPtr, index, count); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + + public void SetRange(int index, Words values) { + udpipe_csharpPINVOKE.Words_SetRange(swigCPtr, index, Words.getCPtr(values)); + if (udpipe_csharpPINVOKE.SWIGPendingException.Pending) throw udpipe_csharpPINVOKE.SWIGPendingException.Retrieve(); + } + +} + +} diff --git a/UDPipe/v1/binary/win64/csharp/Ufal/UDPipe/udpipe_csharp.cs b/UDPipe/v1/binary/win64/csharp/Ufal/UDPipe/udpipe_csharp.cs new file mode 100644 index 0000000000000000000000000000000000000000..01d55de404b051d95e99a2ed6741fcdc0cefa6f7 --- /dev/null +++ b/UDPipe/v1/binary/win64/csharp/Ufal/UDPipe/udpipe_csharp.cs @@ -0,0 +1,16 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +public class udpipe_csharp { +} + +} diff --git a/UDPipe/v1/binary/win64/csharp/Ufal/UDPipe/udpipe_csharpPINVOKE.cs b/UDPipe/v1/binary/win64/csharp/Ufal/UDPipe/udpipe_csharpPINVOKE.cs new file mode 100644 index 0000000000000000000000000000000000000000..08fb1041bc999961dae5278a4ac3e5df51b672ea --- /dev/null +++ b/UDPipe/v1/binary/win64/csharp/Ufal/UDPipe/udpipe_csharpPINVOKE.cs @@ -0,0 +1,1324 @@ +//------------------------------------------------------------------------------ +// +// +// This file was automatically generated by SWIG (http://www.swig.org). +// Version 3.0.8 +// +// Do not make changes to this file unless you know what you are doing--modify +// the SWIG interface file instead. +//------------------------------------------------------------------------------ + +namespace Ufal.UDPipe { + +class udpipe_csharpPINVOKE { + + protected class SWIGExceptionHelper { + + public delegate void ExceptionDelegate(string message); + public delegate void ExceptionArgumentDelegate(string message, string paramName); + + static ExceptionDelegate applicationDelegate = new ExceptionDelegate(SetPendingApplicationException); + static ExceptionDelegate arithmeticDelegate = new ExceptionDelegate(SetPendingArithmeticException); + static ExceptionDelegate divideByZeroDelegate = new ExceptionDelegate(SetPendingDivideByZeroException); + static ExceptionDelegate indexOutOfRangeDelegate = new ExceptionDelegate(SetPendingIndexOutOfRangeException); + static ExceptionDelegate invalidCastDelegate = new ExceptionDelegate(SetPendingInvalidCastException); + static ExceptionDelegate invalidOperationDelegate = new ExceptionDelegate(SetPendingInvalidOperationException); + static ExceptionDelegate ioDelegate = new ExceptionDelegate(SetPendingIOException); + static ExceptionDelegate nullReferenceDelegate = new ExceptionDelegate(SetPendingNullReferenceException); + static ExceptionDelegate outOfMemoryDelegate = new ExceptionDelegate(SetPendingOutOfMemoryException); + static ExceptionDelegate overflowDelegate = new ExceptionDelegate(SetPendingOverflowException); + static ExceptionDelegate systemDelegate = new ExceptionDelegate(SetPendingSystemException); + + static ExceptionArgumentDelegate argumentDelegate = new ExceptionArgumentDelegate(SetPendingArgumentException); + static ExceptionArgumentDelegate argumentNullDelegate = new ExceptionArgumentDelegate(SetPendingArgumentNullException); + static ExceptionArgumentDelegate argumentOutOfRangeDelegate = new ExceptionArgumentDelegate(SetPendingArgumentOutOfRangeException); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="SWIGRegisterExceptionCallbacks_udpipe_csharp")] + public static extern void SWIGRegisterExceptionCallbacks_udpipe_csharp( + ExceptionDelegate applicationDelegate, + ExceptionDelegate arithmeticDelegate, + ExceptionDelegate divideByZeroDelegate, + ExceptionDelegate indexOutOfRangeDelegate, + ExceptionDelegate invalidCastDelegate, + ExceptionDelegate invalidOperationDelegate, + ExceptionDelegate ioDelegate, + ExceptionDelegate nullReferenceDelegate, + ExceptionDelegate outOfMemoryDelegate, + ExceptionDelegate overflowDelegate, + ExceptionDelegate systemExceptionDelegate); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="SWIGRegisterExceptionArgumentCallbacks_udpipe_csharp")] + public static extern void SWIGRegisterExceptionCallbacksArgument_udpipe_csharp( + ExceptionArgumentDelegate argumentDelegate, + ExceptionArgumentDelegate argumentNullDelegate, + ExceptionArgumentDelegate argumentOutOfRangeDelegate); + + static void SetPendingApplicationException(string message) { + SWIGPendingException.Set(new global::System.ApplicationException(message, SWIGPendingException.Retrieve())); + } + static void SetPendingArithmeticException(string message) { + SWIGPendingException.Set(new global::System.ArithmeticException(message, SWIGPendingException.Retrieve())); + } + static void SetPendingDivideByZeroException(string message) { + SWIGPendingException.Set(new global::System.DivideByZeroException(message, SWIGPendingException.Retrieve())); + } + static void SetPendingIndexOutOfRangeException(string message) { + SWIGPendingException.Set(new global::System.IndexOutOfRangeException(message, SWIGPendingException.Retrieve())); + } + static void SetPendingInvalidCastException(string message) { + SWIGPendingException.Set(new global::System.InvalidCastException(message, SWIGPendingException.Retrieve())); + } + static void SetPendingInvalidOperationException(string message) { + SWIGPendingException.Set(new global::System.InvalidOperationException(message, SWIGPendingException.Retrieve())); + } + static void SetPendingIOException(string message) { + SWIGPendingException.Set(new global::System.IO.IOException(message, SWIGPendingException.Retrieve())); + } + static void SetPendingNullReferenceException(string message) { + SWIGPendingException.Set(new global::System.NullReferenceException(message, SWIGPendingException.Retrieve())); + } + static void SetPendingOutOfMemoryException(string message) { + SWIGPendingException.Set(new global::System.OutOfMemoryException(message, SWIGPendingException.Retrieve())); + } + static void SetPendingOverflowException(string message) { + SWIGPendingException.Set(new global::System.OverflowException(message, SWIGPendingException.Retrieve())); + } + static void SetPendingSystemException(string message) { + SWIGPendingException.Set(new global::System.SystemException(message, SWIGPendingException.Retrieve())); + } + + static void SetPendingArgumentException(string message, string paramName) { + SWIGPendingException.Set(new global::System.ArgumentException(message, paramName, SWIGPendingException.Retrieve())); + } + static void SetPendingArgumentNullException(string message, string paramName) { + global::System.Exception e = SWIGPendingException.Retrieve(); + if (e != null) message = message + " Inner Exception: " + e.Message; + SWIGPendingException.Set(new global::System.ArgumentNullException(paramName, message)); + } + static void SetPendingArgumentOutOfRangeException(string message, string paramName) { + global::System.Exception e = SWIGPendingException.Retrieve(); + if (e != null) message = message + " Inner Exception: " + e.Message; + SWIGPendingException.Set(new global::System.ArgumentOutOfRangeException(paramName, message)); + } + + static SWIGExceptionHelper() { + SWIGRegisterExceptionCallbacks_udpipe_csharp( + applicationDelegate, + arithmeticDelegate, + divideByZeroDelegate, + indexOutOfRangeDelegate, + invalidCastDelegate, + invalidOperationDelegate, + ioDelegate, + nullReferenceDelegate, + outOfMemoryDelegate, + overflowDelegate, + systemDelegate); + + SWIGRegisterExceptionCallbacksArgument_udpipe_csharp( + argumentDelegate, + argumentNullDelegate, + argumentOutOfRangeDelegate); + } + } + + protected static SWIGExceptionHelper swigExceptionHelper = new SWIGExceptionHelper(); + + public class SWIGPendingException { + [global::System.ThreadStatic] + private static global::System.Exception pendingException = null; + private static int numExceptionsPending = 0; + + public static bool Pending { + get { + bool pending = false; + if (numExceptionsPending > 0) + if (pendingException != null) + pending = true; + return pending; + } + } + + public static void Set(global::System.Exception e) { + if (pendingException != null) + throw new global::System.ApplicationException("FATAL: An earlier pending exception from unmanaged code was missed and thus not thrown (" + pendingException.ToString() + ")", e); + pendingException = e; + lock(typeof(udpipe_csharpPINVOKE)) { + numExceptionsPending++; + } + } + + public static global::System.Exception Retrieve() { + global::System.Exception e = null; + if (numExceptionsPending > 0) { + if (pendingException != null) { + e = pendingException; + pendingException = null; + lock(typeof(udpipe_csharpPINVOKE)) { + numExceptionsPending--; + } + } + } + return e; + } + } + + + protected class SWIGStringHelper { + + public delegate string SWIGStringDelegate(string message); + static SWIGStringDelegate stringDelegate = new SWIGStringDelegate(CreateString); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="SWIGRegisterStringCallback_udpipe_csharp")] + public static extern void SWIGRegisterStringCallback_udpipe_csharp(SWIGStringDelegate stringDelegate); + + static string CreateString(string cString) { + return cString; + } + + static SWIGStringHelper() { + SWIGRegisterStringCallback_udpipe_csharp(stringDelegate); + } + } + + static protected SWIGStringHelper swigStringHelper = new SWIGStringHelper(); + + + static udpipe_csharpPINVOKE() { + } + + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_Clear")] + public static extern void Children_Clear(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_Add")] + public static extern void Children_Add(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_size")] + public static extern uint Children_size(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_capacity")] + public static extern uint Children_capacity(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_reserve")] + public static extern void Children_reserve(global::System.Runtime.InteropServices.HandleRef jarg1, uint jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Children__SWIG_0")] + public static extern global::System.IntPtr new_Children__SWIG_0(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Children__SWIG_1")] + public static extern global::System.IntPtr new_Children__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Children__SWIG_2")] + public static extern global::System.IntPtr new_Children__SWIG_2(int jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_getitemcopy")] + public static extern int Children_getitemcopy(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_getitem")] + public static extern int Children_getitem(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_setitem")] + public static extern void Children_setitem(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_AddRange")] + public static extern void Children_AddRange(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_GetRange")] + public static extern global::System.IntPtr Children_GetRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_Insert")] + public static extern void Children_Insert(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_InsertRange")] + public static extern void Children_InsertRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_RemoveAt")] + public static extern void Children_RemoveAt(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_RemoveRange")] + public static extern void Children_RemoveRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_Repeat")] + public static extern global::System.IntPtr Children_Repeat(int jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_Reverse__SWIG_0")] + public static extern void Children_Reverse__SWIG_0(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_Reverse__SWIG_1")] + public static extern void Children_Reverse__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_SetRange")] + public static extern void Children_SetRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_Contains")] + public static extern bool Children_Contains(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_IndexOf")] + public static extern int Children_IndexOf(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_LastIndexOf")] + public static extern int Children_LastIndexOf(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Children_Remove")] + public static extern bool Children_Remove(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_delete_Children")] + public static extern void delete_Children(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_Clear")] + public static extern void Comments_Clear(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_Add")] + public static extern void Comments_Add(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_size")] + public static extern uint Comments_size(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_capacity")] + public static extern uint Comments_capacity(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_reserve")] + public static extern void Comments_reserve(global::System.Runtime.InteropServices.HandleRef jarg1, uint jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Comments__SWIG_0")] + public static extern global::System.IntPtr new_Comments__SWIG_0(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Comments__SWIG_1")] + public static extern global::System.IntPtr new_Comments__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Comments__SWIG_2")] + public static extern global::System.IntPtr new_Comments__SWIG_2(int jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_getitemcopy")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Comments_getitemcopy(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_getitem")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Comments_getitem(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_setitem")] + public static extern void Comments_setitem(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_AddRange")] + public static extern void Comments_AddRange(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_GetRange")] + public static extern global::System.IntPtr Comments_GetRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_Insert")] + public static extern void Comments_Insert(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_InsertRange")] + public static extern void Comments_InsertRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_RemoveAt")] + public static extern void Comments_RemoveAt(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_RemoveRange")] + public static extern void Comments_RemoveRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_Repeat")] + public static extern global::System.IntPtr Comments_Repeat([global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_Reverse__SWIG_0")] + public static extern void Comments_Reverse__SWIG_0(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_Reverse__SWIG_1")] + public static extern void Comments_Reverse__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_SetRange")] + public static extern void Comments_SetRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_Contains")] + public static extern bool Comments_Contains(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_IndexOf")] + public static extern int Comments_IndexOf(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_LastIndexOf")] + public static extern int Comments_LastIndexOf(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Comments_Remove")] + public static extern bool Comments_Remove(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_delete_Comments")] + public static extern void delete_Comments(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_ProcessingError_occurred")] + public static extern bool ProcessingError_occurred(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_ProcessingError_message_set")] + public static extern void ProcessingError_message_set(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_ProcessingError_message_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string ProcessingError_message_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_ProcessingError")] + public static extern global::System.IntPtr new_ProcessingError(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_delete_ProcessingError")] + public static extern void delete_ProcessingError(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Token_form_set")] + public static extern void Token_form_set(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Token_form_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Token_form_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Token_misc_set")] + public static extern void Token_misc_set(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Token_misc_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Token_misc_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Token__SWIG_0")] + public static extern global::System.IntPtr new_Token__SWIG_0([global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Token__SWIG_1")] + public static extern global::System.IntPtr new_Token__SWIG_1([global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Token__SWIG_2")] + public static extern global::System.IntPtr new_Token__SWIG_2(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Token_getSpaceAfter")] + public static extern bool Token_getSpaceAfter(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Token_setSpaceAfter")] + public static extern void Token_setSpaceAfter(global::System.Runtime.InteropServices.HandleRef jarg1, bool jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Token_getSpacesBefore")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Token_getSpacesBefore(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Token_setSpacesBefore")] + public static extern void Token_setSpacesBefore(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Token_getSpacesAfter")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Token_getSpacesAfter(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Token_setSpacesAfter")] + public static extern void Token_setSpacesAfter(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Token_getSpacesInToken")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Token_getSpacesInToken(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Token_setSpacesInToken")] + public static extern void Token_setSpacesInToken(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Token_getTokenRange")] + public static extern bool Token_getTokenRange(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Token_getTokenRangeStart")] + public static extern uint Token_getTokenRangeStart(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Token_getTokenRangeEnd")] + public static extern uint Token_getTokenRangeEnd(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Token_setTokenRange")] + public static extern void Token_setTokenRange(global::System.Runtime.InteropServices.HandleRef jarg1, uint jarg2, uint jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_delete_Token")] + public static extern void delete_Token(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Word_id_set")] + public static extern void Word_id_set(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Word_id_get")] + public static extern int Word_id_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Word_lemma_set")] + public static extern void Word_lemma_set(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Word_lemma_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Word_lemma_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Word_upostag_set")] + public static extern void Word_upostag_set(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Word_upostag_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Word_upostag_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Word_xpostag_set")] + public static extern void Word_xpostag_set(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Word_xpostag_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Word_xpostag_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Word_feats_set")] + public static extern void Word_feats_set(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Word_feats_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Word_feats_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Word_head_set")] + public static extern void Word_head_set(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Word_head_get")] + public static extern int Word_head_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Word_deprel_set")] + public static extern void Word_deprel_set(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Word_deprel_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Word_deprel_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Word_deps_set")] + public static extern void Word_deps_set(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Word_deps_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Word_deps_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Word_children_set")] + public static extern void Word_children_set(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Word_children_get")] + public static extern global::System.IntPtr Word_children_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Word__SWIG_0")] + public static extern global::System.IntPtr new_Word__SWIG_0(int jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Word__SWIG_1")] + public static extern global::System.IntPtr new_Word__SWIG_1(int jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Word__SWIG_2")] + public static extern global::System.IntPtr new_Word__SWIG_2(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_delete_Word")] + public static extern void delete_Word(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Words_Clear")] + public static extern void Words_Clear(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Words_Add")] + public static extern void Words_Add(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Words_size")] + public static extern uint Words_size(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Words_capacity")] + public static extern uint Words_capacity(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Words_reserve")] + public static extern void Words_reserve(global::System.Runtime.InteropServices.HandleRef jarg1, uint jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Words__SWIG_0")] + public static extern global::System.IntPtr new_Words__SWIG_0(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Words__SWIG_1")] + public static extern global::System.IntPtr new_Words__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Words__SWIG_2")] + public static extern global::System.IntPtr new_Words__SWIG_2(int jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Words_getitemcopy")] + public static extern global::System.IntPtr Words_getitemcopy(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Words_getitem")] + public static extern global::System.IntPtr Words_getitem(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Words_setitem")] + public static extern void Words_setitem(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Words_AddRange")] + public static extern void Words_AddRange(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Words_GetRange")] + public static extern global::System.IntPtr Words_GetRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Words_Insert")] + public static extern void Words_Insert(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Words_InsertRange")] + public static extern void Words_InsertRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Words_RemoveAt")] + public static extern void Words_RemoveAt(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Words_RemoveRange")] + public static extern void Words_RemoveRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Words_Repeat")] + public static extern global::System.IntPtr Words_Repeat(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Words_Reverse__SWIG_0")] + public static extern void Words_Reverse__SWIG_0(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Words_Reverse__SWIG_1")] + public static extern void Words_Reverse__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Words_SetRange")] + public static extern void Words_SetRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_delete_Words")] + public static extern void delete_Words(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordToken_idFirst_set")] + public static extern void MultiwordToken_idFirst_set(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordToken_idFirst_get")] + public static extern int MultiwordToken_idFirst_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordToken_idLast_set")] + public static extern void MultiwordToken_idLast_set(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordToken_idLast_get")] + public static extern int MultiwordToken_idLast_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_MultiwordToken__SWIG_0")] + public static extern global::System.IntPtr new_MultiwordToken__SWIG_0(int jarg1, int jarg2, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg3, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg4); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_MultiwordToken__SWIG_1")] + public static extern global::System.IntPtr new_MultiwordToken__SWIG_1(int jarg1, int jarg2, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_MultiwordToken__SWIG_2")] + public static extern global::System.IntPtr new_MultiwordToken__SWIG_2(int jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_MultiwordToken__SWIG_3")] + public static extern global::System.IntPtr new_MultiwordToken__SWIG_3(int jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_MultiwordToken__SWIG_4")] + public static extern global::System.IntPtr new_MultiwordToken__SWIG_4(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_delete_MultiwordToken")] + public static extern void delete_MultiwordToken(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordTokens_Clear")] + public static extern void MultiwordTokens_Clear(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordTokens_Add")] + public static extern void MultiwordTokens_Add(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordTokens_size")] + public static extern uint MultiwordTokens_size(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordTokens_capacity")] + public static extern uint MultiwordTokens_capacity(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordTokens_reserve")] + public static extern void MultiwordTokens_reserve(global::System.Runtime.InteropServices.HandleRef jarg1, uint jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_MultiwordTokens__SWIG_0")] + public static extern global::System.IntPtr new_MultiwordTokens__SWIG_0(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_MultiwordTokens__SWIG_1")] + public static extern global::System.IntPtr new_MultiwordTokens__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_MultiwordTokens__SWIG_2")] + public static extern global::System.IntPtr new_MultiwordTokens__SWIG_2(int jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordTokens_getitemcopy")] + public static extern global::System.IntPtr MultiwordTokens_getitemcopy(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordTokens_getitem")] + public static extern global::System.IntPtr MultiwordTokens_getitem(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordTokens_setitem")] + public static extern void MultiwordTokens_setitem(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordTokens_AddRange")] + public static extern void MultiwordTokens_AddRange(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordTokens_GetRange")] + public static extern global::System.IntPtr MultiwordTokens_GetRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordTokens_Insert")] + public static extern void MultiwordTokens_Insert(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordTokens_InsertRange")] + public static extern void MultiwordTokens_InsertRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordTokens_RemoveAt")] + public static extern void MultiwordTokens_RemoveAt(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordTokens_RemoveRange")] + public static extern void MultiwordTokens_RemoveRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordTokens_Repeat")] + public static extern global::System.IntPtr MultiwordTokens_Repeat(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordTokens_Reverse__SWIG_0")] + public static extern void MultiwordTokens_Reverse__SWIG_0(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordTokens_Reverse__SWIG_1")] + public static extern void MultiwordTokens_Reverse__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordTokens_SetRange")] + public static extern void MultiwordTokens_SetRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_delete_MultiwordTokens")] + public static extern void delete_MultiwordTokens(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNode_id_set")] + public static extern void EmptyNode_id_set(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNode_id_get")] + public static extern int EmptyNode_id_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNode_index_set")] + public static extern void EmptyNode_index_set(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNode_index_get")] + public static extern int EmptyNode_index_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNode_form_set")] + public static extern void EmptyNode_form_set(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNode_form_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string EmptyNode_form_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNode_lemma_set")] + public static extern void EmptyNode_lemma_set(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNode_lemma_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string EmptyNode_lemma_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNode_upostag_set")] + public static extern void EmptyNode_upostag_set(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNode_upostag_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string EmptyNode_upostag_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNode_xpostag_set")] + public static extern void EmptyNode_xpostag_set(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNode_xpostag_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string EmptyNode_xpostag_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNode_feats_set")] + public static extern void EmptyNode_feats_set(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNode_feats_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string EmptyNode_feats_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNode_deps_set")] + public static extern void EmptyNode_deps_set(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNode_deps_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string EmptyNode_deps_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNode_misc_set")] + public static extern void EmptyNode_misc_set(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNode_misc_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string EmptyNode_misc_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_EmptyNode__SWIG_0")] + public static extern global::System.IntPtr new_EmptyNode__SWIG_0(int jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_EmptyNode__SWIG_1")] + public static extern global::System.IntPtr new_EmptyNode__SWIG_1(int jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_EmptyNode__SWIG_2")] + public static extern global::System.IntPtr new_EmptyNode__SWIG_2(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_delete_EmptyNode")] + public static extern void delete_EmptyNode(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNodes_Clear")] + public static extern void EmptyNodes_Clear(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNodes_Add")] + public static extern void EmptyNodes_Add(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNodes_size")] + public static extern uint EmptyNodes_size(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNodes_capacity")] + public static extern uint EmptyNodes_capacity(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNodes_reserve")] + public static extern void EmptyNodes_reserve(global::System.Runtime.InteropServices.HandleRef jarg1, uint jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_EmptyNodes__SWIG_0")] + public static extern global::System.IntPtr new_EmptyNodes__SWIG_0(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_EmptyNodes__SWIG_1")] + public static extern global::System.IntPtr new_EmptyNodes__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_EmptyNodes__SWIG_2")] + public static extern global::System.IntPtr new_EmptyNodes__SWIG_2(int jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNodes_getitemcopy")] + public static extern global::System.IntPtr EmptyNodes_getitemcopy(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNodes_getitem")] + public static extern global::System.IntPtr EmptyNodes_getitem(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNodes_setitem")] + public static extern void EmptyNodes_setitem(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNodes_AddRange")] + public static extern void EmptyNodes_AddRange(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNodes_GetRange")] + public static extern global::System.IntPtr EmptyNodes_GetRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNodes_Insert")] + public static extern void EmptyNodes_Insert(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNodes_InsertRange")] + public static extern void EmptyNodes_InsertRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNodes_RemoveAt")] + public static extern void EmptyNodes_RemoveAt(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNodes_RemoveRange")] + public static extern void EmptyNodes_RemoveRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNodes_Repeat")] + public static extern global::System.IntPtr EmptyNodes_Repeat(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNodes_Reverse__SWIG_0")] + public static extern void EmptyNodes_Reverse__SWIG_0(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNodes_Reverse__SWIG_1")] + public static extern void EmptyNodes_Reverse__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_EmptyNodes_SetRange")] + public static extern void EmptyNodes_SetRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_delete_EmptyNodes")] + public static extern void delete_EmptyNodes(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Sentence")] + public static extern global::System.IntPtr new_Sentence(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_words_set")] + public static extern void Sentence_words_set(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_words_get")] + public static extern global::System.IntPtr Sentence_words_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_multiwordTokens_set")] + public static extern void Sentence_multiwordTokens_set(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_multiwordTokens_get")] + public static extern global::System.IntPtr Sentence_multiwordTokens_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_emptyNodes_set")] + public static extern void Sentence_emptyNodes_set(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_emptyNodes_get")] + public static extern global::System.IntPtr Sentence_emptyNodes_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_comments_set")] + public static extern void Sentence_comments_set(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_comments_get")] + public static extern global::System.IntPtr Sentence_comments_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_rootForm_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Sentence_rootForm_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_empty")] + public static extern bool Sentence_empty(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_clear")] + public static extern void Sentence_clear(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_addWord")] + public static extern global::System.IntPtr Sentence_addWord(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_setHead")] + public static extern void Sentence_setHead(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg4); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_unlinkAllNodes")] + public static extern void Sentence_unlinkAllNodes(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_getNewDoc")] + public static extern bool Sentence_getNewDoc(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_getNewDocId")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Sentence_getNewDocId(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_setNewDoc__SWIG_0")] + public static extern void Sentence_setNewDoc__SWIG_0(global::System.Runtime.InteropServices.HandleRef jarg1, bool jarg2, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_setNewDoc__SWIG_1")] + public static extern void Sentence_setNewDoc__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1, bool jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_getNewPar")] + public static extern bool Sentence_getNewPar(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_getNewParId")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Sentence_getNewParId(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_setNewPar__SWIG_0")] + public static extern void Sentence_setNewPar__SWIG_0(global::System.Runtime.InteropServices.HandleRef jarg1, bool jarg2, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_setNewPar__SWIG_1")] + public static extern void Sentence_setNewPar__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1, bool jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_getSentId")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Sentence_getSentId(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_setSentId")] + public static extern void Sentence_setSentId(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_getText")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Sentence_getText(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentence_setText")] + public static extern void Sentence_setText(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_delete_Sentence")] + public static extern void delete_Sentence(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentences_Clear")] + public static extern void Sentences_Clear(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentences_Add")] + public static extern void Sentences_Add(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentences_size")] + public static extern uint Sentences_size(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentences_capacity")] + public static extern uint Sentences_capacity(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentences_reserve")] + public static extern void Sentences_reserve(global::System.Runtime.InteropServices.HandleRef jarg1, uint jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Sentences__SWIG_0")] + public static extern global::System.IntPtr new_Sentences__SWIG_0(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Sentences__SWIG_1")] + public static extern global::System.IntPtr new_Sentences__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Sentences__SWIG_2")] + public static extern global::System.IntPtr new_Sentences__SWIG_2(int jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentences_getitemcopy")] + public static extern global::System.IntPtr Sentences_getitemcopy(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentences_getitem")] + public static extern global::System.IntPtr Sentences_getitem(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentences_setitem")] + public static extern void Sentences_setitem(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentences_AddRange")] + public static extern void Sentences_AddRange(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentences_GetRange")] + public static extern global::System.IntPtr Sentences_GetRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentences_Insert")] + public static extern void Sentences_Insert(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentences_InsertRange")] + public static extern void Sentences_InsertRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentences_RemoveAt")] + public static extern void Sentences_RemoveAt(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentences_RemoveRange")] + public static extern void Sentences_RemoveRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentences_Repeat")] + public static extern global::System.IntPtr Sentences_Repeat(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentences_Reverse__SWIG_0")] + public static extern void Sentences_Reverse__SWIG_0(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentences_Reverse__SWIG_1")] + public static extern void Sentences_Reverse__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, int jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Sentences_SetRange")] + public static extern void Sentences_SetRange(global::System.Runtime.InteropServices.HandleRef jarg1, int jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_delete_Sentences")] + public static extern void delete_Sentences(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_delete_InputFormat")] + public static extern void delete_InputFormat(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_InputFormat_resetDocument__SWIG_0")] + public static extern void InputFormat_resetDocument__SWIG_0(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_InputFormat_resetDocument__SWIG_1")] + public static extern void InputFormat_resetDocument__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_InputFormat_setText")] + public static extern void InputFormat_setText(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_InputFormat_nextSentence__SWIG_0")] + public static extern bool InputFormat_nextSentence__SWIG_0(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_InputFormat_nextSentence__SWIG_1")] + public static extern bool InputFormat_nextSentence__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_InputFormat_newInputFormat")] + public static extern global::System.IntPtr InputFormat_newInputFormat([global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_InputFormat_newConlluInputFormat__SWIG_0")] + public static extern global::System.IntPtr InputFormat_newConlluInputFormat__SWIG_0([global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_InputFormat_newConlluInputFormat__SWIG_1")] + public static extern global::System.IntPtr InputFormat_newConlluInputFormat__SWIG_1(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_InputFormat_newGenericTokenizerInputFormat__SWIG_0")] + public static extern global::System.IntPtr InputFormat_newGenericTokenizerInputFormat__SWIG_0([global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_InputFormat_newGenericTokenizerInputFormat__SWIG_1")] + public static extern global::System.IntPtr InputFormat_newGenericTokenizerInputFormat__SWIG_1(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_InputFormat_newHorizontalInputFormat__SWIG_0")] + public static extern global::System.IntPtr InputFormat_newHorizontalInputFormat__SWIG_0([global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_InputFormat_newHorizontalInputFormat__SWIG_1")] + public static extern global::System.IntPtr InputFormat_newHorizontalInputFormat__SWIG_1(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_InputFormat_newVerticalInputFormat__SWIG_0")] + public static extern global::System.IntPtr InputFormat_newVerticalInputFormat__SWIG_0([global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_InputFormat_newVerticalInputFormat__SWIG_1")] + public static extern global::System.IntPtr InputFormat_newVerticalInputFormat__SWIG_1(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_InputFormat_newPresegmentedTokenizer")] + public static extern global::System.IntPtr InputFormat_newPresegmentedTokenizer(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_InputFormat_CONLLU_V1_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string InputFormat_CONLLU_V1_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_InputFormat_CONLLU_V2_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string InputFormat_CONLLU_V2_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_InputFormat_GENERIC_TOKENIZER_NORMALIZED_SPACES_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string InputFormat_GENERIC_TOKENIZER_NORMALIZED_SPACES_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_InputFormat_GENERIC_TOKENIZER_PRESEGMENTED_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string InputFormat_GENERIC_TOKENIZER_PRESEGMENTED_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_InputFormat_GENERIC_TOKENIZER_RANGES_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string InputFormat_GENERIC_TOKENIZER_RANGES_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_delete_OutputFormat")] + public static extern void delete_OutputFormat(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_OutputFormat_writeSentence")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string OutputFormat_writeSentence(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_OutputFormat_finishDocument")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string OutputFormat_finishDocument(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_OutputFormat_newOutputFormat")] + public static extern global::System.IntPtr OutputFormat_newOutputFormat([global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_OutputFormat_newConlluOutputFormat__SWIG_0")] + public static extern global::System.IntPtr OutputFormat_newConlluOutputFormat__SWIG_0([global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_OutputFormat_newConlluOutputFormat__SWIG_1")] + public static extern global::System.IntPtr OutputFormat_newConlluOutputFormat__SWIG_1(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_OutputFormat_newEpeOutputFormat__SWIG_0")] + public static extern global::System.IntPtr OutputFormat_newEpeOutputFormat__SWIG_0([global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_OutputFormat_newEpeOutputFormat__SWIG_1")] + public static extern global::System.IntPtr OutputFormat_newEpeOutputFormat__SWIG_1(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_OutputFormat_newMatxinOutputFormat__SWIG_0")] + public static extern global::System.IntPtr OutputFormat_newMatxinOutputFormat__SWIG_0([global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_OutputFormat_newMatxinOutputFormat__SWIG_1")] + public static extern global::System.IntPtr OutputFormat_newMatxinOutputFormat__SWIG_1(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_OutputFormat_newHorizontalOutputFormat__SWIG_0")] + public static extern global::System.IntPtr OutputFormat_newHorizontalOutputFormat__SWIG_0([global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_OutputFormat_newHorizontalOutputFormat__SWIG_1")] + public static extern global::System.IntPtr OutputFormat_newHorizontalOutputFormat__SWIG_1(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_OutputFormat_newPlaintextOutputFormat__SWIG_0")] + public static extern global::System.IntPtr OutputFormat_newPlaintextOutputFormat__SWIG_0([global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_OutputFormat_newPlaintextOutputFormat__SWIG_1")] + public static extern global::System.IntPtr OutputFormat_newPlaintextOutputFormat__SWIG_1(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_OutputFormat_newVerticalOutputFormat__SWIG_0")] + public static extern global::System.IntPtr OutputFormat_newVerticalOutputFormat__SWIG_0([global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_OutputFormat_newVerticalOutputFormat__SWIG_1")] + public static extern global::System.IntPtr OutputFormat_newVerticalOutputFormat__SWIG_1(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_OutputFormat_CONLLU_V1_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string OutputFormat_CONLLU_V1_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_OutputFormat_CONLLU_V2_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string OutputFormat_CONLLU_V2_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_OutputFormat_HORIZONTAL_PARAGRAPHS_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string OutputFormat_HORIZONTAL_PARAGRAPHS_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_OutputFormat_PLAINTEXT_NORMALIZED_SPACES_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string OutputFormat_PLAINTEXT_NORMALIZED_SPACES_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_OutputFormat_VERTICAL_PARAGRAPHS_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string OutputFormat_VERTICAL_PARAGRAPHS_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_delete_Model")] + public static extern void delete_Model(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Model_load")] + public static extern global::System.IntPtr Model_load([global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Model_newTokenizer")] + public static extern global::System.IntPtr Model_newTokenizer(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Model_tag__SWIG_0")] + public static extern bool Model_tag__SWIG_0(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg3, global::System.Runtime.InteropServices.HandleRef jarg4); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Model_tag__SWIG_1")] + public static extern bool Model_tag__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Model_parse__SWIG_0")] + public static extern bool Model_parse__SWIG_0(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg3, global::System.Runtime.InteropServices.HandleRef jarg4); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Model_parse__SWIG_1")] + public static extern bool Model_parse__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Model_DEFAULT_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Model_DEFAULT_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Model_TOKENIZER_NORMALIZED_SPACES_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Model_TOKENIZER_NORMALIZED_SPACES_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Model_TOKENIZER_PRESEGMENTED_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Model_TOKENIZER_PRESEGMENTED_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Model_TOKENIZER_RANGES_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Model_TOKENIZER_RANGES_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Pipeline")] + public static extern global::System.IntPtr new_Pipeline(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg3, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg4, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg5); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Pipeline_setModel")] + public static extern void Pipeline_setModel(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Pipeline_setInput")] + public static extern void Pipeline_setInput(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Pipeline_setTagger")] + public static extern void Pipeline_setTagger(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Pipeline_setParser")] + public static extern void Pipeline_setParser(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Pipeline_setOutput")] + public static extern void Pipeline_setOutput(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Pipeline_setImmediate")] + public static extern void Pipeline_setImmediate(global::System.Runtime.InteropServices.HandleRef jarg1, bool jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Pipeline_setDocumentId")] + public static extern void Pipeline_setDocumentId(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Pipeline_process__SWIG_0")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Pipeline_process__SWIG_0(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Pipeline_process__SWIG_1")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Pipeline_process__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Pipeline_DEFAULT_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Pipeline_DEFAULT_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Pipeline_NONE_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Pipeline_NONE_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_delete_Pipeline")] + public static extern void delete_Pipeline(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Trainer_train__SWIG_0")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Trainer_train__SWIG_0([global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg1, global::System.Runtime.InteropServices.HandleRef jarg2, global::System.Runtime.InteropServices.HandleRef jarg3, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg4, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg5, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg6, global::System.Runtime.InteropServices.HandleRef jarg7); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Trainer_train__SWIG_1")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Trainer_train__SWIG_1([global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg1, global::System.Runtime.InteropServices.HandleRef jarg2, global::System.Runtime.InteropServices.HandleRef jarg3, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg4, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg5, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg6); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Trainer_DEFAULT_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Trainer_DEFAULT_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Trainer_NONE_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Trainer_NONE_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Trainer")] + public static extern global::System.IntPtr new_Trainer(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_delete_Trainer")] + public static extern void delete_Trainer(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Evaluator")] + public static extern global::System.IntPtr new_Evaluator(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg3, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg4); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Evaluator_setModel")] + public static extern void Evaluator_setModel(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Evaluator_setTokenizer")] + public static extern void Evaluator_setTokenizer(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Evaluator_setTagger")] + public static extern void Evaluator_setTagger(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Evaluator_setParser")] + public static extern void Evaluator_setParser(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Evaluator_evaluate__SWIG_0")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Evaluator_evaluate__SWIG_0(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2, global::System.Runtime.InteropServices.HandleRef jarg3); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Evaluator_evaluate__SWIG_1")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Evaluator_evaluate__SWIG_1(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Evaluator_DEFAULT_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Evaluator_DEFAULT_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Evaluator_NONE_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Evaluator_NONE_get(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_delete_Evaluator")] + public static extern void delete_Evaluator(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Version_major_set")] + public static extern void Version_major_set(global::System.Runtime.InteropServices.HandleRef jarg1, uint jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Version_major_get")] + public static extern uint Version_major_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Version_minor_set")] + public static extern void Version_minor_set(global::System.Runtime.InteropServices.HandleRef jarg1, uint jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Version_minor_get")] + public static extern uint Version_minor_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Version_patch_set")] + public static extern void Version_patch_set(global::System.Runtime.InteropServices.HandleRef jarg1, uint jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Version_patch_get")] + public static extern uint Version_patch_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Version_prerelease_set")] + public static extern void Version_prerelease_set(global::System.Runtime.InteropServices.HandleRef jarg1, [global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))]string jarg2); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Version_prerelease_get")] + [return: global::System.Runtime.InteropServices.MarshalAs(global::System.Runtime.InteropServices.UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(UTF8Marshaler))] + public static extern string Version_prerelease_get(global::System.Runtime.InteropServices.HandleRef jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Version_current")] + public static extern global::System.IntPtr Version_current(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_new_Version")] + public static extern global::System.IntPtr new_Version(); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_delete_Version")] + public static extern void delete_Version(global::System.Runtime.InteropServices.HandleRef jarg1); + +public class UTF8Marshaler : System.Runtime.InteropServices.ICustomMarshaler { + static UTF8Marshaler static_instance; + + public System.IntPtr MarshalManagedToNative(object managedObj) { + if (managedObj == null) + return System.IntPtr.Zero; + if (!(managedObj is string)) + throw new System.Runtime.InteropServices.MarshalDirectiveException("UTF8Marshaler must be used on a string."); + + // not null terminated + byte[] strbuf = System.Text.Encoding.UTF8.GetBytes((string)managedObj); + System.IntPtr buffer = System.Runtime.InteropServices.Marshal.AllocHGlobal(strbuf.Length + 1); + System.Runtime.InteropServices.Marshal.Copy(strbuf, 0, buffer, strbuf.Length); + + // write the terminating null + System.Runtime.InteropServices.Marshal.WriteByte(buffer + strbuf.Length, 0); + return buffer; + } + + public object MarshalNativeToManaged(System.IntPtr pNativeData) { + int length = 0; + while (System.Runtime.InteropServices.Marshal.ReadByte(pNativeData, length) != 0) + length++; + + // should not be null terminated + byte[] strbuf = new byte[length]; + // skip the trailing null + System.Runtime.InteropServices.Marshal.Copy((System.IntPtr)pNativeData, strbuf, 0, length); + string data = System.Text.Encoding.UTF8.GetString(strbuf); + return data; + } + + public void CleanUpNativeData(System.IntPtr pNativeData) { + System.Runtime.InteropServices.Marshal.FreeHGlobal(pNativeData); + } + + public void CleanUpManagedData(object managedObj) { + } + + public int GetNativeDataSize() { + return -1; + } + + public static System.Runtime.InteropServices.ICustomMarshaler GetInstance(string cookie) { + if (static_instance == null) + return static_instance = new UTF8Marshaler(); + return static_instance; + } +} + + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_Word_SWIGUpcast")] + public static extern global::System.IntPtr Word_SWIGUpcast(global::System.IntPtr jarg1); + + [global::System.Runtime.InteropServices.DllImport("udpipe_csharp", EntryPoint="CSharp_MultiwordToken_SWIGUpcast")] + public static extern global::System.IntPtr MultiwordToken_SWIGUpcast(global::System.IntPtr jarg1); +} + +} diff --git a/UDPipe/v1/binary/win64/csharp/udpipe_csharp.dll b/UDPipe/v1/binary/win64/csharp/udpipe_csharp.dll new file mode 100644 index 0000000000000000000000000000000000000000..dcbaf9ffd90e9ba94e492cdd9dcf830f023131f6 --- /dev/null +++ b/UDPipe/v1/binary/win64/csharp/udpipe_csharp.dll @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:51534a59e8a1cbe06c80a0743aa89d68b89d8b2d34fd6f9c6e6d6d2e7dfdb962 +size 1518592 diff --git a/UDPipe/v1/binary/win64/input.txt b/UDPipe/v1/binary/win64/input.txt new file mode 100644 index 0000000000000000000000000000000000000000..1fc98547955fba48e4d917207f68104c7db833ed --- /dev/null +++ b/UDPipe/v1/binary/win64/input.txt @@ -0,0 +1 @@ +John loves Mary. \ No newline at end of file diff --git a/UDPipe/v1/binary/win64/java/udpipe.jar b/UDPipe/v1/binary/win64/java/udpipe.jar new file mode 100644 index 0000000000000000000000000000000000000000..1402eecf0486e6af3300cbad05601351d9990feb Binary files /dev/null and b/UDPipe/v1/binary/win64/java/udpipe.jar differ diff --git a/UDPipe/v1/binary/win64/java/udpipe_java.dll b/UDPipe/v1/binary/win64/java/udpipe_java.dll new file mode 100644 index 0000000000000000000000000000000000000000..dfd451bc42c3ecb83ffb988228e517ef7f1a75b8 --- /dev/null +++ b/UDPipe/v1/binary/win64/java/udpipe_java.dll @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8bb996bcd5e5d745bad25c46c64e1eac249463d9f85fa1f6d0e09813a8fe313f +size 1464832 diff --git a/UDPipe/v1/binary/win64/output.conllu b/UDPipe/v1/binary/win64/output.conllu new file mode 100644 index 0000000000000000000000000000000000000000..2c4e2a8e7fdac8f784609f1f427f4007d291732a --- /dev/null +++ b/UDPipe/v1/binary/win64/output.conllu @@ -0,0 +1,9 @@ +# newdoc id = input.txt +# newpar +# sent_id = 1 +# text = John loves Mary. +1 John John PROPN NNP Number=Sing 2 nsubj _ _ +2 loves love VERB VBZ Mood=Ind|Number=Sing|Person=3|Tense=Pres|VerbForm=Fin 0 root _ _ +3 Mary Mary PROPN NNP Number=Sing 2 obj _ SpaceAfter=No +4 . . PUNCT . _ 2 punct _ SpacesAfter=\n + diff --git a/UDPipe/v1/binary/win64/udpipe.exe b/UDPipe/v1/binary/win64/udpipe.exe new file mode 100644 index 0000000000000000000000000000000000000000..5918f782e3fe6088f981bf47bda7d49129ecb23a --- /dev/null +++ b/UDPipe/v1/binary/win64/udpipe.exe @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:31eea6f7eaae2c178ffff82786e4d8539272bcd23b4477d8dd6a11a89b2d2f4a +size 1427968 diff --git a/UDPipe/v1/udpipe_csharp/x64/udpipe_csharp.dll b/UDPipe/v1/udpipe_csharp/x64/udpipe_csharp.dll new file mode 100644 index 0000000000000000000000000000000000000000..dcbaf9ffd90e9ba94e492cdd9dcf830f023131f6 --- /dev/null +++ b/UDPipe/v1/udpipe_csharp/x64/udpipe_csharp.dll @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:51534a59e8a1cbe06c80a0743aa89d68b89d8b2d34fd6f9c6e6d6d2e7dfdb962 +size 1518592 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/LICENSE b/UDPipe/v2/udpipe2-ud-2.15-241121/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..d9e352b2f77a35accd82f8ce91c2fef5dab1df22 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/LICENSE @@ -0,0 +1,435 @@ +Attribution-NonCommercial-ShareAlike 4.0 International + +======================================================================= + +Creative Commons Corporation ("Creative Commons") is not a law firm and +does not provide legal services or legal advice. Distribution of +Creative Commons public licenses does not create a lawyer-client or +other relationship. Creative Commons makes its licenses and related +information available on an "as-is" basis. Creative Commons gives no +warranties regarding its licenses, any material licensed under their +terms and conditions, or any related information. Creative Commons +disclaims all liability for damages resulting from their use to the +fullest extent possible. + +Using Creative Commons Public Licenses + +Creative Commons public licenses provide a standard set of terms and +conditions that creators and other rights holders may use to share +original works of authorship and other material subject to copyright +and certain other rights specified in the public license below. The +following considerations are for informational purposes only, are not +exhaustive, and do not form part of our licenses. + + Considerations for licensors: Our public licenses are + intended for use by those authorized to give the public + permission to use material in ways otherwise restricted by + copyright and certain other rights. Our licenses are + irrevocable. Licensors should read and understand the terms + and conditions of the license they choose before applying it. + Licensors should also secure all rights necessary before + applying our licenses so that the public can reuse the + material as expected. Licensors should clearly mark any + material not subject to the license. This includes other CC- + licensed material, or material used under an exception or + limitation to copyright. More considerations for licensors: + wiki.creativecommons.org/Considerations_for_licensors + + Considerations for the public: By using one of our public + licenses, a licensor grants the public permission to use the + licensed material under specified terms and conditions. If + the licensor's permission is not necessary for any reason--for + example, because of any applicable exception or limitation to + copyright--then that use is not regulated by the license. Our + licenses grant only permissions under copyright and certain + other rights that a licensor has authority to grant. Use of + the licensed material may still be restricted for other + reasons, including because others have copyright or other + rights in the material. A licensor may make special requests, + such as asking that all changes be marked or described. + Although not required by our licenses, you are encouraged to + respect those requests where reasonable. More_considerations + for the public: + wiki.creativecommons.org/Considerations_for_licensees + +======================================================================= + +Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International +Public License + +By exercising the Licensed Rights (defined below), You accept and agree +to be bound by the terms and conditions of this Creative Commons +Attribution-NonCommercial-ShareAlike 4.0 International Public License +("Public License"). To the extent this Public License may be +interpreted as a contract, You are granted the Licensed Rights in +consideration of Your acceptance of these terms and conditions, and the +Licensor grants You such rights in consideration of benefits the +Licensor receives from making the Licensed Material available under +these terms and conditions. + + +Section 1 -- Definitions. + + a. Adapted Material means material subject to Copyright and Similar + Rights that is derived from or based upon the Licensed Material + and in which the Licensed Material is translated, altered, + arranged, transformed, or otherwise modified in a manner requiring + permission under the Copyright and Similar Rights held by the + Licensor. For purposes of this Public License, where the Licensed + Material is a musical work, performance, or sound recording, + Adapted Material is always produced where the Licensed Material is + synched in timed relation with a moving image. + + b. Adapter's License means the license You apply to Your Copyright + and Similar Rights in Your contributions to Adapted Material in + accordance with the terms and conditions of this Public License. + + c. BY-NC-SA Compatible License means a license listed at + creativecommons.org/compatiblelicenses, approved by Creative + Commons as essentially the equivalent of this Public License. + + d. Copyright and Similar Rights means copyright and/or similar rights + closely related to copyright including, without limitation, + performance, broadcast, sound recording, and Sui Generis Database + Rights, without regard to how the rights are labeled or + categorized. For purposes of this Public License, the rights + specified in Section 2(b)(1)-(2) are not Copyright and Similar + Rights. + + e. Effective Technological Measures means those measures that, in the + absence of proper authority, may not be circumvented under laws + fulfilling obligations under Article 11 of the WIPO Copyright + Treaty adopted on December 20, 1996, and/or similar international + agreements. + + f. Exceptions and Limitations means fair use, fair dealing, and/or + any other exception or limitation to Copyright and Similar Rights + that applies to Your use of the Licensed Material. + + g. License Elements means the license attributes listed in the name + of a Creative Commons Public License. The License Elements of this + Public License are Attribution, NonCommercial, and ShareAlike. + + h. Licensed Material means the artistic or literary work, database, + or other material to which the Licensor applied this Public + License. + + i. Licensed Rights means the rights granted to You subject to the + terms and conditions of this Public License, which are limited to + all Copyright and Similar Rights that apply to Your use of the + Licensed Material and that the Licensor has authority to license. + + j. Licensor means the individual(s) or entity(ies) granting rights + under this Public License. + + k. NonCommercial means not primarily intended for or directed towards + commercial advantage or monetary compensation. For purposes of + this Public License, the exchange of the Licensed Material for + other material subject to Copyright and Similar Rights by digital + file-sharing or similar means is NonCommercial provided there is + no payment of monetary compensation in connection with the + exchange. + + l. Share means to provide material to the public by any means or + process that requires permission under the Licensed Rights, such + as reproduction, public display, public performance, distribution, + dissemination, communication, or importation, and to make material + available to the public including in ways that members of the + public may access the material from a place and at a time + individually chosen by them. + + m. Sui Generis Database Rights means rights other than copyright + resulting from Directive 96/9/EC of the European Parliament and of + the Council of 11 March 1996 on the legal protection of databases, + as amended and/or succeeded, as well as other essentially + equivalent rights anywhere in the world. + + n. You means the individual or entity exercising the Licensed Rights + under this Public License. Your has a corresponding meaning. + + +Section 2 -- Scope. + + a. License grant. + + 1. Subject to the terms and conditions of this Public License, + the Licensor hereby grants You a worldwide, royalty-free, + non-sublicensable, non-exclusive, irrevocable license to + exercise the Licensed Rights in the Licensed Material to: + + a. reproduce and Share the Licensed Material, in whole or + in part, for NonCommercial purposes only; and + + b. produce, reproduce, and Share Adapted Material for + NonCommercial purposes only. + + 2. Exceptions and Limitations. For the avoidance of doubt, where + Exceptions and Limitations apply to Your use, this Public + License does not apply, and You do not need to comply with + its terms and conditions. + + 3. Term. The term of this Public License is specified in Section + 6(a). + + 4. Media and formats; technical modifications allowed. The + Licensor authorizes You to exercise the Licensed Rights in + all media and formats whether now known or hereafter created, + and to make technical modifications necessary to do so. The + Licensor waives and/or agrees not to assert any right or + authority to forbid You from making technical modifications + necessary to exercise the Licensed Rights, including + technical modifications necessary to circumvent Effective + Technological Measures. For purposes of this Public License, + simply making modifications authorized by this Section 2(a) + (4) never produces Adapted Material. + + 5. Downstream recipients. + + a. Offer from the Licensor -- Licensed Material. Every + recipient of the Licensed Material automatically + receives an offer from the Licensor to exercise the + Licensed Rights under the terms and conditions of this + Public License. + + b. Additional offer from the Licensor -- Adapted Material. + Every recipient of Adapted Material from You + automatically receives an offer from the Licensor to + exercise the Licensed Rights in the Adapted Material + under the conditions of the Adapter's License You apply. + + c. No downstream restrictions. You may not offer or impose + any additional or different terms or conditions on, or + apply any Effective Technological Measures to, the + Licensed Material if doing so restricts exercise of the + Licensed Rights by any recipient of the Licensed + Material. + + 6. No endorsement. Nothing in this Public License constitutes or + may be construed as permission to assert or imply that You + are, or that Your use of the Licensed Material is, connected + with, or sponsored, endorsed, or granted official status by, + the Licensor or others designated to receive attribution as + provided in Section 3(a)(1)(A)(i). + + b. Other rights. + + 1. Moral rights, such as the right of integrity, are not + licensed under this Public License, nor are publicity, + privacy, and/or other similar personality rights; however, to + the extent possible, the Licensor waives and/or agrees not to + assert any such rights held by the Licensor to the limited + extent necessary to allow You to exercise the Licensed + Rights, but not otherwise. + + 2. Patent and trademark rights are not licensed under this + Public License. + + 3. To the extent possible, the Licensor waives any right to + collect royalties from You for the exercise of the Licensed + Rights, whether directly or through a collecting society + under any voluntary or waivable statutory or compulsory + licensing scheme. In all other cases the Licensor expressly + reserves any right to collect such royalties, including when + the Licensed Material is used other than for NonCommercial + purposes. + + +Section 3 -- License Conditions. + +Your exercise of the Licensed Rights is expressly made subject to the +following conditions. + + a. Attribution. + + 1. If You Share the Licensed Material (including in modified + form), You must: + + a. retain the following if it is supplied by the Licensor + with the Licensed Material: + + i. identification of the creator(s) of the Licensed + Material and any others designated to receive + attribution, in any reasonable manner requested by + the Licensor (including by pseudonym if + designated); + + ii. a copyright notice; + + iii. a notice that refers to this Public License; + + iv. a notice that refers to the disclaimer of + warranties; + + v. a URI or hyperlink to the Licensed Material to the + extent reasonably practicable; + + b. indicate if You modified the Licensed Material and + retain an indication of any previous modifications; and + + c. indicate the Licensed Material is licensed under this + Public License, and include the text of, or the URI or + hyperlink to, this Public License. + + 2. You may satisfy the conditions in Section 3(a)(1) in any + reasonable manner based on the medium, means, and context in + which You Share the Licensed Material. For example, it may be + reasonable to satisfy the conditions by providing a URI or + hyperlink to a resource that includes the required + information. + 3. If requested by the Licensor, You must remove any of the + information required by Section 3(a)(1)(A) to the extent + reasonably practicable. + + b. ShareAlike. + + In addition to the conditions in Section 3(a), if You Share + Adapted Material You produce, the following conditions also apply. + + 1. The Adapter's License You apply must be a Creative Commons + license with the same License Elements, this version or + later, or a BY-NC-SA Compatible License. + + 2. You must include the text of, or the URI or hyperlink to, the + Adapter's License You apply. You may satisfy this condition + in any reasonable manner based on the medium, means, and + context in which You Share Adapted Material. + + 3. You may not offer or impose any additional or different terms + or conditions on, or apply any Effective Technological + Measures to, Adapted Material that restrict exercise of the + rights granted under the Adapter's License You apply. + + +Section 4 -- Sui Generis Database Rights. + +Where the Licensed Rights include Sui Generis Database Rights that +apply to Your use of the Licensed Material: + + a. for the avoidance of doubt, Section 2(a)(1) grants You the right + to extract, reuse, reproduce, and Share all or a substantial + portion of the contents of the database for NonCommercial purposes + only; + + b. if You include all or a substantial portion of the database + contents in a database in which You have Sui Generis Database + Rights, then the database in which You have Sui Generis Database + Rights (but not its individual contents) is Adapted Material, + including for purposes of Section 3(b); and + + c. You must comply with the conditions in Section 3(a) if You Share + all or a substantial portion of the contents of the database. + +For the avoidance of doubt, this Section 4 supplements and does not +replace Your obligations under this Public License where the Licensed +Rights include other Copyright and Similar Rights. + + +Section 5 -- Disclaimer of Warranties and Limitation of Liability. + + a. UNLESS OTHERWISE SEPARATELY UNDERTAKEN BY THE LICENSOR, TO THE + EXTENT POSSIBLE, THE LICENSOR OFFERS THE LICENSED MATERIAL AS-IS + AND AS-AVAILABLE, AND MAKES NO REPRESENTATIONS OR WARRANTIES OF + ANY KIND CONCERNING THE LICENSED MATERIAL, WHETHER EXPRESS, + IMPLIED, STATUTORY, OR OTHER. THIS INCLUDES, WITHOUT LIMITATION, + WARRANTIES OF TITLE, MERCHANTABILITY, FITNESS FOR A PARTICULAR + PURPOSE, NON-INFRINGEMENT, ABSENCE OF LATENT OR OTHER DEFECTS, + ACCURACY, OR THE PRESENCE OR ABSENCE OF ERRORS, WHETHER OR NOT + KNOWN OR DISCOVERABLE. WHERE DISCLAIMERS OF WARRANTIES ARE NOT + ALLOWED IN FULL OR IN PART, THIS DISCLAIMER MAY NOT APPLY TO YOU. + + b. TO THE EXTENT POSSIBLE, IN NO EVENT WILL THE LICENSOR BE LIABLE + TO YOU ON ANY LEGAL THEORY (INCLUDING, WITHOUT LIMITATION, + NEGLIGENCE) OR OTHERWISE FOR ANY DIRECT, SPECIAL, INDIRECT, + INCIDENTAL, CONSEQUENTIAL, PUNITIVE, EXEMPLARY, OR OTHER LOSSES, + COSTS, EXPENSES, OR DAMAGES ARISING OUT OF THIS PUBLIC LICENSE OR + USE OF THE LICENSED MATERIAL, EVEN IF THE LICENSOR HAS BEEN + ADVISED OF THE POSSIBILITY OF SUCH LOSSES, COSTS, EXPENSES, OR + DAMAGES. WHERE A LIMITATION OF LIABILITY IS NOT ALLOWED IN FULL OR + IN PART, THIS LIMITATION MAY NOT APPLY TO YOU. + + c. The disclaimer of warranties and limitation of liability provided + above shall be interpreted in a manner that, to the extent + possible, most closely approximates an absolute disclaimer and + waiver of all liability. + + +Section 6 -- Term and Termination. + + a. This Public License applies for the term of the Copyright and + Similar Rights licensed here. However, if You fail to comply with + this Public License, then Your rights under this Public License + terminate automatically. + + b. Where Your right to use the Licensed Material has terminated under + Section 6(a), it reinstates: + + 1. automatically as of the date the violation is cured, provided + it is cured within 30 days of Your discovery of the + violation; or + + 2. upon express reinstatement by the Licensor. + + For the avoidance of doubt, this Section 6(b) does not affect any + right the Licensor may have to seek remedies for Your violations + of this Public License. + + c. For the avoidance of doubt, the Licensor may also offer the + Licensed Material under separate terms or conditions or stop + distributing the Licensed Material at any time; however, doing so + will not terminate this Public License. + + d. Sections 1, 5, 6, 7, and 8 survive termination of this Public + License. + + +Section 7 -- Other Terms and Conditions. + + a. The Licensor shall not be bound by any additional or different + terms or conditions communicated by You unless expressly agreed. + + b. Any arrangements, understandings, or agreements regarding the + Licensed Material not stated herein are separate from and + independent of the terms and conditions of this Public License. + + +Section 8 -- Interpretation. + + a. For the avoidance of doubt, this Public License does not, and + shall not be interpreted to, reduce, limit, restrict, or impose + conditions on any use of the Licensed Material that could lawfully + be made without permission under this Public License. + + b. To the extent possible, if any provision of this Public License is + deemed unenforceable, it shall be automatically reformed to the + minimum extent necessary to make it enforceable. If the provision + cannot be reformed, it shall be severed from this Public License + without affecting the enforceability of the remaining terms and + conditions. + + c. No term or condition of this Public License will be waived and no + failure to comply consented to unless expressly agreed to by the + Licensor. + + d. Nothing in this Public License constitutes or may be interpreted + as a limitation upon, or waiver of, any privileges and immunities + that apply to the Licensor or You, including from the legal + processes of any jurisdiction or authority. + +======================================================================= + +Creative Commons is not a party to its public licenses. +Notwithstanding, Creative Commons may elect to apply one of its public +licenses to material it publishes and in those instances will be +considered the "Licensor." Except for the limited purpose of indicating +that material is shared under a Creative Commons public license or as +otherwise permitted by the Creative Commons policies published at +creativecommons.org/policies, Creative Commons does not authorize the +use of the trademark "Creative Commons" or any other trademark or logo +of Creative Commons without its prior written consent including, +without limitation, in connection with any unauthorized modifications +to any of its public licenses or any other arrangements, +understandings, or agreements concerning use of licensed material. For +the avoidance of doubt, this paragraph does not form part of the public +licenses. + +Creative Commons may be contacted at creativecommons.org. diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/MODELS.txt b/UDPipe/v2/udpipe2-ud-2.15-241121/MODELS.txt new file mode 100644 index 0000000000000000000000000000000000000000..bedeacca81dbed56c98c58241bc901c275f5bad3 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/MODELS.txt @@ -0,0 +1,147 @@ +afrikaans-afribooms-ud-2.15-241121:af_afribooms-ud-2.15-241121:af:afr af_afribooms-ud-2.15-241121.model af_afribooms https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +albanian-staf-ud-2.15-241121:sq_staf-ud-2.15-241121:sq:sqi:alb sq_staf-ud-2.15-241121.model sq_staf https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +ancient_greek-proiel-ud-2.15-241121:grc_proiel-ud-2.15-241121:grc grc_all-ud-2.15-241121.model grc_proiel https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +ancient_greek-perseus-ud-2.15-241121:grc_perseus-ud-2.15-241121 grc_all-ud-2.15-241121.model grc_perseus https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +ancient_greek-ptnk-ud-2.15-241121:grc_ptnk-ud-2.15-241121 grc_all-ud-2.15-241121.model grc_ptnk https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +ancient_hebrew-ptnk-ud-2.15-241121:hbo_ptnk-ud-2.15-241121:hbo hbo_ptnk-ud-2.15-241121.model hbo_ptnk https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +arabic-padt-ud-2.15-241121:ar_padt-ud-2.15-241121:ar:ara ar_padt-ud-2.15-241121.model ar_padt https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +armenian-armtdp-ud-2.15-241121:hy_armtdp-ud-2.15-241121:hy:hye:arm hy_all-ud-2.15-241121.model hy_armtdp https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +armenian-bsut-ud-2.15-241121:hy_bsut-ud-2.15-241121 hy_all-ud-2.15-241121.model hy_bsut https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +basque-bdt-ud-2.15-241121:eu_bdt-ud-2.15-241121:eu:eus eu_bdt-ud-2.15-241121.model eu_bdt https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +belarusian-hse-ud-2.15-241121:be_hse-ud-2.15-241121:be:bel be_hse-ud-2.15-241121.model be_hse https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +bulgarian-btb-ud-2.15-241121:bg_btb-ud-2.15-241121:bg:bul bg_btb-ud-2.15-241121.model bg_btb https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +catalan-ancora-ud-2.15-241121:ca_ancora-ud-2.15-241121:ca:cat ca_ancora-ud-2.15-241121.model ca_ancora https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +chinese-gsdsimp-ud-2.15-241121:zh_gsdsimp-ud-2.15-241121:zh:zho:chi zh_gsdsimp-ud-2.15-241121.model zh_gsdsimp https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +chinese-gsd-ud-2.15-241121:zh_gsd-ud-2.15-241121 zh_gsd-ud-2.15-241121.model zh_gsd https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +classical_armenian-caval-ud-2.15-241121:xcl_caval-ud-2.15-241121:xcl xcl_caval-ud-2.15-241121.model xcl_caval https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +classical_chinese-kyoto-ud-2.15-241121:lzh_kyoto-ud-2.15-241121:lzh lzh_kyoto-ud-2.15-241121.model lzh_kyoto https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +coptic-scriptorium-ud-2.15-241121:cop_scriptorium-ud-2.15-241121:cop cop_scriptorium-ud-2.15-241121.model cop_scriptorium https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +croatian-set-ud-2.15-241121:hr_set-ud-2.15-241121:hr:hrv hr_set-ud-2.15-241121.model hr_set https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +czech-pdt-ud-2.15-241121:cs_pdt-ud-2.15-241121:cs:ces:cze cs_all-ud-2.15-241121.model cs_pdt https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +czech-cac-ud-2.15-241121:cs_cac-ud-2.15-241121 cs_all-ud-2.15-241121.model cs_cac https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +czech-cltt-ud-2.15-241121:cs_cltt-ud-2.15-241121 cs_all-ud-2.15-241121.model cs_cltt https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +czech-fictree-ud-2.15-241121:cs_fictree-ud-2.15-241121 cs_all-ud-2.15-241121.model cs_fictree https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +danish-ddt-ud-2.15-241121:da_ddt-ud-2.15-241121:da:dan da_ddt-ud-2.15-241121.model da_ddt https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +dutch-alpino-ud-2.15-241121:nl_alpino-ud-2.15-241121:nl:nld:dut nl_all-ud-2.15-241121.model nl_alpino https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +dutch-lassysmall-ud-2.15-241121:nl_lassysmall-ud-2.15-241121 nl_all-ud-2.15-241121.model nl_lassysmall https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +english-ewt-ud-2.15-241121:en_ewt-ud-2.15-241121:en:eng en_all-ud-2.15-241121.model en_ewt https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +english-atis-ud-2.15-241121:en_atis-ud-2.15-241121 en_all-ud-2.15-241121.model en_atis https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +english-eslspok-ud-2.15-241121:en_eslspok-ud-2.15-241121 en_all-ud-2.15-241121.model en_eslspok https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +english-gum-ud-2.15-241121:en_gum-ud-2.15-241121 en_all-ud-2.15-241121.model en_gum https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +english-lines-ud-2.15-241121:en_lines-ud-2.15-241121 en_all-ud-2.15-241121.model en_lines https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +english-partut-ud-2.15-241121:en_partut-ud-2.15-241121 en_all-ud-2.15-241121.model en_partut https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +erzya-jr-ud-2.15-241121:myv_jr-ud-2.15-241121:myv myv_jr-ud-2.15-241121.model myv_jr https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +estonian-edt-ud-2.15-241121:et_edt-ud-2.15-241121:et:est et_all-ud-2.15-241121.model et_edt https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +estonian-ewt-ud-2.15-241121:et_ewt-ud-2.15-241121 et_all-ud-2.15-241121.model et_ewt https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +faroese-farpahc-ud-2.15-241121:fo_farpahc-ud-2.15-241121:fo:fao fo_farpahc-ud-2.15-241121.model fo_farpahc https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +finnish-tdt-ud-2.15-241121:fi_tdt-ud-2.15-241121:fi:fin fi_all-ud-2.15-241121.model fi_tdt https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +finnish-ftb-ud-2.15-241121:fi_ftb-ud-2.15-241121 fi_all-ud-2.15-241121.model fi_ftb https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +french-gsd-ud-2.15-241121:fr_gsd-ud-2.15-241121:fr:fra:fre fr_gsd-ud-2.15-241121.model fr_gsd https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +french-parisstories-ud-2.15-241121:fr_parisstories-ud-2.15-241121 fr_all-ud-2.15-241121.model fr_parisstories https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +french-partut-ud-2.15-241121:fr_partut-ud-2.15-241121 fr_all-ud-2.15-241121.model fr_partut https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +french-rhapsodie-ud-2.15-241121:fr_rhapsodie-ud-2.15-241121 fr_all-ud-2.15-241121.model fr_rhapsodie https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +french-sequoia-ud-2.15-241121:fr_sequoia-ud-2.15-241121 fr_all-ud-2.15-241121.model fr_sequoia https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +galician-treegal-ud-2.15-241121:gl_treegal-ud-2.15-241121:gl:glg gl_all-ud-2.15-241121.model gl_treegal https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +galician-ctg-ud-2.15-241121:gl_ctg-ud-2.15-241121 gl_all-ud-2.15-241121.model gl_ctg https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +georgian-glc-ud-2.15-241121:ka_glc-ud-2.15-241121:ka:kat:geo ka_glc-ud-2.15-241121.model ka_glc https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +german-gsd-ud-2.15-241121:de_gsd-ud-2.15-241121:de:deu:ger de_gsd-ud-2.15-241121.model de_gsd https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +german-hdt-ud-2.15-241121:de_hdt-ud-2.15-241121 de_hdt-ud-2.15-241121.model de_hdt https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +gothic-proiel-ud-2.15-241121:got_proiel-ud-2.15-241121:got got_proiel-ud-2.15-241121.model got_proiel https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +greek-gdt-ud-2.15-241121:el_gdt-ud-2.15-241121:el:ell:gre el_all-ud-2.15-241121.model el_gdt https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +greek-gud-ud-2.15-241121:el_gud-ud-2.15-241121 el_all-ud-2.15-241121.model el_gud https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +hebrew-htb-ud-2.15-241121:he_htb-ud-2.15-241121:he:heb he_all-ud-2.15-241121.model he_htb https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +hebrew-iahltknesset-ud-2.15-241121:he_iahltknesset-ud-2.15-241121 he_all-ud-2.15-241121.model he_iahltknesset https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +hebrew-iahltwiki-ud-2.15-241121:he_iahltwiki-ud-2.15-241121 he_all-ud-2.15-241121.model he_iahltwiki https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +hindi-hdtb-ud-2.15-241121:hi_hdtb-ud-2.15-241121:hi:hin hi_hdtb-ud-2.15-241121.model hi_hdtb https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +hungarian-szeged-ud-2.15-241121:hu_szeged-ud-2.15-241121:hu:hun hu_szeged-ud-2.15-241121.model hu_szeged https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +icelandic-modern-ud-2.15-241121:is_modern-ud-2.15-241121:is:ice:isl is_all-ud-2.15-241121.model is_modern https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +icelandic-gc-ud-2.15-241121:is_gc-ud-2.15-241121 is_all-ud-2.15-241121.model is_gc https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +icelandic-icepahc-ud-2.15-241121:is_icepahc-ud-2.15-241121 is_all-ud-2.15-241121.model is_icepahc https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +indonesian-gsd-ud-2.15-241121:id_gsd-ud-2.15-241121:id:ind id_gsd-ud-2.15-241121.model id_gsd https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +indonesian-csui-ud-2.15-241121:id_csui-ud-2.15-241121 id_all-ud-2.15-241121.model id_csui https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +irish-idt-ud-2.15-241121:ga_idt-ud-2.15-241121:ga:gle ga_all-ud-2.15-241121.model ga_idt https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +irish-twittirish-ud-2.15-241121:ga_twittirish-ud-2.15-241121 ga_all-ud-2.15-241121.model ga_twittirish https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +italian-isdt-ud-2.15-241121:it_isdt-ud-2.15-241121:it:ita it_all-ud-2.15-241121.model it_isdt https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +italian-markit-ud-2.15-241121:it_markit-ud-2.15-241121 it_all-ud-2.15-241121.model it_markit https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +italian-old-ud-2.15-241121:it_old-ud-2.15-241121 it_old-ud-2.15-241121.model it_old https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +italian-parlamint-ud-2.15-241121:it_parlamint-ud-2.15-241121 it_all-ud-2.15-241121.model it_parlamint https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +italian-partut-ud-2.15-241121:it_partut-ud-2.15-241121 it_all-ud-2.15-241121.model it_partut https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +italian-postwita-ud-2.15-241121:it_postwita-ud-2.15-241121 it_all-ud-2.15-241121.model it_postwita https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +italian-twittiro-ud-2.15-241121:it_twittiro-ud-2.15-241121 it_all-ud-2.15-241121.model it_twittiro https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +italian-vit-ud-2.15-241121:it_vit-ud-2.15-241121 it_all-ud-2.15-241121.model it_vit https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +japanese-gsdluw-ud-2.15-241121:ja_gsdluw-ud-2.15-241121:ja:jpn ja_all-ud-2.15-241121.model ja_gsdluw https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +japanese-gsd-ud-2.15-241121:ja_gsd-ud-2.15-241121 ja_gsd-ud-2.15-241121.model ja_gsd https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +korean-kaist-ud-2.15-241121:ko_kaist-ud-2.15-241121:ko:kor ko_all-ud-2.15-241121.model ko_kaist https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +korean-gsd-ud-2.15-241121:ko_gsd-ud-2.15-241121 ko_all-ud-2.15-241121.model ko_gsd https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +korean-ksl-ud-2.15-241121:ko_ksl-ud-2.15-241121 ko_all-ud-2.15-241121.model ko_ksl https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +kyrgyz-ktmu-ud-2.15-241121:ky_ktmu-ud-2.15-241121:ky:kir ky_ktmu-ud-2.15-241121.model ky_ktmu https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +latin-ittb-ud-2.15-241121:la_ittb-ud-2.15-241121:la:lat la_ittb-ud-2.15-241121.model la_ittb https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +latin-llct-ud-2.15-241121:la_llct-ud-2.15-241121 la_llct-ud-2.15-241121.model la_llct https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +latin-perseus-ud-2.15-241121:la_perseus-ud-2.15-241121 la_all-ud-2.15-241121.model la_perseus https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +latin-proiel-ud-2.15-241121:la_proiel-ud-2.15-241121 la_proiel-ud-2.15-241121.model la_proiel https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +latin-udante-ud-2.15-241121:la_udante-ud-2.15-241121 la_all-ud-2.15-241121.model la_udante https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +latvian-lvtb-ud-2.15-241121:lv_lvtb-ud-2.15-241121:lv:lav lv_lvtb-ud-2.15-241121.model lv_lvtb https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +lithuanian-alksnis-ud-2.15-241121:lt_alksnis-ud-2.15-241121:lt:lit lt_all-ud-2.15-241121.model lt_alksnis https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +lithuanian-hse-ud-2.15-241121:lt_hse-ud-2.15-241121 lt_all-ud-2.15-241121.model lt_hse https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +low_saxon-lsdc-ud-2.15-241121:nds_lsdc-ud-2.15-241121:nds nds_lsdc-ud-2.15-241121.model nds_lsdc https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +maghrebi_arabic_french-arabizi-ud-2.15-241121:qaf_arabizi-ud-2.15-241121:qaf qaf_arabizi-ud-2.15-241121.model qaf_arabizi https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +maltese-mudt-ud-2.15-241121:mt_mudt-ud-2.15-241121:mt:mlt mt_mudt-ud-2.15-241121.model mt_mudt https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +manx-cadhan-ud-2.15-241121:gv_cadhan-ud-2.15-241121:gv:glv gv_cadhan-ud-2.15-241121.model gv_cadhan https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +marathi-ufal-ud-2.15-241121:mr_ufal-ud-2.15-241121:mr:mar mr_ufal-ud-2.15-241121.model mr_ufal https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +naija-nsc-ud-2.15-241121:pcm_nsc-ud-2.15-241121:pcm pcm_nsc-ud-2.15-241121.model pcm_nsc https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +north_sami-giella-ud-2.15-241121:sme_giella-ud-2.15-241121:se:sme sme_giella-ud-2.15-241121.model sme_giella https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +norwegian-bokmaal-ud-2.15-241121:no_bokmaal-ud-2.15-241121:nb:nob:no:nor no_all-ud-2.15-241121.model no_bokmaal https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +norwegian-nynorsk-ud-2.15-241121:no_nynorsk-ud-2.15-241121:nn:nno no_all-ud-2.15-241121.model no_nynorsk https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +old_church_slavonic-proiel-ud-2.15-241121:cu_proiel-ud-2.15-241121:cu:chu cu_proiel-ud-2.15-241121.model cu_proiel https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +old_east_slavic-torot-ud-2.15-241121:orv_torot-ud-2.15-241121:orv orv_torot-ud-2.15-241121.model orv_torot https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +old_east_slavic-birchbark-ud-2.15-241121:orv_birchbark-ud-2.15-241121 orv_all-ud-2.15-241121.model orv_birchbark https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +old_east_slavic-rnc-ud-2.15-241121:orv_rnc-ud-2.15-241121 orv_rnc-ud-2.15-241121.model orv_rnc https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +old_east_slavic-ruthenian-ud-2.15-241121:orv_ruthenian-ud-2.15-241121 orv_all-ud-2.15-241121.model orv_ruthenian https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +old_french-profiterole-ud-2.15-241121:fro_profiterole-ud-2.15-241121:fro fro_profiterole-ud-2.15-241121.model fro_profiterole https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +ottoman_turkish-boun-ud-2.15-241121:ota_boun-ud-2.15-241121:ota ota_boun-ud-2.15-241121.model ota_boun https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +persian-perdt-ud-2.15-241121:fa_perdt-ud-2.15-241121:fa:fas:per fa_all-ud-2.15-241121.model fa_perdt https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +persian-seraji-ud-2.15-241121:fa_seraji-ud-2.15-241121 fa_all-ud-2.15-241121.model fa_seraji https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +polish-pdb-ud-2.15-241121:pl_pdb-ud-2.15-241121:pl:pol pl_all-ud-2.15-241121.model pl_pdb https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +polish-lfg-ud-2.15-241121:pl_lfg-ud-2.15-241121 pl_all-ud-2.15-241121.model pl_lfg https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +pomak-philotis-ud-2.15-241121:qpm_philotis-ud-2.15-241121:qpm qpm_philotis-ud-2.15-241121.model qpm_philotis https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +portuguese-bosque-ud-2.15-241121:pt_bosque-ud-2.15-241121:pt:por pt_all-ud-2.15-241121.model pt_bosque https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +portuguese-cintil-ud-2.15-241121:pt_cintil-ud-2.15-241121 pt_all-ud-2.15-241121.model pt_cintil https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +portuguese-dantestocks-ud-2.15-241121:pt_dantestocks-ud-2.15-241121 pt_all-ud-2.15-241121.model pt_dantestocks https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +portuguese-gsd-ud-2.15-241121:pt_gsd-ud-2.15-241121 pt_gsd-ud-2.15-241121.model pt_gsd https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +portuguese-petrogold-ud-2.15-241121:pt_petrogold-ud-2.15-241121 pt_all-ud-2.15-241121.model pt_petrogold https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +portuguese-porttinari-ud-2.15-241121:pt_porttinari-ud-2.15-241121 pt_all-ud-2.15-241121.model pt_porttinari https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +romanian-rrt-ud-2.15-241121:ro_rrt-ud-2.15-241121:ro:ron:rum ro_all-ud-2.15-241121.model ro_rrt https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +romanian-nonstandard-ud-2.15-241121:ro_nonstandard-ud-2.15-241121 ro_nonstandard-ud-2.15-241121.model ro_nonstandard https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +romanian-simonero-ud-2.15-241121:ro_simonero-ud-2.15-241121 ro_all-ud-2.15-241121.model ro_simonero https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +russian-syntagrus-ud-2.15-241121:ru_syntagrus-ud-2.15-241121:ru:rus ru_all-ud-2.15-241121.model ru_syntagrus https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +russian-gsd-ud-2.15-241121:ru_gsd-ud-2.15-241121 ru_all-ud-2.15-241121.model ru_gsd https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +russian-poetry-ud-2.15-241121:ru_poetry-ud-2.15-241121 ru_all-ud-2.15-241121.model ru_poetry https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +russian-taiga-ud-2.15-241121:ru_taiga-ud-2.15-241121 ru_all-ud-2.15-241121.model ru_taiga https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +sanskrit-vedic-ud-2.15-241121:sa_vedic-ud-2.15-241121:sa:vsn sa_vedic-ud-2.15-241121.model sa_vedic https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +scottish_gaelic-arcosg-ud-2.15-241121:gd_arcosg-ud-2.15-241121:gd:gla gd_arcosg-ud-2.15-241121.model gd_arcosg https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +serbian-set-ud-2.15-241121:sr_set-ud-2.15-241121:sr:srp sr_set-ud-2.15-241121.model sr_set https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +slovak-snk-ud-2.15-241121:sk_snk-ud-2.15-241121:sk:slk:slo sk_snk-ud-2.15-241121.model sk_snk https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +slovenian-ssj-ud-2.15-241121:sl_ssj-ud-2.15-241121:sl:slv sl_all-ud-2.15-241121.model sl_ssj https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +slovenian-sst-ud-2.15-241121:sl_sst-ud-2.15-241121 sl_all-ud-2.15-241121.model sl_sst https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +spanish-ancora-ud-2.15-241121:es_ancora-ud-2.15-241121:es:spa es_ancora-ud-2.15-241121.model es_ancora https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +spanish-gsd-ud-2.15-241121:es_gsd-ud-2.15-241121 es_all-ud-2.15-241121.model es_gsd https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +swedish-talbanken-ud-2.15-241121:sv_talbanken-ud-2.15-241121:sv:swe sv_all-ud-2.15-241121.model sv_talbanken https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +swedish-lines-ud-2.15-241121:sv_lines-ud-2.15-241121 sv_all-ud-2.15-241121.model sv_lines https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +tamil-ttb-ud-2.15-241121:ta_ttb-ud-2.15-241121:ta:tam ta_ttb-ud-2.15-241121.model ta_ttb https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +telugu-mtg-ud-2.15-241121:te_mtg-ud-2.15-241121:te:tel te_mtg-ud-2.15-241121.model te_mtg https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +turkish-boun-ud-2.15-241121:tr_boun-ud-2.15-241121:tr:tur tr_all-ud-2.15-241121.model tr_boun https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +turkish-atis-ud-2.15-241121:tr_atis-ud-2.15-241121 tr_all-ud-2.15-241121.model tr_atis https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +turkish-framenet-ud-2.15-241121:tr_framenet-ud-2.15-241121 tr_all-ud-2.15-241121.model tr_framenet https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +turkish-imst-ud-2.15-241121:tr_imst-ud-2.15-241121 tr_all-ud-2.15-241121.model tr_imst https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +turkish-kenet-ud-2.15-241121:tr_kenet-ud-2.15-241121 tr_all-ud-2.15-241121.model tr_kenet https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +turkish-penn-ud-2.15-241121:tr_penn-ud-2.15-241121 tr_all-ud-2.15-241121.model tr_penn https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +turkish-tourism-ud-2.15-241121:tr_tourism-ud-2.15-241121 tr_all-ud-2.15-241121.model tr_tourism https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +turkish_german-sagt-ud-2.15-241121:qtd_sagt-ud-2.15-241121:qtd qtd_sagt-ud-2.15-241121.model qtd_sagt https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +ukrainian-iu-ud-2.15-241121:uk_iu-ud-2.15-241121:uk:ukr uk_all-ud-2.15-241121.model uk_iu https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +ukrainian-parlamint-ud-2.15-241121:uk_parlamint-ud-2.15-241121 uk_all-ud-2.15-241121.model uk_parlamint https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +urdu-udtb-ud-2.15-241121:ur_udtb-ud-2.15-241121:ur:urd ur_udtb-ud-2.15-241121.model ur_udtb https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +uyghur-udt-ud-2.15-241121:ug_udt-ud-2.15-241121:ug:uig ug_udt-ud-2.15-241121.model ug_udt https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +vietnamese-vtb-ud-2.15-241121:vi_vtb-ud-2.15-241121:vi:vie vi_vtb-ud-2.15-241121.model vi_vtb https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +welsh-ccg-ud-2.15-241121:cy_ccg-ud-2.15-241121:cy:wel:cym cy_ccg-ud-2.15-241121.model cy_ccg https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +western_armenian-armtdp-ud-2.15-241121:hyw_armtdp-ud-2.15-241121:hyw hyw_armtdp-ud-2.15-241121.model hyw_armtdp https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models +wolof-wtb-ud-2.15-241121:wo_wtb-ud-2.15-241121:wo:wol:wof wo_wtb-ud-2.15-241121.model wo_wtb https://ufal.mff.cuni.cz/udpipe/2/models#universal_dependencies_215_models diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/README.html b/UDPipe/v2/udpipe2-ud-2.15-241121/README.html new file mode 100644 index 0000000000000000000000000000000000000000..1594b8f55a733d72110772bddd9ace0b0a1b3f6c --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/README.html @@ -0,0 +1,4482 @@ + + + + + + +

Universal Dependencies 2.15 Models

+

Universal Dependencies 2.15 Models are distributed under the +CC BY-NC-SA licence. +The models are based solely on Universal Dependencies +2.15 treebanks, and additionally +use multilingual BERT +and RobeCzech.

+

The models require UDPipe 2.

+

Download

+

The latest version 241121 of the Universal Dependencies 2.15 models +can be downloaded from LINDAT/CLARIN repository.

+

The models are also available in the REST service.

+

Acknowledgements

+

This work has been supported by the Ministry of Education, Youth and Sports of +the Czech Republic, Project No. LM2023062 LINDAT/CLARIAH-CZ.

+

The models were trained on Universal Dependencies 2.15 treebanks.

+

For the UD treebanks which do not contain original plain text version, +raw text is used to train the tokenizer instead. The plain texts +were taken from the W2C -- Web to Corpus.

+

Finally, multilingual BERT +and RobeCzech are used to provide +contextualized word embeddings.

+

Publications

+ +

Model Description

+

The Universal Dependencies 2.15 models contain 147 models of 78 languages, each +consisting of a tokenizer, tagger, lemmatizer and dependency parser, all trained +using the UD data. We used the original train-dev-test split, but for treebanks +with only train and no dev data we used last 10% of the train data as dev data. +We produce models only for treebanks with at least 1000 training words.

+

The tokenizer is trained using the SpaceAfter=No features. If the features +are not present in the data, they can be filled in using raw text in the +language in question.

+

The tagger, lemmatizer and parser are trained using gold UD data.

+

Model Performance

+

We present the tokenizer, tagger, lemmatizer and parser performance, measured on +the testing portion of the data, evaluated both on the raw text and using the +gold tokenization. The results are F1 scores measured by the conll18_ud_eval.py +script.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
ModelModeWordsSentsUPOSXPOSUFeatsAllTagsLemmaUASLASMLASBLEX
afrikaans-afribooms-ud-2.15-241121Raw text99.9499.6598.6895.6798.3095.4898.3890.3887.4678.8879.86
afrikaans-afribooms-ud-2.15-241121Gold tokenization——98.7495.7298.3695.5398.4290.5987.6779.1080.02
albanian-staf-ud-2.15-241121Raw text98.3992.6888.9898.3970.1668.0182.8077.4266.4034.1540.49
albanian-staf-ud-2.15-241121Gold tokenization——89.52100.0070.4368.0183.6077.6966.1333.9841.75
ancient_greek-proiel-ud-2.15-241121Raw text99.9849.1997.6897.9292.0490.6994.6582.0078.2262.3966.26
ancient_greek-proiel-ud-2.15-241121Gold tokenization——97.8898.0892.3891.2094.6886.7682.9768.4772.07
ancient_greek-perseus-ud-2.15-241121Raw text99.9798.8593.0886.0491.6685.2386.6880.0374.4054.4455.56
ancient_greek-perseus-ud-2.15-241121Gold tokenization——93.1586.1191.6985.2986.7180.2274.5754.6155.72
ancient_greek-ptnk-ud-2.15-241121Raw text99.9755.1298.49—90.2489.1895.0487.9283.9165.1272.02
ancient_greek-ptnk-ud-2.15-241121Gold tokenization——98.47—90.3689.2795.0991.5987.3668.2275.12
ancient_hebrew-ptnk-ud-2.15-241121Raw text76.0598.0674.1274.1773.4272.3272.2355.7854.0139.7140.12
ancient_hebrew-ptnk-ud-2.15-241121Gold tokenization——97.0997.2595.4994.0792.5092.1188.6875.5572.43
arabic-padt-ud-2.15-241121Raw text94.5882.0991.7089.0489.1588.6890.3178.6674.7966.0968.16
arabic-padt-ud-2.15-241121Gold tokenization——96.9994.3794.5494.0195.2688.1483.6674.8776.34
armenian-armtdp-ud-2.15-241121Raw text99.2895.7096.25—91.9090.6595.1486.9082.1069.4473.94
armenian-armtdp-ud-2.15-241121Gold tokenization——96.86—92.5391.2295.7388.4683.5670.1374.73
armenian-bsut-ud-2.15-241121Raw text99.7998.7397.30—92.1491.3696.6890.0885.5271.1178.28
armenian-bsut-ud-2.15-241121Gold tokenization——97.52—92.3591.5896.8990.5986.0271.6078.76
basque-bdt-ud-2.15-241121Raw text99.9799.8396.27—93.3491.4396.3388.1184.9874.9579.47
basque-bdt-ud-2.15-241121Gold tokenization——96.30—93.3791.4596.3488.1685.0374.9979.50
belarusian-hse-ud-2.15-241121Raw text99.3786.5898.2297.6294.5193.6593.0987.0685.0976.6276.27
belarusian-hse-ud-2.15-241121Gold tokenization——98.8498.2195.1794.2693.6989.6487.4378.5878.05
bulgarian-btb-ud-2.15-241121Raw text99.9194.1799.1797.2797.9596.8598.0094.4991.8085.9086.51
bulgarian-btb-ud-2.15-241121Gold tokenization——99.2997.3898.0596.9698.1095.3192.5786.5587.25
catalan-ancora-ud-2.15-241121Raw text99.9499.4999.0997.1898.6996.9299.4394.7793.2287.8789.32
catalan-ancora-ud-2.15-241121Gold tokenization——99.1797.2898.7697.0199.4994.9393.3788.0589.49
chinese-gsdsimp-ud-2.15-241121Raw text90.2999.1086.9287.1989.6886.4990.2172.5570.0862.7466.30
chinese-gsdsimp-ud-2.15-241121Gold tokenization——95.8195.9899.3795.2599.9086.6883.5677.7281.86
chinese-gsd-ud-2.15-241121Raw text90.2799.1086.6786.9889.6586.2390.2072.2469.8162.5366.10
chinese-gsd-ud-2.15-241121Gold tokenization——95.8595.9999.4295.2999.9286.8883.8477.7582.10
classical_armenian-caval-ud-2.15-241121Raw text98.8060.2897.16—94.9594.1097.4082.7979.5068.8373.76
classical_armenian-caval-ud-2.15-241121Gold tokenization——98.23—96.0595.1398.4988.8185.3073.4078.39
classical_chinese-kyoto-ud-2.15-241121Raw text97.9446.3789.6588.8391.5986.0097.5171.1865.9562.5264.56
classical_chinese-kyoto-ud-2.15-241121Gold tokenization——93.2892.0594.5489.7799.5384.5179.2475.5278.15
coptic-scriptorium-ud-2.15-241121Raw text75.4228.5773.3873.3673.3072.4574.0352.1150.2638.6741.12
coptic-scriptorium-ud-2.15-241121Gold tokenization——97.0196.9297.6795.7197.2490.6987.8577.2380.75
croatian-set-ud-2.15-241121Raw text99.9394.7998.4695.7996.1995.5097.7092.3489.4881.6684.64
croatian-set-ud-2.15-241121Gold tokenization——98.5295.8996.2895.5997.7692.8389.9782.0885.09
czech-pdt-ud-2.15-241121Raw text99.9393.3799.2998.4298.7898.2299.3994.9293.5590.6892.23
czech-pdt-ud-2.15-241121Gold tokenization——99.3698.5198.8698.3199.4795.7094.3291.3492.90
czech-cac-ud-2.15-241121Raw text99.9999.6899.6798.3298.1397.7699.1896.1694.9590.8992.85
czech-cac-ud-2.15-241121Gold tokenization——99.6898.3398.1497.7799.1996.1694.9590.9292.87
czech-cltt-ud-2.15-241121Raw text99.3296.9298.7993.9894.1093.7298.5490.8089.0981.4386.95
czech-cltt-ud-2.15-241121Gold tokenization——99.2494.3794.5694.1399.0192.0990.1182.0487.76
czech-fictree-ud-2.15-241121Raw text99.9998.9599.1797.0797.8996.8899.2796.1794.7489.6292.52
czech-fictree-ud-2.15-241121Gold tokenization——99.1897.0897.9096.8999.2896.2594.8089.7492.64
danish-ddt-ud-2.15-241121Raw text99.8289.8097.8399.8297.3296.4497.5288.7486.7179.5781.68
danish-ddt-ud-2.15-241121Gold tokenization——98.06100.0097.5696.7197.6889.9787.9380.6582.80
dutch-alpino-ud-2.15-241121Raw text99.7589.1098.0297.0997.8296.7395.6693.5291.4685.2582.50
dutch-alpino-ud-2.15-241121Gold tokenization——98.2397.2897.9896.8895.8994.9292.8686.6083.78
dutch-lassysmall-ud-2.15-241121Raw text99.8684.6197.7896.7897.5596.3496.2492.9690.8583.3681.99
dutch-lassysmall-ud-2.15-241121Gold tokenization——98.0297.1097.8696.7296.3995.1892.9886.1184.68
english-ewt-ud-2.15-241121Raw text99.0187.5596.5796.2497.0695.2796.9490.9789.1482.6683.86
english-ewt-ud-2.15-241121Gold tokenization——97.5097.1797.9796.2097.8793.4291.5285.1086.21
english-atis-ud-2.15-241121Raw text100.0080.0398.91—98.5098.0499.6794.1992.7187.4189.83
english-atis-ud-2.15-241121Gold tokenization——99.01—98.5698.1299.6596.0994.4790.0192.36
english-eslspok-ud-2.15-241121Raw text99.8788.6098.5998.68—98.06—94.0492.6890.5392.21
english-eslspok-ud-2.15-241121Gold tokenization——98.7298.81—98.19—96.1294.6691.9093.81
english-gum-ud-2.15-241121Raw text99.7196.0698.1498.0897.9897.1398.9093.0091.2385.8887.29
english-gum-ud-2.15-241121Gold tokenization——98.3998.3698.2797.4099.1793.7491.9286.4887.90
english-lines-ud-2.15-241121Raw text99.9387.7797.6496.8797.0894.4798.3891.0788.4480.6383.67
english-lines-ud-2.15-241121Gold tokenization——97.7296.9697.1694.5398.4391.8989.2281.2484.39
english-partut-ud-2.15-241121Raw text99.7299.0297.3497.2696.8295.8298.2593.8291.8684.0087.14
english-partut-ud-2.15-241121Gold tokenization——97.5997.5197.0796.0798.5394.0792.1184.3187.40
erzya-jr-ud-2.15-241121Raw text99.1097.0287.7587.3378.8773.6984.0272.7862.9941.5147.05
erzya-jr-ud-2.15-241121Gold tokenization——88.5287.9779.5274.2484.6473.7463.7841.8447.46
estonian-edt-ud-2.15-241121Raw text99.9491.4697.8098.4096.6595.6095.4588.9886.5081.0380.14
estonian-edt-ud-2.15-241121Gold tokenization——97.9198.4596.7395.7195.5389.8587.3581.8480.91
estonian-ewt-ud-2.15-241121Raw text98.6378.0394.9596.1994.0991.8694.0483.4880.2772.4273.82
estonian-ewt-ud-2.15-241121Gold tokenization——96.3097.5395.3893.1795.2887.4783.9775.3676.72
faroese-farpahc-ud-2.15-241121Raw text99.7492.7797.3893.0994.3992.3899.7486.3582.4868.5075.88
faroese-farpahc-ud-2.15-241121Gold tokenization——97.5693.2894.6092.52100.0087.3283.3569.3076.97
finnish-tdt-ud-2.15-241121Raw text99.7090.8297.6198.2395.9795.0692.0790.3488.3882.1578.29
finnish-tdt-ud-2.15-241121Gold tokenization——97.9298.5496.2695.4192.3491.7289.7083.1779.26
finnish-ftb-ud-2.15-241121Raw text99.9186.8496.7495.0896.7194.1195.6590.2687.6180.4281.05
finnish-ftb-ud-2.15-241121Gold tokenization——97.0395.3396.8494.3895.7792.3289.6282.9083.38
french-gsd-ud-2.15-241121Raw text98.9594.6797.4798.9597.3496.7697.8393.5691.5685.3687.34
french-gsd-ud-2.15-241121Gold tokenization——98.48100.0098.3997.7998.8695.0493.2387.0188.35
french-parisstories-ud-2.15-241121Raw text99.6493.3697.4599.6494.9193.3998.8480.6477.4066.2173.69
french-parisstories-ud-2.15-241121Gold tokenization——97.80100.0095.2393.7199.1881.7478.5267.1374.56
french-partut-ud-2.15-241121Raw text99.4298.6497.7897.5195.2894.4497.9794.9493.2582.9788.47
french-partut-ud-2.15-241121Gold tokenization——98.3198.1295.8194.9398.5495.5494.0183.5989.02
french-rhapsodie-ud-2.15-241121Raw text99.1699.8297.4599.1696.5795.5998.4787.7384.6576.4880.84
french-rhapsodie-ud-2.15-241121Gold tokenization——98.33100.0097.3896.4599.2989.0285.9277.4881.52
french-sequoia-ud-2.15-241121Raw text99.1288.7798.38—97.4197.0098.2493.9892.7286.7189.23
french-sequoia-ud-2.15-241121Gold tokenization——99.28—98.2997.8699.0995.7594.4988.5490.42
galician-treegal-ud-2.15-241121Raw text98.7487.9996.2994.3795.3793.5297.2783.2979.1868.5872.41
galician-treegal-ud-2.15-241121Gold tokenization——97.5495.4796.4494.5998.4786.9382.5372.4176.46
galician-ctg-ud-2.15-241121Raw text99.2297.2297.1696.9999.0696.5598.0785.3682.8571.1375.73
galician-ctg-ud-2.15-241121Gold tokenization——97.8897.7299.8497.2698.8387.0084.3672.9577.61
georgian-glc-ud-2.15-241121Raw text99.1295.8895.8995.8791.3590.9394.0383.1878.9068.7172.92
georgian-glc-ud-2.15-241121Gold tokenization——96.5996.5791.9791.5494.7384.7380.2669.5273.98
german-gsd-ud-2.15-241121Raw text99.6783.6396.6797.5391.2488.7296.9187.2783.5366.1075.49
german-gsd-ud-2.15-241121Gold tokenization——97.0797.9091.6889.2397.2489.2385.4667.8577.49
german-hdt-ud-2.15-241121Raw text99.9092.3998.5598.4694.1993.7997.6896.9296.0084.9490.48
german-hdt-ud-2.15-241121Gold tokenization——98.6698.5994.3293.9397.7797.6196.7285.6291.18
gothic-proiel-ud-2.15-241121Raw text100.0031.1296.1396.6590.1088.0094.7178.6772.5558.5163.15
gothic-proiel-ud-2.15-241121Gold tokenization——96.6897.2291.0589.2994.7786.9381.0168.6472.88
greek-gdt-ud-2.15-241121Raw text99.8790.1998.1298.1595.6895.0096.0492.9191.1381.5781.64
greek-gdt-ud-2.15-241121Gold tokenization——98.2898.3095.8595.1796.1393.7091.8482.2282.28
greek-gud-ud-2.15-241121Raw text99.9294.9897.1196.2994.4290.6695.7692.9890.1576.4480.55
greek-gud-ud-2.15-241121Gold tokenization——97.1596.3394.4590.6895.8293.6590.8276.9081.03
hebrew-htb-ud-2.15-241121Raw text85.1099.6983.0283.0081.4680.8082.9770.4868.0655.8159.83
hebrew-htb-ud-2.15-241121Gold tokenization——97.7297.6795.9995.4397.3492.5390.0379.6982.23
hebrew-iahltknesset-ud-2.15-241121Raw text87.98100.0085.2985.2581.6380.7986.8471.3368.8856.0662.80
hebrew-iahltknesset-ud-2.15-241121Gold tokenization——96.9396.9592.7091.8498.2990.0987.4072.6580.96
hebrew-iahltwiki-ud-2.15-241121Raw text88.6496.7886.1386.1281.9380.9587.4175.8974.0158.2967.00
hebrew-iahltwiki-ud-2.15-241121Gold tokenization——97.1497.1592.4791.4798.3693.6691.3875.8485.70
hindi-hdtb-ud-2.15-241121Raw text100.0098.7297.5997.1994.2192.2698.9295.3092.3979.4687.81
hindi-hdtb-ud-2.15-241121Gold tokenization——97.5997.1894.2392.2798.9295.4192.5079.5887.94
hungarian-szeged-ud-2.15-241121Raw text99.8595.8996.76—94.2993.5894.9188.2484.6674.8978.03
hungarian-szeged-ud-2.15-241121Gold tokenization——96.84—94.4393.6695.0288.7085.0875.2078.33
icelandic-modern-ud-2.15-241121Raw text99.4494.5997.7495.2989.2986.4697.0985.6982.7364.7775.00
icelandic-modern-ud-2.15-241121Gold tokenization——98.2495.8589.6986.8797.6186.5583.5465.4975.94
icelandic-gc-ud-2.15-241121Raw text99.7294.6494.7282.0385.0079.7191.8283.4179.0358.4669.15
icelandic-gc-ud-2.15-241121Gold tokenization——95.0082.5185.5080.2291.9884.1779.7759.0269.68
icelandic-icepahc-ud-2.15-241121Raw text99.8292.6996.8993.3392.0987.2496.3787.0883.2566.8574.53
icelandic-icepahc-ud-2.15-241121Gold tokenization——97.0593.5692.2287.4596.5187.5883.7067.3175.07
indonesian-gsd-ud-2.15-241121Raw text99.4993.0494.3093.8695.5688.7998.0887.8481.8672.6877.23
indonesian-gsd-ud-2.15-241121Gold tokenization——94.7894.2596.0089.1898.4988.6682.5973.4378.01
indonesian-csui-ud-2.15-241121Raw text99.4591.0195.9696.1196.8195.3698.1786.5182.2076.6678.83
indonesian-csui-ud-2.15-241121Gold tokenization——96.4896.6397.3295.8598.8187.9383.4277.6179.92
irish-idt-ud-2.15-241121Raw text99.8897.5895.9394.9990.7287.6295.7787.1681.6465.3072.34
irish-idt-ud-2.15-241121Gold tokenization——96.0495.1490.8387.7695.8987.5081.9765.4472.54
irish-twittirish-ud-2.15-241121Raw text98.5046.6290.63——90.6388.2878.9872.6058.8557.12
irish-twittirish-ud-2.15-241121Gold tokenization——91.84——91.8489.5485.8079.2666.7564.25
italian-isdt-ud-2.15-241121Raw text99.7499.0798.5198.4098.0697.6798.5894.6592.9586.6887.71
italian-isdt-ud-2.15-241121Gold tokenization——98.7598.6698.3097.9398.8495.0893.3987.0888.14
italian-markit-ud-2.15-241121Raw text99.6298.2496.9897.0794.1692.5388.3488.4884.7070.6078.16
italian-markit-ud-2.15-241121Gold tokenization——97.3597.4194.4292.7888.6689.2785.4871.2078.90
italian-old-ud-2.15-241121Raw text99.0897.7696.3086.8191.8783.2496.4985.3780.9364.3772.68
italian-old-ud-2.15-241121Gold tokenization——97.1587.2792.7183.8297.3588.2083.5067.1675.55
italian-parlamint-ud-2.15-241121Raw text99.4294.1298.6498.0597.9697.0298.7091.9489.9884.4586.25
italian-parlamint-ud-2.15-241121Gold tokenization——99.2298.5998.4897.5099.2093.4091.4386.0887.84
italian-partut-ud-2.15-241121Raw text99.73100.0098.4398.4398.1697.5898.6095.7493.7987.1788.62
italian-partut-ud-2.15-241121Gold tokenization——98.6098.6098.3097.7298.7995.8093.7687.0988.54
italian-postwita-ud-2.15-241121Raw text99.3649.5396.6196.3996.1594.8796.4083.0579.2068.9970.63
italian-postwita-ud-2.15-241121Gold tokenization——97.2096.9596.6595.4096.9688.0683.7875.3076.72
italian-twittiro-ud-2.15-241121Raw text98.9446.6795.8495.6194.7093.1294.3082.9578.2865.6966.30
italian-twittiro-ud-2.15-241121Gold tokenization——96.7196.3095.6793.8595.2388.3483.5071.8372.07
italian-vit-ud-2.15-241121Raw text99.7595.0698.1497.2997.6496.1498.8592.2089.3181.2583.96
italian-vit-ud-2.15-241121Gold tokenization——98.3997.6897.8596.5199.0993.0390.1182.0684.81
japanese-gsdluw-ud-2.15-241121Raw text95.1899.7293.9193.6695.1893.5993.6586.3085.6976.6476.59
japanese-gsdluw-ud-2.15-241121Gold tokenization——98.4298.1599.9998.0297.8595.2394.2986.5885.22
japanese-gsd-ud-2.15-241121Raw text96.17100.0095.0294.2896.1694.0195.1188.0787.3781.1281.42
japanese-gsd-ud-2.15-241121Gold tokenization——98.5997.6299.9897.3298.5595.1494.2489.2589.12
korean-kaist-ud-2.15-241121Raw text100.00100.0096.2687.65—87.4594.4689.0987.2083.1380.96
korean-kaist-ud-2.15-241121Gold tokenization——96.2687.65—87.4594.4689.0987.2083.1380.96
korean-gsd-ud-2.15-241121Raw text99.8793.9396.5090.6399.6888.3293.8788.2584.6581.6977.71
korean-gsd-ud-2.15-241121Gold tokenization——96.6790.8499.8188.5294.0188.8885.2482.3278.31
korean-ksl-ud-2.15-241121Raw text100.0099.2296.7589.63—87.8395.1589.8386.3881.5880.07
korean-ksl-ud-2.15-241121Gold tokenization——96.7489.64—87.8395.1589.9286.4781.6680.15
kyrgyz-ktmu-ud-2.15-241121Raw text99.1698.0390.8190.3677.0972.5088.5883.5572.5953.1262.75
kyrgyz-ktmu-ud-2.15-241121Gold tokenization——91.5691.1177.7873.1789.3384.4773.4353.6263.27
latin-ittb-ud-2.15-241121Raw text99.9891.7999.1196.6397.1995.8099.1789.4887.5481.4284.91
latin-ittb-ud-2.15-241121Gold tokenization——99.1496.6797.2495.8499.2190.4588.5282.0585.50
latin-llct-ud-2.15-241121Raw text99.9999.4999.7397.0997.1396.8397.7995.3594.3888.9990.31
latin-llct-ud-2.15-241121Gold tokenization——99.7397.0997.1396.8497.8095.3694.3988.9990.31
latin-perseus-ud-2.15-241121Raw text98.2399.0991.4680.0383.3676.5987.6076.9370.0952.2858.28
latin-perseus-ud-2.15-241121Gold tokenization——93.1881.5584.9278.0489.2178.0971.1252.6159.23
latin-proiel-ud-2.15-241121Raw text99.8537.4096.5296.5890.7189.4296.0876.5772.3659.0064.80
latin-proiel-ud-2.15-241121Gold tokenization——97.0697.1091.5590.4196.3083.8879.6267.9473.42
latin-udante-ud-2.15-241121Raw text99.6098.4591.1675.6184.5372.5787.6176.7469.6448.8852.99
latin-udante-ud-2.15-241121Gold tokenization——91.4275.7384.7872.6587.8776.9369.8148.9153.07
latvian-lvtb-ud-2.15-241121Raw text99.2798.0997.1591.7495.1891.3296.7689.4586.5678.8081.97
latvian-lvtb-ud-2.15-241121Gold tokenization——97.8392.4295.8991.9997.4290.5387.6079.9683.09
lithuanian-alksnis-ud-2.15-241121Raw text99.9187.8796.0390.4991.2289.7293.5982.9179.3568.7471.87
lithuanian-alksnis-ud-2.15-241121Gold tokenization——96.1590.5991.3189.8393.6884.1780.5969.6672.80
lithuanian-hse-ud-2.15-241121Raw text97.3097.3090.3189.9382.2078.7588.3571.6762.3545.1853.97
lithuanian-hse-ud-2.15-241121Gold tokenization——92.1791.8984.0680.3890.8575.2864.9146.7255.70
low_saxon-lsdc-ud-2.15-241121Raw text99.2590.2389.96—71.8469.1483.8974.3165.2137.0248.45
low_saxon-lsdc-ud-2.15-241121Gold tokenization——90.59—72.4369.6484.3975.4866.2537.1348.74
maghrebi_arabic_french-arabizi-ud-2.15-241121Raw text91.657.0078.9072.0683.0370.3751.4357.8549.9836.3724.60
maghrebi_arabic_french-arabizi-ud-2.15-241121Gold tokenization——86.5578.6690.6477.3354.8976.1465.6347.2931.71
maltese-mudt-ud-2.15-241121Raw text99.8486.2995.6495.55—95.24—84.6179.5467.9171.94
maltese-mudt-ud-2.15-241121Gold tokenization——95.7595.68—95.34—85.3280.1968.4172.44
manx-cadhan-ud-2.15-241121Raw text97.3698.2594.09—95.8493.3293.3487.6084.1477.7477.73
manx-cadhan-ud-2.15-241121Gold tokenization——96.68—98.4395.8595.8892.5789.1282.9081.70
marathi-ufal-ud-2.15-241121Raw text94.1692.6382.73—75.1871.5384.1866.6760.3440.0047.84
marathi-ufal-ud-2.15-241121Gold tokenization——87.14—78.6474.5187.1472.3365.2943.7151.13
naija-nsc-ud-2.15-241121Raw text99.97100.0098.12—98.9497.5999.3993.1090.5587.5189.19
naija-nsc-ud-2.15-241121Gold tokenization——98.15—98.9597.6099.4293.1390.5887.5289.21
north_sami-giella-ud-2.15-241121Raw text99.8798.7991.6493.4289.1684.9587.0775.7470.9260.1458.71
north_sami-giella-ud-2.15-241121Gold tokenization——91.7893.5789.3085.0887.1975.9971.1860.3058.92
norwegian-bokmaal-ud-2.15-241121Raw text99.8297.2798.3998.9597.4896.8298.6294.0092.7887.1889.00
norwegian-bokmaal-ud-2.15-241121Gold tokenization——98.5999.1397.6596.9998.8294.6793.4387.7989.65
norwegian-nynorsk-ud-2.15-241121Raw text99.9394.5498.3699.0697.2996.4598.4093.9492.4785.9088.09
norwegian-nynorsk-ud-2.15-241121Gold tokenization——98.5599.2097.4696.6898.5594.6993.2486.8589.04
old_church_slavonic-proiel-ud-2.15-241121Raw text100.0040.0596.2396.4889.7888.0190.2178.0173.6460.7562.07
old_church_slavonic-proiel-ud-2.15-241121Gold tokenization——96.6896.9790.4288.9990.2985.1380.5668.4569.16
old_east_slavic-torot-ud-2.15-241121Raw text100.0034.5395.3495.4189.7087.4788.4277.0272.4258.6558.48
old_east_slavic-torot-ud-2.15-241121Gold tokenization——95.8795.9190.6388.7188.4885.6080.7768.2866.57
old_east_slavic-birchbark-ud-2.15-241121Raw text99.9916.6688.7499.3575.3671.1865.2165.1958.3432.6627.06
old_east_slavic-birchbark-ud-2.15-241121Gold tokenization——88.8899.3575.9971.8165.2876.8969.9140.3732.66
old_east_slavic-rnc-ud-2.15-241121Raw text99.7794.5697.5791.4989.5182.0590.6376.9173.2254.5657.05
old_east_slavic-rnc-ud-2.15-241121Gold tokenization——97.8291.6989.7982.3290.8979.5375.6956.3158.99
old_east_slavic-ruthenian-ud-2.15-241121Raw text99.8799.6196.1789.3587.7380.6182.8978.0974.3053.7749.03
old_east_slavic-ruthenian-ud-2.15-241121Gold tokenization——96.2389.7787.7881.0282.9678.1674.3553.7349.06
old_french-profiterole-ud-2.15-241121Raw text99.82100.0097.1597.0597.5495.6399.7991.0487.4780.0584.53
old_french-profiterole-ud-2.15-241121Gold tokenization——97.3397.2497.7295.8299.9791.2987.7280.3184.80
ottoman_turkish-boun-ud-2.15-241121Raw text99.4187.9687.3290.5180.8772.9082.1961.5851.2632.8336.22
ottoman_turkish-boun-ud-2.15-241121Gold tokenization——87.7790.9781.2473.2182.5262.3451.8233.1036.63
persian-perdt-ud-2.15-241121Raw text99.6699.8397.4597.4097.6595.6598.9693.5891.3986.2388.74
persian-perdt-ud-2.15-241121Gold tokenization——97.7597.7097.9595.9499.2894.0991.8786.7789.30
persian-seraji-ud-2.15-241121Raw text99.6598.7597.9597.9297.9597.4798.2791.6688.8584.4284.51
persian-seraji-ud-2.15-241121Gold tokenization——98.2798.2398.2797.7698.5492.3789.5285.0085.11
polish-pdb-ud-2.15-241121Raw text99.8697.0098.9996.0796.0595.3598.1294.4092.5785.8488.86
polish-pdb-ud-2.15-241121Gold tokenization——99.1196.2396.2295.5198.2394.9593.1086.3289.30
polish-lfg-ud-2.15-241121Raw text99.8599.6599.0196.1896.6895.2298.1796.9195.6290.0492.40
polish-lfg-ud-2.15-241121Gold tokenization——99.1896.3596.8695.3998.3197.2996.0090.4492.73
pomak-philotis-ud-2.15-241121Raw text99.7989.4295.42—88.8587.8891.3788.3081.8063.7367.56
pomak-philotis-ud-2.15-241121Gold tokenization——95.54—88.9887.9991.4989.2482.6564.3468.30
portuguese-bosque-ud-2.15-241121Raw text99.6889.7397.78—96.9295.8598.3692.3189.9880.6984.65
portuguese-bosque-ud-2.15-241121Gold tokenization——98.11—97.1996.1298.6593.4691.0881.7885.74
portuguese-cintil-ud-2.15-241121Raw text99.4178.6697.4496.0495.3393.2397.4985.3082.2872.3375.94
portuguese-cintil-ud-2.15-241121Gold tokenization——98.0496.6595.9393.8198.0687.6484.5174.4778.14
portuguese-dantestocks-ud-2.15-241121Raw text96.4738.2794.2396.4593.8492.8893.6685.3883.0875.3475.93
portuguese-dantestocks-ud-2.15-241121Gold tokenization——97.7199.9897.3596.3595.9393.0490.5684.2382.70
portuguese-gsd-ud-2.15-241121Raw text99.2986.2597.4989.6494.6089.1897.1492.7590.8080.1785.14
portuguese-gsd-ud-2.15-241121Gold tokenization——98.2791.7696.0791.2797.9894.2592.3582.7686.84
portuguese-petrogold-ud-2.15-241121Raw text99.5993.1198.79—98.6998.2199.1294.6993.5388.5390.01
portuguese-petrogold-ud-2.15-241121Gold tokenization——99.10—98.9698.4799.5495.6194.3789.4491.03
portuguese-porttinari-ud-2.15-241121Raw text94.6828.0593.90—93.4493.1094.1785.8584.3178.6281.30
portuguese-porttinari-ud-2.15-241121Gold tokenization——99.20—98.7298.3699.4596.4895.2390.1991.95
romanian-rrt-ud-2.15-241121Raw text99.7095.5097.8397.1997.4196.9197.9991.9088.4481.8883.42
romanian-rrt-ud-2.15-241121Gold tokenization——98.1197.4397.6797.1698.2592.6489.1182.3283.92
romanian-nonstandard-ud-2.15-241121Raw text98.8396.7796.1691.9490.5889.2494.8689.0684.9968.5376.59
romanian-nonstandard-ud-2.15-241121Gold tokenization——97.2992.9791.5690.1995.9490.7686.6270.0477.84
romanian-simonero-ud-2.15-241121Raw text99.84100.0098.4697.9497.5597.2298.8894.0192.0985.4288.34
romanian-simonero-ud-2.15-241121Gold tokenization——98.6298.0997.7097.3799.0494.3692.4185.6988.61
russian-syntagrus-ud-2.15-241121Raw text99.6798.3198.48—94.0193.7698.1893.8091.6782.7688.83
russian-syntagrus-ud-2.15-241121Gold tokenization——98.81—94.3494.0798.4694.5192.3483.3289.36
russian-gsd-ud-2.15-241121Raw text99.5096.4998.0497.5294.5593.4096.9191.5988.6280.9984.54
russian-gsd-ud-2.15-241121Gold tokenization——98.5197.9494.9793.7897.2992.8389.7481.8485.48
russian-poetry-ud-2.15-241121Raw text99.5995.9697.86—94.4393.8997.0189.1086.1477.1380.68
russian-poetry-ud-2.15-241121Gold tokenization——98.24—94.7794.2397.3690.0487.0777.8481.36
russian-taiga-ud-2.15-241121Raw text98.0786.0195.55—93.1292.1294.7783.2779.8671.2174.38
russian-taiga-ud-2.15-241121Gold tokenization——97.27—94.9193.8396.4785.9782.3373.6276.76
sanskrit-vedic-ud-2.15-241121Raw text100.0029.2193.56—89.1985.3493.4365.3556.8349.0152.10
sanskrit-vedic-ud-2.15-241121Gold tokenization——93.95—90.4786.8393.5778.2369.0860.9064.49
scottish_gaelic-arcosg-ud-2.15-241121Raw text97.4261.2693.8389.6591.0988.5295.1380.8676.4165.2770.06
scottish_gaelic-arcosg-ud-2.15-241121Gold tokenization——96.6192.6394.0191.5797.7186.9782.5871.9576.15
serbian-set-ud-2.15-241121Raw text99.9993.0099.0995.9296.1095.6997.8093.6091.1883.5486.95
serbian-set-ud-2.15-241121Gold tokenization——99.1195.9796.1495.7397.7994.3291.8884.2987.68
slovak-snk-ud-2.15-241121Raw text100.0081.6997.6990.1293.4089.3496.5491.5889.9480.3784.70
slovak-snk-ud-2.15-241121Gold tokenization——97.8390.3593.4889.5696.5793.9992.3082.6887.13
slovenian-ssj-ud-2.15-241121Raw text99.9498.9598.7897.0197.1296.5798.5994.3792.7887.2289.16
slovenian-ssj-ud-2.15-241121Gold tokenization——98.8497.0797.1796.6398.6494.5192.9187.3789.28
slovenian-sst-ud-2.15-241121Raw text99.8795.4798.4596.9097.0196.1998.8384.8282.1273.8277.42
slovenian-sst-ud-2.15-241121Gold tokenization——98.5997.0097.0896.2898.9785.3382.6374.2377.91
spanish-ancora-ud-2.15-241121Raw text99.9598.6999.0696.2298.8095.8399.4793.8092.1587.1188.69
spanish-ancora-ud-2.15-241121Gold tokenization——99.1196.2698.8595.8699.5194.0092.3587.3088.85
spanish-gsd-ud-2.15-241121Raw text99.7393.8497.10—96.8695.1598.6192.5290.3678.9484.50
spanish-gsd-ud-2.15-241121Gold tokenization——97.35—97.1295.3898.8693.4291.1879.7185.29
swedish-talbanken-ud-2.15-241121Raw text99.8496.5398.4197.2297.2196.1998.6292.7390.3484.1887.11
swedish-talbanken-ud-2.15-241121Gold tokenization——98.5997.4197.3996.4098.7893.1290.7284.6887.54
swedish-lines-ud-2.15-241121Raw text99.9688.5097.7095.4292.9689.9097.7891.1387.9775.3082.66
swedish-lines-ud-2.15-241121Gold tokenization——97.7395.4993.0489.9697.8291.8988.6776.0283.39
tamil-ttb-ud-2.15-241121Raw text94.2697.5284.1982.2784.2977.7189.3570.7362.2350.6355.60
tamil-ttb-ud-2.15-241121Gold tokenization——89.0487.0389.4982.2094.3278.3368.9856.6361.77
telugu-mtg-ud-2.15-241121Raw text99.5896.6293.6393.6398.4893.35—90.0383.2476.0079.24
telugu-mtg-ud-2.15-241121Gold tokenization——94.0494.0498.8993.76—90.9884.0576.6479.89
turkish-boun-ud-2.15-241121Raw text96.5786.2589.9685.9680.9271.6290.6072.9366.9849.0961.03
turkish-boun-ud-2.15-241121Gold tokenization——93.0088.8982.9073.3293.6280.4573.8152.5966.63
turkish-atis-ud-2.15-241121Raw text99.9079.2898.42—97.9797.8298.9689.3187.5684.8586.15
turkish-atis-ud-2.15-241121Gold tokenization——98.53—98.1197.9499.0791.6389.7286.9888.39
turkish-framenet-ud-2.15-241121Raw text99.9099.2796.83—94.7993.9796.6393.3684.3674.3777.84
turkish-framenet-ud-2.15-241121Gold tokenization——96.93—94.8994.0796.7393.5284.5374.5077.97
turkish-imst-ud-2.15-241121Raw text97.3197.3892.7392.5389.4486.5993.5576.4869.2958.1763.97
turkish-imst-ud-2.15-241121Gold tokenization——95.2094.8691.6588.6595.8881.3973.7660.6667.22
turkish-kenet-ud-2.15-241121Raw text100.0098.1293.78—91.9090.8093.5284.1571.5362.3165.22
turkish-kenet-ud-2.15-241121Gold tokenization——93.80—91.9190.8293.5184.2871.6162.4065.30
turkish-penn-ud-2.15-241121Raw text99.2782.8995.68—94.4693.4194.2884.7272.2162.6765.14
turkish-penn-ud-2.15-241121Gold tokenization——96.39—95.1094.0694.9586.9174.0963.7766.34
turkish-tourism-ud-2.15-241121Raw text99.99100.0098.79—94.9894.5798.2897.1491.4981.6687.10
turkish-tourism-ud-2.15-241121Gold tokenization——98.80—94.9994.5998.3097.1591.5081.6887.12
turkish_german-sagt-ud-2.15-241121Raw text98.9199.4490.21—80.1975.4090.7670.9260.6840.9950.56
turkish_german-sagt-ud-2.15-241121Gold tokenization——91.11—80.8075.9291.4772.3761.7941.5551.31
ukrainian-iu-ud-2.15-241121Raw text99.8196.2398.0294.2994.5193.2697.6390.7288.3779.3183.57
ukrainian-iu-ud-2.15-241121Gold tokenization——98.2394.5094.7093.4597.8291.3288.9479.6984.00
ukrainian-parlamint-ud-2.15-241121Raw text99.8899.6298.3498.5494.9193.9598.8993.3690.7181.6587.38
ukrainian-parlamint-ud-2.15-241121Gold tokenization——98.4798.6495.0094.0499.0193.5390.8981.7187.50
urdu-udtb-ud-2.15-241121Raw text100.0098.3194.1892.3182.8778.6197.3588.0082.8857.4475.16
urdu-udtb-ud-2.15-241121Gold tokenization——94.1792.2982.8578.5897.3788.1182.9657.4375.25
uyghur-udt-ud-2.15-241121Raw text99.5481.8789.7491.7987.9980.6794.7475.5964.7050.0457.43
uyghur-udt-ud-2.15-241121Gold tokenization——90.2192.3488.4481.1495.2377.3566.3451.1458.63
vietnamese-vtb-ud-2.15-241121Raw text86.0693.7378.4777.51—77.3485.7756.6249.6241.0545.25
vietnamese-vtb-ud-2.15-241121Gold tokenization——89.8388.75—88.5499.5176.2265.8555.2961.23
welsh-ccg-ud-2.15-241121Raw text99.5697.7995.6394.6389.8787.5994.6987.5281.5763.8470.76
welsh-ccg-ud-2.15-241121Gold tokenization——96.0395.0090.2687.9595.1188.5482.5464.7771.75
western_armenian-armtdp-ud-2.15-241121Raw text99.8998.6896.91—92.7191.9797.1089.3784.8770.3076.52
western_armenian-armtdp-ud-2.15-241121Gold tokenization——96.98—92.8092.0497.2089.6485.1170.5476.76
wolof-wtb-ud-2.15-241121Raw text99.2391.9594.0793.9993.5391.3495.1584.0478.7666.9070.21
wolof-wtb-ud-2.15-241121Gold tokenization——95.0894.9694.3392.2495.9386.1980.8669.0672.20
+ + diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/af_afribooms-ud-2.15-241121.model/af_afribooms.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/af_afribooms-ud-2.15-241121.model/af_afribooms.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..589735e53d553f37f6f0ef2123c461c0271c43cc --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/af_afribooms-ud-2.15-241121.model/af_afribooms.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f071a346104b4e3128c95431fff81bc8eec1181c25ce3ce11b733db5f1c1199c +size 34819 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/af_afribooms-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/af_afribooms-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/af_afribooms-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/af_afribooms-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/af_afribooms-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..609d563b8097b1155f587862365a05659196e8fd --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/af_afribooms-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d039ea87a11c8af709d7afaa684740486b4a90a3aaefe01de3eb3fd1398f1063 +size 223 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/af_afribooms-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/af_afribooms-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..69b659e03652b57c6d969adf05f69dbe8348e31d --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/af_afribooms-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:fcd57a288af00601d549c63539e08211782e521818592cbeded38da5a19b2b84 +size 10598 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/af_afribooms-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/af_afribooms-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..ac6a15b5b9a50a7d129d1b4659b4c54cd0be3310 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/af_afribooms-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2bac8e359aca396624fa1beea614b32792c57578a29879a0835385793a4aa471 +size 73227 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/af_afribooms-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/af_afribooms-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..f2267924dca23dad8fd7e5ec0a1adcd91f3663d5 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/af_afribooms-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1f5cb04c2e30fc4072fddd05b1abeb58f7e60f97d939b2ca8a1d83099c79b1b1 +size 909 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/af_afribooms-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/af_afribooms-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..02d5ad1233780aebbcf799e618991136244b1c6c --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/af_afribooms-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b99dd7f790edeafc10fb3c408f69295e7e283d0a031ccc0b854153752f93349a +size 54775072 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/af_afribooms-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/af_afribooms-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..e62a46b9dc11dd860283145376f485b29ed255dc --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/af_afribooms-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b3e494ac9ab79d26fa504cc2859f663fc1992ff0db36ca2da6e440ad890fa190 +size 2111 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ar_padt-ud-2.15-241121.model/ar_padt.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/ar_padt-ud-2.15-241121.model/ar_padt.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..5897fb1d29fd568a487b27fd3ac3a370c350140a --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ar_padt-ud-2.15-241121.model/ar_padt.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1b134f75774135a4d09740964bc6bf21c75b3bc6d0909d7c02fe9c0b8b8e0b3d +size 140268 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ar_padt-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/ar_padt-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ar_padt-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ar_padt-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/ar_padt-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..d4b56b93f2df345533c6a238b5d696b7b106ef52 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ar_padt-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:14607e21b591c05d5d20a3e3059885c23a5b7be85984a600671a328b564d9271 +size 730 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ar_padt-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/ar_padt-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..162843283271fe003734d60fbecbab1a172cce87 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ar_padt-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1f246e7044e375a49861a69d07bdb2e16aa9137ecabdd1c893fffbf1f9ea15f0 +size 10566 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ar_padt-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/ar_padt-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..63f7d3749173e361b0877ce657076d3d4ee6d443 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ar_padt-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9f07b4721ee1e5543f0ed9326373c5acff1f80e1a1bf2c31d344bb931fa793c5 +size 5577669 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ar_padt-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/ar_padt-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..afa7a606b3c7f8c276acfaac15b5b98bc7610623 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ar_padt-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4e14b47b485197a48122b50d928eaeb5f3a88640147634eba5d40864b7989bd1 +size 874 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ar_padt-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/ar_padt-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..0cdef2fa59c2312310058d374556728845038c51 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ar_padt-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6a3d25a733019601f14458134ec4489e9fe09e27f538111516a82fd585130561 +size 115039120 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ar_padt-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/ar_padt-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..51a6f15991b7f8bc5cde2953940622e2a789c31d --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ar_padt-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6066e88fb05e90eec81f8e2c5a611eb7cdd90a2e39e4e7a997971bc220e65681 +size 2117 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/be_hse-ud-2.15-241121.model/be_hse.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/be_hse-ud-2.15-241121.model/be_hse.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..3b0ce710fa8c280de97d9b0e2c60d164def2742e --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/be_hse-ud-2.15-241121.model/be_hse.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5022a8b8760de8684fd3c21b855e367849c32a4a43a6f8348b8d7df08c60ae2e +size 327069 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/be_hse-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/be_hse-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/be_hse-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/be_hse-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/be_hse-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..5c100b6131ae77f6eb6afc52bbe5491aa1f9c961 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/be_hse-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b7843242c4b9259e9c7a209129cdfa50b0b78c8d87a8158aa46dfbc74574246e +size 1527 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/be_hse-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/be_hse-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..43c0cf8606a70736af63bacb6c25fbd1ba8750a0 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/be_hse-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a22db46396fcf3b0e275b77b9108fab0eff0173512a309ff10de8f858613d0b3 +size 10559 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/be_hse-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/be_hse-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..4eb46c47ef77cd5bd5303b7cf0212b27af31cec0 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/be_hse-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d04c746ac15d3ebc340fd56676675a60afdb469f3a35cab8670490ea0ab4af3a +size 1186367 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/be_hse-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/be_hse-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..c9286c71d3ba948a71068f5b27902b1480834676 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/be_hse-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:99daa548bc39c28b091fa944db6ed572f16dfb115ca9019f9084a3e99338d12e +size 867 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/be_hse-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/be_hse-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..1e682e5ba6cfdee12b05fc4b37ebc7428c12ec5e --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/be_hse-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f5face6d9ecf632884ae800d863add971f858ae2eb2890b24736ccba3025440d +size 128596748 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/be_hse-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/be_hse-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..804edc23c011ed6b0d6a47c25c06d79ac92ae173 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/be_hse-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2f0d4467f0e389006a6236953cf96eb17788e315ebe14f4b406dd35fa0696ab9 +size 2117 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/bg_btb-ud-2.15-241121.model/bg_btb.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/bg_btb-ud-2.15-241121.model/bg_btb.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..b3f6dfded2a767864c8450f09b1e637acda3b5bc --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/bg_btb-ud-2.15-241121.model/bg_btb.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:adedd5e2d6c5e74af4ead65f46c1c9ab38fa53edd5c238ea368ac77916bcd804 +size 217408 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/bg_btb-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/bg_btb-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/bg_btb-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/bg_btb-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/bg_btb-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..628ededa471bc20fc62431da76473e3e87913203 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/bg_btb-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:56f3eff79fd36ae95a53f00267b223d5dd6faaa2a8c2fff86987c8ec3ff4e65d +size 594 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/bg_btb-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/bg_btb-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..725c4796a98ac0992c492fddba5ab3acb44a3b4e --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/bg_btb-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:48d2e96e45799f911fedc4ee4b93a7b35cffac51bac20f6008236c3700c7a710 +size 10558 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/bg_btb-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/bg_btb-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..56c89dde2ab305ac3264d0b1ef77fac3db4a83a3 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/bg_btb-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:bb841d8f316af10309919617049caf6be4a0181001eb290129add97012c4e409 +size 525229 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/bg_btb-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/bg_btb-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..276a9506e9c7c74a85dea6afabc81f9efdf4dde8 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/bg_btb-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d2ee8b94676e9671f48d0a9c851154f7766c65f39c6ca19b21b0657f486c3982 +size 867 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/bg_btb-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/bg_btb-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..7bbaba438285fc5c4c9545f925156dc2ec5376ee --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/bg_btb-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ca6cb5eaa40af643dc0cd8c4c45e28c8ef95ced4356cdddcc6b7b8353c6966ea +size 100787084 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/bg_btb-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/bg_btb-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..7bb5abc461c33bf29ff97746221fc2a382151412 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/bg_btb-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:463c210a34abe4f66686d85c01efd95e19cdcc054be9ee96e5e7f5a063c19b25 +size 2118 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ca_ancora-ud-2.15-241121.model/ca_ancora.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/ca_ancora-ud-2.15-241121.model/ca_ancora.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..7b408ce5eba9660852cc743e696e2340264611b4 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ca_ancora-ud-2.15-241121.model/ca_ancora.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e3520949cbbe065ef08c69dc6e0a692a4014c46e922c976429ac628f0914da23 +size 226728 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ca_ancora-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/ca_ancora-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ca_ancora-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ca_ancora-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/ca_ancora-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..53f2d8b83deb5d638a98adcb67bee1cd8f370796 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ca_ancora-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b18c44389ec2797d5f856d7f8de143f36ff21d2389546fb99b54f305b7fa7411 +size 390 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ca_ancora-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/ca_ancora-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..2f43795560b23a43a94ffe47527bda1a6bf7cbcf --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ca_ancora-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:74fb7b0df7a421d67657a25822743b8ad2bec587ef20987713f1ec7e68f700bd +size 10579 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ca_ancora-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/ca_ancora-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..8d015e55685a0ec7e5b22c4166b4ca091c62d9b9 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ca_ancora-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3d5fd9cfa49a924aaae0796b94408ad0f0f0757b7d799ed5cfb300f98f59f830 +size 6249519 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ca_ancora-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/ca_ancora-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..cf917df97055fe4533506f3ec452a5ee4fe6c945 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ca_ancora-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:639a7a81ee80521d65adc6fb2b7d9ffbcce6189c74aecdddb89a974af47a23c2 +size 888 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ca_ancora-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/ca_ancora-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..7122d2d89a9b8d6b61feca6b124fb429b6c28947 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ca_ancora-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d70136e47a49ee53dc14478462466cba3f9beb55443804584dda119cc80d87af +size 112620472 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ca_ancora-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/ca_ancora-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..331150ebc92dd6a65e186bc28907599d75dd3491 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ca_ancora-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5f7b2df38515dfb7d48a878bcae7f4e0c5f08a93f67d243a3e2f14c3e9ab05c3 +size 2117 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/cop_scriptorium-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/cop_scriptorium-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/cop_scriptorium-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/cop_scriptorium-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/cop_scriptorium-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..5ea3ead28fabe5b8d498179e3f7057c5a243f61b --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/cop_scriptorium-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a208d6eb6f38b07de2aa00da1935428a0624c6155b407a73c09e15721a57ce55 +size 226 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/cop_scriptorium-ud-2.15-241121.model/cop_scriptorium.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/cop_scriptorium-ud-2.15-241121.model/cop_scriptorium.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..bbcf62ac2bbe7349fa950c7b48e36c1d223f747e --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/cop_scriptorium-ud-2.15-241121.model/cop_scriptorium.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e17f69a8bb4a4d980624ad07b568e000f341da5580bbff53cf26b9883d2cd3c6 +size 149368 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/cop_scriptorium-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/cop_scriptorium-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..2a543522050c5751c26b8a4dc894dc06a440e95c --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/cop_scriptorium-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:654ae26c8ece076d5de6e52a3309fc39d66145b2158b0e80b66bd8fafb2bfcd2 +size 10619 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/cop_scriptorium-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/cop_scriptorium-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..4dce8f3dbee90eb391d70939986175659d86d4fc --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/cop_scriptorium-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:50f1bf942872e225d106f3f830ee0b16d34e93e5a5bb521ddec5cdf614c9d01f +size 255221 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/cop_scriptorium-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/cop_scriptorium-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..184ff17608b82e114798a51a65b130b1f0c3a247 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/cop_scriptorium-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:72654dc3a3cf97ab577147cf6d178c766a4f93162e92dd9d6fcf391527d5bc36 +size 930 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/cop_scriptorium-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/cop_scriptorium-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..688246b75875149c42a4614fd1b61ca7b89aedc7 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/cop_scriptorium-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:21d6cd2aa203610b7c89a65546b2e3f8c11ec79449c8d89e6d30b67cceefe9d8 +size 53487604 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/cop_scriptorium-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/cop_scriptorium-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..a6c7310f8a37199cd6085eff7e50a9a8e9544368 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/cop_scriptorium-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4e010daf0184b5d32e6257f25ec26452657850ae85eb37ed35ab3934daf4612b +size 2112 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/cs_all-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/cs_all-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/cs_all-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/cs_all-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/cs_all-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..c6dc82521b02e46df3bfe146d0b5a0c99c4e1bb4 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/cs_all-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:03343a5a051e393d7d66e9e13a3d6da3f98fce2f7e76ea99f1b75fc35410ed84 +size 3506 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/cs_all-ud-2.15-241121.model/cs_cac.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/cs_all-ud-2.15-241121.model/cs_cac.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..7cec390a4c11eff0dac9307e567b7c489ccea204 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/cs_all-ud-2.15-241121.model/cs_cac.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:64f3897b97378ab9b32cfdd41f5e3e9fcb044baa3f575acfd5d41e5b266b0f95 +size 35917 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/cs_all-ud-2.15-241121.model/cs_cltt.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/cs_all-ud-2.15-241121.model/cs_cltt.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..cc9559e84ac8c2fca473e8d24a42ff89113b9e48 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/cs_all-ud-2.15-241121.model/cs_cltt.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e60e518e4a013f3ed7ac7f9dde09a19eabe9d1e84a2925bec186140cf07d5aee +size 36721 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/cs_all-ud-2.15-241121.model/cs_fictree.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/cs_all-ud-2.15-241121.model/cs_fictree.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..e075dd587f37f0d88a46e74e76a7db1c0919c0d1 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/cs_all-ud-2.15-241121.model/cs_fictree.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a0822af9a86423df3f9d24081c84f39d9ecb822fb6114d6db28c536d63a37343 +size 36875 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/cs_all-ud-2.15-241121.model/cs_pdt.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/cs_all-ud-2.15-241121.model/cs_pdt.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..43ef4b62f5ae0484c881666d5861788145eac1c9 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/cs_all-ud-2.15-241121.model/cs_pdt.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e1a4870603dd4aecf42f2de8e0459073a0918c5f7b8ea404f302f0e63f4ef866 +size 219130 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/cs_all-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/cs_all-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..230c04b3be2da4066c1b2455ef1badc206dd1dfd --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/cs_all-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c4df73624c9b33213c8b97d39c376ef3bb1f0f31ec8ca517935b6be42970347f +size 41746 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/cs_all-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/cs_all-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..c72458899338b2de5331e83b6808d2463f04e78e --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/cs_all-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1718ea4a02445def442f29f9b09d4221d2db6b5487a2f516a2ad07d307c47e08 +size 21578018 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/cs_all-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/cs_all-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..ffcc8a429e21c0d00247770fa6fec87d5723ce18 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/cs_all-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:15f5b438a2a0016c192ef8002fcaa9179f21629b4aff3149e9b75cdf2055f5d3 +size 1174 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/cs_all-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/cs_all-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..76fc92260a0cb70015e861d6feeae00e56394f1b --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/cs_all-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7c0c51b038b466057379c84e1b18ef36868dc65c50fcbb0e6de653a6722726bf +size 259262604 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/cs_all-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/cs_all-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..778583b51f4536a9c94c03286f2bab3c0cd71779 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/cs_all-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:25eebe5b70b348273b7e7d7d2cc2d7ca79adfe901c756d3b67a2487e9b6e49b7 +size 2183 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/cu_proiel-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/cu_proiel-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/cu_proiel-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/cu_proiel-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/cu_proiel-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..641af1ef704d633a609acdcade8c67d65264907b --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/cu_proiel-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2a1f052728c302ae39b2234682d07eb509204b39f6bb7ccbb038d5e3350fe333 +size 1355 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/cu_proiel-ud-2.15-241121.model/cu_proiel.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/cu_proiel-ud-2.15-241121.model/cu_proiel.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..cbccb934824654c7a9b2299ac2399b73519b3385 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/cu_proiel-ud-2.15-241121.model/cu_proiel.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7157f0a4c798714d2b45ec8cedea55bc31677a8464b06b5f1e0626b9b5ab48d8 +size 224578 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/cu_proiel-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/cu_proiel-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..a633e25f31859556fa6ae86c15dcd01983c9e162 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/cu_proiel-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:17886a65972659cfb5797e6db73a2978e68a7e2054be6f1897cfe7f618e200d0 +size 10580 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/cu_proiel-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/cu_proiel-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..fa4893114bcaaa175cc2e7f41c30bbf50d3144a6 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/cu_proiel-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e03ce9e9e1b1db6390203cd6e23b3aab0147312d0c31ff7e2c4899e2f4980d30 +size 1054706 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/cu_proiel-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/cu_proiel-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..92f92449bff4c47dbc43b7e4b1be448fbf5a13e6 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/cu_proiel-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:acef36e9ac3e72f9c07fbaa884ebd0c6bd0d89fb9d995b14b6393e71170910ed +size 888 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/cu_proiel-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/cu_proiel-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..359b4dd7b64c83a24b44c81405e4915e046dbb1d --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/cu_proiel-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:238b564bdf377f77dc1d9de2f7b2ab04511a6987d18127587697f251c54886ef +size 139127056 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/cu_proiel-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/cu_proiel-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..87fbf18535d2894bd0651b640cdeb046ce4ee84e --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/cu_proiel-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6913615fcfa73f9db036337b5c623dc3eeb44eca2f0021b81ee2d41c8f8dcfac +size 2117 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/cy_ccg-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/cy_ccg-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/cy_ccg-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/cy_ccg-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/cy_ccg-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..61de9bbd6528994f5fe8551154d8e20ace7e85f2 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/cy_ccg-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a25d2b8a6872786e516ef3f73ef4d6baaa2508ad5cf37b232dcbfbbfa4d89002 +size 412 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/cy_ccg-ud-2.15-241121.model/cy_ccg.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/cy_ccg-ud-2.15-241121.model/cy_ccg.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..44f30cb8d6baa84bf408dfe68880a5774c0fc886 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/cy_ccg-ud-2.15-241121.model/cy_ccg.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:15c95245281aea4533ce1e1941956b0a9c802557cb1d7a53e627e8660c24822d +size 37044 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/cy_ccg-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/cy_ccg-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..b36bbf40be0eb1c98c50af35990556fcb29580b9 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/cy_ccg-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:027b83d5487984c1889d1f458531ea1ecfc9ab685acdff7e8c229e5846d82649 +size 10557 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/cy_ccg-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/cy_ccg-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..5a61f2f25b3a2554c597efee5a3f823586fdf525 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/cy_ccg-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:82322f2b72721a787a61d4876df9346fcf1b4b2fcc2ef78fef067e7906370648 +size 83435 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/cy_ccg-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/cy_ccg-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..f38934784e658648fde1b5beb1e2c50677045fbd --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/cy_ccg-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:37147607d914b49c3653c65601c7029a069ca2e2c66d630f6df27241ccbadb1f +size 867 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/cy_ccg-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/cy_ccg-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..a81425cd062bf319028f52926a824eb6c9b0df0b --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/cy_ccg-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0f5ea37ccf31389462811160a61781ddc9cd078349ebf779633a68a5390977f8 +size 56367644 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/cy_ccg-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/cy_ccg-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..713e14317c36a66deb56170f7b906a7b090345ed --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/cy_ccg-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:56a6a6a5adedbfb7df5b3bc8490fd64ffd5a9891254a91d4a19f2814844d01fe +size 2114 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/da_ddt-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/da_ddt-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/da_ddt-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/da_ddt-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/da_ddt-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..88fd03fe146dffc6f1c82abc39233d898ebb6022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/da_ddt-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6424ca2d4f27a3c5ddad5e506e35d32f5a0b4f5656fb0bfbb85e2d37c4f25fc5 +size 345 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/da_ddt-ud-2.15-241121.model/da_ddt.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/da_ddt-ud-2.15-241121.model/da_ddt.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..a62f4e6e91a0a97811bb63bead0842e5c3dd1fee --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/da_ddt-ud-2.15-241121.model/da_ddt.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:008ace90a5577f22fecee4e0772f18351a8b87d7f5f6d8c921fbb8df24d523f7 +size 35998 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/da_ddt-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/da_ddt-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..3d88fcafd6feea950683d797e338b8743c23ff73 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/da_ddt-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7c6bc87acf6c5d520be4091533395a9963898294df3913d3447e6688cf6735af +size 10557 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/da_ddt-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/da_ddt-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..f2aea0c3cb2e32d4a722e9e2bc2dd04dfa0974bf --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/da_ddt-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:19e61d3297f281d57aed3b233e0d52a1032e400458986a6b261fae8ac54f9950 +size 161081 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/da_ddt-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/da_ddt-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..f33506a9189e2c54b44dae1362769d4d04d3d6b1 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/da_ddt-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:875e1b70d172e73800c6bbbad855c4ec2953bcb2b333c1ec5761b522ce762ee5 +size 867 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/da_ddt-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/da_ddt-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..6522a0a597658c3964e4a5e8fe2e3874d8734629 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/da_ddt-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:405651330f86bcf265f435a57f0ae4ec8175940cb23595ada77bbe79aa638634 +size 90161388 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/da_ddt-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/da_ddt-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..2030e08bcd92e958a14cf5c2eb885d8025b8a79b --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/da_ddt-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:405bef8bcc5610b8a6d148237691c82efb1a042a92a93729b413687a5ebd03dd +size 2110 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/de_gsd-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/de_gsd-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/de_gsd-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/de_gsd-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/de_gsd-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..15ef2d532bc9df20e14123191a356fd7de4ec119 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/de_gsd-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:59b07fae7ac2a88860292bd6f3ea4c6a7617b79bcde4d47e3ccfe2e3a557f875 +size 1054 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/de_gsd-ud-2.15-241121.model/de_gsd.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/de_gsd-ud-2.15-241121.model/de_gsd.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..a0cc68c05d871464f2d356251518fd83bebf0ebe --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/de_gsd-ud-2.15-241121.model/de_gsd.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9292e7854ad6fc17e32fbe441f39170f53e745fa0659280380f3d6a2ad967246 +size 244712 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/de_gsd-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/de_gsd-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..763723c56f0d60f61e67994e841646007d4498fd --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/de_gsd-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e1e76b9ac9d4a7ad8aa2ba01a660f7eb2a0f58c62c374fa4a704d10f0512e8ac +size 10557 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/de_gsd-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/de_gsd-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..8f663eee506c315f17a1cad9cd97f319a4460605 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/de_gsd-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3df01ced0b7d7227602435bbe0a313e74ac837d86ac4e89c6d4206aca26afcb7 +size 485498 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/de_gsd-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/de_gsd-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..fcb728c7d8b1de626822a7c7c756c796f3b1f1f5 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/de_gsd-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6a03266ccb06ecaa516b4224f37e21a86c92d792ce74e074db8b7cdbf7a8b2c7 +size 867 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/de_gsd-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/de_gsd-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..0f69c142298201d8678827172ed8f4438d7117c8 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/de_gsd-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3453156df8361034474f2fc4176eeaa7b53c12d5d146567d898164e47d0d7699 +size 113295532 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/de_gsd-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/de_gsd-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..0eacd60ecfe741d12aec0e5a5c33872694e28f14 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/de_gsd-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1aec6aeb4fb661e86899fa6b0a95be42051a39425323bf9331b6fd51ecf99a7c +size 2116 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/de_hdt-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/de_hdt-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/de_hdt-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/de_hdt-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/de_hdt-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..25dd822f959e5ace042deb39dc95d006bfa11ec8 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/de_hdt-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e9d147e944a92dc7b692d1bdf81e4d6cc83b0c389a94ace79e56eeb0f04b0bc0 +size 903 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/de_hdt-ud-2.15-241121.model/de_hdt.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/de_hdt-ud-2.15-241121.model/de_hdt.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..3fb27407e0b973994e36f176592fd56f85dbcfcb --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/de_hdt-ud-2.15-241121.model/de_hdt.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:78856a6bafa407def9ffd74d1b52e3447e1616497fb8891d927f0558cd385935 +size 214139 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/de_hdt-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/de_hdt-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..e74f79c443f0e4951b7ce76e37b9b80831c783f5 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/de_hdt-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1cbc624652421552cb7cebf183baaa3a9c268f38b3a21a5bf7b8a57d748683f1 +size 10558 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/de_hdt-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/de_hdt-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..df815269e3342aa82e375c324ce2bb1e2a02b6e9 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/de_hdt-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7083c2f642b4a2611b23f8d64abd8643d2c7dabe2f9127655cb060955a868435 +size 2341441 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/de_hdt-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/de_hdt-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..6b44305c304f16f1f6d4c5faa1d6ff7136467d7d --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/de_hdt-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e501486bf5a3d934925bb6e943033087eee01021710f569ceb6fa65ef6edfc87 +size 867 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/de_hdt-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/de_hdt-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..2b38ed87ce02dc80d5206de0f7f4af78b2609be8 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/de_hdt-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:39cbda3d5cf794d14b41a11f96139bf67737aa43d727e944aee83b76cc2a1ee2 +size 241416104 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/de_hdt-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/de_hdt-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..44a8a0d892c8796b3cea96ea5e352caabcebc51d --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/de_hdt-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2919e3f4f191dc945fde892221f69b6834ff0627aa94eb347deb86a8b1674d00 +size 2117 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/el_all-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/el_all-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/el_all-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/el_all-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/el_all-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..927dee39cd21599a2dee4f228cd470b689761423 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/el_all-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6d212cbb34d1de238e42ab2914f929206acc2134583c88748c7cdde98e383982 +size 806 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/el_all-ud-2.15-241121.model/el_gdt.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/el_all-ud-2.15-241121.model/el_gdt.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..cdfec528f7be1b84d396fd86e77596954c7c52a0 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/el_all-ud-2.15-241121.model/el_gdt.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8810507fdde47ea2fc4282cafaa619f3040fbd4268a2353ec687cf37dfb99771 +size 40477 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/el_all-ud-2.15-241121.model/el_gud.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/el_all-ud-2.15-241121.model/el_gud.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..76a4257fd429a8d955c00b431e8901c52cc08513 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/el_all-ud-2.15-241121.model/el_gud.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:51f5d77e2401041dcb917196e1b6993ff1e0639a487adefb2ed28a3f2d7dfee5 +size 36867 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/el_all-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/el_all-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..2bdc147f054322f0086bf8d1d073cc911a79dd1f --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/el_all-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f8adcca2955ad741522c8da94070f977e28625a19f9226f263f45f73b372b7c8 +size 21100 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/el_all-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/el_all-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..00dd4a7569d18e54cd6dcdf928751074dd42fe20 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/el_all-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b5d626f84b15beea4993fe3e0a381318024cd5e89fd02e14676089ee7709a51f +size 241580 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/el_all-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/el_all-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..049d871b813b0d63a7d21540627108309ec82bd9 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/el_all-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a4a665b0ccaf3a04037ab412de77fd83ff56d7057adf12e85e475c73a1d9bd9b +size 974 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/el_all-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/el_all-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..64f3e6d728fcb7b751ae2f9578ef05173abe4bf5 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/el_all-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:bbd1676be7aa588ef92d10f79b7e49acfdd0eacada6678c62a533e2b03d4b191 +size 94803596 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/el_all-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/el_all-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..3c13e4d9392f9634a49fa1f9b4082bddafc001f6 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/el_all-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:abeabf6cee4664711b14af08d6ffca7b8cfe409c95965d70728a7713c1c68124 +size 2178 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/en_all-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/en_all-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/en_all-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/en_all-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/en_all-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..8a7bff0a43fb8d7ba805abfd264255ee00d6e581 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/en_all-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:549c2a5663c554696aa98e2e4456d71934a8c9627cf30c49ac0cd473717b63aa +size 692 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/en_all-ud-2.15-241121.model/en_atis.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/en_all-ud-2.15-241121.model/en_atis.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..210b7158b985b278c87b862ace0b602f6664afb3 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/en_all-ud-2.15-241121.model/en_atis.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:56bf9936caaa6c175da0c876b5ddfd77b392a90b2e90fccfcf91840dae548978 +size 194280 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/en_all-ud-2.15-241121.model/en_eslspok.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/en_all-ud-2.15-241121.model/en_eslspok.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..e98bcd7ac8a4a5064d5879895575f3db8c922e14 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/en_all-ud-2.15-241121.model/en_eslspok.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9323c607bb587185a302ac675ba62789a30b71ff9194ac32b23a1f2a7d77e14b +size 32373 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/en_all-ud-2.15-241121.model/en_ewt.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/en_all-ud-2.15-241121.model/en_ewt.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..27eb3a62f1e1569d2461617614ab19a04198a7ce --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/en_all-ud-2.15-241121.model/en_ewt.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:05a3d3be2b8b1b47cd649b18566bcb579472be1f93ee4e4d0ee8d72ecb6b6805 +size 45700 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/en_all-ud-2.15-241121.model/en_gum.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/en_all-ud-2.15-241121.model/en_gum.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..3e57f33e6ed67b2594060342b9a125f99075ab8b --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/en_all-ud-2.15-241121.model/en_gum.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b5b0cd6f1856a0115b15f5319502e959ad7ec750b78b2c6947d97bccdd8df89f +size 243451 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/en_all-ud-2.15-241121.model/en_lines.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/en_all-ud-2.15-241121.model/en_lines.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..12949bde40a712f6294820f9043ef536df94dbac --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/en_all-ud-2.15-241121.model/en_lines.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f83558e7c145e206d699e52cd3be5e3f5d98d287246ba60c5cea524fc294b707 +size 38669 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/en_all-ud-2.15-241121.model/en_partut.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/en_all-ud-2.15-241121.model/en_partut.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..acd5e87d4b3fd2c55ee789d7455c216a5c669e6f --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/en_all-ud-2.15-241121.model/en_partut.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:306a44ced597ba8da9db70d4673fa07509c8f563f7d347101ad2ef5df3f216ce +size 36314 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/en_all-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/en_all-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..e55c71e7ded17a8b19bb17a1f37efeded1a778cc --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/en_all-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:231152bd557d5257fff77453e38375bde0b5240efa43cd3e660f7fa5b887ea46 +size 62599 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/en_all-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/en_all-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..84beaa1aac0cb92959debf4851832cc83e0c8e2b --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/en_all-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a83bf93f657d081146d2bce8cda97d2e3115f892a89145cb25a34f84349ad6ec +size 6781705 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/en_all-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/en_all-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..e584c7c450f92f5adaeb36b495abe107f002c1c3 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/en_all-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e5114a3e602b95348c52145d22f1c7a18d83dcc62dd4dbfce5263383170380f2 +size 1406 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/en_all-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/en_all-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..149574349921f9500a72d2b79f9c84225d62e245 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/en_all-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ddc2b8581493d805906d9458b28fb5b4bb1ce0d1645718b0bde01ceeff51d6d2 +size 120620552 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/en_all-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/en_all-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..a110f43dee0c9b7d23213055f82a92d5adeaf163 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/en_all-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b8259ddbd0fa5fd8f175a93ead4893be52a6db1c5bf6eb1f093c53d6abae9ddd +size 2181 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/es_all-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/es_all-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/es_all-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/es_all-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/es_all-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..2eaa626106f9d7633028c4529ea7436e1a8adcca --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/es_all-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ba251eb9cdce0d174aacb671746fbf51821d86d06cb94edca754ad0cd5ac2357 +size 760 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/es_all-ud-2.15-241121.model/es_gsd.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/es_all-ud-2.15-241121.model/es_gsd.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..4bc582d015ce5fc30291764b7e0e38adfb9d9a31 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/es_all-ud-2.15-241121.model/es_gsd.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:cc292f720bdf56f1593a7ec2d5422352b249674b65f16f609127705e2b8600e8 +size 72829 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/es_all-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/es_all-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..b5343d89012610867c18bd1c0872260a1a503364 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/es_all-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4eb3307028f0fa535132e67ff6ec71a7db58413bf29e97e45d4ba070186ffc37 +size 21356 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/es_all-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/es_all-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..d0ae46b61f73c56f40b52f62ab1e6d314df62dfc --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/es_all-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:695026f5a6a8cd1748706b342ec6599d76b18eec9f7b32b9a283a7e103e73173 +size 7544646 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/es_all-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/es_all-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..5d88eb0a47be6c28bcfc5d8f6fc72247368ac55b --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/es_all-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:fd3564693cd17d66ac3f0e36e06469fd026eb0ac500e995d35efd4585d7b6965 +size 992 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/es_all-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/es_all-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..977c74aea171f54205319bce414aa528a1d455e1 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/es_all-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:014b70e708f7a7b318b92cb825d8b75e9534491b7d94b0e795bd0082e7880ec8 +size 145322596 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/es_all-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/es_all-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..80e77a4c798e8406b9df2d4c5b5f3521b83bba52 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/es_all-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:97b3b00ba709024b31da44b8d589640144e5cc3c9a13c53466fc3f8f6ca60b10 +size 2181 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/es_ancora-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/es_ancora-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/es_ancora-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/es_ancora-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/es_ancora-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..9854b7debba83b909f75d6e7b6b1359622051cd9 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/es_ancora-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d475c709efd8d21f4002a37021cb5d497703c7bbec1d6170779c2549a17574a5 +size 499 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/es_ancora-ud-2.15-241121.model/es_ancora.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/es_ancora-ud-2.15-241121.model/es_ancora.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..a2bbfda256ce6e983eacabe926bfeec4d7eee17c --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/es_ancora-ud-2.15-241121.model/es_ancora.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5fa9737fd230fed87a856fd6cd6100813ce373e9f6b00f108305801ada7ecc36 +size 232167 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/es_ancora-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/es_ancora-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..84a64d54ed2a9f8fa38f963c30abb1bfbce3a815 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/es_ancora-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b18adeb9c1cf65eac4a79b4b910338a2d73e9fb39bef345361a986e0be2f0073 +size 10579 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/es_ancora-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/es_ancora-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..4ff131c413a4e7ea7b8e7546ccbc4abbe112dd58 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/es_ancora-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:499755f1c8ec464e415009363d4bec985961c0bcbac4089ce9628dde0a88a654 +size 7218389 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/es_ancora-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/es_ancora-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..d4971110fc050524a505e72f0e89e3c8d3fd7563 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/es_ancora-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e31897d8d3ba0606270116403c460bf1b5e5c2d661b63735f07bbf0584d20fa7 +size 888 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/es_ancora-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/es_ancora-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..cdd9d8017ff27b8645ac26561ba2b657a33a61ef --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/es_ancora-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9b7ef7401890b0eee08217e081ed57b09f6374e043ad62598d8cbd39d84ac59f +size 119155148 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/es_ancora-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/es_ancora-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..0c29a780fe9542a3708595aaeb89c8bfda65061b --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/es_ancora-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e15c08b55dcb6eda3f35d7ad98f746f444233c9eca1c6ccede4bb36b8f33c352 +size 2118 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/et_all-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/et_all-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/et_all-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/et_all-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/et_all-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..95a2c7144297fbea83a9b8549e978a494390b771 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/et_all-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:cd1f44108472c189a1bf8c5c14004366ea3c55279362c796151b9bbdd8ab3166 +size 1489 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/et_all-ud-2.15-241121.model/et_edt.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/et_all-ud-2.15-241121.model/et_edt.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..68e43a181b1e4400f55e85cb3b64a7553f2761d0 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/et_all-ud-2.15-241121.model/et_edt.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:517080db2be4388d65f60dbd659656085856de474a835af68a88b0d656f8e2ba +size 215096 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/et_all-ud-2.15-241121.model/et_ewt.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/et_all-ud-2.15-241121.model/et_ewt.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..5020ddb9f2ba0dda138182a7b0be8c44dd428821 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/et_all-ud-2.15-241121.model/et_ewt.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b1b32e18dbe7053a4796ecf977c3fb2c75219fed364994ec877abf5f4156385c +size 38868 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/et_all-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/et_all-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..79ebf37116cb99b2c4930a63fdf2d8198b238fd5 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/et_all-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7f7be9c54885b2fa905732c22d97114e33786562a342713bbcafc9ffdc237b32 +size 21100 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/et_all-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/et_all-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..72418323c5b504918ca155da7a4c8b8735f65795 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/et_all-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c40152d2ac2d76cdcc71595662dbfa06210f0436c57e635080914f8b4d9ecc71 +size 1739934 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/et_all-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/et_all-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..e3004df04446bb9623d2490cd8093de75ac11058 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/et_all-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:15aa83f13a1cda5612a34b276821883121bc437ab2271480725236f889d236d1 +size 974 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/et_all-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/et_all-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..1d04f961e4f197138ed4404cedbe078c3b34b15e --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/et_all-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d1e08eac11bddedf894a6ec0ecfc2b8e4410d2d462c1ccda7ffa51f6f9ec062f +size 155835812 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/et_all-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/et_all-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..6b9fa16d0ed62fa4ee8566e4177d678e7c0c3f25 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/et_all-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d381f6e3452ec20a72a3a736e840530539aa46f094abfcc5d653e12051d62531 +size 2179 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/eu_bdt-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/eu_bdt-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/eu_bdt-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/eu_bdt-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/eu_bdt-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..957b4111b30a37a88de1f5933fbe9a184914d7b4 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/eu_bdt-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a21fd2db5bbeeb299bfb3a70235ada70a3792687051a7f70c6fe2524cdd591cf +size 965 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/eu_bdt-ud-2.15-241121.model/eu_bdt.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/eu_bdt-ud-2.15-241121.model/eu_bdt.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..71929ba08c0747715db9f3cdc589f02f7041a11f --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/eu_bdt-ud-2.15-241121.model/eu_bdt.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:eaff1ebc29690964a6fe362a60282a29a16e29ebf2e638ce51886033f76cd08b +size 34844 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/eu_bdt-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/eu_bdt-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..19332b6820c53239fcda15088c72d79fa2a781e9 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/eu_bdt-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a5520388bafe887e6fbb4daa75329f4d5363273513edf466ac309272f4e794a4 +size 10617 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/eu_bdt-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/eu_bdt-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..93efdee6b5309580b2ae97913c8e969399461edd --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/eu_bdt-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0d5c24350d76d53b1ad37ca406bf1a1a8b533b039aea71f190f7607fd8973d72 +size 256230 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/eu_bdt-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/eu_bdt-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..9cb300b20a0d91b4df1b4de093c0e305fd609eef --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/eu_bdt-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:22f9883a8c3c706bb72527a278af71c8fa3687701dd43e9273481779021cb943 +size 867 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/eu_bdt-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/eu_bdt-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..6705fa5e9394dabc172005b11b0a4716546408f5 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/eu_bdt-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:94d019035e06ea71fda96f8db72a5e6c092d9f1de582080730bce329e8f4e57e +size 94902468 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/eu_bdt-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/eu_bdt-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..3120bde69655e765be33e0c36d57446769ff2776 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/eu_bdt-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9d26cb7ebaeb43d41db84fbe819b5615c80a1336f2d8ff96593ffd911c932f27 +size 2113 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/fa_all-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/fa_all-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/fa_all-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/fa_all-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/fa_all-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..ac30691c81a91cf16dccbb374fd889f1942d1b1e --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/fa_all-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0b15746128f0ab75e3e46170b17f2c0a4df605e693b1f51cef2d0285be86e3f5 +size 282 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/fa_all-ud-2.15-241121.model/fa_perdt.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/fa_all-ud-2.15-241121.model/fa_perdt.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..c7f33456011104977eb2b5643f09880929970acb --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/fa_all-ud-2.15-241121.model/fa_perdt.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b21e62f124f9cd2c2bcca9a748a57b7b26dab644fe5609416cdce4c66b4f3852 +size 93092 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/fa_all-ud-2.15-241121.model/fa_seraji.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/fa_all-ud-2.15-241121.model/fa_seraji.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..a1899afb8b7fb4a38d942de80a38ccab38a791e3 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/fa_all-ud-2.15-241121.model/fa_seraji.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e3806edf7f8e69f2baa2f9376072eae93df1a19d7b1307760980e26c8b707a9a +size 47431 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/fa_all-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/fa_all-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..be6149fe3fe08e4f78ce28463e8e87b00b070dbf --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/fa_all-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:00b5899bde358ad8688d7a279456c63ff683d770c5b78be5143fe0a531501408 +size 21434 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/fa_all-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/fa_all-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..68ba912b7d3d4105f9ed4c536d91f7dd5aa6faa0 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/fa_all-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b13c569d1f3e513df5e52e3426e270be3c280a1b682250120d1a9f5fe51d4acc +size 1505426 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/fa_all-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/fa_all-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..9f7b37b816f33b29b86c8c0e7ab55329af58af05 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/fa_all-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c28dc33a1e6004aa7de7b1d9eea680032f12af1089aeea9f41caaa6bc5474d29 +size 1004 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/fa_all-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/fa_all-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..68e868d6cb4dc789b6df3aa35e6ce04babf529b8 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/fa_all-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:561d469a1b5306dc12b293c1c38a62688ed986f082fd7e3ecf363fe79e1142c6 +size 122353060 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/fa_all-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/fa_all-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..0d991d90caca1b697c6af48abb3e661ea82e50c8 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/fa_all-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a7f8064ee23037df830ff0996e963f42800bec1e417637ffc4351288ef34552c +size 2179 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/fi_all-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/fi_all-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/fi_all-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/fi_all-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/fi_all-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..4f394f7afc0e50856b1fa30bc0d40aec52f7527d --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/fi_all-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:23b4b8ea74e8f5dc9ad5f39de1c7043ee0a8fa38f3015a16fe4862c9baf5137f +size 3536 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/fi_all-ud-2.15-241121.model/fi_ftb.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/fi_all-ud-2.15-241121.model/fi_ftb.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..d39e540be4f7ae5af6d052c5143044786bf1e372 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/fi_all-ud-2.15-241121.model/fi_ftb.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:dd4b8d96db9dbdce80c3b3e50b48fbfea2db0b97717ec4ab33c101521b70be3a +size 208347 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/fi_all-ud-2.15-241121.model/fi_tdt.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/fi_all-ud-2.15-241121.model/fi_tdt.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..7c0f9b070677cba47ee813bbef6b27a9c11902b2 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/fi_all-ud-2.15-241121.model/fi_tdt.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f2cbbaa045e696d5f502552e9ef65f6a9e4d0f0e5ee6c88e377f596970b91446 +size 243972 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/fi_all-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/fi_all-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..b6b211b9b3800926ed18e9adf9d0dcf8a990dd47 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/fi_all-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b3517ca78d7a2787b8f31e34502692b25c3ed0ef2e5daa36effc171c1afab7d7 +size 21103 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/fi_all-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/fi_all-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..2b85f994b0b6494449fcc16916a3de0e6e75fd99 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/fi_all-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2b966aff07033dfaa9efca08e8ba3cbaca82f2f4302ee91569e6aed06f2f917c +size 1358837 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/fi_all-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/fi_all-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..9aa1c755c12384bf2c2c0feafb5c899a0f3e2645 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/fi_all-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7c7251524861a4a1a7fbbc0b63670327b89703aede480b02658d021aaec827fb +size 974 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/fi_all-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/fi_all-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..9fd2ad366b27524d30a77a03f26c5fcd45f4393c --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/fi_all-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:12189085b0a295d82b6a466d1282d4513435d44f1b1b188441423881534dccdf +size 156513300 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/fi_all-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/fi_all-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..8800096ebb555fd71e83b75f9a647eb1b2b27eea --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/fi_all-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6acf28069b48686da63ee9c0a9649b2732885935fba53e28b1738f36d08d43b1 +size 2184 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/fo_farpahc-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/fo_farpahc-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/fo_farpahc-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/fo_farpahc-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/fo_farpahc-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..dde6694703d4464020bb2f967d96539ff8608b89 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/fo_farpahc-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e3bbe5418adf056481216990cea7b0ba1499ce86a1f9d3f3b5caf75059cf6cc8 +size 214 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/fo_farpahc-ud-2.15-241121.model/fo_farpahc.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/fo_farpahc-ud-2.15-241121.model/fo_farpahc.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..1791e945f36c81f75d3b57c3907e3c5d2e86ea1f --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/fo_farpahc-ud-2.15-241121.model/fo_farpahc.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:37351f9c9cc85ee45e929346c73a782184184bf5c4c146c07b31143ad62aba37 +size 32599 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/fo_farpahc-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/fo_farpahc-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..2bd3bbe87db444bf9c71fc5966adbe967e35afe4 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/fo_farpahc-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a2537793a1f912af4e6f7af7cced7faef53bc6c2f9003539bf07a250640bf467 +size 10644 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/fo_farpahc-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/fo_farpahc-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..4d746cd309b15c5e6acdeac489eb3edc53f8c992 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/fo_farpahc-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:81f0883a28535708f5deea00c2dddd6c4528d5c0e2ddea6c77bd77d8bcc02292 +size 33889 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/fo_farpahc-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/fo_farpahc-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..6e9441e20346e1f13fc2bc4c55593e3b4f002ab5 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/fo_farpahc-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7423ae066bdc4295c78802939b695388e00cb9373656e753444508fd595cd8a5 +size 895 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/fo_farpahc-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/fo_farpahc-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..69f01c5605924dede5d3e8b60badf7fa776e94b4 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/fo_farpahc-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3304d5c15792d6609f8f4b403e7a5c7d3a9ca3106c9a5e4e439f810150aac2a6 +size 52133648 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/fo_farpahc-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/fo_farpahc-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..afa159a52eef4f5bb6004fdd2d940c18ace7a068 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/fo_farpahc-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:642737661e414c416c97988f1c1f321f6ead5daf57c9f6574ec4a8f96e7c67f7 +size 2109 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/fr_all-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/fr_all-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/fr_all-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/fr_all-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/fr_all-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..53631993eba91439ab9adf5f97d81ff8d107977c --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/fr_all-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d30a5dbd41e7a24a26ff911012a658296a168886dff327abb99b8fe162fb2252 +size 864 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/fr_all-ud-2.15-241121.model/fr_parisstories.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/fr_all-ud-2.15-241121.model/fr_parisstories.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..9427636e6df713aa3b706de54a2507cce4b51c6f --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/fr_all-ud-2.15-241121.model/fr_parisstories.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2c801e13877c24230a508919c2c81e1a5a4f4d3807593df3a5bf071d1873beb1 +size 203796 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/fr_all-ud-2.15-241121.model/fr_partut.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/fr_all-ud-2.15-241121.model/fr_partut.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..ea8d2bef9c028e9aa8c765beb7c054a67f94f50e --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/fr_all-ud-2.15-241121.model/fr_partut.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6dd05448bc5d39a634db70766e40ef1dc461b7c8905e5aea2f96fcddb4efd2a1 +size 35917 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/fr_all-ud-2.15-241121.model/fr_rhapsodie.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/fr_all-ud-2.15-241121.model/fr_rhapsodie.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..6b624187a645b02f88724bc94e11ddab19222072 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/fr_all-ud-2.15-241121.model/fr_rhapsodie.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:022c731882381733db460f67fe4fda85e7fef08d1316cdbe3b81e654ab72cdbc +size 33763 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/fr_all-ud-2.15-241121.model/fr_sequoia.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/fr_all-ud-2.15-241121.model/fr_sequoia.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..1f77bc439894967e908a0dede7201cc555fc778e --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/fr_all-ud-2.15-241121.model/fr_sequoia.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b7310b0458fb6dd1bc1be9603099246b9c23530694b85c01c8e6c79a67b5ee45 +size 36881 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/fr_all-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/fr_all-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..ff329ac76b42c23c046b94d4e212ce59ebcfed2f --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/fr_all-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:11095c4b2a2af2341bd67d1b1a7e8274330173b2854d40c78155ad39fff0c8b3 +size 53305 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/fr_all-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/fr_all-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..9b6ab6277893e6b0c39c51ea11261cd12b021dd3 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/fr_all-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:17889810537a517cceb5d4d829c1bfb495be88db331c7bfaf2fcabae5de46932 +size 8367180 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/fr_all-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/fr_all-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..12ae578cc55c35c1718a4e5149ff5fdd22c69b06 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/fr_all-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c6b283e3ff22a3f2d533b4f79bf38f7e4ac12e599424b1534c146a1799ed9604 +size 1385 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/fr_all-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/fr_all-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..81a7302c8e98ed5e2d19356ccfd76f506893f133 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/fr_all-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7348796af922d92545c6a6a69b78fd5da3695cb12606443b1f0162f0d363d6a8 +size 144833612 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/fr_all-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/fr_all-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..6aa60382d9b43c1aee20eccc0763455b5e2d1989 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/fr_all-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:caeeca33a04df5d395512e87daab57cf7bf5e0aaa401d5aad4e82d0df94d30f3 +size 2179 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/fr_gsd-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/fr_gsd-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/fr_gsd-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/fr_gsd-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/fr_gsd-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..b200e4aa5068e79ff96d541a118fdfb14b73cd23 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/fr_gsd-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f077ca90ceb8fa654e1f5529000ca3ff0296a21ce323778d45412afa032f0f66 +size 671 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/fr_gsd-ud-2.15-241121.model/fr_gsd.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/fr_gsd-ud-2.15-241121.model/fr_gsd.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..a52d65cde4017310fb18a7b3850603584f4ca114 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/fr_gsd-ud-2.15-241121.model/fr_gsd.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:29c69f9139f2693fcc5da2899ce4626324009a097f2b63da6ebe75d90f94d11c +size 258797 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/fr_gsd-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/fr_gsd-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..60d47dc04e04878b2cc3e70dded7e415578688e6 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/fr_gsd-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0c088db095ac97199124bd945f7cb878d06c44ee41dd33d5c84b1fbadcc75db5 +size 10617 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/fr_gsd-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/fr_gsd-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..fb6df366782aee4c1d0b741bdf847d42744050c8 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/fr_gsd-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6c046ddccec05527d7310ab0eba17b22f74a5e9fca6e25a1ae99b876ea9e607e +size 671574 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/fr_gsd-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/fr_gsd-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..f9e931fbb4cb9d44f76fca3ba1a3ddfeb109baa7 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/fr_gsd-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b3e5754f4cd94fd8af10eedca70f531624e5f712674ff123e05727044cc8ae21 +size 867 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/fr_gsd-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/fr_gsd-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..3671983a1dbc0456e523f606bdf8555209f24606 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/fr_gsd-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:cdff8bba4a13a908e3ad332bb94fa4de16a70ab0804686b1f847a92741a21f2b +size 116218224 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/fr_gsd-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/fr_gsd-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..6e21926cd5523398d860be8cccffef57591c34be --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/fr_gsd-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:fd941d2424c59ee6ad871b0b133695732e3c098e4e73619ad493d435276512bf +size 2115 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/fro_profiterole-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/fro_profiterole-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/fro_profiterole-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/fro_profiterole-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/fro_profiterole-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..303db08afd3536722b7d68539a13d3801b08b0ae --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/fro_profiterole-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8017d536e99473c31ade224f9fb2943c3a877a69ef3bf26888f8d681505dcf3a +size 216 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/fro_profiterole-ud-2.15-241121.model/fro_profiterole.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/fro_profiterole-ud-2.15-241121.model/fro_profiterole.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..d48ca96ab42ebb715088f461840d2261926b0e54 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/fro_profiterole-ud-2.15-241121.model/fro_profiterole.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:537e2e324958f6c2ed130680b3779ff7fd64d1af0db97a908fe43b0c85e03945 +size 35227 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/fro_profiterole-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/fro_profiterole-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..bcffc2bb75e4218d633a07f7513c7a90576e8e13 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/fro_profiterole-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ee735f5ae0593eef6bd79c2c82de8151ab63ed56151737c33ca3bc79305ed73a +size 10620 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/fro_profiterole-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/fro_profiterole-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..1dd84d3a26bc1d488274946e948b976dd11ab34d --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/fro_profiterole-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a24d0b4bfd6a9e3b4b92debcaed0f69dd06aaf1ee4ad73703d0408fd3c112e2a +size 7460947 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/fro_profiterole-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/fro_profiterole-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..61b6ccb743bc1293525128f3a4756d25a8cf4e5c --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/fro_profiterole-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7ca5a26e5c114e4d7c54873fd9141db09d7c4ae27b87b24f44c2d94104ae4dac +size 930 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/fro_profiterole-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/fro_profiterole-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..78f504464de0d1b02e9ab69e4f271a7c45469105 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/fro_profiterole-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:72c192d740c0c1f760b4242128489ca0e673ec91d4a375f92db85e8bfb50c09c +size 99441000 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/fro_profiterole-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/fro_profiterole-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..d940cad480113e0cd9636927d3fd882916b6e909 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/fro_profiterole-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:66a01ad425845273cdc60677a41a4a5079474da0b666f3a1dbacf22d68901596 +size 2113 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ga_all-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/ga_all-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ga_all-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ga_all-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/ga_all-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..b65a7524a8c01e79ffdbf5bf9db1a5a54368efe4 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ga_all-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:72db2ef368e58d979c0a1312dde6b0ba28255cdfa77a3c370359547a567bc9dc +size 1097 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ga_all-ud-2.15-241121.model/ga_idt.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/ga_all-ud-2.15-241121.model/ga_idt.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..754e9403123156494d47066048d46166cbe0a371 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ga_all-ud-2.15-241121.model/ga_idt.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6b892fae5648f3ff1218dde0f84f3dd413f7ab7191c24dd9b2ddcc1ed0369f0c +size 36164 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ga_all-ud-2.15-241121.model/ga_twittirish.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/ga_all-ud-2.15-241121.model/ga_twittirish.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..216d74ad9875f730eb05adbf6cbeb9de389f1376 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ga_all-ud-2.15-241121.model/ga_twittirish.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:28ba13cacda5ce2dbf13c2a5260ee34f6c94311768c3e9372c6aac3b08eb1d31 +size 41976 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ga_all-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/ga_all-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..6386d06880814361f284550f4d36496236897470 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ga_all-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:60ac0312d4c59fe64237405b2b44e804396325a53df29d2c7fdfeb456375e542 +size 21689 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ga_all-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/ga_all-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..c186ffddb4cd4678f791dcc5b752dc4e56428292 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ga_all-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b0d5a75acc82dbb5de48c3a2e1e9ccffd0d0e06e916417180b44f4c3811fa496 +size 287868 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ga_all-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/ga_all-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..1dd4f5314310c1ac266c5768390882cebdd1eb0c --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ga_all-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:76e3f1c412a738eb9439e4ab6d3ecc548fc248431069f7d53f6863e1bfdfd9c5 +size 1016 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ga_all-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/ga_all-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..22a7ba2894c233c51b9e1319913aecd151955349 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ga_all-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9cc51a25acec482372dff1ea9539af907632339a91947af3bc9cf7f94039e7e7 +size 101138032 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ga_all-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/ga_all-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..9525de1972aeece5e9e9ed2a920f7d0b94536343 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ga_all-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4b7d8e3922734c442c6a3bcb91a1343ec1be83431bb670a878cb9cca642deb3d +size 2178 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/gd_arcosg-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/gd_arcosg-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/gd_arcosg-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/gd_arcosg-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/gd_arcosg-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..89520bfae7774f63ec49a6c0011229d424de43da --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/gd_arcosg-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a2af7cc6bab7f59a05c2759354d0886589e8827c9e4428e1d5e769c2cc2adbfc +size 348 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/gd_arcosg-ud-2.15-241121.model/gd_arcosg.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/gd_arcosg-ud-2.15-241121.model/gd_arcosg.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..c73b234e20735dc0076f768951b4541e2c34657d --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/gd_arcosg-ud-2.15-241121.model/gd_arcosg.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2febd54c2f2b9343d9a07bf3eda92d0942e8b8378b55f3647dda0469e650552d +size 211610 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/gd_arcosg-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/gd_arcosg-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..5bfe8c20f2c1d512b0e290e0f8ec874d7bdb6920 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/gd_arcosg-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:38fadc73fae0a9fb8477f14f9edc154734defd102c650c155c4a1a265ca4f922 +size 10579 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/gd_arcosg-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/gd_arcosg-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..25ded8c7d3956530bb469e034348146fdf0c7b0b --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/gd_arcosg-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6930fe0d2d65032208400d5d3bca3c6670cf041597259b56e78d97304f9be955 +size 106801 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/gd_arcosg-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/gd_arcosg-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..0f506ec68f0d0156e7320af174336ca58f120354 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/gd_arcosg-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9418773696fc77044e1785193f57e430d96671e3dd88c56f36e42894bae0fcbe +size 888 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/gd_arcosg-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/gd_arcosg-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..60d3bf728e0e71ecd59c63d46430b5e5e194b67f --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/gd_arcosg-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b616be53d0a2a4128dfdbfc626c70315dc2e1fcb892fa31afccd7d229f68738c +size 86016696 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/gd_arcosg-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/gd_arcosg-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..b12f00549029c9f3a53d2d32f5656dc2dbe9a0c8 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/gd_arcosg-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:824b929afa711422e6e3fb9d1d7ffc3a95a083bc5ebcb8675c704268923affd5 +size 2114 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/gl_all-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/gl_all-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/gl_all-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/gl_all-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/gl_all-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..3edbed30ae591ff4dd3cd25512c5c1d63009a855 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/gl_all-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4981d1fd9fb4ee8611f8862c5f5642894e53813a15d6e7a2a5763ac50ef63eaa +size 354 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/gl_all-ud-2.15-241121.model/gl_ctg.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/gl_all-ud-2.15-241121.model/gl_ctg.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..318d3e7dad2d634d61b339d63a38e9acfb2c02e1 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/gl_all-ud-2.15-241121.model/gl_ctg.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:cea18a688752babf344cda481dc757d2e364764873ad55d02028965c83c818be +size 231423 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/gl_all-ud-2.15-241121.model/gl_treegal.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/gl_all-ud-2.15-241121.model/gl_treegal.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..f2037d0c2a1795c815112a6aa632215727422b83 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/gl_all-ud-2.15-241121.model/gl_treegal.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9ca88118957c5c0c162c7cb25aa5c74e8529e324b8df2f401b6d8e158c36b9e2 +size 210858 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/gl_all-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/gl_all-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..29269e16242745368b0e67b66a350c171c32b7f6 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/gl_all-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:35fa3c3404f998035132ad18e5b63bcd0bbe7b16e7ef8192a78bbc36a5c01460 +size 21368 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/gl_all-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/gl_all-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..118fe6ace8c37dc4acf4e0dba22426b08edf719a --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/gl_all-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7004fb0a99cf8a7b02fd03374d674be42d428a7cc8225665eea8a4423dd876b6 +size 178949 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/gl_all-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/gl_all-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..db78db84e0ca0be6be7e4dc44ea047a1581f2188 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/gl_all-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2e59d102a63ebe6cfc4e8edd3c647c26af5dfbd69e909aa731f6c9fa2225987c +size 998 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/gl_all-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/gl_all-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..7ef1f623213d749938fc40fd9ae613bd9b39d322 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/gl_all-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5744e7088ebbb18c0a66175a280c8a56c611782b0439c217fa86e9949210b010 +size 92549100 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/gl_all-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/gl_all-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..d910294d123d5dfcb26448b237ac1bd38cb00ce7 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/gl_all-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:052f5e7e9a759800bcfa277a9ed31968c2b9e0b6efcb12072bf987fd5a31ec28 +size 2178 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/got_proiel-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/got_proiel-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/got_proiel-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/got_proiel-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/got_proiel-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..84b35d36aa36f482ce71c966df3811ba54705869 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/got_proiel-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f4392dd498e0de30dbe975a99b8859f7e8047da40a47c4e8f99fcc286e7035c6 +size 640 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/got_proiel-ud-2.15-241121.model/got_proiel.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/got_proiel-ud-2.15-241121.model/got_proiel.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..912ef2c2b7db49799c1eb111fb22929c177b2dae --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/got_proiel-ud-2.15-241121.model/got_proiel.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:bab8ff2d2ac7bbb9966319397fd87d6d90c9fafabded5a8d3b4b7c57d61528e9 +size 31949 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/got_proiel-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/got_proiel-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..ea8696f8f2f6c9871580f3e3a69ad05b72bc093e --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/got_proiel-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:bc910fa8604a62404e5fde829a26f54fa67e994b051b6f00601756a069f9b795 +size 10585 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/got_proiel-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/got_proiel-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..69ed1a653df87c8d9bc05474f093aae583841bc0 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/got_proiel-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:901189a11bc0773289bf63e8c84ea8931e611f9bf86a783de3a070e37eff2f43 +size 257972 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/got_proiel-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/got_proiel-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..6148ce538727a4fda337665a90346a1ccb74551c --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/got_proiel-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d4e2df94ffff9bee38175948b61305fa84a7de826b28054b7cf0d353cdbc8746 +size 895 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/got_proiel-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/got_proiel-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..ac547742927ec6114739c29e02ed2f3bbe94247d --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/got_proiel-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e5cac5c655738ec16a3a897544034f99c58dd2821da0ff57e34268e555ff4427 +size 59331020 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/got_proiel-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/got_proiel-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..aef28f192ad04f012d1fe03ae30feeabefdcc2fb --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/got_proiel-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:de1dbe49e54a87d7d2fd0dafb8ef031686fb42a8f4190f6d73787e6b6c2e85ff +size 2114 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/grc_all-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/grc_all-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/grc_all-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/grc_all-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/grc_all-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..f13e7c3faba04e04d7e797e98b8d950bb242d6ba --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/grc_all-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:19364ba2682994d75fa19ae9c9add375bda9d3a015061c51ff10d28beaacd54e +size 1452 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/grc_all-ud-2.15-241121.model/grc_perseus.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/grc_all-ud-2.15-241121.model/grc_perseus.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..749ad8c1ac10c5f7a53b216a7a0ad6d5381e170a --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/grc_all-ud-2.15-241121.model/grc_perseus.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6cc28429e8e792c0ae4839ed60a7f6939c4b00f9b4ad931b73f8912e0d5be431 +size 43978 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/grc_all-ud-2.15-241121.model/grc_proiel.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/grc_all-ud-2.15-241121.model/grc_proiel.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..6e580bfb8bb01d4c4c20b40eda816bc512f72c4d --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/grc_all-ud-2.15-241121.model/grc_proiel.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c48b1377a77a666809a7fb0556c2714e8c2a36c47cd8cd43934aaebf1cc2d0ed +size 227169 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/grc_all-ud-2.15-241121.model/grc_ptnk.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/grc_all-ud-2.15-241121.model/grc_ptnk.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..da7b9dcd112f5b2538cfb5497c710cd98a6a53f6 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/grc_all-ud-2.15-241121.model/grc_ptnk.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f0fb571b69de0c2d7ad6774c52bc1f746693c7fac3a3585e8bfca73852698bfb +size 224414 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/grc_all-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/grc_all-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..db259eb3eac67b07bf53f4038528aa257d243172 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/grc_all-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9c9408498a6fbc562b61f656e3e243a43d4c16a487d4058cc1daae9ce1dac61a +size 32065 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/grc_all-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/grc_all-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..85f6eb76d3d0c1fd533b57b89787f7e5d6719876 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/grc_all-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d9a34736d78c2d90188afed8bdfeca2907c0a54605138d6bd295a5e3c5d71e57 +size 1979731 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/grc_all-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/grc_all-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..200e95e0dd47de8483ca2783f034f3c38efad5d5 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/grc_all-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2bbbd4c33b0b1d752be099ef84a5b7eff31599f756fce5fcb6b807f60bc7e80a +size 1136 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/grc_all-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/grc_all-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..838af9b0074025dec7288c09beac8c238b90c8fc --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/grc_all-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a7e25a6b469d4347f80a81c3e64956893895032ca39bffa367cd71bdc02a1899 +size 182754516 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/grc_all-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/grc_all-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..597bd4fa98cdf535dc4971a078a840d43a814b02 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/grc_all-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:31e278064341fa4ab00e0045a00b94fbec7154fc425125ee5a6e534b41e0cbd4 +size 2183 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/gv_cadhan-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/gv_cadhan-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/gv_cadhan-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/gv_cadhan-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/gv_cadhan-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..0a7fd72fd099c78548ed244cab13b20dbabf286b --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/gv_cadhan-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c6f3eddc845ef12f37c82822cc70ef1836728d0138e8b28e166eecdd78a83eef +size 229 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/gv_cadhan-ud-2.15-241121.model/gv_cadhan.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/gv_cadhan-ud-2.15-241121.model/gv_cadhan.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..54acaac5cd39c6fd38d876ca57e662fd835dca91 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/gv_cadhan-ud-2.15-241121.model/gv_cadhan.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:46e6ea13f0875eb82b989522628f20e2944579a1e1e933625599db7309e89ca3 +size 36404 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/gv_cadhan-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/gv_cadhan-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..0da30b51f76d920b738284b960e2465704f5fd8c --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/gv_cadhan-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e6bf674d3353c091e21469096e7fb784faeb2f1aefc5dc844ad2a554fea1b8db +size 10637 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/gv_cadhan-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/gv_cadhan-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..11eb3487a07e9bd4f8ab57523001f8389244e5bd --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/gv_cadhan-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ae41a0989e6d958669b92c11019a2cfbcafab2aadcd05c697d3d652ed7abd8d4 +size 25460 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/gv_cadhan-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/gv_cadhan-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..e776b4565c8e5c9c169de6164e67dda4fd77b8d6 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/gv_cadhan-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:edb81afcb204708b011cca41d759a5480dedcb7123a0cb6aca37f525196aa203 +size 888 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/gv_cadhan-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/gv_cadhan-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..3d47f6080c9f997b8004f7634af24dfb7050170e --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/gv_cadhan-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b01f5c1947e25f77843e877825c81229cdad4576da9f578d1e5a65e7ea1b961c +size 51636700 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/gv_cadhan-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/gv_cadhan-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..ff8cde4ec36a5fb3c6385a2cfd4ff3c9e982965d --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/gv_cadhan-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0432dee27940a9eba58ca0721cb1377a34fd51bfe6e56a56e70b25755a40fffe +size 2109 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/hbo_ptnk-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/hbo_ptnk-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/hbo_ptnk-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/hbo_ptnk-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/hbo_ptnk-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..ce62f491de9c856e7095ac719325772ce4f49534 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/hbo_ptnk-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:73ea13e435dc7fec1090af8988bdfa89b491c28fa9f48da5061b3f0854bbf7e5 +size 300 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/hbo_ptnk-ud-2.15-241121.model/hbo_ptnk.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/hbo_ptnk-ud-2.15-241121.model/hbo_ptnk.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..5a1833f5144b2c95d1a8e868e23356be37dce1d6 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/hbo_ptnk-ud-2.15-241121.model/hbo_ptnk.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c8102209f740fc94a6982c60ba58f178ca77b66fe2932142f2e3ff3197526a2c +size 275431 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/hbo_ptnk-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/hbo_ptnk-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..528feabb0f5fdceb11778e89e1390f5a2d89a0c2 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/hbo_ptnk-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:921842b2f14012143ca3fc3742243dc26788e6df4127c8a9c9470434e8e3ddc4 +size 10572 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/hbo_ptnk-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/hbo_ptnk-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..2641abbb1f332a508cad98c4ab80ba23462376d9 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/hbo_ptnk-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b89593a2d18784ea69094f801fe145afee914e6753078460eb894d3a7a8fd0fc +size 637582 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/hbo_ptnk-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/hbo_ptnk-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..55276685b78084bd60c88daecf3c93177ae97511 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/hbo_ptnk-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0f31ecb64f23cbcf31bda5f698ff36b40e0e639775d890f2499e03a5f227c712 +size 881 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/hbo_ptnk-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/hbo_ptnk-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..c592de84b7051bcb7e44e57fdb37ffa12509f971 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/hbo_ptnk-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a2045ebbac03060ff18570fee312ff3b04eaa9f9e9a29016b41027892946c60c +size 56454992 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/hbo_ptnk-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/hbo_ptnk-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..ce5259518679d339f27b97fed85e4108bc1fd17f --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/hbo_ptnk-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5b6b7512bfb14d4cf5d3468cce7f3b2c67160541881c8690b77ecaa77fff430a +size 2114 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/he_all-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/he_all-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/he_all-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/he_all-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/he_all-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..ad23ab5367bc0a46086a7307ab346c299152a595 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/he_all-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:13637914333ab1c64c4057d98adf5e4eae44c71dd46fc6988d2a6ca7f4110263 +size 1054 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/he_all-ud-2.15-241121.model/he_htb.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/he_all-ud-2.15-241121.model/he_htb.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..4f2b5fb0ccf9b8ae7559850ad36ff8d10be9ea36 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/he_all-ud-2.15-241121.model/he_htb.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2d80556337665adab8858f9dec7f829b4c23ef107349f676023de69b4f22cc9c +size 153854 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/he_all-ud-2.15-241121.model/he_iahltknesset.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/he_all-ud-2.15-241121.model/he_iahltknesset.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..3dbd59d2515998fbec6403a7595174bb9532c475 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/he_all-ud-2.15-241121.model/he_iahltknesset.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0caed0e569e4b8b49aa53909008cc7f451be73122d063bee560dfa694339aec8 +size 78332 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/he_all-ud-2.15-241121.model/he_iahltwiki.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/he_all-ud-2.15-241121.model/he_iahltwiki.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..01a84c4f3305f7bb3debf32e5b529d93c1eafd1c --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/he_all-ud-2.15-241121.model/he_iahltwiki.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:773206ea9ea214d7fe1a6da64cf562bbc2f8df0a39865a4446e5c5d23394b5ed +size 323311 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/he_all-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/he_all-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..c23b86a230842eeb8e3bc256a6df6aa3282fe8f8 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/he_all-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:aa9c427c251ff416f98c902649ba5bbe5cf8d8236429191f6f846f6e68bb9b19 +size 32267 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/he_all-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/he_all-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..39ba6197420ddd3bac51122c7c1e9a7daed65790 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/he_all-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3a5c8d64ada68e5c7d4e511679e7d91657df66f10ab8933c086317b429ce7b38 +size 550649 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/he_all-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/he_all-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..0fcca7b0c7f672d3ceb76accb47490a266f3c5ac --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/he_all-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2082e93c1377aad4f3dc975c42f0ac9ce2f1d0251737f91ce0af605157623773 +size 1157 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/he_all-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/he_all-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..22d418e5ea3824a67af13b3370a2328c07992004 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/he_all-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e75ad684846061441fe0cc985eec5722d909d378ad61be63c4ca30013a69005c +size 111363128 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/he_all-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/he_all-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..b8e8e62c4e85d7f4e08cb53d9e73bd508b9151a3 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/he_all-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1b90f124962ab2e7b17b5847b38668d3423f0ca1e464ed85bdb40be0082bc7b5 +size 2178 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/hi_hdtb-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/hi_hdtb-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/hi_hdtb-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/hi_hdtb-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/hi_hdtb-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..8cb202f3747b8b12b4e54e999dc05242afd5fc31 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/hi_hdtb-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:eac6db6b70bd899f9003ade058cc3e12bb1ba9202abcd6a188f14b650c372618 +size 1267 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/hi_hdtb-ud-2.15-241121.model/hi_hdtb.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/hi_hdtb-ud-2.15-241121.model/hi_hdtb.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..b407be4d13ed838fe72c8102676933272762154f --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/hi_hdtb-ud-2.15-241121.model/hi_hdtb.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:01fd428b9ee8bcfc166f86671ee77ac0d482b84d0ba0e14f62b1244c06727034 +size 208998 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/hi_hdtb-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/hi_hdtb-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..500df85e9fdf4fe4231050397594204737036fd0 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/hi_hdtb-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:31fdefff97167e836c29f56392b154e175643b42d770a7a6ae2c63526d86b54b +size 10564 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/hi_hdtb-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/hi_hdtb-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..4d4d745aaa32ebd3b8bb66054d41e56cd2c03189 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/hi_hdtb-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3384593624a2dc257445b34dd83a294dd7afb11386cc8dc0b34ebbe94cd6494d +size 8402979 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/hi_hdtb-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/hi_hdtb-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..65d70a0cf704255be99a58c0ba87c12c10568c5f --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/hi_hdtb-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:49f3ee1a63528dacd50934c8e2a2d582b21e3c9f07af79ee724f9a49c87a4e9b +size 874 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/hi_hdtb-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/hi_hdtb-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..0c16530a558710cbc7c352a66d9737e46b51c69c --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/hi_hdtb-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:99a4d76e79c72b2f154ecea3c83415f69714657148f7dfd837cad25fd49cf832 +size 98344788 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/hi_hdtb-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/hi_hdtb-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..d5e1ee10b82991451dfed412015e5549141c026e --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/hi_hdtb-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:725038f077413536d9d4103dad8057d2fc57a5794f8d253bfc9a9f2e020c120e +size 2113 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/hr_set-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/hr_set-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/hr_set-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/hr_set-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/hr_set-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..a8ff3894ca3cf983d0815f935aab0fb66b6c0562 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/hr_set-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a49041210f014af7a743c4137ed2862e77fbcc51249f671d0d4c81a0916b7e9a +size 932 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/hr_set-ud-2.15-241121.model/hr_set.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/hr_set-ud-2.15-241121.model/hr_set.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..0307e4f6102fbfd49c1f98a1acdb57f1d82fbc4b --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/hr_set-ud-2.15-241121.model/hr_set.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c8c0ea76a5ec3aee2e9d64696431af20593743d2377c9afe3c648f269356c04d +size 37258 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/hr_set-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/hr_set-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..ca644228a6f7d65a0ae5b9451cc2532b4144964a --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/hr_set-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2e891e0b525f603395fdc0d2999344db5634b2be4819d8ab808f7a9cf137a53a +size 10558 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/hr_set-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/hr_set-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..334b77efe698b4141a9cb19441b87554848a481f --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/hr_set-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:77b59fdfbf3d2e61148a27983633b0267a00c513c85e0476c2dd5c506846525c +size 414779 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/hr_set-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/hr_set-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..5ecb5250b0edeed478db8a97dac49469b98111bb --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/hr_set-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:bfe7288e0db2a5dffde398e0dfb629738cf9bbeb6104c82284afc3eea5385f4f +size 867 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/hr_set-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/hr_set-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..707d4ffc03f3d27d531e008e03546eada3c871b9 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/hr_set-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:acdf7ca7061790dfa8a2e722bb06875f750d4400feca08665be83364ad4a5a9d +size 107409152 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/hr_set-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/hr_set-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..8277d6fb2f85c0af95289b2d5d18c49ccdd5e443 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/hr_set-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:bc55b6ab18c117ba9d00d8c47b88639124e5841e4df51797cb0d8c7cec5f3576 +size 2117 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/hu_szeged-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/hu_szeged-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/hu_szeged-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/hu_szeged-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/hu_szeged-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..e9d0256ba5d5c3d0900ebe2a2a1993197df851fa --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/hu_szeged-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3d8e628a18f429d9a0b1803488269064d8037e5c47c54712ad0761de47f8f1a3 +size 677 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/hu_szeged-ud-2.15-241121.model/hu_szeged.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/hu_szeged-ud-2.15-241121.model/hu_szeged.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..5e2504f4066a69cd335ab36ad5fdc9e7b54734bb --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/hu_szeged-ud-2.15-241121.model/hu_szeged.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5d6b0cac420d4b1b175e5bb73107d34f5a80c1ab1c93a44992303b5c0b6c0a16 +size 35140 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/hu_szeged-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/hu_szeged-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..84373d7b92ed13e7df7c46857b4450b61cb5af18 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/hu_szeged-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0b8524dd9b57dbeb8cfb5b9856543ae298e4f17966e4aa5ae15c2dad4f897b45 +size 10578 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/hu_szeged-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/hu_szeged-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..b8248e22f931ca7248bee896d3fbf2d371fbd803 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/hu_szeged-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:44c01971339068341a41487c865790a3c5aee94cefb35135ee1f5be3bad4c4d5 +size 86379 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/hu_szeged-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/hu_szeged-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..c2a8ed89e0880c131f75b62a7dc5cfe4abdfa084 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/hu_szeged-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:fd3d9a7f2142bac1934bbb5529a48049da492f324807a3e8c5bdebb645ad4a06 +size 888 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/hu_szeged-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/hu_szeged-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..529285cc10e0b30073312ff5045e6c6100013130 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/hu_szeged-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:dfe7fe343b9cbd65df01c015486afeed450ec8e584b8aab246ed3e18033610a3 +size 56191188 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/hu_szeged-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/hu_szeged-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..c971ab20422e3fcee925bc28aaf53ed97d6ccf6d --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/hu_szeged-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8be2688d9548b06cec855861f9127e2a61bc193e7a66d265be867d7151204a1d +size 2112 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/hy_all-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/hy_all-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/hy_all-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/hy_all-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/hy_all-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..f10f3010348b22ca0224f55cdb9cea609612c3ab --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/hy_all-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3b971772119e58673e919f14f73051f671f43b7427f53a3ebf03b51269240822 +size 1695 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/hy_all-ud-2.15-241121.model/hy_armtdp.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/hy_all-ud-2.15-241121.model/hy_armtdp.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..93482fd8c989924cd4de8b3e1252d2a05f476d1a --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/hy_all-ud-2.15-241121.model/hy_armtdp.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:cb8d4cc7847540dd0f34a5a7308c9413bc17e34b350f0f5046979ab511339363 +size 45124 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/hy_all-ud-2.15-241121.model/hy_bsut.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/hy_all-ud-2.15-241121.model/hy_bsut.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..c4e11289e3a05cf0155e87913276987a6014242d --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/hy_all-ud-2.15-241121.model/hy_bsut.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1bc3ea817ce30615bfd4af43e0d7a9ef6218a47fa0c34edb1e9ded0e3a26495d +size 43990 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/hy_all-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/hy_all-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..899bf8a3fc86700b6618fd187acc47da95aba5a8 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/hy_all-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1749e6d2fc9d6eabbbdf84d5350990f1cd0c2d206c0f6dc63d3fdbd47c7b17d4 +size 21489 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/hy_all-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/hy_all-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..21adcfd73f45a9dc025f7529db8925796e3d28a2 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/hy_all-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e82086c9708537596990d6319705187e080197a81fe1a7bbfcdf0ffac1f9a4b0 +size 3141253 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/hy_all-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/hy_all-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..40d820cec970a475f4267df9720bd18eec88ab2c --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/hy_all-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6dccdb34888070ab1ee8a4685f151f07c536f1def4cc473ce4dd85c1be94e554 +size 998 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/hy_all-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/hy_all-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..329c138cc7fd5dae05c3aeb0ab66561cc3cccf67 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/hy_all-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:64e7f25a6b3e43cae1bdad2f3cfe0712043d11176f86bd9c70160cba2aaff0f5 +size 112947480 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/hy_all-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/hy_all-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..4f1a9e6b29dd2bebac48c4039c16ff805d1d15a4 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/hy_all-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:732dd4fdd4dd1c2543b4c2215e9fd298009ad0210feeb93517b0be0a3847838c +size 2177 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/hyw_armtdp-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/hyw_armtdp-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/hyw_armtdp-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/hyw_armtdp-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/hyw_armtdp-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..0749d703bd4aa2ffb398c3e201fd217b3564b5cb --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/hyw_armtdp-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:de1e62a2ebeecd999033cb5a617ee6dcef2346493fa4d78590328d71023b03e3 +size 1296 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/hyw_armtdp-ud-2.15-241121.model/hyw_armtdp.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/hyw_armtdp-ud-2.15-241121.model/hyw_armtdp.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..4de4b479859a54bab03854de63a92e225087239b --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/hyw_armtdp-ud-2.15-241121.model/hyw_armtdp.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:dadf1258dbf94eafceb8d2f1e34986c4a7e5b8b342617b733ea6f88deb6cf7cd +size 236645 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/hyw_armtdp-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/hyw_armtdp-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..fdb94ce98156a4a8bc94e0de2a18f60cec7677ca --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/hyw_armtdp-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a957ea518c0ee62538d4630400ff2c1f2d68b7db62066a7dc0d3d1d9ef65a050 +size 10645 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/hyw_armtdp-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/hyw_armtdp-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..f4b75ad35a2964109ecaffea0c6e38b7d0347b95 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/hyw_armtdp-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:63bc5cdec8789b9f24ee6becc8b563f5bb02a4f7242e30427547eb0fb263e5c9 +size 1972253 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/hyw_armtdp-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/hyw_armtdp-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..790623f97c21ecebfa8c05582a36743dff8ef4f3 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/hyw_armtdp-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1d7012931897499e26554988293099c545bb645c115218e207c961e02aedce84 +size 895 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/hyw_armtdp-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/hyw_armtdp-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..0a0d04dd65e5f09551acea2f124a605e0a60cf01 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/hyw_armtdp-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1ad938042eda2bf532b121cecba40c60d88ce43c89fdefd0d576a7644a571e5e +size 98821016 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/hyw_armtdp-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/hyw_armtdp-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..c1c41f3be9acbd5093c0e8034808af93f797f948 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/hyw_armtdp-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:dd7f664d4720c98ab5e62a5fb1d2cea715a5ac7a1b4b254a6881a0b5aa385dec +size 2113 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/id_all-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/id_all-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/id_all-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/id_all-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/id_all-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..d7aee75a2b9fe7d12c87ed207a19eeb02748d1a9 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/id_all-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:94b2b3190c361ac230b978fdb93b5a4fc9932983850c55c3394f7ad5dae14105 +size 222 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/id_all-ud-2.15-241121.model/id_csui.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/id_all-ud-2.15-241121.model/id_csui.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..ef209006c5c2f9a585614c342db2934f77c02c0b --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/id_all-ud-2.15-241121.model/id_csui.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:17c836e61acceefea404fe726b46948c6b172e4880192b030e9760cc8b6e5bfe +size 37810 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/id_all-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/id_all-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..6988cf5674a2b26539a882ab42a4ccc63e534324 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/id_all-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:84c8a7529f0c2d3d4f2a9ccaa75317eb2b193d8abbd00ef2e732c37f20ce293e +size 21165 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/id_all-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/id_all-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..c99a74c9458f3924cfa530d567fee805f541d2c1 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/id_all-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7e2653fe941310530c649285f561fc306c87207e42a85e4c0b8037c861aa7004 +size 1047332 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/id_all-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/id_all-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..bd1eafdeed460abfa15712b01217990cf28eb9cd --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/id_all-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ea0e0fb75a260537f4d3182cf1ab3469ac87d5f23c88ec96c97a87c67c357b1c +size 980 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/id_all-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/id_all-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..4226dbc02d627dd1b7944ce073c5f8008b6ebd34 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/id_all-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:366912e7edfd7c7ab57498d82611615c7f95f70dfbcfddd3bcc5a3f67182431d +size 96886872 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/id_all-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/id_all-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..42f7014e41472e47820e558dc50ce03940407af5 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/id_all-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:97fd5226314c3917363ebc64d90598aaf51ae59bd7b72c6c17469f11df65fc5b +size 2175 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/id_gsd-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/id_gsd-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/id_gsd-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/id_gsd-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/id_gsd-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..7dc55f87bc77ab3672d80965333ae271b7156f99 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/id_gsd-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2e8d429b39a4c18b52df48439260135a06e8c7074664f5fdee7b4eef9ab123bc +size 223 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/id_gsd-ud-2.15-241121.model/id_gsd.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/id_gsd-ud-2.15-241121.model/id_gsd.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..5fc02aba43be5f9fa348a34acbb24f0efafddeb6 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/id_gsd-ud-2.15-241121.model/id_gsd.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:13bf0b967668b70b81b44758e1960a50d70782415ed338c958cda84b9db7e98c +size 70480 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/id_gsd-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/id_gsd-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..cb26963aaf51743b140b8879488ac7d6fe4910a2 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/id_gsd-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8cf363488a84379c481b2f17d31a33de027d50c8f7e8bb8ad146118b36c84e37 +size 10556 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/id_gsd-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/id_gsd-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..809aae905c8c19012afc0d8d3cf9c6089e495106 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/id_gsd-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ca9c452b7714daaf4b9c83531ae3c208cac5c92a4a4411f4f5e138c9505f4008 +size 1026882 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/id_gsd-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/id_gsd-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..f69cc89f701d82daf507e24dd9cab7b432cf9925 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/id_gsd-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:36c3f67e8fdeaca2f641cac14c89cfec5401505c14acaf2304b2456fb95fb28f +size 867 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/id_gsd-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/id_gsd-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..175d90d9ad37c8ad48230a87726d51d96804851e --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/id_gsd-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:04b21ba9aff05694331d139b0bb2dd61d12dccf4e1a9660889ec6ffd90257b30 +size 93011872 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/id_gsd-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/id_gsd-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..03101d8f4afe376526c076bae1d5cfa5452b08b1 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/id_gsd-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b5971ccafd082c9d89eab17983a97580b1812193f4dab612488edcdd3b645a0b +size 2111 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/is_all-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/is_all-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/is_all-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/is_all-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/is_all-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..9d095e167e4533709dc5f2b1e6c2d9aa48ee3410 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/is_all-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:133f044c6f38b282ff91f56ba929ecfb8eae43786634aaf295a78eea7931622b +size 1238 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/is_all-ud-2.15-241121.model/is_gc.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/is_all-ud-2.15-241121.model/is_gc.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..84eeb7dd7f11fceb32b07efd1fcc7c0a1779812f --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/is_all-ud-2.15-241121.model/is_gc.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:eccc70548a1f97b68a8d263ab3ba4883da4ba7d2a9b6d2b6b1aa55a5c32276d5 +size 37933 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/is_all-ud-2.15-241121.model/is_icepahc.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/is_all-ud-2.15-241121.model/is_icepahc.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..2ed3ca5de2bfc32e5972496ae34d4cabf847eb91 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/is_all-ud-2.15-241121.model/is_icepahc.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d05e244050d162ad345035e63a15c8f6d4dc5c753c2a8272c8fa18a663e9b520 +size 211120 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/is_all-ud-2.15-241121.model/is_modern.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/is_all-ud-2.15-241121.model/is_modern.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..a7256a37b0741d20287f2f7a82b8d38a47a2fa68 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/is_all-ud-2.15-241121.model/is_modern.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:fe4c1435a05f747037c5e00b47c98378132387d3f058328aaceaa6a209a4bf96 +size 36125 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/is_all-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/is_all-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..fa391b667542076f57a157bf93d506f4aa191da9 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/is_all-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ee6e02f8d83c18922aaf596951fdd22c20424174d9ae3b01c2636c0034c21ff9 +size 31666 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/is_all-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/is_all-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..2d7d899467790995c6cad80b00841fd36dcb229e --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/is_all-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:cf2fb1ea0a2df6bad1b9185060f9041943963f198e0876b014940a18952c9c2f +size 1075777 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/is_all-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/is_all-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..0eb9a160fe5add3e193d8074afd50229a70facd0 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/is_all-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:64a6a338fd56215aafb0b4f26203387bd7f9f2e05da39d8ab4d0e63bc2a093c1 +size 1103 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/is_all-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/is_all-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..f240a34c063ac7741082d0b9e11c84c2dfcb715e --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/is_all-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9c25ca04017f5e456d19235c2312c8a8f9fc21a13bd710e49d5fabb0d9301773 +size 153367700 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/is_all-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/is_all-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..ff8abda81661564ea2b0732ceb62a2126948258c --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/is_all-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:90d612b9db6d99ab2e141c7a9b82b44f919ac43ed350211ce6c042be16b19101 +size 2182 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/it_all-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/it_all-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/it_all-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/it_all-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/it_all-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..2bda2a28356434c60d7a0e91265c9d8e8b9c062e --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/it_all-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:02675319a9cafbcaca864d278a2104f912deb94d1f9e13e3707b98bac446112b +size 808 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/it_all-ud-2.15-241121.model/it_isdt.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/it_all-ud-2.15-241121.model/it_isdt.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..a05450e88f7f5ed580883665a7a78cc0a76eb0f1 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/it_all-ud-2.15-241121.model/it_isdt.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b093a64e6998144e549631c91792b806e8e331f43f38c6bee389d3f90cee42ce +size 231927 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/it_all-ud-2.15-241121.model/it_markit.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/it_all-ud-2.15-241121.model/it_markit.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..0b163f841e7133530b7e06058984f455b1a2a722 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/it_all-ud-2.15-241121.model/it_markit.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ef1a5ee9e0ff68b72873947824a5c52db30598e2e031961e2e813832ffe85e1a +size 210356 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/it_all-ud-2.15-241121.model/it_parlamint.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/it_all-ud-2.15-241121.model/it_parlamint.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..29c962e62d1ab1d7fe9611d2e7dba406639dbd4e --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/it_all-ud-2.15-241121.model/it_parlamint.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:dd2e71faba51debe1e4d1dbf015982357f8bdfd59415293db3c1c009121d101e +size 35007 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/it_all-ud-2.15-241121.model/it_partut.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/it_all-ud-2.15-241121.model/it_partut.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..3b0a2b6bfb101797be166fe8fe9cc99ede7a5762 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/it_all-ud-2.15-241121.model/it_partut.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:db1e82c31e65bbca8bd2acd0a482b190086c4cb64066579d12517fc2c6204b7a +size 212181 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/it_all-ud-2.15-241121.model/it_postwita.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/it_all-ud-2.15-241121.model/it_postwita.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..cbdb90ab300fa636c33f00eb11468723ace8da14 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/it_all-ud-2.15-241121.model/it_postwita.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:94b77ae40c20100b2cbfa105b0daa9290eea7d2a5c284a2fd55c328847e2c150 +size 52849 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/it_all-ud-2.15-241121.model/it_twittiro.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/it_all-ud-2.15-241121.model/it_twittiro.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..65f93e62027b687dbc0bc201506df0f66bc32bea --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/it_all-ud-2.15-241121.model/it_twittiro.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2c83694f07e4affc11390733e3bedff01b6d600d4252197527d8fac9d15c26d6 +size 214330 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/it_all-ud-2.15-241121.model/it_vit.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/it_all-ud-2.15-241121.model/it_vit.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..8a5a9088b127cabc207a179f142b87125de9816f --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/it_all-ud-2.15-241121.model/it_vit.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:03a4fca91c6edf5607bc60ff9061c105af4283c74eb7b3c37aafeede2f5d88c4 +size 217481 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/it_all-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/it_all-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..d21493563194857dfc6580101a5e85b2a917bed7 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/it_all-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b4f0196c943df6a2b39e9b6dc4727864f22d9503f3cab14882c5142dfea73730 +size 83615 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/it_all-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/it_all-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..4bec000c87857d4441fb4bc855ae4b70a570eebc --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/it_all-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:77dd0e6ded27c6ffccc4715714d65f3588092fc93503cca7f3520211fa879132 +size 1858819 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/it_all-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/it_all-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..76b71886626028fd51c0430aa9426eecc88eb25c --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/it_all-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7d431e3802004ce17e5f7002e46fb316fc94cbc83e438a268813fbd7019771c2 +size 1670 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/it_all-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/it_all-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..e8bf64225613e57dc14dbac2bc945469b8aa2b55 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/it_all-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f476d5351d156dae71da9041b1f570b370c3796b189e8a3e9761adbb0e80d543 +size 153224700 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/it_all-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/it_all-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..fbdcffab25608bc8890befb603a5fd5a5ff893c7 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/it_all-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c8fae3a23b2f6f416f6508fc7bf9b8d33cb72cc354bcbae3a8b964a30439b85f +size 2182 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/it_old-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/it_old-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/it_old-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/it_old-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/it_old-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..4e725243a0351a3a69ee8734d67a254cb0891a33 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/it_old-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:39faf99450c85241c4206db2c7ed214456235bbec194267816caa732b02308b3 +size 671 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/it_old-ud-2.15-241121.model/it_old.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/it_old-ud-2.15-241121.model/it_old.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..60fac1d1e171e2bd8dffcc3584133e0f07e517f5 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/it_old-ud-2.15-241121.model/it_old.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ea4e1597ea739bb93a2037c26a0e28af885589a2e2a4434546c75172a891f374 +size 43605 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/it_old-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/it_old-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..02511c4945eb9afc6670de182b0e876f91b87aa8 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/it_old-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f1d2a0337505c7f1fb3b5d98c8b1e51d2a58978b6873452bdaebc9bbeed7e1b5 +size 10560 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/it_old-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/it_old-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..ad84a4e682760850c1a942a4781a63187b23733f --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/it_old-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:403ef6da23ae689b1b9fa6dd36d9fb9c4439e3cf8fd57cd73f6656a62edd54e2 +size 740596 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/it_old-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/it_old-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..269b24a77241cb33623e6cc6973183ac2a9b7d7d --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/it_old-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0e22661e103f569637a1f2b469140eee2a11b19eebc295bc8cab59452dddbe2d +size 867 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/it_old-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/it_old-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..0b090dd6b2f0679c9e009db231d603d90a5ccbb8 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/it_old-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c55259d18101b9acc2a01f74cc0e7b8701d8a603d9ef368e0baeb0cdd3c10e3a +size 96499344 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/it_old-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/it_old-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..52cdc6167a8c91c74e5efd5a803f828bd5cd5ac1 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/it_old-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7471d412c0b60f378833884c9770a5206a19e87a18a8ff773194f2f6191bd961 +size 2118 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ja_all-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/ja_all-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ja_all-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ja_all-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/ja_all-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..1616f11b2e212aec47fcb67ec7eb0d52d804d13f --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ja_all-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ba37efe1209cfbbd8fc905a3d9a6f7e5f218b0a5ff26a954af55eae82880e011 +size 128 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ja_all-ud-2.15-241121.model/ja_gsdluw.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/ja_all-ud-2.15-241121.model/ja_gsdluw.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..c2589a367373411ca227133b60a60494c2600229 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ja_all-ud-2.15-241121.model/ja_gsdluw.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:96324675b1ec8cf436da582e6fb3fd140f296465d7b89401a88e83b1f53669f1 +size 872359 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ja_all-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/ja_all-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..f7977e7ada998d560ec1fc847565aae59407d470 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ja_all-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:51642371a6476020078abd87cea4ad77af89ec716f6f826a14820f8f544b33d5 +size 21322 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ja_all-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/ja_all-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..8284f98acf68384d1895480d04f4e81f095ffe87 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ja_all-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:57a5ff132298a29ce2da4094b2fb31f3bd42567983fcd4d7700d3c7fab36d844 +size 20245603 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ja_all-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/ja_all-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..6c2548afa63a6aeba1f0f00ec2062b12ccea1e25 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ja_all-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3bb2056035db1ad3512f0b0050ba33eabf6944a07ccd17f7ee55a43dc285eeca +size 992 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ja_all-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/ja_all-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..81830f36a98b053c78796f4360af8420f6dc34b3 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ja_all-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1e648f5d11aef62b3e0d14f368e5c7bea17a71653b367b98594a299197589150 +size 125365964 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ja_all-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/ja_all-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..e2fc5b165f0da56133415466e89d2cd2a564911c --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ja_all-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a9c79ddf0ec3b9b674fbe4f703dfd48c4f9bb0056f8f28b937bd517be535ee06 +size 2177 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ja_gsd-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/ja_gsd-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ja_gsd-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ja_gsd-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/ja_gsd-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..44528509cdb45fa795f0f603e3da918c7ac786a7 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ja_gsd-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d027e17cf4f21610a4d7ca1cfdce5db34175c1b1ae9e841235a0244cce18f5e1 +size 128 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ja_gsd-ud-2.15-241121.model/ja_gsd.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/ja_gsd-ud-2.15-241121.model/ja_gsd.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..9eba9c4193ae6962bc00b173be96d7ac245e4567 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ja_gsd-ud-2.15-241121.model/ja_gsd.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:12e57d91a02fd5bac210a18e5ba16a7bbd684b109239ac85b7de51d12c5abd23 +size 869072 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ja_gsd-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/ja_gsd-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..ef92109b0a436a7f67b50709738a5811d9a36276 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ja_gsd-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:def986207d83220b5b49a06423e747ba63099cd19593d1b8cccb472415e38fa4 +size 10557 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ja_gsd-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/ja_gsd-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..25f77a51952b841db478c9f0cdff372f29a9a7b1 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ja_gsd-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:75b537c7fcf2ef324ce6683c99667d133defd7778fdbe7584617e70dee90e94a +size 13025616 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ja_gsd-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/ja_gsd-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..d8f2e3621574feae09c6b24f7c8fde6d33084898 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ja_gsd-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4468463bc839df1b7d93f7eb600e5cea0972b95cf8e0ad2cc43722182fef8ac5 +size 867 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ja_gsd-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/ja_gsd-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..e43fb1906e93489e26fdd369f94c5a52e46fa71e --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ja_gsd-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:39653b4465bbb1125b4f443fb96656759f1f62c28d097c6ca930be9ea5456d1a +size 103837872 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ja_gsd-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/ja_gsd-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..777e7014686c7080d32fdb0f58c2e71e29318d32 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ja_gsd-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:331e5eea1f56c3e6e2cfb86f1529e71c2754f58875d51792e37b68e9ec92c38c +size 2114 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ka_glc-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/ka_glc-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ka_glc-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ka_glc-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/ka_glc-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..e374bf0825c609bd22e55ffb4f3926d137f8327e --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ka_glc-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5e9e52cb012b586f51a35ee528fea7e3414dc4df542fe99f70bfd219e90776ee +size 727 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ka_glc-ud-2.15-241121.model/ka_glc.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/ka_glc-ud-2.15-241121.model/ka_glc.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..7e25e27d84aa1a8209e9b9fc245d416688301ab2 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ka_glc-ud-2.15-241121.model/ka_glc.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:917600ef2fd32cc187fcb81fb6a8d1eaf3620bfbdc23670ab6b04ca7825e9c24 +size 289145 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ka_glc-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/ka_glc-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..48ed1612772751e197afd1806169fb13eb55808a --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ka_glc-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9f30b82d6ca030edd99757f7109e9f2f5a1cb8251ded5b752c2194c8de69f9ce +size 10557 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ka_glc-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/ka_glc-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..ecebef2ef20d467db5dc4a7b60378f9a6aeb6d08 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ka_glc-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e2911f924ad22b718b97ce99b2ffbd543eb3ffb957c68593d31311df0e838464 +size 745821 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ka_glc-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/ka_glc-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..579bc0e16d4e63443cd10e4be99dda6770b93533 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ka_glc-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e6d7ac3807c823a9e2fe8348e5bfe546f94d82b002b722b1ef52fa674555cba2 +size 867 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ka_glc-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/ka_glc-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..33ed9aefc512074ea5c56ebb665aa85745247194 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ka_glc-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b0aaf8d270282d247bbc79b6d59316367c1503034b5034ceba6252ff730dd0df +size 60466152 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ka_glc-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/ka_glc-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..b3b67f8e83819800ff41454599f78df4218c6ef8 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ka_glc-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7736ce80a5aa22b87e4537fedaa0eaaf0dbe7c6aebf08fa3219d1d80dc6ce94f +size 2114 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ko_all-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/ko_all-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ko_all-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ko_all-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/ko_all-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..6c911860ec10ae23a7c3834601327cd1d95a3442 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ko_all-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c4b79a24b76180ca6316f44f5bd165d806af7c31f08d77c1f0749dc826dfcd5c +size 123 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ko_all-ud-2.15-241121.model/ko_gsd.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/ko_all-ud-2.15-241121.model/ko_gsd.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..5603284de4f23479809f3af50bac8cef1d4958e1 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ko_all-ud-2.15-241121.model/ko_gsd.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2440bffd202e40c030e6606bea6a1d68489f41bf2af9821441cafdf63670e5f2 +size 599175 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ko_all-ud-2.15-241121.model/ko_kaist.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/ko_all-ud-2.15-241121.model/ko_kaist.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..122ba3cf017b61e87ec85336fb9c1987f4f74125 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ko_all-ud-2.15-241121.model/ko_kaist.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:df5ad52fd108100f690b60cd379916ad0e9f0b01c5f219f4ddb653b6925bf45b +size 239500 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ko_all-ud-2.15-241121.model/ko_ksl.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/ko_all-ud-2.15-241121.model/ko_ksl.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..af1f79e22d9fc4c539e0f1f3fbb99d283ba08f17 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ko_all-ud-2.15-241121.model/ko_ksl.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:56ced9cec0db392f44126837eaa4ca0eafbe87fe034b9f12f7126888d11376c0 +size 131831 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ko_all-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/ko_all-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..012fff0bbfbfc5ba999ec70cb62ae212a4e6ffb7 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ko_all-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5954d40cf68c8e6d440d1aaf3f2b932e017240828a4fe0eb5809e010a520efa3 +size 31518 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ko_all-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/ko_all-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..f3da2d91f6071fdfb7aefd458b68e890c665761e --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ko_all-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:391106674c0c0526ba8b8f74176d14854633c213516c1c712ff9a59ce9b3cc9a +size 9190403 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ko_all-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/ko_all-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..323fc116db0e635b1b23518e308f48c21bdae096 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ko_all-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1eaa560ea6a6eca63dc0fbc3b777b3b68ccc9935e9a2cc7f505ba61766fe5b0f +size 1079 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ko_all-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/ko_all-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..38119747c69ac34888dff69450ac5e7fdac31f3a --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ko_all-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:44b9ccdece45118cb56872fc0b9ca20726c8b497611ef6e4d805c80c0816f92c +size 176088684 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ko_all-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/ko_all-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..7a37b527cfed3d5952b1aa6ae0c57fbcad7d1cef --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ko_all-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:501c17be3093eda0ed7f2721988f2f98b01ce6c272a72d493b9690a7c9e58ca3 +size 2180 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ky_ktmu-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/ky_ktmu-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ky_ktmu-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ky_ktmu-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/ky_ktmu-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..9ae877a27aedaead9d14f259aff0f424daca0376 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ky_ktmu-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:fbfe409111b621cb98f96dc722cd4181792f2ca5b06b2adace2e8aab6edbcc33 +size 534 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ky_ktmu-ud-2.15-241121.model/ky_ktmu.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/ky_ktmu-ud-2.15-241121.model/ky_ktmu.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..4a1f7c1e1a221174a994964c351269d18a229904 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ky_ktmu-ud-2.15-241121.model/ky_ktmu.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7bad42282d015166e96895ec1d68b19765d86745f5075739903e883d1ea5a62a +size 39504 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ky_ktmu-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/ky_ktmu-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..e5974e3313b2b0b6004975303bc049d90e794138 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ky_ktmu-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1565f3eb9bf98955ed75eb2dbfc0e32cc629acfa568d2aebb7c5d55f13050e4c +size 10564 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ky_ktmu-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/ky_ktmu-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..c843fc0353af43e5af0ec3991793eca511279895 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ky_ktmu-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2f63045d28dfd5e70203564821a29059fc439ebccf5dcca4ae6391a6a4936f02 +size 75209 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ky_ktmu-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/ky_ktmu-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..57d2b04d6c31d7d46ad5608d06267e352a644837 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ky_ktmu-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4ce4de8c4863e40a5dacf78a3c4a7d6af43a9321b5dc73fc0c74bbf707f4b35f +size 874 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ky_ktmu-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/ky_ktmu-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..a6bbecf1ea64f6b1a4c7ca0a550d11e15d44b80d --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ky_ktmu-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5c689a5e4b4d969d27bfa9fad6dfb7d1bd4ff443d70642219cec01353f36be83 +size 52639204 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ky_ktmu-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/ky_ktmu-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..cc01c9cf083c02e31935c8cae181e8c348eb3bf8 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ky_ktmu-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:cff50475f6187c41df35c1bce5dc6b234d25c1d6648248f29ee30fadd9ee3a0d +size 2111 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/la_all-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/la_all-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/la_all-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/la_all-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/la_all-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..9933794e384e66f4decba7278417c596975f509b --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/la_all-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c33aa9f5ff1eedbef9882d099f5a72c126c5b3e119c06933e9da9688447ebe8d +size 5056 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/la_all-ud-2.15-241121.model/la_perseus.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/la_all-ud-2.15-241121.model/la_perseus.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..ac626b4ae2ec46fc5a2975a1ae0e6cfc91541a3b --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/la_all-ud-2.15-241121.model/la_perseus.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:69743b213b276ac4879596caa02c9f87c3c76c4f862f1fdfb5f666edf93e73ac +size 200574 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/la_all-ud-2.15-241121.model/la_udante.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/la_all-ud-2.15-241121.model/la_udante.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..c2ae808228297bb9b7ce60b6caf8a2e338ebf163 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/la_all-ud-2.15-241121.model/la_udante.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:12cdd2a56bb8547efea81e4f99493252b0a35e7ff462999026e936e8632bb681 +size 34587 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/la_all-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/la_all-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..577b7eba707794e7551e6d6e9f728feb3c47b9c0 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/la_all-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9a94f5bda98b400eb26ea020d262745369f135480142062df8fb62429c7d0594 +size 52393 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/la_all-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/la_all-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..e053e47c1963c798afe307640c0753bf28895ede --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/la_all-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0b3dcd5a1a1a57f2586ece1d0256f6baf7b7f2c2ac4f9f3c78e430e7b7bd65d7 +size 1824637 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/la_all-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/la_all-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..a2beba5b801f3d9cba63a7b763682371e07817d0 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/la_all-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:482ca0a35987297a1acdfe7154af57068079d123e22fb0c19e9130d8d4cfc7f3 +size 1325 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/la_all-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/la_all-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..698f3bc00c2a8c54112b3e48801aead979b12fef --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/la_all-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6385f99365429d38235779c7c03eddeab04624289a90729f8b051f33cc28fe3d +size 167994052 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/la_all-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/la_all-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..d732743a74f12d20b453806c448892412205d6ec --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/la_all-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:659c114054d3192beb90d887d912b05aba715e17ae556dbedb2d8feaa97ae1e9 +size 2185 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/la_ittb-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/la_ittb-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/la_ittb-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/la_ittb-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/la_ittb-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..762c4a7a1e245b638ab838c6aa92c9d57ab7b24d --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/la_ittb-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d5834f02cd81095738d4c284a8e185052475d26a2dadec92e32a4a8c0068b07d +size 2760 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/la_ittb-ud-2.15-241121.model/la_ittb.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/la_ittb-ud-2.15-241121.model/la_ittb.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..fc57bd102d3d1d7c7344c4fdc551c66dc47ec0b5 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/la_ittb-ud-2.15-241121.model/la_ittb.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7a70a12828171fe8e592da5720f000b0ab48054d4bbc0d87af291a6e72a86f89 +size 195779 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/la_ittb-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/la_ittb-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..edbb81a89c7cc206dd7fd39c024688494c637062 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/la_ittb-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e2773b3e2e9aad1d83cd8360beb9d449c5e32c6a61882d97b2e791025eac7aa6 +size 10567 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/la_ittb-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/la_ittb-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..e1dbb235334155bc9788620aefd75f09ffff3c79 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/la_ittb-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:cb2927bbfb074aedb8b5329192261d19a515bcea736dd878e8d1affb6dd96bf2 +size 613276 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/la_ittb-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/la_ittb-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..9e142ff704b6f552e8049aafc4762f96909c7434 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/la_ittb-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a7814a991c72c47756f9998fde432a5ab828a70d4ea52a9f0d5cf5f97a7cad8d +size 874 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/la_ittb-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/la_ittb-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..0f47d57f1d062911e4dad970b42a3d6b1a21e6b7 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/la_ittb-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:89fe8f46f0e3aabdc1ed1631152e59a0749e10eb256d3c5494557eed54c8d1ea +size 110878960 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/la_ittb-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/la_ittb-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..53aad01e503e88b15194b5adcf363216d96603b8 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/la_ittb-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9d2b50511d2243be7f93ad01f9967f70a72ce46b30e0a20fca73f7ef54923650 +size 2119 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/la_llct-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/la_llct-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/la_llct-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/la_llct-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/la_llct-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..061db88b4ecb591a4024cf231462bae9466fdd43 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/la_llct-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e7eed483549e79cab0d43ff3fd53fbad9e62faa13ba3f9a7435b86237a92166d +size 840 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/la_llct-ud-2.15-241121.model/la_llct.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/la_llct-ud-2.15-241121.model/la_llct.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..ab459f1e47cc441734e276f242232a03474fc971 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/la_llct-ud-2.15-241121.model/la_llct.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:25d874c8deb94d4d65de8a4cfdda5e86782f3ac9536933fae28190967a5fb5ba +size 31886 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/la_llct-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/la_llct-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..e95b97ba92ffabda530734b43c6cd6195347db4d --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/la_llct-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e6f1f715bc898c2fb766de3d1741de1de6f0f64b2961a27e19aad1d636756206 +size 10566 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/la_llct-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/la_llct-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..3caabc7bc762fe8c7d7bef00d4eaa381f266767a --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/la_llct-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c2b1c55cf64bee1b56be7a9a213df86bf8b178f8029e4686c26f6a4f7e3bb196 +size 274066 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/la_llct-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/la_llct-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..164d76565fd580aeba6d32d2259a721c3ed5e3b7 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/la_llct-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:46ea4f4f22fc89f0c66c9b47b5ff35f04260569ab5d5f7f61134d0b68c23c949 +size 874 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/la_llct-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/la_llct-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..ec9db37832080cd961efcdc9bee1107b7fec4e61 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/la_llct-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:62bb1d8b41f567070bf55dab3d61b93c5b97efd8d9eeac778a24166c3b492e1e +size 98645792 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/la_llct-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/la_llct-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..f24310618678d8dd3d9aee243a3512e10dc2257d --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/la_llct-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:55a1e95d97d7e0fb3a7d5f8255dbc2f1115383bd8502550d567e6e6242c04f88 +size 2117 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/la_proiel-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/la_proiel-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/la_proiel-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/la_proiel-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/la_proiel-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..0901f6887900f679ae3a057bbc08ae1001135855 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/la_proiel-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:449a336551b8ef2642d4543714bb3b5af6e80a5d848a6e61fda0e681af060897 +size 1029 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/la_proiel-ud-2.15-241121.model/la_proiel.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/la_proiel-ud-2.15-241121.model/la_proiel.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..441dff0cdd62ba18728ab9db6569dab1bc05b419 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/la_proiel-ud-2.15-241121.model/la_proiel.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:eede719a0f011258734d80c28f753fc68097dfe54143d12033248c4508cb565f +size 222674 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/la_proiel-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/la_proiel-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..6e7c0cd83cec3d9336535b695c60436eefcd57aa --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/la_proiel-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:bccefef7d3a690a511ead8c72a81637908c1cb2f41766c55e80fff8c0aa6d6be +size 10579 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/la_proiel-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/la_proiel-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..1eefa538910cbeadb5803973e8bd655f689dff99 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/la_proiel-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a481728a2d522af2e29687e3180d77f167e1932b188e8b5174f51c68f2c5e222 +size 699914 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/la_proiel-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/la_proiel-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..75037fb62cd66a0fc2ab501db97eebc6d3c7de6d --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/la_proiel-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b7bb3ad42dab4d22e9b4c390664b960ff1c16671760b233e46968c34c371d254 +size 888 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/la_proiel-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/la_proiel-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..1f5a32d71f64b2104468030ec436d6aacb99193d --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/la_proiel-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f00f290f04286346aaf929792a4c22d5429167d1c62b730b61c17ebccfca4eaa +size 109141280 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/la_proiel-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/la_proiel-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..04a603236b1c57212f9e7f79a2f282e67686d650 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/la_proiel-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:959dd733a7d4a2c58489a6bbd5465264831a4a81602ede544a888fd72226adc9 +size 2115 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/lt_all-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/lt_all-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/lt_all-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/lt_all-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/lt_all-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..1902df8c6f3b3ca30bcbf350214d4fc29a82682c --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/lt_all-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:fdabef62776d22c26c68543829778cddd483d508b326f5ad22422721db25bbf2 +size 1212 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/lt_all-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/lt_all-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..e093040dc204fa6eae79cec7a2fea2f2ca58f297 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/lt_all-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:bdc67aae421f833a18e69f4836cc87cb72f325a441dd3256dd8c4d2f99abb82d +size 21368 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/lt_all-ud-2.15-241121.model/lt_alksnis.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/lt_all-ud-2.15-241121.model/lt_alksnis.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..f741776cd5f28dd441316dc05b9a69cc1dda46cb --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/lt_all-ud-2.15-241121.model/lt_alksnis.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b6e6dd972cdd31faa417bf205d5787da4e5c2c6578c8f54f91a502679cf0e6d8 +size 37025 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/lt_all-ud-2.15-241121.model/lt_hse.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/lt_all-ud-2.15-241121.model/lt_hse.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..62e13d75e9b9eeff84cfd17778bac5d187781c4e --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/lt_all-ud-2.15-241121.model/lt_hse.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1754e6fdf7af86ccef627118a655381951f2d2d5d428eef905e1f20af704000b +size 203774 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/lt_all-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/lt_all-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..f1c7459ae4d36eef0a16b3afbbab391012b5d606 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/lt_all-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:50b066baa91711302e9c3e9a8f2a7d4c2297ca32037bec876c014448704d1486 +size 493178 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/lt_all-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/lt_all-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..e599f404fca9e15c6f1a5ae83a6fa00e7fbaccea --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/lt_all-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:224905e3140bf3fd0939debd09e450aa384a6e66f9e0febcadef0ec23dfe738b +size 998 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/lt_all-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/lt_all-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..ffde3b5aeb5841febfa29c38dd99b1ab797b4346 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/lt_all-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:969c94fe203ff896e473f0117af82296e8b35887271ad7d1691d6da0d829a9ec +size 94239172 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/lt_all-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/lt_all-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..c3c2818a8fea466ef1ead64ba387842ba34a9959 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/lt_all-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0480a29bde937b453d57d3f319c17a00fcfee2ca39aa0b88719c06867d5769b2 +size 2178 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/lv_lvtb-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/lv_lvtb-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/lv_lvtb-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/lv_lvtb-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/lv_lvtb-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..6849ce428c272d15ccba26f764ca8900212db8b3 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/lv_lvtb-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2e312af1235b53fc8f926485b93f5965469f41e23f8b5ce02ab11a6175f83739 +size 1219 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/lv_lvtb-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/lv_lvtb-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..b1e489e58a0fa3e0652c68fa19b9236a3745d4f6 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/lv_lvtb-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0a320dc81646775f6b33a2f793870cd206367b265e6c3b5888f34630e7de49f5 +size 10566 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/lv_lvtb-ud-2.15-241121.model/lv_lvtb.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/lv_lvtb-ud-2.15-241121.model/lv_lvtb.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..3090b607de211c67fe3b0a1416ab60f044b881da --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/lv_lvtb-ud-2.15-241121.model/lv_lvtb.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f8bc9fe7e33c657484cab9b9e0a688ccd377c6af08620ed417cec878d775f6cc +size 38819 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/lv_lvtb-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/lv_lvtb-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..b1091c36f910d01e610a6aa16f19bcbedcd8d4b9 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/lv_lvtb-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4a405c68c7496c8d9cf64c2118661e393c6b6f4621921a4bb5fb6d5867625b0e +size 13289745 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/lv_lvtb-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/lv_lvtb-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..6f60f3054f8aec064d27227c8e963948ebd9ea54 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/lv_lvtb-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:88a765daf44ffc65020850f56b02b16f41f4fe3e366c3a97257d3b482ba4bf4b +size 874 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/lv_lvtb-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/lv_lvtb-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..ce7bfffb6a33edea0a8057ea1d5c82f89e28850e --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/lv_lvtb-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9422fb7e05f1a2bad18c28e815fbb2a76a7fe2a3f274d93964fbd5f70c40d5f3 +size 126130504 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/lv_lvtb-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/lv_lvtb-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..dd44ed15dc08f37ec9e0b4ee9d09a5238553920d --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/lv_lvtb-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1a45bf34500e668324f54b0dd2be71d87753bb50e90723b71ff958ecb624d48e +size 2120 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/lzh_kyoto-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/lzh_kyoto-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/lzh_kyoto-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/lzh_kyoto-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/lzh_kyoto-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..bc63b3114be0a4ce7bb8311ec19807487ec891cd --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/lzh_kyoto-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:98d01e6f2d4b2e74d53b0e7fdc7c34eb99ef6c2fea79b031aa35fb69c9fa3fe1 +size 192 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/lzh_kyoto-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/lzh_kyoto-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..fd6ad947e7fd6ff7676ea65aaa7b3225048f5678 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/lzh_kyoto-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:13ce0a8aa0cad14ca0f253debb8b430bb04f31ee7ce6a70a8295df20c2c1900e +size 10578 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/lzh_kyoto-ud-2.15-241121.model/lzh_kyoto.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/lzh_kyoto-ud-2.15-241121.model/lzh_kyoto.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..43c346c5ff0ba494c356c7316548cca89fc2f45e --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/lzh_kyoto-ud-2.15-241121.model/lzh_kyoto.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a1a482ac535a834b186857c03d7b381690705ebdc765634f6930c84a84068c8a +size 1554228 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/lzh_kyoto-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/lzh_kyoto-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..1ed6f2dcce048e3378b5a75e185c71ae9313165a --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/lzh_kyoto-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:bb7e7b8e2d9504fb302d89c9d12a6ab6ce590aab34b662e71044fb959ad2f5d5 +size 417311 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/lzh_kyoto-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/lzh_kyoto-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..be438e3216d71c55d9d42ef12010d39771564363 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/lzh_kyoto-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6706226ec038e8ebd359ba24d68d593872f9cecc99548a9e37fdd283d91051d4 +size 888 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/lzh_kyoto-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/lzh_kyoto-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..9eac118f0b34ac4d3c620444e10c1d7a799694e5 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/lzh_kyoto-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:40e58f489fb3e0de50c741ca79a6b3bba4f9fbc64af5966556eb4b343e3de062 +size 96216492 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/lzh_kyoto-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/lzh_kyoto-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..a79064d54e701f6fbc2d8402602c200384c92efb --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/lzh_kyoto-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:580d1416b048a1c4bb63cf128408623e0dacfb7033f4e9111188448408e73773 +size 2114 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/mr_ufal-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/mr_ufal-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/mr_ufal-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/mr_ufal-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/mr_ufal-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..1c23544566215d65df3a7978fc273120d2b14ae8 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/mr_ufal-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3e4841ebbc718922dc6b1b0bb016f7670f2e98ceac29160ebb0b3f27cd74eda7 +size 435 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/mr_ufal-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/mr_ufal-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..46977060633151206b06bf608be59d9c8f959c26 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/mr_ufal-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:bcf8d79bc4fdae0cc19163ca822814a94be84812d8bfc7e8516b4c8bff9bef8f +size 10624 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/mr_ufal-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/mr_ufal-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..a4cb8f0f927e4c7a84a1418d76ea6f8ab1cffcdc --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/mr_ufal-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0eb8518a2629be249780490b29fa0054348a7ccfb433da128a098adbfb09371a +size 87932 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/mr_ufal-ud-2.15-241121.model/mr_ufal.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/mr_ufal-ud-2.15-241121.model/mr_ufal.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..872d5dd693391238a47050b4f78d44f551574029 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/mr_ufal-ud-2.15-241121.model/mr_ufal.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:937859f8300108c60c3cf2bfa2971d196507f09e9bc9095ce63b6c14ade58905 +size 205455 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/mr_ufal-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/mr_ufal-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..3eb52051ecc4863aa91898bd0552520a241d7612 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/mr_ufal-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8225d9faea654dc2702e7977047fac1d977a83ad7f03d20e07d83253020305d9 +size 874 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/mr_ufal-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/mr_ufal-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..df1e4a93a04ad42db3cdc28e7e5bd099a40cac57 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/mr_ufal-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8f24ca2ebf10fb03272165730e9d3f1704a97efc52cc6e84a394b0b4d1b42779 +size 51411836 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/mr_ufal-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/mr_ufal-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..259931d7d1110b771096f9428edf126116160c3d --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/mr_ufal-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:979b4d7f8a49d22219bfd94cf268c3ee51b7da0e2bf525ee1fa4ad0d72b2c395 +size 2109 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/mt_mudt-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/mt_mudt-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/mt_mudt-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/mt_mudt-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/mt_mudt-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..fea4d2ac7344ab54cc7dadf27573531e1385456a --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/mt_mudt-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8e32b36f07b84708a3707dfccecdc822ba4ccd910c51eaf12c555b653b43caa3 +size 115 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/mt_mudt-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/mt_mudt-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..23a5a4a56a8998e268ddfa54c2bf249b5f74b912 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/mt_mudt-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a14641af3e1b897a4cb0d39acbe6a8f4abd48911f36b0231b09d0357c554f6db +size 10682 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/mt_mudt-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/mt_mudt-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..71c78d1f5be7c0d26bb84447f472bce3d34301a7 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/mt_mudt-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:192e9b5537d048c4d6c03031789d1f300392b0f84be68c5b3552f3f0479ad5d3 +size 55092 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/mt_mudt-ud-2.15-241121.model/mt_mudt.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/mt_mudt-ud-2.15-241121.model/mt_mudt.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..9f8102a342f44034ce4992b34c269ef70020fd04 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/mt_mudt-ud-2.15-241121.model/mt_mudt.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:52fdb95cca11e3be39bc27ad23a28910492283764aecfba2968e85bf179e90ce +size 36453 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/mt_mudt-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/mt_mudt-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..0a50298c8a8fdd38c8c4c4f97ba38bca31cac09f --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/mt_mudt-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:98e898ace7c89a597f9a12a22973f23e811bfa790689860879e5bffc6ff7183d +size 874 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/mt_mudt-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/mt_mudt-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..d8a33b905712601a261c47d06f1749f4c26c2f1c --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/mt_mudt-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:689a52f193563e77251f9fe55f52e3dd042b6691946323f3499c8abc4392326b +size 54844728 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/mt_mudt-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/mt_mudt-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..6c3b65bc66b8799501106b6d116df848c94886b1 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/mt_mudt-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:23537ba2204914d8926448add4bfe568d2679bf180abf4ec6021b1eb2af8acae +size 2106 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/myv_jr-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/myv_jr-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/myv_jr-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/myv_jr-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/myv_jr-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..08d7a5033e54b31c0d241b822e03ac63fe3c9842 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/myv_jr-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9b56ac322a8b6af47dae7eda393f5d8e097e4dc84c44a6c207837a5fb7ac80ea +size 1293 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/myv_jr-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/myv_jr-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..7dd598555584a176420044a93a9ed76e075c090f --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/myv_jr-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2a76167712e028caeb6b9392aeae994a6ebf46f48ee12f6de055d80bfdbb4161 +size 10557 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/myv_jr-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/myv_jr-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..857c186036dfce7fcf9bc7873a266fafb6053519 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/myv_jr-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5148135b8410f9aabef9b775df097ae44a854ad08a84223293911fa5c9f0f9e8 +size 283736 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/myv_jr-ud-2.15-241121.model/myv_jr.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/myv_jr-ud-2.15-241121.model/myv_jr.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..ec3b8a15c621ef135d2e665de1cf608a1d6aba57 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/myv_jr-ud-2.15-241121.model/myv_jr.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9727523161d6bc5372265ceae617ea07618bc2e4c4faaf0be6f10d7f459e3fb6 +size 34623 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/myv_jr-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/myv_jr-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..191f85cfef4c5672fb97d2c2b7cf78acab15a1c8 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/myv_jr-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:45199e01fac16738d83abd5504a284dbc99408c20239537f43e17f80d3c4f383 +size 867 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/myv_jr-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/myv_jr-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..e29ad45aa43f0a112a289c16421ed2587c0dc906 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/myv_jr-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:bb8fe489b6d30b615ce3a4afaddcbb09b71830c73078b22b23667c75d2a7494c +size 55686048 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/myv_jr-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/myv_jr-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..4f2263ee82ff579b7a66d36a3b9e69bbb2972b07 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/myv_jr-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:eb60819cc442cb78bf51e756e709de10b75f36f14875924c85979b4bc91e29ad +size 2112 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/nds_lsdc-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/nds_lsdc-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/nds_lsdc-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/nds_lsdc-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/nds_lsdc-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..7b30d317c47c2850fc549f695ee702e3169f8006 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/nds_lsdc-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a52ac2b0b4132abd7ae7a21b76202504ba7fb902e6fba2327adad04dab03d33e +size 570 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/nds_lsdc-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/nds_lsdc-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..87b56023d1a2f87d5e61c7219288772caada8d42 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/nds_lsdc-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:024704942aad76defcd47cbe48129da1dbf3a45652b440da133482efd2b7dbb3 +size 10571 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/nds_lsdc-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/nds_lsdc-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..8047889a4f8a38a386cd9b05ea3049fbb9c4c57c --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/nds_lsdc-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:bddc946c2df1ce91447d0eba78ab3ee9bce928cd482701555239337c01e3f758 +size 138016 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/nds_lsdc-ud-2.15-241121.model/nds_lsdc.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/nds_lsdc-ud-2.15-241121.model/nds_lsdc.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..0b12220f91fd48d8575aa8ad8d8e76e7f250c876 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/nds_lsdc-ud-2.15-241121.model/nds_lsdc.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4635800c50802f96b5dd14c9df31043469bef47b666bd543d335ac97e5e72123 +size 34781 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/nds_lsdc-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/nds_lsdc-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..69ffe866af292db039950b5c648a89b39ff9286d --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/nds_lsdc-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:fadca3550c027b2e1cce374bbde9a15c26ed5a2a2495292a0076ab394d4b3f77 +size 881 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/nds_lsdc-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/nds_lsdc-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..eb36b8f1b370aa6a315129d48c671f15c1667f22 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/nds_lsdc-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:89c78cb685487237be3418aaa3cd2d05ec20728abb0e1796c244f802bbbdf733 +size 54439276 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/nds_lsdc-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/nds_lsdc-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..344062452f7220858688510f2ba51690a62fba1d --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/nds_lsdc-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2cfa66e8dc8adf258fa84e45f23f197086f7351c56a92607e7cd4eb3ff776b3e +size 2111 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/nl_all-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/nl_all-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/nl_all-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/nl_all-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/nl_all-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..0304ce7bc75ad297b79947def3e42eb50ede4115 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/nl_all-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:60d30d356d22a4511c77566becaffe4ad45fb2b77beaa0a924004e5e4d8bda5d +size 182 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/nl_all-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/nl_all-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..eb0b71b70fa880ca015c39d8438971e14a98c6fe --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/nl_all-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d38301166de009370ebd34174e41564619e4fb91c247f9dacae81b42d0aeabc8 +size 21770 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/nl_all-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/nl_all-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..ad7eb6f52d9138610ffe6938a5e751235df35efd --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/nl_all-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f29ea4ee15c61abef5811a8d7a22bbba4ca316d776e4feeceb2e28abcef75652 +size 1211180 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/nl_all-ud-2.15-241121.model/nl_alpino.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/nl_all-ud-2.15-241121.model/nl_alpino.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..63d3fff43221e81327d444296d713c98b057136b --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/nl_all-ud-2.15-241121.model/nl_alpino.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b1106fe073c2a4559566ccb397639a19d83c49795639d60e479a05747540767b +size 208608 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/nl_all-ud-2.15-241121.model/nl_lassysmall.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/nl_all-ud-2.15-241121.model/nl_lassysmall.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..f568a02bf77cbde05c62974979cc84cb34d11238 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/nl_all-ud-2.15-241121.model/nl_lassysmall.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:bf0deb3dc37fe6c64257d5aac87f35a31ae711e4d785e24063613692d9acffb8 +size 38722 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/nl_all-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/nl_all-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..cf11d63d7a83cd5b6e97f97424686124e9e68389 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/nl_all-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e9b9d482dd035d4597bb574bd82b0f56892a95b1895960389d7c9c3299739fec +size 1034 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/nl_all-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/nl_all-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..fdaa07243d21fec11e179bef08097c844edb9dda --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/nl_all-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c005c3149a3c6bb1916f1e6fe72260715adf3802b89112de5be8f42dfa4bc53b +size 131285032 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/nl_all-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/nl_all-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..68dc99cfdd29dad29d87ed39cbc82dfe4e0ca25c --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/nl_all-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5c2b4f5b753b6b81fcd3d46883ff7641cf156cfec42bc7ef88619b377741decf +size 2179 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/no_all-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/no_all-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/no_all-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/no_all-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/no_all-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..acc3a738aa716b182ee987c539735810b3a21eba --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/no_all-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5ce6a47041552ff1cde8fa0119ecd34edcc3350266db853294396700e83c8753 +size 564 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/no_all-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/no_all-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..a1a963fd560c2412651bd64ed587eaf00613aefa --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/no_all-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d9ed4b6eaabb1a66919c00598f0ca6bd6cf595ae823ffdab93c54630698e6a4f +size 21635 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/no_all-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/no_all-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..04dc79ae8b68dcb5b9892f7c9a673562fb7ebf0d --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/no_all-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:329858599ce3a00baa926f0960d4dbdf18ad7cee9646bb58873d09e59be8def0 +size 612596 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/no_all-ud-2.15-241121.model/no_bokmaal.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/no_all-ud-2.15-241121.model/no_bokmaal.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..f0c96ac580b79a6d4d3230563dea3202edd69816 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/no_all-ud-2.15-241121.model/no_bokmaal.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7e3842ed5191638046bbbcd060d3e1b6e07e173d83ea107c7ef60cb7b4c6fbf7 +size 212660 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/no_all-ud-2.15-241121.model/no_nynorsk.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/no_all-ud-2.15-241121.model/no_nynorsk.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..3246f87560a45308b1384067e7eadcc4a7ba904e --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/no_all-ud-2.15-241121.model/no_nynorsk.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d2ee66fe55c14508b65f68e2dae9ebc7726520fbde21d185c2aeab4f0d5921e6 +size 211362 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/no_all-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/no_all-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..cafd2b4a2f4c73898948e368bcc2e9dc63778989 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/no_all-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e20a40f25617e736af55fa6c7630b6b6a58c5983584193328316cf685efaee8b +size 1022 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/no_all-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/no_all-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..8d40203e5088c17c0ab48e146614857d0557f1a8 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/no_all-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:58ba6c2f0578a4b999c2e1f5a5d17b31cf2a2a7827a1b5ac4bfb5477cbafdea3 +size 127352744 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/no_all-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/no_all-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..e35e63bb69864f884d8f4e13f86756b38031dda4 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/no_all-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9b3e661e398d316d44d4c7e10cae11da2e00c0a20d446054b34c053a68e18c85 +size 2177 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/orv_all-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/orv_all-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/orv_all-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/orv_all-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/orv_all-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..d44d085e7860235a7250860dc493d32411d0715a --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/orv_all-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:abe33670971204f7c76565df90b6db634593e913543940dfddf97dedccddd72c +size 2723 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/orv_all-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/orv_all-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..2ee6d3f6dff4ce417c9051a78110d7b04053e820 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/orv_all-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f3903d2708681d2356f51ef570006d920376e99e962ec14e43a5a05a5eb3a1e6 +size 42635 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/orv_all-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/orv_all-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..3c894693816bcef670dc4afd61950d2b993b7851 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/orv_all-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e451a03bb4c4285f3814a41a13b137790e0104191e052a9abd6f5ecbf78da703 +size 4529335 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/orv_all-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/orv_all-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..52d84b5d59185e5261056c3d03b826702362ffcd --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/orv_all-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b814dbf163e6ce4b7407bb54a38cfdb3454cb445d4150c17a0ab06f410f240b6 +size 1271 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/orv_all-ud-2.15-241121.model/orv_birchbark.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/orv_all-ud-2.15-241121.model/orv_birchbark.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..6590498fc1180e8eca21c6c6c605d3465578dc66 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/orv_all-ud-2.15-241121.model/orv_birchbark.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a1e7837c8030a7fc6bdbb7533e17336b732d45f71a547a46ec46260a24faaab5 +size 206212 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/orv_all-ud-2.15-241121.model/orv_ruthenian.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/orv_all-ud-2.15-241121.model/orv_ruthenian.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..82cc91a75882ae4b08f10d8f62edf30098f19b91 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/orv_all-ud-2.15-241121.model/orv_ruthenian.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8ed40b655d0ef1ca37b37f1d4a4dffc46972dfde7059f4c01950d83cf6c142a4 +size 42023 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/orv_all-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/orv_all-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..c6d09daefa4a065834e5c28068866eef4d01203a --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/orv_all-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8e00aeb2182f6b53f335f122c056fbabf2d41c767184ba6e142c63f8992a05d4 +size 213170268 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/orv_all-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/orv_all-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..e089354094f8d829672b0a215ddc4c06e694d15f --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/orv_all-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1ace0744b2f3b28cca4db84f2b1ec34bf4eb510ff89f1f79019b5b779ea2d7aa +size 2183 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/orv_rnc-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/orv_rnc-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/orv_rnc-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/orv_rnc-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/orv_rnc-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..8497ac2e21d3cad8f43d8f4b020f15043b533503 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/orv_rnc-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b059b9868fe943db3f2bf86bbded45048f7323bdb44b9aa8e4a2c2c6c179f938 +size 1662 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/orv_rnc-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/orv_rnc-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..ad95731794d3b957138ae6a8ee27677552712132 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/orv_rnc-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:283d1e493c87e2f49bcf4653ec30ae935eee087c69276363519e9728e7e7fe27 +size 10566 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/orv_rnc-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/orv_rnc-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..528b09d9e6612be72377a8973aea1e84a0f3bff3 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/orv_rnc-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:47f03dd0f9d5bba49edde7a41f534f6d829479e04b99f10dbc6f5a1c818298c2 +size 1933941 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/orv_rnc-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/orv_rnc-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..1a9b8a51c145617ee37d35df02c543c55975707c --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/orv_rnc-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7e8abfc7d771d0124f73b2d9c050fba1d4d274a3ee35b43997783d2e417b4f99 +size 874 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/orv_rnc-ud-2.15-241121.model/orv_rnc.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/orv_rnc-ud-2.15-241121.model/orv_rnc.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..9fb8eb172f5b7e05ace9fc17d1cea511fc80563b --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/orv_rnc-ud-2.15-241121.model/orv_rnc.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b2170fca91088d82636ac5609ebacee0339fefd3d7f70de80a6fd183202e3b79 +size 43101 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/orv_rnc-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/orv_rnc-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..0ef2b49433bfb8daed9fa19b80c1bdaa0537d22a --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/orv_rnc-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f6e3078d47b8be0611a35c97f523a20488dc8906f1a867ad340ce76739bbe7c2 +size 113388060 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/orv_rnc-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/orv_rnc-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..d422a9f0bd6061423ace3d2c42de91264d60f001 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/orv_rnc-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c0b5db224c8ef88707ee7c0482887e870c5721bae8d05b667607cedc44289dbe +size 2117 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/orv_torot-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/orv_torot-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/orv_torot-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/orv_torot-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/orv_torot-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..9c0532adb47e80e0b2c591b6524fef7d395304b6 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/orv_torot-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f06c4719458931bf2333d4436d5c6033c555707129fd8ea8721382ef65304c2b +size 1052 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/orv_torot-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/orv_torot-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..22cd7b48a4bf7a4e155a5307b42d22dcabcde1db --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/orv_torot-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c66f60f007eebc57e5674d702259fb2a07d580db61e21eea528394de78896b4f +size 10580 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/orv_torot-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/orv_torot-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..6097befa001d7e32605dd63f8fd6686ccd92f4e2 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/orv_torot-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e9ca5703edd1dabc2ffb73c2812a1c4ab06d97f4521584f0fa9546ee5da53296 +size 1224174 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/orv_torot-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/orv_torot-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..1a72b8d422a48dc37a7179f34699be16fea810e1 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/orv_torot-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:76caf3be86d126620e85959face645c9188d11fa79cdcaa50a06a3661d20cb15 +size 888 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/orv_torot-ud-2.15-241121.model/orv_torot.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/orv_torot-ud-2.15-241121.model/orv_torot.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..f9787da75c8a598ddabeaf23cb8b8d24c370bd76 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/orv_torot-ud-2.15-241121.model/orv_torot.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c577dd13a9bd38e62e6a5f50d870f1243e9605fa430ad32e35f8765b761edc3d +size 215788 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/orv_torot-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/orv_torot-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..f1ddb7f3e5a638b389d7f4c8e656d9a79537656b --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/orv_torot-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:70694730201cb035ee9abec8d3c38d79d8585b19676044f3c772da3f696dd9d8 +size 151637548 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/orv_torot-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/orv_torot-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..ed598c64e39368ab2e1bb8f92a5b85f8cd3d22d1 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/orv_torot-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2333bcd5f5df8a388aa9482246345b46f28a1c7196526aea9f69a431d19b218b +size 2116 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ota_boun-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/ota_boun-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ota_boun-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ota_boun-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/ota_boun-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..bdf6eb6f5461e8f73e27db5f9cd4d0b3e14b1a29 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ota_boun-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e6ee867b38addedcb697520fdd9126c7039f1f2586bc85e3f7477bd96a762691 +size 314 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ota_boun-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/ota_boun-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..0992e42a1ed1df0cc2d45572a532b15f2c3ee69f --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ota_boun-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:da3209597dda12e13d105ca68128dcce408bd4e0bc807c560f803bfa3e0ae3c1 +size 10570 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ota_boun-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/ota_boun-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..1fb53ba1eace36f8ab183d6f496744adb9941871 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ota_boun-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c720a999989155645cd13713ad83aaefb06a0e4503a117aaa2d39cf4cdeb063f +size 27716 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ota_boun-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/ota_boun-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..229c37682a1a9db02702d62a6abd1ac08e2eda98 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ota_boun-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:679c2f9ff22c2aace4a668979974ea70e22b04a36b126987d0e2094abc1f8700 +size 881 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ota_boun-ud-2.15-241121.model/ota_boun.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/ota_boun-ud-2.15-241121.model/ota_boun.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..46fce5f0b270ff97b3ca0b9cd24646047b914f14 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ota_boun-ud-2.15-241121.model/ota_boun.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a8efe3c34a4dee627fe9f586ebb278f1b8a2d03bcff625baadc9c08099c3e513 +size 33900 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ota_boun-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/ota_boun-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..d1025f58510ee4a779e71ce5ad75199188d0e8ac --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ota_boun-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c520b619f8d1a047c7a7c22a463bfd42b16a148f7d48bc9a95c07714253382e4 +size 50685032 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ota_boun-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/ota_boun-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..c94ac1f33a8d219c7b3dc025f75b7e452bc95ec8 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ota_boun-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ac3b840cbec8458dff1fc5cb6e2fb77421bdbe8694accb8d168fd2dedb066bcf +size 2111 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/pcm_nsc-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/pcm_nsc-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/pcm_nsc-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/pcm_nsc-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/pcm_nsc-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..56bbd3826e3757024373f8e5194535b168ef0bb9 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/pcm_nsc-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:691bb65bb4533f3775307cc13e8b912387a3f0ee53af96092e10b65c5046e42e +size 381 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/pcm_nsc-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/pcm_nsc-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..24388767cd891cc673fdfc9aca6131b2df08bb6b --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/pcm_nsc-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b250e275db15b22ed759ff9fb039f3be1bfc3b1a400de0935f231918654ba3fc +size 10624 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/pcm_nsc-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/pcm_nsc-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..0657090f682325bf42b3d3771ea469c668f202be --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/pcm_nsc-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d0657fac9b456d1505235ca6a831c178da7479a80290c88ad0d530c56b554faf +size 7078235 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/pcm_nsc-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/pcm_nsc-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..090e4e6750f526e68e2443d25ee622218a48fd6b --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/pcm_nsc-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f56548acfe740d989f54caf28790194a1ce48d7e5947483ce9a88ad9159a4d6f +size 874 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/pcm_nsc-ud-2.15-241121.model/pcm_nsc.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/pcm_nsc-ud-2.15-241121.model/pcm_nsc.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..12f2fb97e4b39e62c3de713f4bb30d96eef75dc0 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/pcm_nsc-ud-2.15-241121.model/pcm_nsc.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ed6d6ed95bde85939c7f683504a2403d2489438d801c199694466c8f83139b8c +size 203342 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/pcm_nsc-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/pcm_nsc-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..31246a5e34c75e8760901314f6742b4577de2d98 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/pcm_nsc-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:de651773a2374986cca42fe1852a97885fc317fd13fc543b1439ad3c2a8883a1 +size 83494036 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/pcm_nsc-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/pcm_nsc-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..d233bd39006093e22d0b50aa6db3ba7f47d9bbf4 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/pcm_nsc-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f7433bdb4a11441ddf6dfb9d5dd9af03f17edb01948818065828fe4303cfa119 +size 2110 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/pl_all-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/pl_all-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/pl_all-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/pl_all-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/pl_all-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..a05f99330fa60f67388fb76dfe169dec41817df1 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/pl_all-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ecab794ee97574528ad14343de447df06d1bcb481d396b6fad52e52772fea407 +size 1991 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/pl_all-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/pl_all-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..f7fa8a8ea0bdf73d60bdd2a92da062134f2fc222 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/pl_all-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8508769aaa4fbf1d41e55093a18044343a0e12b33a891026968e9ecc11a2159c +size 21102 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/pl_all-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/pl_all-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..6ffd7e78bdd50a145c0ca6c632bcdba0b3207f2e --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/pl_all-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b3f572621e8f4c46b912cf0baf6bb0992c4b55ca66d7739e84c6ae52d37cb365 +size 1314341 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/pl_all-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/pl_all-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..476cb374f4405cd2e7ea55233cab86195a87ec45 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/pl_all-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:16a3ed901faadb8e76c63b6f3ff4ff5f82e52469b8322fec25f368a30beb92bb +size 974 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/pl_all-ud-2.15-241121.model/pl_lfg.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/pl_all-ud-2.15-241121.model/pl_lfg.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..5ca92eb8586c87173233592b92cd0a9127feb97c --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/pl_all-ud-2.15-241121.model/pl_lfg.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4548cc121583b6db79f80488ae4af578ffb084c59ea3613244705cc3d78a981e +size 36801 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/pl_all-ud-2.15-241121.model/pl_pdb.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/pl_all-ud-2.15-241121.model/pl_pdb.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..fe046c3e4cc8846d8b5d02618b5f6d2241af00b5 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/pl_all-ud-2.15-241121.model/pl_pdb.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3a66fdfe36a2428a7308a70bc3eab4d4a66b6eb7c4fadc2cf332e09b3479f1cd +size 239232 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/pl_all-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/pl_all-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..e21ad673554cad971c7660688e99014f9a00c50b --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/pl_all-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:636a4d0899f1c8fb8bdd92ea0f7258a767467b460d9113274c90fd80d96eee82 +size 149402192 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/pl_all-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/pl_all-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..27089db622f311d4a3924cf54bf027f683bb0e0f --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/pl_all-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:482cd43d77d9362e4db5efb29e0567ee1ce12ee90124811d05fcf7303854e15f +size 2182 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/pt_all-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/pt_all-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/pt_all-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/pt_all-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/pt_all-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..c41b981c7635927eb67ae145459ea68a594a3240 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/pt_all-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ffc9b6685c118c0028005bc3a656bbb2c007ce716b67459ed6552eb0657b1621 +size 914 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/pt_all-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/pt_all-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..b02b601d801e97e44feaccdbba047302b7de0f64 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/pt_all-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9d23d0bbaeb0df7af36ac344d8ffc29b4cc3de6dc681c2de4281610f98569c36 +size 63800 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/pt_all-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/pt_all-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..a8e42e04892f1a15a9aa058e7e9b17c1a8ef7e12 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/pt_all-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1d513972abf20a988aa309cb4af5c7fea218317607eed385e8e18329e6d64b49 +size 1413142 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/pt_all-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/pt_all-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..6a809a00e76fce83719b96d58fe5515121c31e37 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/pt_all-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7e844482baeb4a93c82f31bdf2bd7f119a9f4a1b4236e4a52c6b8c2af89b1138 +size 1508 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/pt_all-ud-2.15-241121.model/pt_bosque.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/pt_all-ud-2.15-241121.model/pt_bosque.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..0545862b3f374d7ef1b86689075dfa2f6c6b40d1 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/pt_all-ud-2.15-241121.model/pt_bosque.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:cccf9c658f6d6242acf129abe42e8ac3cbcce7357298b7d45eed9bf6b5b23e01 +size 52325 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/pt_all-ud-2.15-241121.model/pt_cintil.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/pt_all-ud-2.15-241121.model/pt_cintil.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..f16a190a75a36d833827946e35c987b8d4e3eeae --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/pt_all-ud-2.15-241121.model/pt_cintil.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6947a0eab6618f9a25e1829673864e59761b64f36bde0506a68654ffd0226f83 +size 231792 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/pt_all-ud-2.15-241121.model/pt_dantestocks.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/pt_all-ud-2.15-241121.model/pt_dantestocks.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..eb39c5e9a419b65196290cc446165a5440dcac68 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/pt_all-ud-2.15-241121.model/pt_dantestocks.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:58b68b340d85504a8e9cce5cade09a11860fe819535637e2066fb94ad2874c01 +size 217027 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/pt_all-ud-2.15-241121.model/pt_petrogold.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/pt_all-ud-2.15-241121.model/pt_petrogold.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..de6a18cdc4e08c514fc6988f4aaffccb91a50333 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/pt_all-ud-2.15-241121.model/pt_petrogold.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:84ec451e680b5e0350588e10226776f5d705ede2eb37123c0f9c61b9e889a8be +size 50220 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/pt_all-ud-2.15-241121.model/pt_porttinari.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/pt_all-ud-2.15-241121.model/pt_porttinari.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..42d864b979449748e2fa25e955215345366136ec --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/pt_all-ud-2.15-241121.model/pt_porttinari.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:92abefcde756d12b6f66bad4cfc4a64715b4acc740b7f7e06caaef1f7fd84676 +size 216398 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/pt_all-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/pt_all-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..681adbbd2192634264b049a1ee104f644c5d24d1 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/pt_all-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3b3436b7681442e3bcf51747bc6dab8bc74913dcc9144ba47d48a1cb194763ef +size 171910600 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/pt_all-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/pt_all-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..ced0372cb4ebf626105c32603b2b416006e1ece4 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/pt_all-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f40a127e6567c5be6f8d1427748fe843114f2a5bb1065c55654c263a095d3b5f +size 2179 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/pt_gsd-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/pt_gsd-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/pt_gsd-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/pt_gsd-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/pt_gsd-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..8e582b5e009134c04d5a0f1e60ce3d7269332731 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/pt_gsd-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:642dbaa63d0963e9835beaeea0ce5c6d61288fd07ab02f0dcad0698fe04050bc +size 456 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/pt_gsd-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/pt_gsd-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..b5825095f12a3967e30e5c3e7f90246c31601047 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/pt_gsd-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9371c6e5d1f56a5d964964bf0e722115e05bc9e3580917930f88f9e3f6830317 +size 10557 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/pt_gsd-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/pt_gsd-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..96d1f08ec5a62b4a0549467a59a9039db3500a30 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/pt_gsd-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:55eb7983abfa5aef7f976405ea60906871938d59dc33363b76d6115de2a51d71 +size 341240 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/pt_gsd-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/pt_gsd-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..98d202904bb8f4497c911823a7c78a0f670afa9c --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/pt_gsd-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d5b869c0c38f155c1a89acc866109f479e38ac9acea96ab4678684d4f2dd81c0 +size 867 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/pt_gsd-ud-2.15-241121.model/pt_gsd.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/pt_gsd-ud-2.15-241121.model/pt_gsd.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..da8a79411f006cc99bf635c91ca98345273e8780 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/pt_gsd-ud-2.15-241121.model/pt_gsd.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:784f90ca2c200db670e4eddcb841fcd39d83d712bcf376893fd0274c540f7a85 +size 236227 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/pt_gsd-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/pt_gsd-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..d991b8c37baa3964a6f61a86c91302ee829760f2 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/pt_gsd-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:fe869e525a132825ff8a0c8b0ef61b9243f799561de956f85703fdfd4a3c53f4 +size 104266508 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/pt_gsd-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/pt_gsd-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..4b048830a6139d37025b4be49c8799a2f340676a --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/pt_gsd-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:401383bf38c6ab975e7fc1ec3fc98ab584b19e44fe441e6ea9578c51905f84a5 +size 2114 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/qaf_arabizi-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/qaf_arabizi-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/qaf_arabizi-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/qaf_arabizi-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/qaf_arabizi-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..9424156c01394701655502eb2534e604b21eda69 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/qaf_arabizi-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e2bf349ec93652d1e8aee65b5eb27ef39ae8dad7c68693a4c6a8e7f91b3a20ba +size 202 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/qaf_arabizi-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/qaf_arabizi-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..e1c1d0df50e8a13dd8743c63189a0176460a44ef --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/qaf_arabizi-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a26807cded502c1adec9de5808c5cffd6a18858dacccae9a91897ab6af11b712 +size 10593 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/qaf_arabizi-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/qaf_arabizi-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..68ef530e6ad39553da53e85f0c8013114beba01c --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/qaf_arabizi-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ad7e1e550d1737fda50ce17bdf7a0e446659a000eb1cfff558f3d58f904cf083 +size 324855 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/qaf_arabizi-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/qaf_arabizi-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..58ef350165a467e10351f37cad2b76458341a05c --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/qaf_arabizi-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:78ab5aa08c390cd668f490e89ea65eeb8eeb811595f388bbe01f6ee94d3f7d1e +size 902 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/qaf_arabizi-ud-2.15-241121.model/qaf_arabizi.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/qaf_arabizi-ud-2.15-241121.model/qaf_arabizi.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..f740dd996d8f2b71196d183095b66aae0650729e --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/qaf_arabizi-ud-2.15-241121.model/qaf_arabizi.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0277599b2f5c8b329d6d0e51e30725c8dcef3d949fc9b4f11bdbb83c87366afc +size 46217 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/qaf_arabizi-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/qaf_arabizi-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..42c243003d22c13ed00f8004164a58c71e5fc0ab --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/qaf_arabizi-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:295fc45d636563eafe65e1c10f644358b3a19c23f58b90242621de59a804ecd2 +size 70906788 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/qaf_arabizi-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/qaf_arabizi-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..87b80f9ba0cc558f3271d6c015a025231d98b8c4 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/qaf_arabizi-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d62df1a34b6af972026c5b3e024095c82a10313fca162f305096af8b66e29a09 +size 2116 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/qpm_philotis-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/qpm_philotis-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/qpm_philotis-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/qpm_philotis-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/qpm_philotis-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..26200e9f00aff9a6c0fc5a60aa61792835069cc5 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/qpm_philotis-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0d8ed5f90e86a2ed8bea77d42d66d3e39e9f730d947b5bc591625632155d8602 +size 770 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/qpm_philotis-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/qpm_philotis-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..7de43db13a4a53f8d7c5074b77fa7678c28840ef --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/qpm_philotis-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f83b93f1ad4f08fd9e54a0b8438f3929c25aa2f30c149269abe0c3e0a17519b1 +size 10660 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/qpm_philotis-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/qpm_philotis-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..0dceffc7494cb44b744c0c5288ac6482fe0e0e28 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/qpm_philotis-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c6a2f9e29ece971ae8cb85470eb671e55322323e7a186e89c2bcbdd702ed15f8 +size 113332 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/qpm_philotis-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/qpm_philotis-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..17102865a7c475a565052b1829d0d42fa0bdf924 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/qpm_philotis-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:30dda351024afce98fa6c35c20ca81864cf11fb67410e20d4c17b06bb8115e25 +size 909 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/qpm_philotis-ud-2.15-241121.model/qpm_philotis.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/qpm_philotis-ud-2.15-241121.model/qpm_philotis.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..cf9233f7d6a6850273cc1f9162467dcedb599e54 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/qpm_philotis-ud-2.15-241121.model/qpm_philotis.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:da58b8d7612d067606a4be97f4775e0123ed75317b0ac0e5fe3ebaa4f56d490e +size 210725 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/qpm_philotis-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/qpm_philotis-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..45ac40e62451affb0f8206918cd33e136b8c8d9d --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/qpm_philotis-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:cb8d60435b2a210a761ce2d2f230e0824b095c89c52904979f5b897ba12630a6 +size 57704440 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/qpm_philotis-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/qpm_philotis-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..beddd1361fe3090817d3041b0a7c41a7c4068fda --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/qpm_philotis-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0ee8e322f06d937386d284ed4774e842a9a90b3a4bd79a73832bfed5fc3a5af5 +size 2113 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/qtd_sagt-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/qtd_sagt-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/qtd_sagt-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/qtd_sagt-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/qtd_sagt-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..49b460d858bf63bc18a8248c2c112d09356b7f57 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/qtd_sagt-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:275d59d76c268558918857b79c5d7eda0c7d4dd4e76722b53099b5c9af7a0ae8 +size 773 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/qtd_sagt-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/qtd_sagt-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..2b63413ed8ad168e857e4cb0b1c275f4ff4cb73c --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/qtd_sagt-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:677516b219b3fe374c9ca9f611e905221e7731bfed11811f4bf29b954c82f3f8 +size 10571 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/qtd_sagt-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/qtd_sagt-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..f1419cb371c69cf252c51ec0cbd2f00c19904ef8 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/qtd_sagt-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:03b2e9db36f333db571dcf4e17bcad216c055162429b1db7d784b62706a74129 +size 76941 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/qtd_sagt-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/qtd_sagt-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..7732ce64bb0e5d1e51fda25236fb4ab70c644824 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/qtd_sagt-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ba5a96ccdfd418b786f077fc6a2a6b55153b02636fe301628766fbebd575a084 +size 881 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/qtd_sagt-ud-2.15-241121.model/qtd_sagt.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/qtd_sagt-ud-2.15-241121.model/qtd_sagt.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..791e39128de42a10459b27e576039f6ba809b9bb --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/qtd_sagt-ud-2.15-241121.model/qtd_sagt.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ce11fcd335d442e70c759a48de34fcb9c365a499a1739f391ec977d09d6f9eb1 +size 36094 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/qtd_sagt-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/qtd_sagt-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..8a4561a26a8c9a24d68c8c43ec26a5f87fa04bc5 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/qtd_sagt-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d8ef55975b616715a79d7d9f566d1fdabc50669162fb705da67d209fd5142d4b +size 53676468 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/qtd_sagt-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/qtd_sagt-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..6c4b766b72104d5c0d42c82e285ee36bcb7c80bc --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/qtd_sagt-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:da6c6076cd752318b6b937a484dad59d06166d01ccff50227f06b66999fbdea5 +size 2111 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ro_all-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/ro_all-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ro_all-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ro_all-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/ro_all-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..97627ce6cc0f3035817d67f5e85e2d7c9ff14906 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ro_all-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:665f443377a95e4306abad335bc11046b5aeddf9a21e09b2ed969a14eb89d72d +size 1030 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ro_all-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/ro_all-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..c422fec76f9fcf7876ead3e367dd3e5f136ead0d --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ro_all-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c72568392f609f62e97513b6977e5adfad057b02727a66f5e173e1ae8e04b181 +size 32134 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ro_all-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/ro_all-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..97ebccc5b4c8dc508ac900f40cb69eaff47b94e5 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ro_all-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:195bf819a011a300bba6b8c009fc5a326f33eebe451364e50e364278c514d5cb +size 2290221 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ro_all-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/ro_all-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..dd055cb51ca74aaf63456ef936ddacac79172dce --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ro_all-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4ef4bda6e1bec4ca13680b51a273784275f5d5a398230a2bf6eda0aad1aadf43 +size 1145 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ro_all-ud-2.15-241121.model/ro_rrt.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/ro_all-ud-2.15-241121.model/ro_rrt.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..2553cc07c8a0defb1a489db64cb0c791a4a1ac42 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ro_all-ud-2.15-241121.model/ro_rrt.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ad8461b50d4fbb951077672a07e721a90e974b5711c870b4dee3e08f450cdfb5 +size 220324 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ro_all-ud-2.15-241121.model/ro_simonero.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/ro_all-ud-2.15-241121.model/ro_simonero.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..ffdf97f55d86fa47cf2cff5fabce51d52b7a530e --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ro_all-ud-2.15-241121.model/ro_simonero.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9feb988f180d59d5b47be1ec93bf8828df43f61d848d4e259767f1b8e7f6c0ed +size 213277 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ro_all-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/ro_all-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..1d304ae44a68d7bd5748cd94a1e3797423ed54f5 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ro_all-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:be4228ab1f470716b2c985960c6a14480f3a8fee935babec99bd636db2f71dfb +size 172591660 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ro_all-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/ro_all-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..122e998cb193d868b8c38504190f53c7b6773671 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ro_all-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:52979d692f40f2f2491b29cbec06aa8036afe6de23826902bf1c9cf1dcc97727 +size 2182 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ro_nonstandard-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/ro_nonstandard-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ro_nonstandard-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ro_nonstandard-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/ro_nonstandard-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..8e0310ab26b13f7899a50c731fbf3aa137015096 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ro_nonstandard-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:54368bc42ac8de4e77f95f2c33b06099e206b0d0df18b04f7c82f7c8c57b1800 +size 620 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ro_nonstandard-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/ro_nonstandard-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..958ef66b2fe34d9fe62c6e9b1cb0b6829c8fce40 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ro_nonstandard-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d6ba1537bf866b7fe92fae4631ed524a6a87fc2d208caebc588e726a611e6d09 +size 10615 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ro_nonstandard-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/ro_nonstandard-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..8773932490f98ca7f9a4dc1a59757a2f1e6e84af --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ro_nonstandard-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f5d0aa836fab07bfae9b61c1a73334db8f7776ba314f1ea07572459114354d37 +size 1802130 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ro_nonstandard-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/ro_nonstandard-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..10f3eca655b7be4da1a6c6f6a5f99e85925d3af0 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ro_nonstandard-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1b13682311a138d151ac0568e2338574da022bf12968b56baf98f618f864e22a +size 923 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ro_nonstandard-ud-2.15-241121.model/ro_nonstandard.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/ro_nonstandard-ud-2.15-241121.model/ro_nonstandard.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..554a5efd6365592baa314ce23916e0f27e17530f --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ro_nonstandard-ud-2.15-241121.model/ro_nonstandard.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3eb56c015c2823c652be4a333f52a71575e169a25fdad7a17d95ab856cc10b14 +size 36183 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ro_nonstandard-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/ro_nonstandard-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..b4939debca6972870055305860be6304561b283e --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ro_nonstandard-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c5364886679a439e5d0e35714406d0b4eaaee173f15f225e739e366c44b30ce3 +size 134157296 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ro_nonstandard-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/ro_nonstandard-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..80343256f62cee78bcb7d8ba9976e67cde683d32 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ro_nonstandard-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5a06fce1375a58c4fb8c41d7f71b5f5823602771c68ae6b856d79dd9bf77c643 +size 2119 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ru_all-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/ru_all-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ru_all-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ru_all-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/ru_all-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..a525fa11ffced3023a13ea9d66eaf700e77038f1 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ru_all-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:fb9a229fa8defbe8dd8ca1b52a36e19a0140e6f4af5a7347f3aa06c04923b7d7 +size 2244 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ru_all-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/ru_all-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..f461ddfa3443510a5365d245de3cc8d32857ae64 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ru_all-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ec7eaab0e6372e91050719209845259d9bd3426cc22573223917c5c2dd478abe +size 42345 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ru_all-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/ru_all-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..2c4a64bf397d2feb80302800e1fe8c3d764f9730 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ru_all-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f7b693f3dd1e13334c7b44a679766fcef681bbc2f936d117b55e6d9e94cab8f8 +size 3844627 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ru_all-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/ru_all-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..0ab60ed4145e6d6f0c7ddf736c7993f9d0f2994d --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ru_all-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d6ff44b1610a02619303bc4799c5f2625a51c25f6a731c5b9bf9c9dc7eadb3c1 +size 1226 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ru_all-ud-2.15-241121.model/ru_gsd.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/ru_all-ud-2.15-241121.model/ru_gsd.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..6e9f47c9383b465195c4ff38bb42b52be1d7a3cc --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ru_all-ud-2.15-241121.model/ru_gsd.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:87a5c2be8f45044c2c83e9948d0301ff04ca377b10d12a7f984300733a3b0cea +size 230622 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ru_all-ud-2.15-241121.model/ru_poetry.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/ru_all-ud-2.15-241121.model/ru_poetry.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..ab146cff955346d9de2a69932f2380ec6f125f98 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ru_all-ud-2.15-241121.model/ru_poetry.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5d63ab44b71dd9e9eeb3c64a6138eb74d2a27e02dc16035c3d5cc9c7d7ddcfa7 +size 215298 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ru_all-ud-2.15-241121.model/ru_syntagrus.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/ru_all-ud-2.15-241121.model/ru_syntagrus.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..a1acb1e3b862b72fe4695be7ba28ba313be18636 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ru_all-ud-2.15-241121.model/ru_syntagrus.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6affdb705d4598eaf1671061a2ab5b07c7d63a2c450ef343d98c83b4ca9afcbd +size 224094 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ru_all-ud-2.15-241121.model/ru_taiga.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/ru_all-ud-2.15-241121.model/ru_taiga.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..4d2cb2e064f6ef4b41886f63a9bce2f2196a0d34 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ru_all-ud-2.15-241121.model/ru_taiga.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:716d832fa0705b489b06c57590ca02da4e7d5ab786855621338151251c96cd5f +size 51037 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ru_all-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/ru_all-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..c9a4cde66680fe1a39249bd5341b4ee188aefa9d --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ru_all-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e38fecc6bc6ad5491c0099da2587186ffcb05c54925ef1422726a77c6baea96e +size 244488636 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ru_all-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/ru_all-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..f4fe1a32551943a6130f4c7d425637fc51d96012 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ru_all-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ef2836cd73901e316c516dfcb1ec62294dee14ec3cbb23252b40496b933c0f83 +size 2180 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/sa_vedic-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/sa_vedic-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/sa_vedic-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/sa_vedic-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/sa_vedic-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..0c950bce5ed05c836968de282deb416e4ae6ade7 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/sa_vedic-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d4b43dadc848dd301620b1418c4ec8a2312415fd38984d81cc149cba5cd3a5f2 +size 438 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/sa_vedic-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/sa_vedic-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..6a423f42fb5246c69a8418b9aa3a05c85dfddbfa --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/sa_vedic-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ab21a23cf7ca00f76fb583dc3d70edf572e648eb7f7f0befb64fcad6b49ecaf3 +size 10632 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/sa_vedic-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/sa_vedic-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..38bba45ae2b8a3162bbe137e6e9bc0b4d236f768 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/sa_vedic-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5fc916bd99f8499f2cda04dcb1a5c9e2647d026e582fea09d9360cee8e904878 +size 14175720 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/sa_vedic-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/sa_vedic-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..11817faac577d113f2e4dc1786f9df7c621cfce9 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/sa_vedic-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:cb20b58f8a9b5ae35131661f13eff63cee58340e0ef0876109d8ab274461e74b +size 881 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/sa_vedic-ud-2.15-241121.model/sa_vedic.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/sa_vedic-ud-2.15-241121.model/sa_vedic.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..f95fe8690f42b3b5220bf3271c274926d8f59561 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/sa_vedic-ud-2.15-241121.model/sa_vedic.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:fc169b446c03a3edbf032d3a86694c3f815f83dffb88b08e77b892c64811cb1f +size 194604 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/sa_vedic-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/sa_vedic-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..15842c0e0dbc6586b2a948c1d2f3dc4517ff37b8 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/sa_vedic-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:fa6c2d8034d95bf4ebaba952f07977da0eff68379fbd9dcaef1d87602c4da941 +size 118411132 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/sa_vedic-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/sa_vedic-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..0bf818983c4821b3799489aed4f67b8f44bdff7f --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/sa_vedic-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b015e7984e3a4b04d41ac70dd5428cb5cdc5c2031b58648b106dd2777c3d4540 +size 2113 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/sk_snk-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/sk_snk-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/sk_snk-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/sk_snk-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/sk_snk-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..3efb7180434bf6a1eb642e7b633a3d8ff1ca04c7 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/sk_snk-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c206b4dd742f086632342dcf8b4c50fe0574b80c4e0450f61916daa36015b083 +size 1228 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/sk_snk-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/sk_snk-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..00c40c305f6ff8e8f3d48af28ce61af2b5e07a00 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/sk_snk-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:70e36e7fe4a187e7b99f93c000b11e129f841eae43419c588ce216e4e3d685d1 +size 10559 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/sk_snk-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/sk_snk-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..f04f701e5a1c7a81ee21e2f8712a5dec4d3996ae --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/sk_snk-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3d4b4dfa5f2ae4835fd3adf3ae9a386e96507edd868be877d3b92fded225ba63 +size 432930 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/sk_snk-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/sk_snk-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..a54ef23f5b753084364115c8e956ec3c5fe3d274 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/sk_snk-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f9e49eaf10fb82a74f93bc6568aa9800c443aee820d6ed679d85a660f709c727 +size 867 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/sk_snk-ud-2.15-241121.model/sk_snk.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/sk_snk-ud-2.15-241121.model/sk_snk.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..c0244b51916e01f67ba8c60a39637c31d0524ead --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/sk_snk-ud-2.15-241121.model/sk_snk.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:71e201cd30cc6d17e05aa625b525aca89dea5006948ab97f72dab3bf0ea6fb53 +size 38457 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/sk_snk-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/sk_snk-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..cac0dc5c87622350c37e3532e05cfa2998ed6519 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/sk_snk-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c5650f4961efe7c23802d0044962f47a491ff55af72dc055b80b761bc4ee2df4 +size 97539188 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/sk_snk-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/sk_snk-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..cc11cd58b184020f23b8ff95909d418c2983cb0a --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/sk_snk-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:30222a4e1674a764bd3df9c6ba63bcb4a4ffc0c9d57af93cf8f401b7bc9c65cd +size 2118 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/sl_all-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/sl_all-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/sl_all-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/sl_all-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/sl_all-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..b6569d7d271ca947eb6034c6fd3b3b2dd6b6e2e1 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/sl_all-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2a0730f6d00ce8342191a5af6e97f5f6e4c6eca5fc81ac97d514005fda392ff1 +size 1237 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/sl_all-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/sl_all-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..ae53f625c7d9415394b0086d1038bc7ef096dd03 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/sl_all-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d839f259a20386a0dd9a1dfe5e8ce07fa03bf50835fb456106ed5fdd9c3cd2a0 +size 21102 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/sl_all-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/sl_all-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..12d4b97e8e388b21528f338b40db7bd439a26732 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/sl_all-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b5b2e4080d5acc06b2241be5c25ac1c78013566027897a903728d73d9c0fe973 +size 6891738 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/sl_all-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/sl_all-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..f3d2922c4bd9c5efba06b9990c1534609be7760b --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/sl_all-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a76a92f9697d2dec41aef6e4a055da0a501933f320efd6c6681fd099e285430f +size 974 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/sl_all-ud-2.15-241121.model/sl_ssj.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/sl_all-ud-2.15-241121.model/sl_ssj.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..3feb98e156f71aed5aab5ffb2f8fc1b4c8df0c80 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/sl_all-ud-2.15-241121.model/sl_ssj.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f0a073677c9cb200532d3e793b0b186dbae70e141137c8290ec0f0e89bf1d569 +size 39608 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/sl_all-ud-2.15-241121.model/sl_sst.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/sl_all-ud-2.15-241121.model/sl_sst.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..f1b178eeb38cffded809aeca4759fbf017fda9ea --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/sl_all-ud-2.15-241121.model/sl_sst.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:457a9c05f379636b212ffcd720fd91ad5cd262637e02517513a76eff3ee066b6 +size 33917 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/sl_all-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/sl_all-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..f16659216fceb75c4985d4e47f1480ebbaabd3b3 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/sl_all-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:bb08e43fda915394ed0368c3bcff903a56a6893ea945eb71aae0d41ca02b9791 +size 124308448 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/sl_all-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/sl_all-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..95b9f254c1c7b71e63f1d97842893562e97173b4 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/sl_all-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:41e7a6c96859c70f1afaae258c3e0458b60b8170e6953ce928a8af3d3ca74adc +size 2182 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/sme_giella-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/sme_giella-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/sme_giella-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/sme_giella-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/sme_giella-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..b98e5c36f82ef5469fe426122f5fe36702917b17 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/sme_giella-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:72e6a2740aca6ab8a9f5b70003cff3819dbcb37e8f04683b2185518bcba6582d +size 458 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/sme_giella-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/sme_giella-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..5eea2f8305a152f27049c932add7e1ab16ad00d9 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/sme_giella-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:120342ee436823488244e84304bcc152e1014b509d63d02d1cb200cd76e62c9f +size 10585 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/sme_giella-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/sme_giella-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..02ad36f3b044f1693a73a612800ab89cc157d02b --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/sme_giella-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7600afc4df6ed4e5e658f1c7051310ebdb994ce4a6d82c99932781cdbc1afd3c +size 89222 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/sme_giella-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/sme_giella-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..598e4acf0ec14767d5a60e8b4957659dc2972b05 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/sme_giella-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5d959dd10e68e6ff3cfb8edc6df9c8d5aa3ca5bb78b24c3aecb0f924048a2402 +size 895 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/sme_giella-ud-2.15-241121.model/sme_giella.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/sme_giella-ud-2.15-241121.model/sme_giella.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..a7160e74732412c54b3ffe09a299996f9f97d1f0 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/sme_giella-ud-2.15-241121.model/sme_giella.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:622d3d62e0f93c70b64128e4924a19c10d3edcae93e8f1d851ca72bb1bd7e49c +size 34325 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/sme_giella-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/sme_giella-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..a343253ff97b943fbfa598aa3ca9441b4529c875 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/sme_giella-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:40db50cb029672500437c7c6ae93cdbf963f226d46fd49c4a6b7806bd184375c +size 56134748 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/sme_giella-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/sme_giella-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..b5d259587b123107686f028c722268684ce918bd --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/sme_giella-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f3bf74553a0d353d60c4dd34e68dbbbdb50d7c9f5263f0dbb5349ce78d59b941 +size 2114 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/sq_staf-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/sq_staf-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/sq_staf-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/sq_staf-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/sq_staf-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..3b2300b14c0af77ff9be3b2596293525ad7d5ac9 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/sq_staf-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:180c23985b3f1d9b47ceaa473cec1ea5de7d8bc160a640f27287fe43d6d9a4ab +size 372 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/sq_staf-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/sq_staf-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..e5fd7a7072cdb4f6097967bca6ff4d36a7ff9650 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/sq_staf-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7389136a179201bb32c6522092ccc8104015ba967ccf6281ce3d791ad6b967af +size 10625 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/sq_staf-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/sq_staf-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..4c4d246ede74406293b67439b5451fd1523effcf --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/sq_staf-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:108ac3b6120503cfd612f3b52cf7a010f55c9387dbd8e991baa2f398d3079ae4 +size 118231 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/sq_staf-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/sq_staf-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..b5b43b646eeb33cb9e36dcbaa40fdb4c706d4da9 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/sq_staf-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:95f97bf9ea63deddf34f76cd082d1c51595bc93f811b2ed82194dc83bfe31f38 +size 874 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/sq_staf-ud-2.15-241121.model/sq_staf.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/sq_staf-ud-2.15-241121.model/sq_staf.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..845076c883afd72721ddb1a12f2a914b0ff78cba --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/sq_staf-ud-2.15-241121.model/sq_staf.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10b3a1a64e40ba83a7e57838a2141e21199b5af806dfcede1e1daff42d0ec36c +size 32770 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/sq_staf-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/sq_staf-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..93d2a03a6a428a652d3b08dece264fe2c1e827ef --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/sq_staf-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a9aa486dd41819c8c1d17cf1048fc98aba5a56183b3497cf7c3f7261d27e50e4 +size 51064836 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/sq_staf-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/sq_staf-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..375b35a8a9f3c54e42e560effbc52b1877004977 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/sq_staf-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7e79994d0a3ccf454544875b815e7ad1bf862ce498281bd2a8762a0a2af16583 +size 2111 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/sr_set-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/sr_set-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/sr_set-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/sr_set-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/sr_set-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..bacdbee6fd2fb1ab489692c335847690b59f3bf7 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/sr_set-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7dd19caa81e79d0068c40b78ed2b561d1c48c3f75d802bbbed1fe671d44f2deb +size 822 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/sr_set-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/sr_set-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..9aae3c65778dde8fd933df517b6a5160591571da --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/sr_set-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6a4b7b4378a897558df6f6cbbc2698f5794b5a199d93cf5098d4fd9222951621 +size 10558 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/sr_set-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/sr_set-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..80849568dd4c17733d0b57678eaaf5900bb8b4f9 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/sr_set-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e4f8b113a386fd0625fec7bbeffd0823c57d4ef297e77fe2c52a45ff9608508b +size 242332 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/sr_set-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/sr_set-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..9836a15c7e5d14a797ced52d1fcdfa0b4611d456 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/sr_set-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:721fd6156a0cd5044b939fe739d071cc7a56f2e777efaf0388a4d7f228e4ff17 +size 867 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/sr_set-ud-2.15-241121.model/sr_set.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/sr_set-ud-2.15-241121.model/sr_set.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..ce74b1fc9d36981a432665b60f8707d760d862cb --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/sr_set-ud-2.15-241121.model/sr_set.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8462548c345aa1806a60a968874ceca95ace10ad647b52e5c623e5f4fe44ddec +size 35714 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/sr_set-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/sr_set-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..55eef7ac8d58b28c2f20c2e6178e52548305f867 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/sr_set-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:cf6560cb56efabab0a90dc2d929c3bd86d41e8b89b80afad41cde88421d9e998 +size 94105704 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/sr_set-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/sr_set-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..96c8c24f493f61e6a7a16f79a0e26e060cf50d69 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/sr_set-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:cc722576d62e7d8675766959d52df2f4848777d8cf063c34b05086adbcb2ea17 +size 2116 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/sv_all-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/sv_all-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/sv_all-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/sv_all-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/sv_all-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..dccf80eabb59ff016c1be5202fc1bfe5a0e4899a --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/sv_all-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1e02210139f3f62e3656d094ac4716e0b5a56b2d0d07d612c6cc299b04fa9a5d +size 524 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/sv_all-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/sv_all-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..6b70f19ca319983616116f6f91f9c8262656c5e8 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/sv_all-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f9d64d1f06047148d994674cf0bc89a16cac480f9a510a1bde58cfff98c16534 +size 21636 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/sv_all-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/sv_all-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..e8fc6c6dd73d640c1603b67ea355ed877caeb427 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/sv_all-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:606b9a1cc3287468b63629efdbc9f58cc417aeab9a81b7d220ca1f793ce95014 +size 447352 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/sv_all-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/sv_all-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..2c2aea781669839892fe63ce8472deb7bab16791 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/sv_all-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2030bdbe73f47aa6f01b72a6e5d70c170f970f048ec429167765a5651c8b2469 +size 1022 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/sv_all-ud-2.15-241121.model/sv_lines.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/sv_all-ud-2.15-241121.model/sv_lines.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..179860e0d59894af07f487baaa902aa0a5f02eaa --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/sv_all-ud-2.15-241121.model/sv_lines.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c876f479064b63c9bfc308855bcb64d12fa51190d4b9b1b6d8bb7f14abcbaf42 +size 35004 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/sv_all-ud-2.15-241121.model/sv_talbanken.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/sv_all-ud-2.15-241121.model/sv_talbanken.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..d29a5783f32a9d72fb98a4f0be2e05ca1a00459a --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/sv_all-ud-2.15-241121.model/sv_talbanken.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:98e6218387891509fef48e0dcfce48c00b8a72057cbdf1ce78fd40fd55048d3d +size 205148 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/sv_all-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/sv_all-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..83c6a5f356e40a932da6a97ba453b9ac63006a29 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/sv_all-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:bdbb0dfe3d16036a9d38cfb9f06be0f91b63c7f25936742b23b09e7cb9b6d8ec +size 98173072 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/sv_all-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/sv_all-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..12825cdb538f799a0c65ca8fb0554f1b520c5b50 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/sv_all-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4570e11827a30ed5f900511ea5f91254683569f8f5e69693c941162c5d4e975b +size 2178 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ta_ttb-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/ta_ttb-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ta_ttb-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ta_ttb-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/ta_ttb-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..54ee5eb97f8b724447e247ecd6c70f3e1de694b9 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ta_ttb-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:dc97c5b4954b36c04ec5c4faa5dae86ccfc6f7fb585b4d245ce98a48ad62ea41 +size 346 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ta_ttb-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/ta_ttb-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..8acc1ab68e87e83be3b271c6514c2328eb8ec110 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ta_ttb-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a26fa653d5bd795e79aba5b9bb615d28cad5026f18ef3394087ca3be8a44d55d +size 10557 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ta_ttb-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/ta_ttb-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..63cb006663215db28453d89d9a6532e6bec0df3d --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ta_ttb-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:13e4bf4c47107a64be332e4bdb6da39706f23f1052f786f6d74886833d8e00c4 +size 250512 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ta_ttb-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/ta_ttb-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..2256d800d2db2c68528a447537d5ae5885ed8c51 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ta_ttb-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b4f45b1ce348ebfdf912f2424e5ba312390b1569386e579668fd14d4ec78ed27 +size 867 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ta_ttb-ud-2.15-241121.model/ta_ttb.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/ta_ttb-ud-2.15-241121.model/ta_ttb.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..78222c72804b9709c3fa9f8bc604bdb92c7d45fc --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ta_ttb-ud-2.15-241121.model/ta_ttb.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2c67770a4c5595f630f380cdfa8d350f911d92fb33a26cee9345fd75e4c0a8be +size 220253 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ta_ttb-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/ta_ttb-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..133d676366d06672754e07291bc3d59a60311e17 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ta_ttb-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:25bf3527d6482165c67d194e05c6a88226ffa003fece3424bde74eddbae2a841 +size 52052872 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ta_ttb-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/ta_ttb-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..8c8c6d71cda18a0907021d4b5c4984e1c728ba37 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ta_ttb-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:26b58e329adfc64e44d80b0699c094e230225c57aeeccdc4fac429a15aabaae8 +size 2113 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/te_mtg-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/te_mtg-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/te_mtg-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/te_mtg-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/te_mtg-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..7cf86aaef6618d7cc285a521cb4a95030cc949a8 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/te_mtg-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a5e4285530c1f2b1b558c19fb859eb54726d2f2f78be7df0db52be526fbec943 +size 121 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/te_mtg-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/te_mtg-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..c1b553af1bba2a83c4799b710a878f8196514131 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/te_mtg-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a2dd02d337c2ad436c100493f0f51f16e3aed1dbf21529f6f471aa4e2ec10fd6 +size 10614 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/te_mtg-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/te_mtg-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..1bb07a4af0b029742cd82c18037e0c8684129bae --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/te_mtg-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2e0ec0a3f4571e5ee9ba786065c13487063680f639d2ace2f32a4f25797e579c +size 85729 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/te_mtg-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/te_mtg-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..939fc98817adcdf265dbfcf1fbc932ab3b3085ba --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/te_mtg-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ddbdcd353e915143e5c623ce2e98b758f42667a598ea02db65cfc2315302c224 +size 867 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/te_mtg-ud-2.15-241121.model/te_mtg.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/te_mtg-ud-2.15-241121.model/te_mtg.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..3a819111a35e8f56c84ef866da8e50ed418d07c3 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/te_mtg-ud-2.15-241121.model/te_mtg.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:45c488a4a7f54c728f4add6b64e5057256cbb74941c0a89aa71fbe0b6698510d +size 34769 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/te_mtg-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/te_mtg-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..8fa921c597f04cbea7f8629e01f221d50bc2413b --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/te_mtg-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a7079d2e7e0a9e50568ab9348f9868529541d98a7779c13532bc6c01d3359a11 +size 51046060 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/te_mtg-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/te_mtg-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..96148c1c7d90b530e7091c5ce74b98d9373a3a8d --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/te_mtg-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:92ad80b68cf9d832482608b61b8a6175e6a25417ac7a9d4cdbd9fd9919f299c1 +size 2104 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/tr_all-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/tr_all-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/tr_all-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/tr_all-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/tr_all-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..1aebaed4c84ed4d59a8818632c8bb4513f1bc1e0 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/tr_all-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5f5e2c982ca50d956fa2a7d8756367f12f271aacf637feae32a093a68c25a9a9 +size 1798 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/tr_all-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/tr_all-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..dd67ec02fee8f247fe9a969ccd74783742be50ed --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/tr_all-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b7412c3294c488949947b7f753389ecd04c2f1ec8e4f970b734dc5b5f960df3b +size 73222 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/tr_all-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/tr_all-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..33bc49234d67af4f2aa8ad6c648f60f4a063641f --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/tr_all-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:339bf03223e59295681c3fd4418c789f9194b4e3234dc74eb981eaf56ced3233 +size 1419545 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/tr_all-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/tr_all-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..dd8ef9b1a597f2ee51d010f3a3e946803e33acb5 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/tr_all-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:cd11a303707d068f1d5795a412c6f46085f18bf0806dfeed77aeeed958484dd2 +size 1529 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/tr_all-ud-2.15-241121.model/tr_atis.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/tr_all-ud-2.15-241121.model/tr_atis.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..11f79a7b0eaa41a91052ac2cf5e8b8663712e3bd --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/tr_all-ud-2.15-241121.model/tr_atis.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2851110d07645f4a1710bff65413223b2af4ed3468a298d00bc6a7a53de68807 +size 34272 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/tr_all-ud-2.15-241121.model/tr_boun.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/tr_all-ud-2.15-241121.model/tr_boun.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..5d9b355e02653ec69ba53c3ca72f882fc4772e1b --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/tr_all-ud-2.15-241121.model/tr_boun.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:27a2d7770a20c0bd0b0f4d637eba8cc1385e68caf986c72c23526b7423c941d8 +size 83444 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/tr_all-ud-2.15-241121.model/tr_framenet.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/tr_all-ud-2.15-241121.model/tr_framenet.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..21b33fc712be3ae7f59e0b3036558126653e266b --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/tr_all-ud-2.15-241121.model/tr_framenet.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6c51d1eecf863efcf85479913eed18d9a66a4d53226a4f6d734b49fa5fce0bd9 +size 34035 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/tr_all-ud-2.15-241121.model/tr_imst.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/tr_all-ud-2.15-241121.model/tr_imst.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..2aa2e7a2938e10e907dd016c399b7d1c25867c42 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/tr_all-ud-2.15-241121.model/tr_imst.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:62f75a5295b20c7f527427b4891ab0d0585de0398d735a8645d61fafda92d5bb +size 55177 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/tr_all-ud-2.15-241121.model/tr_kenet.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/tr_all-ud-2.15-241121.model/tr_kenet.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..ac1b4c15dbc0d3677780e91295015b329d8a269e --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/tr_all-ud-2.15-241121.model/tr_kenet.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1a766b1be7fbd73973a2bbe6670e5710dad1a3aa8cddf35613d9e093a4f4bfdd +size 35405 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/tr_all-ud-2.15-241121.model/tr_penn.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/tr_all-ud-2.15-241121.model/tr_penn.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..d5408694fcaeff29a040606565eb93cbb4870f11 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/tr_all-ud-2.15-241121.model/tr_penn.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6bb48d789a8ce344c9a43a6226230817485a7da137410f41361a1a9ff035e252 +size 36575 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/tr_all-ud-2.15-241121.model/tr_tourism.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/tr_all-ud-2.15-241121.model/tr_tourism.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..76117c8c090c575f1323c356c0ac615cacbc447a --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/tr_all-ud-2.15-241121.model/tr_tourism.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b1060609401128f8492bdf4e180c2c0c4899d329c428dd36dcd2c80de90589d5 +size 31317 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/tr_all-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/tr_all-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..71132f55239ecea07d3757f510c5cf58ed959bff --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/tr_all-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2e5d71234dd7b0a65d82550ac6ce1b1b9ee8904199190d736c0bc2abb6bbd4d4 +size 170395396 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/tr_all-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/tr_all-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..e8386f62a5b1d70b2c3d9509cb4092209c04a595 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/tr_all-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c88d903cf649f674ceaf59d8824ba960b2b90e5a48ee67047525ee42c0aff5d1 +size 2179 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ug_udt-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/ug_udt-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ug_udt-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ug_udt-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/ug_udt-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..d5d850b2a2dfdb5225b4c5e2be07e8f9de7f12ed --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ug_udt-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1fe98184364f0fd5044853c1232bb1195729eba65210bd20544f8ace56bd8189 +size 369 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ug_udt-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/ug_udt-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..c998dbf6751ba4103c7d84d18e8882e0360d4bb5 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ug_udt-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f11d94e00bbc0172ca7f0399ff64c06a4f0496bcc3697322d9b3e52d20a41ff7 +size 10556 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ug_udt-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/ug_udt-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..a090fef862731266eabcd2c9c32662673346c740 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ug_udt-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:eb9527532c6e01561ca25a25bf8b61ae3cc08648d440b496331730ef33465bcd +size 483374 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ug_udt-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/ug_udt-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..93d3bd09e34d30ecf0fc237b6c23adba880d0381 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ug_udt-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:266ac99dbdabd0dfe21659db5c1390dd600a89208373ec81d0361b7a153dabb0 +size 867 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ug_udt-ud-2.15-241121.model/ug_udt.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/ug_udt-ud-2.15-241121.model/ug_udt.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..451ea552337997d677f347923c6428ce782ed7fc --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ug_udt-ud-2.15-241121.model/ug_udt.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:639ca9a1f119e7b64146bbacf1b40f51877bda85864a8f8257a559fb464aaeff +size 201271 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ug_udt-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/ug_udt-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..227291767868dbfba4599d6943145f715d914c58 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ug_udt-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:18cf9e4948ed3d865c77546d47cfb421e6579483750662e1401554d96cd1f919 +size 54789120 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ug_udt-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/ug_udt-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..ae962a2e673adf0faf7ad32da243ad271339aac6 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ug_udt-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3c91ad2f2fedcea9f64e4d67849ba27fc74ac60854ffd378e427bd7cbd94d193 +size 2111 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/uk_all-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/uk_all-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/uk_all-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/uk_all-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/uk_all-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..d448b75e7914e565ada93bc540a9581791b710ff --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/uk_all-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:20afd64987e47192d527e33c9deab82fb4a6a78a4c937ed166efbc71a1ce3ae7 +size 1786 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/uk_all-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/uk_all-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..a7aedce38186c6694554735b72a6f5394e16db52 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/uk_all-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:75ecbf766e77ce4901314948409235839a8513d1f9ed55f8d81471d1f5f5b63a +size 21436 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/uk_all-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/uk_all-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..674c92510538476a54b77b540be5aae9f545dc3c --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/uk_all-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2471b82cd8185d0c1f0820c7ff1bdeca1ad007fdec7dcf202409025ea2550e92 +size 6176757 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/uk_all-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/uk_all-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..5103a4f7aca961bab1ddf97005c0a40de1b62e27 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/uk_all-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:cf979a3def2d4627fc2cc540798f12b67d34c9882daa574bc403f225c3306822 +size 1004 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/uk_all-ud-2.15-241121.model/uk_iu.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/uk_all-ud-2.15-241121.model/uk_iu.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..5f74a03ebfdcc867175be15d298a9fdf96b65056 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/uk_all-ud-2.15-241121.model/uk_iu.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8bea2d1e6545488b9cc1265445a5800c0d4da9fc4637718acd97bd2609c45bfe +size 45071 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/uk_all-ud-2.15-241121.model/uk_parlamint.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/uk_all-ud-2.15-241121.model/uk_parlamint.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..55e270df6aa9e5ed1dc81a84585ff1a4f592f265 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/uk_all-ud-2.15-241121.model/uk_parlamint.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2630a9069c187837977c54797b6708c3927a67387760917a4409d6af5d8c260b +size 211555 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/uk_all-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/uk_all-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..efdcbcb402cf9a53048b9a12469d339016215e0e --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/uk_all-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:982e046f78d21f93ec0ba5798dae4b3e7d39efc5139bc006b1cc6b2ab7d20b2e +size 107964476 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/uk_all-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/uk_all-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..30c3de09a2b529dc500cf2ce21fc8485805018db --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/uk_all-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2b70437630c6086a319255df6ec4364f9db945a0d2e0209bbffc640158848077 +size 2181 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ur_udtb-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/ur_udtb-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ur_udtb-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ur_udtb-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/ur_udtb-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..8eda02d6eb971042634377ab0effd75ba9b27165 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ur_udtb-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:218b45f9209276d978cd8bd4a101858f672b1e75a26bf95a0396df4f7faf504d +size 1362 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ur_udtb-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/ur_udtb-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..02e672e67c61ecc5e752f6ea55f337ef89caafc4 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ur_udtb-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b862cb46afd341c4e2dd50a044daaffc4102abe6f8cf05675c5bace788c97574 +size 10564 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ur_udtb-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/ur_udtb-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..dd51f2e9af5ff064143c721a9b42d7a10b690120 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ur_udtb-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:61bec47fec61789e4199facf2ef2b9826acfd8a1d3f75fcebabb6fef57d6d3f5 +size 3423812 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ur_udtb-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/ur_udtb-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..b7478a62d2f6aded71ddd9e5fd1a35a2ed530186 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ur_udtb-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c80a4f94077ccd9645189791bc2cfb1770446117f6f2e0c4e80f985ff41eaf6d +size 874 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ur_udtb-ud-2.15-241121.model/ur_udtb.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/ur_udtb-ud-2.15-241121.model/ur_udtb.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..63c29928f6ba427e1d016a6cd1bef3899ca0d76c --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ur_udtb-ud-2.15-241121.model/ur_udtb.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:89000dca1d3f6a1fdfebf09d4256b4a55b0e4baddb2e9a912675abc73c0f6116 +size 38582 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ur_udtb-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/ur_udtb-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..975bb4dbf201b1557fdf4034cbe8b3edb69c38cf --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ur_udtb-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0a9f9a19bc933a5d5768dda5ed785173405b871209036e0798c3f62673fb1a23 +size 90738652 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/ur_udtb-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/ur_udtb-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..ffc52c8080a72803da24fbdd4fcaff6cb4a0d6f9 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/ur_udtb-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8e5ee80f9cf396b0913cc173aa228863655f3549ddd0ea3452fe894d1445e5b4 +size 2115 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/vi_vtb-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/vi_vtb-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/vi_vtb-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/vi_vtb-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/vi_vtb-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..4aeba0ca66e213fdc641470d44bbf389284186e2 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/vi_vtb-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0e6fa5c15eb18ebd61e590eacd75f687359400b37a9de81838c7fb7ace560b7f +size 115 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/vi_vtb-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/vi_vtb-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..43fa9c51a30a6317dcb171ab606a9ee4f92f034d --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/vi_vtb-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:88b7dede7e5bcc94409754404d70af028845e1538afa7f4b0734b7b672d83e8f +size 10615 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/vi_vtb-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/vi_vtb-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..31d46a30c98a61918de2ee52364a887a09304ca2 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/vi_vtb-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:99ebff9305d35c783aa17b15fd457a9fc14e8e69936507b2bf1d5a01ee6fb584 +size 52746 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/vi_vtb-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/vi_vtb-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..1dd9ccfe7411c3326e6554ad409975f82dcbef57 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/vi_vtb-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4606fedb964a85e234d2974832e70e087caa63de6932954b4b4e8984e53d3108 +size 867 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/vi_vtb-ud-2.15-241121.model/vi_vtb.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/vi_vtb-ud-2.15-241121.model/vi_vtb.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..e9eb971fbeb915a04c0765f6bb5cecf4c0a6a221 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/vi_vtb-ud-2.15-241121.model/vi_vtb.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:77575ac684a1d41325d712bbf430160d9fa0167a1db1467363c8b293773302c2 +size 222259 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/vi_vtb-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/vi_vtb-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..71855e06004496ea8f9ac1791f532e28780516f4 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/vi_vtb-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a2fabfd4831b4d6253e0760f9f420798088fa87c42d28284af32f5b57c7807d9 +size 56485780 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/vi_vtb-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/vi_vtb-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..f1b2a938d05e07d4ea02044a944b313876860c54 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/vi_vtb-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:974c4506cf435a6adb365c7d8d5071ce275960198626ec4c7e8b24d9973d42a3 +size 2109 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/wo_wtb-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/wo_wtb-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/wo_wtb-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/wo_wtb-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/wo_wtb-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..dcd5dde76d8b854679d8d0de8bed8acceb6c3cc7 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/wo_wtb-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ebda351384fe827c360a3b467fafde99d5db5707dde95623769a354d0ec8de1c +size 483 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/wo_wtb-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/wo_wtb-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..6511bada313153b056c6e2848bd690f9731a35c7 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/wo_wtb-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e7e0c1fbaf2adbe857c5bb15164587624b58cca61e82dd98f86604667a296bf1 +size 10556 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/wo_wtb-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/wo_wtb-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..7905d72301df7b911b2bb82aef45f6579f6044b8 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/wo_wtb-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3ce67bbab79842375d227af8291a826e01503a3300410ecab4852f371ecea159 +size 61677 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/wo_wtb-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/wo_wtb-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..e961185a929523ac534f9c769c28e58c1d2811d3 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/wo_wtb-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:afb21b9ee505cf89276063af365ef9c493cf42f27649fab1660671d68c461a87 +size 867 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/wo_wtb-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/wo_wtb-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..69c1e44751c74c7bbf925531c630786dfa4502b6 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/wo_wtb-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a5a0f5bc18d8bfb44ac9962ab7c1e33d21e9a3ab4e029f2e74b74de5cb821d65 +size 53941856 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/wo_wtb-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/wo_wtb-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..b85ee12aa08b119cea1c931fb2dca791981d50b9 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/wo_wtb-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7199b9bb4fa365f6e307b52c07cf2bbdf21770aed5e4735915c9e180a9ea9f93 +size 2112 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/wo_wtb-ud-2.15-241121.model/wo_wtb.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/wo_wtb-ud-2.15-241121.model/wo_wtb.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..864d42f82a438e5d210f4355d82650f2fb63879f --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/wo_wtb-ud-2.15-241121.model/wo_wtb.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:405d93bfe981f53be715a989a852a9bae0e10b18f17c93cbaa9731ca4c64492d +size 209666 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/xcl_caval-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/xcl_caval-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/xcl_caval-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/xcl_caval-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/xcl_caval-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..116a00cadc210dd299a075ff5e1b9e1ed950b2f8 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/xcl_caval-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4003bc5129acc047df6494ee38a6671043a04ad59045e9444aa3f7ea2f4c3b00 +size 601 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/xcl_caval-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/xcl_caval-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..45dd46fd72a5e458888e2c70c3497593ebd2c7b7 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/xcl_caval-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7ca5926a9823bd1694481b3711575cd92f35f79e21e48be14c8630a860d7126e +size 10638 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/xcl_caval-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/xcl_caval-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..c092a4b7b6abf8c6d298059df6122239251514c1 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/xcl_caval-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d2467d7f1c7e41c8eb57d72c9a03d8aa12764611829fb99fff28ce97303ead6a +size 790587 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/xcl_caval-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/xcl_caval-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..5c7cbc63ecb497b51ff47e9b0f8e1d8a029c6fe9 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/xcl_caval-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a10224d21df721e6657d52db708db1ee3844bbdf52fd97f6e38b144c926b2551 +size 888 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/xcl_caval-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/xcl_caval-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..baa146de3dc2cda98ffe726cdabeba0c96464fd5 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/xcl_caval-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a145e81e5b7703e39b55133de6961a187e3e194bb437e698097bb621949f6501 +size 87163012 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/xcl_caval-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/xcl_caval-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..5e7580ac64892ff5c3e8ed7527bdfebbd2f3ff85 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/xcl_caval-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7603e1005cd3569bf1b8e7f91f374089145f2444d5bd25b017ada3cc22923396 +size 2113 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/xcl_caval-ud-2.15-241121.model/xcl_caval.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/xcl_caval-ud-2.15-241121.model/xcl_caval.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..51326077adfec3d167df9d69bcffd8348a32a15b --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/xcl_caval-ud-2.15-241121.model/xcl_caval.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0a86023d05d3550147907846016ede8fe6d1f00b2fd7a1f6e7eda73097b6ad76 +size 207526 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/zh_gsd-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/zh_gsd-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/zh_gsd-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/zh_gsd-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/zh_gsd-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..5a79741ac4d0f8b6c7ce965dfceaf2e8f550f789 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/zh_gsd-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c4b832a2ac95f28d7a68705ca3264252805e8e3d0a1c39d15d60c44cb9b15bf0 +size 164 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/zh_gsd-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/zh_gsd-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..1ef15664349d10127ca421d529c668ffd3393991 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/zh_gsd-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3255738f5b9b6548c47649e8a87a911013746f5b1c4b25c568c10d6acaefcd55 +size 10555 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/zh_gsd-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/zh_gsd-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..527e2d6b0094083ff3bbb056f1c0be78042b4444 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/zh_gsd-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:dd4230eb4e45b62b0863fc5f046cd6593dc283d630eab3bd55a3dcc117ba4a59 +size 1379826 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/zh_gsd-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/zh_gsd-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..0cc9a3347d783ef17a66bb257f3c7411c32f8de0 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/zh_gsd-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6ead9648e4e98f902a45a63520ba177e5ec2e5bdc43dca9b8e2629a1add1a805 +size 867 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/zh_gsd-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/zh_gsd-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..65838ab00f6c92a30cb590ae7d44f741c7ec2965 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/zh_gsd-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:aa591b1bee170ab5af413adf52565a6cf152eb0fb9865997b271d75d3865a359 +size 95469016 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/zh_gsd-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/zh_gsd-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..5382f65cd31b76de8a6ef720ce0107b195640d49 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/zh_gsd-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:42e81f12cb8f2bfcd74c4f32a6c0b5f5a9736696d44b750b98ee6437ad5bffd0 +size 2111 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/zh_gsd-ud-2.15-241121.model/zh_gsd.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/zh_gsd-ud-2.15-241121.model/zh_gsd.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..e6f212ca8a58b9d2aa934d29825d294ea05465bb --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/zh_gsd-ud-2.15-241121.model/zh_gsd.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3c2268a621d7dee884ef9c58d9c384886e85622d64052b6d11904eb03e9c8f60 +size 1042729 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/zh_gsdsimp-ud-2.15-241121.model/checkpoint b/UDPipe/v2/udpipe2-ud-2.15-241121/zh_gsdsimp-ud-2.15-241121.model/checkpoint new file mode 100644 index 0000000000000000000000000000000000000000..4b6d2ce9385aee552ea6a95c58b13a0048531022 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/zh_gsdsimp-ud-2.15-241121.model/checkpoint @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:10c68e19b9ee3362d19ad75f9c2549e6a6df8727525accb8601b1bc248546f7c +size 71 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/zh_gsdsimp-ud-2.15-241121.model/consistent_feats.table b/UDPipe/v2/udpipe2-ud-2.15-241121/zh_gsdsimp-ud-2.15-241121.model/consistent_feats.table new file mode 100644 index 0000000000000000000000000000000000000000..d5ea04b2ad5f6397eac979767793ffe6a48eef9b --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/zh_gsdsimp-ud-2.15-241121.model/consistent_feats.table @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2f30c58f70402641cfa69030a1e2128b6b415451cd13635025bb94ec558fadaa +size 164 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/zh_gsdsimp-ud-2.15-241121.model/log b/UDPipe/v2/udpipe2-ud-2.15-241121/zh_gsdsimp-ud-2.15-241121.model/log new file mode 100644 index 0000000000000000000000000000000000000000..f29cbd01b1dc674f38881952e8f34f1019adae01 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/zh_gsdsimp-ud-2.15-241121.model/log @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b9c8564ab866ce666e965f24328989e4fd3b45cb0c4ebecdc02e001d742dabfb +size 10583 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/zh_gsdsimp-ud-2.15-241121.model/mappings.pickle b/UDPipe/v2/udpipe2-ud-2.15-241121/zh_gsdsimp-ud-2.15-241121.model/mappings.pickle new file mode 100644 index 0000000000000000000000000000000000000000..9312040771d269b6bf954e81eb96dc30fbdbe7cb --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/zh_gsdsimp-ud-2.15-241121.model/mappings.pickle @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e99f7be05e5e8f9635d60bdc5817a1d2e080fdd07103196dd9b3f68e0710bacf +size 1372336 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/zh_gsdsimp-ud-2.15-241121.model/options.json b/UDPipe/v2/udpipe2-ud-2.15-241121/zh_gsdsimp-ud-2.15-241121.model/options.json new file mode 100644 index 0000000000000000000000000000000000000000..756c141445c7dd8685fd53dc193c4354d2ac56f7 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/zh_gsdsimp-ud-2.15-241121.model/options.json @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:14cca87f67cd1f515d95ee38b045933041ea767af107f8f181a5386fcd731e0c +size 895 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/zh_gsdsimp-ud-2.15-241121.model/weights.data-00000-of-00001 b/UDPipe/v2/udpipe2-ud-2.15-241121/zh_gsdsimp-ud-2.15-241121.model/weights.data-00000-of-00001 new file mode 100644 index 0000000000000000000000000000000000000000..cbe4c6339d7aef2a1d612c17ab320ce5ae777a44 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/zh_gsdsimp-ud-2.15-241121.model/weights.data-00000-of-00001 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:12507df1f0ff1ba573d8ef16c96c4bcfa4aab2ddfbe932f5866f571c6107a2df +size 95321556 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/zh_gsdsimp-ud-2.15-241121.model/weights.index b/UDPipe/v2/udpipe2-ud-2.15-241121/zh_gsdsimp-ud-2.15-241121.model/weights.index new file mode 100644 index 0000000000000000000000000000000000000000..f800acc26003c9485e9ad146653c8791c4e9cdb1 --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/zh_gsdsimp-ud-2.15-241121.model/weights.index @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:8a7d4bb79fd8be20aab3e4394b76ed2f80cd772afa9880910506928f1be51735 +size 2111 diff --git a/UDPipe/v2/udpipe2-ud-2.15-241121/zh_gsdsimp-ud-2.15-241121.model/zh_gsdsimp.tokenizer b/UDPipe/v2/udpipe2-ud-2.15-241121/zh_gsdsimp-ud-2.15-241121.model/zh_gsdsimp.tokenizer new file mode 100644 index 0000000000000000000000000000000000000000..4644655980b7e37298cf166615ba4f474089510b --- /dev/null +++ b/UDPipe/v2/udpipe2-ud-2.15-241121/zh_gsdsimp-ud-2.15-241121.model/zh_gsdsimp.tokenizer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:42f5690ded454e20d52d6eb1ea3eaee94b32705b3c33f3ac60f7061f32509364 +size 1012880