code stringlengths 3 1.05M | repo_name stringlengths 4 116 | path stringlengths 4 991 | language stringclasses 9 values | license stringclasses 15 values | size int32 3 1.05M |
|---|---|---|---|---|---|
// © Copyright 2013 Paul Thomas <paul@stackfull.com>. All Rights Reserved.
// sf-virtual-repeat directive
// ===========================
// Like `ng-repeat` with reduced rendering and binding
//
(function(){
'use strict';
// (part of the sf.virtualScroll module).
var mod = angular.module('sf.virtualScroll');
var DONT_WORK_AS_VIEWPORTS = ['TABLE', 'TBODY', 'THEAD', 'TR', 'TFOOT'];
var DONT_WORK_AS_CONTENT = ['TABLE', 'TBODY', 'THEAD', 'TR', 'TFOOT'];
var DONT_SET_DISPLAY_BLOCK = ['TABLE', 'TBODY', 'THEAD', 'TR', 'TFOOT'];
// Utility to clip to range
function clip(value, min, max){
if( angular.isArray(value) ){
return angular.forEach(value, function(v){
return clip(v, min, max);
});
}
return Math.max(min, Math.min(value, max));
}
mod.directive('sfVirtualRepeat', ['$log', '$rootElement', function($log, $rootElement){
return {
require: '?ngModel',
transclude: 'element',
priority: 1000,
terminal: true,
compile: sfVirtualRepeatCompile
};
// Turn the expression supplied to the directive:
//
// a in b
//
// into `{ value: "a", collection: "b" }`
function parseRepeatExpression(expression){
var match = expression.match(/^\s*([\$\w]+)\s+in\s+([\S\s]*)$/);
if (! match) {
throw new Error("Expected sfVirtualRepeat in form of '_item_ in _collection_' but got '" +
expression + "'.");
}
return {
value: match[1],
collection: match[2]
};
}
// Utility to filter out elements by tag name
function isTagNameInList(element, list){
var t, tag = element.tagName.toUpperCase();
for( t = 0; t < list.length; t++ ){
if( list[t] === tag ){
return true;
}
}
return false;
}
// Utility to find the viewport/content elements given the start element:
function findViewportAndContent(startElement){
/*jshint eqeqeq:false, curly:false */
var root = $rootElement[0];
var e, n;
// Somewhere between the grandparent and the root node
for( e = startElement.parent().parent()[0]; e !== root; e = e.parentNode ){
// is an element
if( e.nodeType != 1 ) break;
// that isn't in the blacklist (tables etc.),
if( isTagNameInList(e, DONT_WORK_AS_VIEWPORTS) ) continue;
// has a single child element (the content),
if( e.childElementCount != 1 ) continue;
// which is not in the blacklist
if( isTagNameInList(e.firstElementChild, DONT_WORK_AS_CONTENT) ) continue;
// and no text.
for( n = e.firstChild; n; n = n.nextSibling ){
if( n.nodeType == 3 && /\S/g.test(n.textContent) ){
break;
}
}
if( n == null ){
// That element should work as a viewport.
return {
viewport: angular.element(e),
content: angular.element(e.firstElementChild)
};
}
}
throw new Error("No suitable viewport element");
}
// Apply explicit height and overflow styles to the viewport element.
//
// If the viewport has a max-height (inherited or otherwise), set max-height.
// Otherwise, set height from the current computed value or use
// window.innerHeight as a fallback
//
function setViewportCss(viewport){
var viewportCss = {'overflow': 'auto'},
style = window.getComputedStyle ?
window.getComputedStyle(viewport[0]) :
viewport[0].currentStyle,
maxHeight = style && style.getPropertyValue('max-height'),
height = style && style.getPropertyValue('height');
if( maxHeight && maxHeight !== '0px' ){
viewportCss.maxHeight = maxHeight;
}else if( height && height !== '0px' ){
viewportCss.height = height;
}else{
viewportCss.height = window.innerHeight;
}
viewport.css(viewportCss);
}
// Apply explicit styles to the content element to prevent pesky padding
// or borders messing with our calculations:
function setContentCss(content){
var contentCss = {
margin: 0,
padding: 0,
border: 0,
'box-sizing': 'border-box'
};
content.css(contentCss);
}
// TODO: compute outerHeight (padding + border unless box-sizing is border)
function computeRowHeight(element){
var style = window.getComputedStyle ? window.getComputedStyle(element)
: element.currentStyle,
maxHeight = style && style.getPropertyValue('max-height'),
height = style && style.getPropertyValue('height');
if( height && height !== '0px' && height !== 'auto' ){
$log.debug('Row height is "%s" from css height', height);
}else if( maxHeight && maxHeight !== '0px' && maxHeight !== 'none' ){
height = maxHeight;
$log.debug('Row height is "%s" from css max-height', height);
}else if( element.clientHeight ){
height = element.clientHeight+'px';
$log.debug('Row height is "%s" from client height', height);
}else{
throw new Error("Unable to compute height of row");
}
angular.element(element).css('height', height);
return parseInt(height, 10);
}
// The compile gathers information about the declaration. There's not much
// else we could do in the compile step as we need a viewport parent that
// is exculsively ours - this is only available at link time.
function sfVirtualRepeatCompile(element, attr, linker) {
var ident = parseRepeatExpression(attr.sfVirtualRepeat);
return {
post: sfVirtualRepeatPostLink
};
// ----
// Set up the initial value for our watch expression (which is just the
// start and length of the active rows and the collection length) and
// adds a listener to handle child scopes based on the active rows.
function sfVirtualRepeatPostLink(scope, iterStartElement, attrs){
var rendered = [];
var rowHeight = 0;
var scrolledToBottom = false;
var stickyEnabled = "sticky" in attrs;
var dom = findViewportAndContent(iterStartElement);
// The list structure is controlled by a few simple (visible) variables:
var state = 'ngModel' in attrs ? scope.$eval(attrs.ngModel) : {};
// - The index of the first active element
state.firstActive = 0;
// - The index of the first visible element
state.firstVisible = 0;
// - The number of elements visible in the viewport.
state.visible = 0;
// - The number of active elements
state.active = 0;
// - The total number of elements
state.total = 0;
// - The point at which we add new elements
state.lowWater = state.lowWater || 100;
// - The point at which we remove old elements
state.highWater = state.highWater || 300;
// - Keep the scroll event from constantly firing
state.threshold = state.threshold || 1;
var lastFixPos = 0;
// TODO: now watch the water marks
setContentCss(dom.content);
setViewportCss(dom.viewport);
// When the user scrolls, we move the `state.firstActive`
dom.viewport.bind('scroll', sfVirtualRepeatOnScroll);
// The watch on the collection is just a watch on the length of the
// collection. We don't care if the content changes.
scope.$watch(sfVirtualRepeatWatchExpression, sfVirtualRepeatListener, true);
// and that's the link done! All the action is in the handlers...
return;
// ----
// Apply explicit styles to the item element
function setElementCss (element) {
var elementCss = {
// no margin or it'll screw up the height calculations.
margin: '0'
};
if( !isTagNameInList(element[0], DONT_SET_DISPLAY_BLOCK) ){
// display: block if it's safe to do so
elementCss.display = 'block';
}
if( rowHeight ){
elementCss.height = rowHeight+'px';
}
element.css(elementCss);
}
function makeNewScope (idx, colExpr, containerScope) {
var childScope = containerScope.$new(),
collection = containerScope.$eval(colExpr);
childScope[ident.value] = collection[idx];
childScope.$index = idx;
childScope.$first = (idx === 0);
childScope.$last = (idx === (collection.length - 1));
childScope.$middle = !(childScope.$first || childScope.$last);
childScope.$watch(function updateChildScopeItem(){
collection = containerScope.$eval(colExpr);
childScope[ident.value] = collection[idx];
});
return childScope;
}
function addElements (start, end, colExpr, containerScope, insPoint) {
var frag = document.createDocumentFragment();
var newElements = [], element, idx, childScope;
for( idx = start; idx !== end; idx ++ ){
childScope = makeNewScope(idx, colExpr, containerScope);
element = linker(childScope, angular.noop);
setElementCss(element);
newElements.push(element);
frag.appendChild(element[0]);
}
insPoint.after(frag);
return newElements;
}
function recomputeActive() {
// We want to set the start to the low water mark unless the current
// start is already between the low and high water marks.
var start = clip(state.firstActive, state.firstVisible - state.lowWater, state.firstVisible - state.highWater);
// Similarly for the end
var end = clip(state.firstActive + state.active,
state.firstVisible + state.visible + state.lowWater,
state.firstVisible + state.visible + state.highWater );
state.firstActive = clip(start, 0, state.total - state.visible - state.lowWater);
state.active = Math.min(end, state.total) - state.firstActive;
}
function sfVirtualRepeatOnScroll(evt){
if( !rowHeight ){
return;
}
var diff = Math.abs(evt.target.scrollTop - lastFixPos);
if(diff > (state.threshold * rowHeight)){
// Enter the angular world for the state change to take effect.
scope.$apply(function(){
state.firstVisible = Math.floor(evt.target.scrollTop / rowHeight);
state.visible = Math.ceil(dom.viewport[0].clientHeight / rowHeight);
$log.debug('scroll to row %o', state.firstVisible);
var sticky = evt.target.scrollTop + evt.target.clientHeight >= evt.target.scrollHeight;
recomputeActive();
$log.debug(' state is now %o', state);
$log.debug(' sticky = %o', sticky);
});
lastFixPos = evt.target.scrollTop;
}
}
function sfVirtualRepeatWatchExpression(scope){
var coll = scope.$eval(ident.collection);
if( coll && coll.length !== state.total ){
state.total = coll.length;
recomputeActive();
}
return {
start: state.firstActive,
active: state.active,
len: coll ? coll.length : 0
};
}
function destroyActiveElements (action, count) {
var dead, ii, remover = Array.prototype[action];
for( ii = 0; ii < count; ii++ ){
dead = remover.call(rendered);
dead.scope().$destroy();
dead.remove();
}
}
// When the watch expression for the repeat changes, we may need to add
// and remove scopes and elements
function sfVirtualRepeatListener(newValue, oldValue, scope){
var oldEnd = oldValue.start + oldValue.active,
newElements;
if( newValue === oldValue ){
$log.debug('initial listen');
newElements = addElements(newValue.start, oldEnd, ident.collection, scope, iterStartElement);
rendered = newElements;
if( rendered.length ){
rowHeight = computeRowHeight(newElements[0][0]);
}
}else{
var newEnd = newValue.start + newValue.active;
var forward = newValue.start >= oldValue.start;
var delta = forward ? newValue.start - oldValue.start
: oldValue.start - newValue.start;
var endDelta = newEnd >= oldEnd ? newEnd - oldEnd : oldEnd - newEnd;
var contiguous = delta < (forward ? oldValue.active : newValue.active);
$log.debug('change by %o,%o rows %s', delta, endDelta, forward ? 'forward' : 'backward');
if( !contiguous ){
$log.debug('non-contiguous change');
destroyActiveElements('pop', rendered.length);
rendered = addElements(newValue.start, newEnd, ident.collection, scope, iterStartElement);
}else{
if( forward ){
$log.debug('need to remove from the top');
destroyActiveElements('shift', delta);
}else if( delta ){
$log.debug('need to add at the top');
newElements = addElements(
newValue.start,
oldValue.start,
ident.collection, scope, iterStartElement);
rendered = newElements.concat(rendered);
}
if( newEnd < oldEnd ){
$log.debug('need to remove from the bottom');
destroyActiveElements('pop', oldEnd - newEnd);
}else if( endDelta ){
var lastElement = rendered[rendered.length-1];
$log.debug('need to add to the bottom');
newElements = addElements(
oldEnd,
newEnd,
ident.collection, scope, lastElement);
rendered = rendered.concat(newElements);
}
}
if( !rowHeight && rendered.length ){
rowHeight = computeRowHeight(rendered[0][0]);
}
dom.content.css({'padding-top': newValue.start * rowHeight + 'px'});
}
dom.content.css({'height': newValue.len * rowHeight + 'px'});
if( scrolledToBottom && stickyEnabled ){
dom.viewport[0].scrollTop = dom.viewport[0].clientHeight + dom.viewport[0].scrollHeight;
}
}
}
}
}]);
}());
| looker/angular-virtual-scroll | src/virtual-repeat.js | JavaScript | mit | 14,764 |
require('../helpers');
const assert = require('assert');
const ironium = require('../../src');
const Promise = require('bluebird');
describe('processing', ()=> {
const errorCallbackQueue = ironium.queue('error-callback');
const errorPromiseQueue = ironium.queue('error-promise');
const errorGeneratorQueue = ironium.queue('error-generator');
function untilSuccessful(done) {
ironium.runOnce((error)=> {
if (error)
setTimeout(()=> untilSuccessful(done));
else
done();
});
}
describe('with callback error', ()=> {
// First two runs should fail, runs ends at 3
let runs = 0;
before(()=> {
errorCallbackQueue.eachJob((job, callback)=> {
runs++;
if (runs > 2)
callback();
else
callback(new Error('fail'));
});
});
before(()=> errorCallbackQueue.queueJob('job'));
before(untilSuccessful);
it('should repeat until processed', ()=> {
assert.equal(runs, 3);
});
});
describe('with rejected promise', ()=> {
// First two runs should fail, runs ends at 3
let runs = 0;
before(()=> {
errorPromiseQueue.eachJob(()=> {
runs++;
if (runs > 2)
return Promise.resolve();
else
return Promise.reject(new Error('fail'));
});
});
before(()=> errorPromiseQueue.queueJob('job'));
before(untilSuccessful);
it('should repeat until processed', ()=> {
assert.equal(runs, 3);
});
});
describe('with generator error', ()=> {
// First two runs should fail, runs ends at 3
let runs = 0;
before(()=> {
errorGeneratorQueue.eachJob(function*() {
runs++;
switch (runs) {
case 1: {
throw new Error('fail');
}
case 2: {
yield Promise.reject(Error('fail'));
break;
}
}
});
});
before(()=> errorGeneratorQueue.queueJob('job'));
before(untilSuccessful);
it('should repeat until processed', ()=> {
assert.equal(runs, 3);
});
});
});
| djanowski/ironium | test/queues/error_test.js | JavaScript | mit | 2,127 |
from flask import Flask, render_template
app = Flask(__name__)
@app.route('/')
def mainRoute():
return render_template('hello.html')
@app.route('/jujitsu')
def jujitsu():
return render_template('jujitsu.html')
if __name__ == '__main__':
app.run(debug=True,host='0.0.0.0', port=8080)
| CrazyDiamond567/docker-cloud-test | unh698.py | Python | mit | 302 |
/**
* Created by Andrei on 10/14/2014.
*/
import java.util.concurrent.Executors;
import java.util.concurrent.ExecutorService;
import java.util.Date;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.net.InetAddress;
public class ThreadPoolApp {
public static void main (String[] args) {
if (args.length < 2)
ThreadPoolApp.error();
try {
int numberOfJobs = Integer.parseInt(args[0]);
int numberOfThreads = Integer.parseInt(args[1]);
if ((numberOfJobs < 1) || (numberOfThreads < 1))
ThreadPoolApp.error();
ExecutorService pool = Executors.newFixedThreadPool(numberOfThreads);
Job[] jobs = new Job[numberOfJobs];
for (int i = 0; i < numberOfJobs; i++) {
if (i == 0) {
jobs[0] = new Job(0){
public void run() {
//Undertake required work, here we will emulate it by sleeping for a period
System.out.println("Job: " + jobNumber + " is being processed by thread: "
+ Thread.currentThread().getName());
try {
Thread.sleep((int)(1000));
System.out.println("Hello World!");
DateFormat dateFormat = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
//get current date time with Date()
Date date = new Date();
System.out.println(dateFormat.format(date));
//get current date time with Calendar()
Calendar cal = Calendar.getInstance();
System.out.println(dateFormat.format(cal.getTime()));
} catch (InterruptedException e) {
//no cathing as example should not experience interruptions
}
System.out.println("Job: " + jobNumber + " is ending in thread: "
+ Thread.currentThread().getName());
}
};
pool.execute(jobs[0]);
}
if (i == 1) {
jobs[1] = new Job(1){
public void run() {
//Undertake required work, here we will emulate it by sleeping for a period
System.out.println("Job: " + jobNumber + " is being processed by thread: "
+ Thread.currentThread().getName());
try {
Thread.sleep((int)(1000));
try {
java.net.InetAddress localMachine = java.net.InetAddress.getLocalHost();
System.out.println("Hostname of local machine: " + localMachine.getHostName());
} catch (Exception ex) {
//comment
}
} catch (InterruptedException e) {
//no cathing as example should not experience interruptions
}
System.out.println("Job: " + jobNumber + " is ending in thread: "
+ Thread.currentThread().getName());
}
};
pool.execute(jobs[1]);
}
if ( i > 1) {
jobs[i] = new Job(i);
pool.execute(jobs[i]);
}
//pool.execute(jobs[i]); //executes the given command at some future time
}
pool.shutdown(); //Shutdown: previously submitted tasks are executed,
//but no new tasks will be accepted.
System.out.println(" Last line " + Thread.currentThread().getName());
} catch (NumberFormatException e) {
ThreadPoolApp.error();
}
}
private static void error() {
System.out.println("ThreadPoolApp must be run with two positive valued" +
" integer arguments. The first detaling the number of jobs" +
" the second the number of processing threads in the pool");
System.exit(0); //exit the program
}
} | abrabete/threadpool_example | IntelliJ/src/ThreadPoolApp.java | Java | mit | 4,608 |
#ifndef WF_INPUT_DEVICE_HPP
#define WF_INPUT_DEVICE_HPP
#include <wayfire/nonstd/wlroots.hpp>
namespace wf
{
class input_device_t
{
public:
/**
* General comment
* @return The represented wlr_input_device
*/
wlr_input_device *get_wlr_handle();
/**
* @param enabled Whether the compositor should handle input events from
* the device
* @return true if the device state was successfully changed
*/
bool set_enabled(bool enabled = true);
/**
* @return true if the compositor should receive events from the device
*/
bool is_enabled();
protected:
wlr_input_device *handle;
input_device_t(wlr_input_device *handle);
};
}
#endif /* end of include guard: WF_INPUT_DEVICE_HPP */
| ammen99/wayfire | src/api/wayfire/input-device.hpp | C++ | mit | 758 |
require 'wasted'
begin
require 'pry'
# rescue LoadError
end
| tombroomfield/wasted | spec/spec_helper.rb | Ruby | mit | 64 |
<?php
namespace Oro\Bundle\EmailBundle\EventListener\Datagrid;
use Oro\Bundle\DataGridBundle\Datasource\Orm\OrmDatasource;
use Oro\Bundle\DataGridBundle\Event\BuildAfter;
use Oro\Bundle\EmailBundle\Datagrid\EmailQueryFactory;
class IncomingEmailGridListener
{
/** @var EmailQueryFactory */
protected $emailQueryFactory;
/**
* @param EmailQueryFactory $emailQueryFactory
*/
public function __construct(EmailQueryFactory $emailQueryFactory)
{
$this->emailQueryFactory = $emailQueryFactory;
}
/**
* @param BuildAfter $event
*/
public function onBuildAfter(BuildAfter $event)
{
/** @var OrmDatasource $datasource */
$datasource = $event->getDatagrid()->getDatasource();
$this->emailQueryFactory->addFromEmailAddress($datasource->getQueryBuilder());
}
}
| orocrm/platform | src/Oro/Bundle/EmailBundle/EventListener/Datagrid/IncomingEmailGridListener.php | PHP | mit | 847 |
<?php
namespace GhaenCollege\ScrumBundle\Entity;
use Doctrine\ORM\EntityRepository;
/**
* TestRepository
*
* This class was generated by the Doctrine ORM. Add your own custom
* repository methods below.
*/
class TestRepository extends EntityRepository
{
}
| mahmud-kasaei/Scrum4u | src/GhaenCollege/ScrumBundle/Entity/TestRepository.php | PHP | mit | 264 |
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Windows;
// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
[assembly: AssemblyTitle("ReactiveProperty Test")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("ReactiveProperty Test")]
[assembly: AssemblyCopyright("Copyright © 2015-2017 emoacht")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
// Setting ComVisible to false makes the types in this assembly not visible
// to COM components. If you need to access a type in this assembly from
// COM, set the ComVisible attribute to true on that type.
[assembly: ComVisible(false)]
//In order to begin building localizable applications, set
//<UICulture>CultureYouAreCodingWith</UICulture> in your .csproj file
//inside a <PropertyGroup>. For example, if you are using US english
//in your source files, set the <UICulture> to en-US. Then uncomment
//the NeutralResourceLanguage attribute below. Update the "en-US" in
//the line below to match the UICulture setting in the project file.
//[assembly: NeutralResourcesLanguage("en-US", UltimateResourceFallbackLocation.Satellite)]
[assembly: ThemeInfo(
ResourceDictionaryLocation.None, //where theme specific resource dictionaries are located
//(used if a resource is not found in the page,
// or application resource dictionaries)
ResourceDictionaryLocation.SourceAssembly //where the generic resource dictionary is located
//(used if a resource is not found in the page,
// app, or any theme specific resource dictionaries)
)]
// Version information for an assembly consists of the following four values:
//
// Major Version
// Minor Version
// Build Number
// Revision
//
// You can specify all the values or you can default the Build and Revision Numbers
// by using the '*' as shown below:
// [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("1.2.0.0")]
[assembly: AssemblyFileVersion("1.2.0.0")]
| emoacht/WlanProfileViewer | Source/ReactivePropertyTest/Properties/AssemblyInfo.cs | C# | mit | 2,287 |
module.exports = {
getDates: function(d) {
var today = padDate(d);
return {
startTime: today + lowerBoundTime(),
endTime: today + upperBoundTime()
};
}
};
function padDate (d){
function pad (n) { return n < 10 ? '0' + n : n }
return d.getUTCFullYear() + '-'
+ pad(d.getUTCMonth() + 1 ) + '-'
+ pad(d.getUTCDate()) + 'T';
}
function lowerBoundTime() {
return '00:00:00Z';
}
function upperBoundTime() {
return '23:59:59Z';
} | iOnline247/heyo | utils/dateHelpers.js | JavaScript | mit | 449 |
/**
* Java Modular Image Synthesis Toolkit (JMIST)
* Copyright (C) 2018 Bradley W. Kimmel
*
* Permission is hereby granted, free of charge, to any person
* obtaining a copy of this software and associated documentation
* files (the "Software"), to deal in the Software without
* restriction, including without limitation the rights to use,
* copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following
* conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
*/
package ca.eandb.jmist.framework.scatter;
import ca.eandb.jmist.framework.Function1;
import ca.eandb.jmist.framework.Random;
import ca.eandb.jmist.framework.SurfacePointGeometry;
import ca.eandb.jmist.math.Vector3;
/**
* A <code>SurfaceScatterer</code> representing a absorptive layer with sieve
* effects in the ABM-B/ABM-U light transport models.
* @author Brad Kimmel
* @see ABMSurfaceScatterer
*/
public final class ABMSieveAbsorbingSurfaceScatterer implements SurfaceScatterer {
/** Serialization version ID. */
private static final long serialVersionUID = -8261906690789778531L;
/** The absorption coefficient of the medium (in m<sup>-1</sup>). */
private final Function1 absorptionCoefficient;
/** The thickness of the medium (in meters). */
private final double thickness;
/**
* Creates a new <code>AbsorbingSurfaceScatterer</code>.
* @param absorptionCoefficient The absorption coefficient of the medium
* (in m<sup>-1</sup>).
* @param thickness The thickness of the medium (in meters).
*/
public ABMSieveAbsorbingSurfaceScatterer(Function1 absorptionCoefficient,
double thickness) {
this.absorptionCoefficient = absorptionCoefficient;
this.thickness = thickness;
}
@Override
public Vector3 scatter(SurfacePointGeometry x, Vector3 v,
boolean adjoint, double lambda, Random rnd) {
double abs = absorptionCoefficient.evaluate(lambda);
double p = -Math.log(1.0 - rnd.next()) * Math.cos(Math.abs(x.getNormal().dot(v))) / abs;
return (p > thickness) ? v : null;
}
}
| bwkimmel/jmist | jmist-core/src/main/java/ca/eandb/jmist/framework/scatter/ABMSieveAbsorbingSurfaceScatterer.java | Java | mit | 2,738 |
module.exports = require("./src/moment-interval"); | luisfarzati/moment-interval | index.js | JavaScript | mit | 50 |
// namespace plexus
var plexus = plexus || {};
window._plexus = plexus;
(function(plx) {
console.log("plexus.js [loaded]");
//------------------------------
// Plexus utilties functions
//------------------------------
plx.each = function(obj, iterator, context) {
if (!obj) return;
if (obj instanceof Array) {
for (var i = 0, li = obj.length; i <li; i++) {
if (iterator.call(context, obj[i], i) === false) return;
}
} else {
for (var key in obj) {
if (iterator.call(context, obj[key], key) === false) return;
}
}
};
plx.extend = function(target) {
var sources = arguments.length >= 2 ? Array.prototype.slice.call(arguments, 1) : [];
plx.each(sources, function(src) {
for (var key in src) {
if (src.hasOwnProperty(key))
target[key] = src[key];
}
});
return target;
};
var ClassLoader = {
id: (0 | (Math.random() * 998)),
instanceId: (0 | (Math.random() * 998)),
compileSuper: function(func, name, id) {
var str = func.toString();
var pstart = str.indexOf('('), pend = str.indexOf(')');
var params = str.substring(pstart + 1, pend);
params = params.trim();
var bstart = str.indexOf('{'), bend = str.lastIndexOf('}');
var str = str.substring(bstart + 1, bend);
while (str.indexOf('this._super') != -1) {
var sp = str.indexOf('this._super');
var bp = str.indexOf('(', sp);
var bbp = str.indexOf(')', bp);
var superParams = str.substring(bp + 1, bbp);
superParams = superParams.trim();
var coma = superParams ? ',' : '';
str = str.substring(0, sp) + 'ClassLoader[' + id + '].' + name + '.call(this' + coma + str.substring(bp + 1);
}
return Function(params, str);
},
newId: function() {
return this.id++;
},
newInstanceId: function() {
return this.instanceId++;
}
};
ClassLoader.compileSuper.ClassLoader = ClassLoader;
plx.Class = function() {
};
var FuncRegexTest = /\b_super\b/;
var releaseMode = false;
plx.Class.extend = function(props) {
var _super = this.prototype;
var prototype = Object.create(_super);
var classId = ClassLoader.newId();
ClassLoader[classId] = _super;
var desc = { writable: true, enumerable: false, configurable: true };
prototype.__instanceId = null;
function Class() {
this.__instanceId = ClassLoader.newInstanceId();
if (this.ctor)
this.ctor.apply(this, arguments);
};
Class.id = classId;
desc.value = classId;
Object.defineProperty(prototype, "__pid", desc);
Class.prototype = prototype;
desc.value = Class;
Object.defineProperty(Class.prototype, 'constructor', desc);
for(var idx = 0, li = arguments.length; idx < li; ++idx) {
var prop = arguments[idx];
for (var name in prop) {
var isFunc = (typeof prop[name] === 'function');
var override = (typeof _super[name] === 'function');
var hasSuperCall = FuncRegexTest.test(prop[name]);
if (releaseMode && isFunc && override && hasSuperCall) {
desc.value = ClassLoader.compileSuper(prop[name], name, classId);
Object.defineProperty(prototype, name, desc);
} else if(isFunc && override && hasSuperCall) {
desc.value = (function(name, fn) {
return function() {
var tmp = this._super;
this._super = _super[name];
var ret = fn.apply(this, arguments);
this._super = tmp;
return ret;
};
})(name, prop[name]);
Object.defineProperty(prototype, name, desc);
} else if (isFunc) {
desc.value = prop[name];
Object.defineProperty(prototype, name, desc);
} else {
prototype[name] = prop[name];
}
// ... Getters and Setters ... ?
}
}
Class.extend = plx.Class.extend;
Class.implement = function(prop) {
for (var name in prop) {
prototype[name] = prop[name];
}
};
return Class;
};
//------------------------------
// Plexus GameObject
//------------------------------
/**
* @class GameObject
*/
var GameObject = plx.Class.extend({
_components: {},
_data: null,
ctor: function() {
this._id = (+new Date()).toString(16) + (Math.random() * 1000000000 | 0).toString(16) + (++GameObject.sNumOfObjects);
},
getId: function() {
return this._id;
},
getUserData: function() {
return this._data;
},
setUserData: function(data) {
// plx.extend(this._data, data);
this._data = data;
},
getComponent: function(component) {
var name = component;
if (typeof component === 'function') {
name = component.prototype.name;
}
return this._components[name];
},
addComponent: function(component) {
if (!component || !component.name)
return;
this._components[component.name] = component;
if (typeof component.setOwner === 'function')
component.setOwner(this);
return this;
},
// Remove component data by removing the reference to it.
removeComponent: function(component) {
// Allows either a component function or a string of a component name to be passed in.
var name = component;
if (typeof component === 'function') {
name = component.prototype.name;
}
// Remove component data by removing the reference to it.
component = this._components[name];
delete this._components[name];
if (typeof component.setOwner === 'function')
component.setOwner(null);
return this;
},
getTag: function() {
return this._tag;
},
setTag: function(tagValue) {
this._tag = tagValue;
}
});
GameObject.sNumOfObjects = 0;
//------------------------------
// Plexus Component
//------------------------------
/**
* @class GameComponent
*/
var GameComponent = plx.Class.extend({
_owner: null,
ctor: function() {
},
getOwner: function() {
return this._owner;
},
setOwner: function(owner) {
this._owner = owner;
}
});
//------------------------------
// Plexus System
//------------------------------
/**
* @class System
*/
var System = plexus.Class.extend({
_managedObjects: [],
_managedSystems: [],
ctor: function() {
},
addSubSystem: function(sub) {
if (sub && sub.name) {
this._managedSystems[sub.name] = sub;
this._managedSystems.push(sub);
}
},
removeSubSystem: function(sub) {
var name = sub;
if (typeof sub === 'function') {
name = sub.prototype.name;
}
var origin = this._managedSystems[name];
delete this._managedSystems[name];
var idx = this._managedSystems.indexOf(origin);
if (idx != -1) {
this._managedSystems.splice(idx, 1);
}
return origin;
},
addObject: function(obj) {
this._managedObjects.push(obj);
// added in subsystems.
this._managedSystems.forEach(function(elt, i) {
elt.order(obj);
return true;
});
},
removeObject: function(obj) {
var index = this._managedObjects.indexOf(obj);
if (index != -1) {
this._managedObjects.splice(index, 1);
// remove in subsystems.
this._managedSystems.every(function(elt, i) {
elt.unorder(elt);
return true;
});
}
},
update: function(dt) {
this._managedSystems.forEach(function(elt, i) {
elt.update(dt);
return true;
});
}
});
/**
* @class SubSystem
*/
var SubSystem = plexus.Class.extend({
_managed: [],
check: function(obj) {
if (!this.name)
return false;
if (typeof obj.getComponent === 'function')
return obj.getComponent(this.name);
return false;
},
order: function(obj) {
if (this.check(obj)) {
this._managed.push(obj);
}
},
unorder: function(obj) {
var index = -1;
if ((index = _managed.indexOf(obj)) != -1) {
if (this.check(obj)) {
this._managed.splice(index, 1);
}
}
},
update: function(dt) {
var self = this;
// console.log(JSON.stringify(self._managed, null, 4));
this._managed.every(function(elt, i) {
if (typeof self.updateObjectDelta === 'function')
self.updateObjectDelta(elt, dt);
return true;
}, self);
},
updateObjectDelta: function(obj, dt) {
if (!this.name)
return;
var comp = obj.getComponent(this.name);
comp && comp.update(dt);
}
});
//------------------------------
// SubSystems
//------------------------------
var InputSystem = SubSystem.extend({
name: 'input',
check: function(obj) {
if (typeof obj.getComponent === 'function') {
return obj.getComponent(this.name);
}
return false;
}
});
/**
* @class PhysicsSystem
*/
var PhysicsSystem = SubSystem.extend({
name: 'physics',
check: function(obj) {
if (typeof obj.getComponent=== 'function') {
return obj.getComponent(this.name);
}
return false;
},
updateObjectDelta: function(obj, dt) {
}
});
/**
* @class AnimatorSystem
*/
var AnimatorSystem = SubSystem.extend({
name: 'animator',
check: function(obj) {
if (typeof obj.getComponent === 'function') {
return obj.getComponent(this.name);
}
return false;
},
updateObjectDelta: function(obj, dt) {
var comp = obj.getComponent(this.name);
comp && comp.update(dt);
}
});
var _systemInstance = undefined;
System.getInstance = function getSystem() {
if (!_systemInstance)
_systemInstance = new System;
return _systemInstance;
};
plx.GameSystem = System;
plx.GameSubSystem = SubSystem;
plx.InputSystem = InputSystem;
plx.PhysicsSystem = PhysicsSystem;
plx.AnimatorSystem = AnimatorSystem;
plx.GameComponent = GameComponent;
plx.GameObject = GameObject;
})(plexus);
// vi: ft=javascript sw=4 ts=4 et :
| keyhom/xstudio-html5 | src/plexus/js/plexus-base.js | JavaScript | mit | 12,046 |
using System;
namespace SingleSignOnKata.sso
{
public interface SingleSignOnRegistry
{
SSOToken RegisterNewSession(String userName, String password);
bool IsValid(SSOToken token);
void Unregister(SSOToken token);
}
}
| emilybache/Single-Sign-On-Kata | CSharp/SingleSignOnKata/sso/SingleSignOnRegistry.cs | C# | mit | 257 |
<?php
namespace Ackintosh\Snidel;
/**
* @codeCoverageIgnore
*/
function msg_send()
{
return false;
}
| ackintosh/snidel | tests/msg_send.php | PHP | mit | 108 |
<?php
namespace Application\Migrations;
use Doctrine\DBAL\Migrations\AbstractMigration,
Doctrine\DBAL\Schema\Schema;
/**
* Auto-generated Migration: Please modify to your need!
*/
class Version20120802054929 extends AbstractMigration
{
public function up(Schema $schema)
{
// this up() migration is autogenerated, please modify it to your needs
$this->abortIf($this->connection->getDatabasePlatform()->getName() != "mysql");
$this->addSql("CREATE TABLE users (id INT AUTO_INCREMENT NOT NULL, username VARCHAR(25) NOT NULL, salt VARCHAR(32) NOT NULL, password VARCHAR(40) NOT NULL, email VARCHAR(60) NOT NULL, is_active TINYINT(1) NOT NULL, UNIQUE INDEX UNIQ_1483A5E9F85E0677 (username), UNIQUE INDEX UNIQ_1483A5E9E7927C74 (email), PRIMARY KEY(id)) ENGINE = InnoDB");
}
public function down(Schema $schema)
{
// this down() migration is autogenerated, please modify it to your needs
$this->abortIf($this->connection->getDatabasePlatform()->getName() != "mysql");
$this->addSql("DROP TABLE users");
}
}
| theaudience-brett/podcasts | app/DoctrineMigrations/Version20120802054929.php | PHP | mit | 1,101 |
require 'spec_helper'
require 'date'
require 'bigdecimal'
require 'xeroid/objects/invoice'
require 'xeroid/objects/account'
require 'xeroid/objects/payment'
module Xeroid::Objects
describe Payment do
let(:invoice) { Invoice.new(id: "abcde-12345-abcde-12345") }
let(:account) { Account.new(code: "NWBC") }
let(:amount) { BigDecimal.new("10.00") }
let(:date) { Date.parse("2012-11-15") }
let(:payment) { Payment.new(invoice: invoice, account: account, amount: amount, date: date) }
it "can return its invoice" do
payment.invoice.should == invoice
end
it "can return its account" do
payment.account.should == account
end
it "can return its date" do
payment.date.should == date
end
it "can return its amount" do
payment.amount.should == amount
end
it "returns nil for currency_rate by default" do
payment.currency_rate.should be_nil
end
context "with currency_rate" do
let(:currency_rate) { BigDecimal.new("1.2") }
let(:payment) { Payment.new(invoice: invoice, account: account, amount: amount, date: date, currency_rate: currency_rate) }
it "can return its currency_rate" do
payment.currency_rate.should == currency_rate
end
end
end
end
| fidothe/xeroid | spec/xeroid/objects/payment_spec.rb | Ruby | mit | 1,277 |
const sqlite = require('sqlite');
const exec = require('child_process').exec;
const program = require('commander');
const config = require('./config');
const fetchGroups = require('./lib/fetch-groups');
const fetchMembers = require('./lib/fetch-members');
program
.version('0.0.0')
.option('-a, --accessToken [value]', 'Facebook access token')
.parse(process.argv);
if(program.accessToken) {
callMe();
} else {
program.help();
}
async function callMe() {
let db;
try {
db = await sqlite.open(config.dbName);
} catch(err) {
console.error('unable to connect to database: ', config.dbName);
}
await db.exec(`
CREATE TABLE IF NOT EXISTS fb_groups(
id INTEGER PRIMARY KEY AUTOINCREMENT,
name TEXT NOT NULL,
fb_group_id NUMERIC NOT NULL UNIQUE,
fb_privacy TEXT NOT NULL,
fb_bookmark_order INTEGER NOT NULL,
timestamp DATETIME DEFAULT 'now'
);
`);
await db.exec(`
CREATE TABLE IF NOT EXISTS fb_users(
id INTEGER PRIMARY KEY AUTOINCREMENT,
name TEXT NOT NULL,
fb_user_id NUMERIC NOT NULL UNIQUE,
timestamp DATETIME DEFAULT 'now'
);
`);
await db.exec(`
CREATE TABLE IF NOT EXISTS fb_groups_users(
id INTEGER PRIMARY KEY AUTOINCREMENT,
group_id INTEGER NOT NULL REFERENCES fb_groups,
user_id INTEGER NOT NULL REFERENCES db_users,
is_admin BOOLEAN NOT NULL DEFAULT FALSE,
timestamp DATETIME DEFAULT 'now',
UNIQUE(group_id, user_id)
);
`);
const result = await fetchGroups(program.accessToken);
result.data.forEach(async function(gr) {
try {
// Insert data for all the groups there
await db.run(`
INSERT OR IGNORE INTO fb_groups (name, fb_group_id, fb_privacy, fb_bookmark_order)
SELECT :name, :id, :privacy, :bookmark_order
`, {
':name': gr.name,
':id': gr.id,
':privacy': gr.privacy,
':bookmark_order': gr.bookmark_order,
});
} catch(err) {
console.error(err)
}
});
const groups = await db.all(`SELECT * FROM fb_groups`);
groups.forEach(async function(gr) {
let membersEmmiter = await fetchMembers({
accessToken: program.accessToken,
groupId: gr.fb_group_id,
});
let chunkNum = 0;
let totalMembers = 0;
let prevTimestamp = new Date();
console.log(`Processing group "${ gr.name }" with id ${gr.fb_group_id}`)
await new Promise((res, rej) => {
membersEmmiter.on('error', err => rej(err));
membersEmmiter.on('end', err => res());
membersEmmiter.on('load', async (res) => {
const membersList = res.resp.data;
const newTimestamp = new Date();
chunkNum += 1;
totalMembers += membersList.length;
console.log(`Processing #${ chunkNum } total of ${ totalMembers } members, lasted ${ (newTimestamp - prevTimestamp) / 1000 }s from group ${ gr.name } with id ${ gr.fb_group_id }`)
prevTimestamp = newTimestamp;
for(let i = 0, l = membersList.length; i < l; i++) {
let member = membersList[i];
try {
await db.run(`
INSERT OR IGNORE INTO fb_users ( name, fb_user_id)
SELECT :name, :id
`, {
':name': member.name,
':id': member.id,
});
let user = await db.get(`SELECT * FROM fb_users WHERE fb_user_id = :id`, {
':id': member.id,
});
await db.run(`
INSERT OR IGNORE INTO fb_groups_users ( group_id, user_id, is_admin)
SELECT :group_id, :user_id, :is_admin
`, {
':group_id': gr.id,
':user_id': user.id,
':is_admin': !!member.administrator,
});
} catch (err) {
console.error(err)
}
}
});
});
});
}
| suricactus/fb-group-members | index.js | JavaScript | mit | 3,912 |
<?php
namespace FS\Injection\Pico;
if (!defined('ABSPATH')) {
exit; // Exit if accessed directly.
}
class Engine
{
protected $delimiter;
protected $pattern;
public function __construct($delimiter = ['\{{2}', '\}{2}'])
{
$this->setDelimiter($delimiter);
}
public function setDelimiter(array $delimiter)
{
$this->delimiter = $delimiter;
$this->pattern = "/{$delimiter[0]}\s*('?[\w\.]*'?)([\s?\|\w]*)\s?{$delimiter[1]}/";
return $this;
}
public function render($content, array $payload = [])
{
$engine = $this;
return preg_replace_callback($this->pattern, function ($matches) use ($payload, $engine) {
preg_match("/^'.*'$/", $matches[1], $alphanum);
if ($alphanum) {
$filters = explode('|', trim($matches[2]));
return $engine->applyFilters(trim($alphanum[0], '\''), $filters);
}
$keys = explode('.', trim($matches[1]));
$filters = explode('|', trim($matches[2]));
$value = $payload;
while ($keys) {
$key = array_shift($keys);
if (!isset($value[$key])) {
return '';
}
$value = $value[$key];
}
return $engine->applyFilters($value, $filters);
}, $content);
}
public function renderFile($filePath, array $payload = [])
{
return $this->render($this->getFileContent($filePath));
}
protected function getFileContent($filePath)
{
return file_get_contents($filePath);
}
protected function applyFilters($value, array $filters)
{
$filters = array_filter($filters);
if (!$filters) {
return $value;
}
foreach ($filters as $filter) {
$filter = trim($filter);
$value = $filter($value);
}
return $value;
}
}
| flagshipcompany/flagship-for-woocommerce | src/Injection/Pico/Engine.php | PHP | mit | 1,971 |
# encoding: utf-8
# Code generated by Microsoft (R) AutoRest Code Generator.
# Changes may cause incorrect behavior and will be lost if the code is
# regenerated.
module Azure::Mysql::Mgmt::V2017_12_01
module Models
#
# The properties used to create a new server.
#
class ServerPropertiesForCreate
include MsRestAzure
@@discriminatorMap = Hash.new
@@discriminatorMap["Default"] = "ServerPropertiesForDefaultCreate"
@@discriminatorMap["PointInTimeRestore"] = "ServerPropertiesForRestore"
@@discriminatorMap["GeoRestore"] = "ServerPropertiesForGeoRestore"
@@discriminatorMap["Replica"] = "ServerPropertiesForReplica"
def initialize
@createMode = "ServerPropertiesForCreate"
end
attr_accessor :createMode
# @return [ServerVersion] Server version. Possible values include: '5.6',
# '5.7'
attr_accessor :version
# @return [SslEnforcementEnum] Enable ssl enforcement or not when connect
# to server. Possible values include: 'Enabled', 'Disabled'
attr_accessor :ssl_enforcement
# @return [StorageProfile] Storage profile of a server.
attr_accessor :storage_profile
#
# Mapper for ServerPropertiesForCreate class as Ruby Hash.
# This will be used for serialization/deserialization.
#
def self.mapper()
{
client_side_validation: true,
required: false,
serialized_name: 'ServerPropertiesForCreate',
type: {
name: 'Composite',
polymorphic_discriminator: 'createMode',
uber_parent: 'ServerPropertiesForCreate',
class_name: 'ServerPropertiesForCreate',
model_properties: {
version: {
client_side_validation: true,
required: false,
serialized_name: 'version',
type: {
name: 'String'
}
},
ssl_enforcement: {
client_side_validation: true,
required: false,
serialized_name: 'sslEnforcement',
type: {
name: 'Enum',
module: 'SslEnforcementEnum'
}
},
storage_profile: {
client_side_validation: true,
required: false,
serialized_name: 'storageProfile',
type: {
name: 'Composite',
class_name: 'StorageProfile'
}
}
}
}
}
end
end
end
end
| Azure/azure-sdk-for-ruby | management/azure_mgmt_mysql/lib/2017-12-01/generated/azure_mgmt_mysql/models/server_properties_for_create.rb | Ruby | mit | 2,647 |
import * as HTTPStatus from 'http-status-codes';
import * as express from 'express';
import Logger from './Logger';
export default class ErrorHandler {
private logger: Logger;
constructor() {
this.logger = new Logger('ErrorHandler');
}
handleError(err: Error, _, res: express.Response, next: Function): express.Response {
if (!err) {
return next();
}
this.logger.error('handleError', err.message);
return res.status(HTTPStatus.INTERNAL_SERVER_ERROR).json({
message: process.env.NODE_ENV === 'development' ? err.message : 'Internal error',
});
}
}
| simon-tannai/nodejs-typescript-boilerplate | src/utils/ErrorHandler.ts | TypeScript | mit | 599 |
'use strict';
let mongoose = require('mongoose'),
fs = require('fs');
require('../models/project-model');
let Project = mongoose.model('Project');
require('../models/user-model');
let User = mongoose.model('User');
let getCount = function(req, res, next) {
Project.count({}, function(err, count) {
if (err) {
next(err);
return;
}
res.status(200);
res.json(count);
});
};
let getByArea = function(req, res, next) {
let currentArea = req.params.area;
if (!currentArea || currentArea === "") {
next({
message: "Bad request!",
status: 404
});
return;
}
Project.find({
'area': currentArea
}).sort('-year')
.exec(function(err, projects) {
if (err) {
next(err);
return;
}
res.status(200);
res.json(projects);
});
};
let getById = function(req, res, next) {
let currentId = req.params.id;
if (!currentId || currentId === "") {
next({
message: "Bad request!",
status: 404
});
return;
}
Project.findOne({
'_id': currentId
}, function(err, project) {
if (err) {
next(err);
return;
} else if (project === null) {
next({
message: "Project not found!",
status: 404
});
return;
}
res.status(200);
res.json(project);
});
};
let create = function(req, res, next) {
var newProject = new Project(req.body);
var authKey = req.headers['x-auth-key'];
User.findOne({
'authKey': authKey
}, function(err, user) {
if (err) {
next(err);
return;
} else if (user === null) {
next({
message: "Authentication failed!",
status: 401
});
return;
}
newProject.save(function(err) {
if (err) {
let error = {
message: err.message,
status: 400
};
next(err);
return;
} else {
res.status(201);
res.json(newProject);
}
});
});
};
let bulckCreate = function(req, res, next) {
let len = req.body.length;
for (let i = 0; i < len; i++) {
var newProject = new Project(req.body[i]);
var fileName = newProject.fileName;
var areaName = newProject.area;
var filePath = './files/projects/' + areaName + '/' + fileName;
var bitmap = fs.readFileSync(filePath);
var bufer = new Buffer(bitmap).toString('base64');
newProject.file = bufer;
newProject.save(function(err) {
if (err) {
let error = {
message: err.message,
status: 400
};
next(err);
return;
} else {
}
});
console.log(fileName);
};
res.json({});
};
let controller = {
getByArea,
getById,
create,
bulckCreate
};
module.exports = controller;
| veselints/belin | controllers/projects-controller.js | JavaScript | mit | 3,316 |
import Logger from 'utils/logger';
const logger = new Logger('[push-simple/serviceworker]');
function onPush(event) {
logger.log("Received push message", event);
let title = (event.data && event.data.text()) || "Yay a message";
let body = "We have received a push message";
let tag = "push-simple-demo-notification-tag";
var icon = '/assets/turtle-logo-120x120.png';
event.waitUntil(
self.registration.showNotification(title, { body, icon, tag })
)
}
function onPushSubscriptionChange(event) {
logger.log("Push subscription change event detected", event);
}
self.addEventListener("push", onPush);
self.addEventListener("pushsubscriptionchange", onPushSubscriptionChange);
| rossta/serviceworker-rails-sandbox | app/assets/javascripts/push-simple/serviceworker.js | JavaScript | mit | 697 |
var http = require('../simpleHttp'),
config = require('../config'),
zmq = require('zmq'),
_ = require('lodash'),
argv = require('yargs').argv,
logic = (argv.logic ? require('./' + argv.logic).logic : require('./sampleLogic').logic),
modelRoot = (argv.modelRoot ? argv.modelRoot : '/Store/TestOrg');
//Stuff going out
var storeSocket = zmq.socket('push');
var zmqStoreLocation = 'tcp://' + config.realTimeStoreZmqHost + ':' + config.realTimeStoreZmqPort;
storeSocket.connect(zmqStoreLocation);
console.log('bound to store at ' + zmqStoreLocation);
//Stuff coming in
var blpSubscriberSocket = zmq.socket('pull');
var zmqBlpLocation = 'tcp://' + config.blpServerZmqHost + ':' + config.blpServerZmqPort;
blpSubscriberSocket.bindSync(zmqBlpLocation);
console.log('listening for stream updates at ' + zmqBlpLocation);
var onNew = function(msg){
var val = JSON.parse(msg);
var _publishReceived = (new Date()).getTime();
_.forEach(val,function(evt){
evt._metadata = evt._metadata ? evt._metadata : {};
evt._metadata.perfPublishReceived = _publishReceived;
});
var updates = logic(val,modelRoot);
if(updates){
_.forEach(updates,function(update){
//tell it where to go...
if(update.path.indexOf(modelRoot) < 0){
update.path = modelRoot + update.path;
}
update.data._metadata = update.data._metadata ? update.data._metadata : {};
update.data._metadata.perfSendToStore = (new Date()).getTime();
storeSocket.send(JSON.stringify(update));
});
}
};
//'message' is the zmq event, our preferred semantics would be 'POST'
blpSubscriberSocket.on('message', onNew);
var client = http.create(config.eventServerHttpHost, config.eventServerHttpPort, 3);
client.post('/SubscribeStream',{
streamName: config.testStreamName,
protocol: 'zmq',
host: config.blpServerZmqHost,
port: config.blpServerZmqPort
}); | JediMindtrick/Hyperloop | App3_BusinessLogicProcessor/serveBLP.js | JavaScript | mit | 1,833 |
// Generated by jsScript 1.10.0
(function() {
AutoForm.hooks({
updatePassword: {
onSubmit: function(insertDoc, updateDoc, currentDoc) {
if (insertDoc["new"] !== insertDoc.confirm) {
sAlert.error('Passwords do not match');
return false;
}
Accounts.changePassword(insertDoc.old, insertDoc["new"], function(e) {
$('.btn-primary').attr('disabled', null);
if (e) {
return sAlert.error(e.message);
} else {
return sAlert.success('Password Updated');
}
});
return false;
}
}
});
Template.account.events({
'click .js-delete-account': function() {
return Meteor.call('deleteAccount', Meteor.userId());
}
});
Template.setUserName.helpers({
user: function() {
return Meteor.user();
}
});
}).call(this);
| patrickbolle/meteor-starter-purejs | client/views/account/account.js | JavaScript | mit | 879 |
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace WindowsIotLedDriver
{
// An interface used to get callbacks from the animator or in a chain of animation.
internal interface IAnimationTickListner
{
// This callback will be fired on every animation tick. The time given is the
// time since the last animation tick.
bool NotifiyAnimationTick(int timeElapsedMs);
}
}
| QuinnDamerell/WindowsIotLedDriver | WindowsIotLedDriver/Interfaces/IAnimationTickListener.cs | C# | mit | 487 |
import sys
import time as tmod
import warnings
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
sns.set()
import pandas as pd
warnings.simplefilter("ignore")
sys.path.insert(0, "../FATS/")
import FATS
iterations = 100000
lc_size = 1000
random = np.random.RandomState(42)
results = {
"StetsonK": np.empty(iterations),
"StetsonJ": np.empty(iterations),
"AndersonDarling": np.empty(iterations)}
for it in range(iterations):
fs = FATS.FeatureSpace(featureList=list(results.keys()))
# a simple time array from 0 to 99 with steps of 0.01
time = np.arange(0, 100, 100./lc_size).shape
# create 1000 magnitudes with mu 0 and std 1
mags = random.normal(size=lc_size)
# create 1000 magnitudes with difference <= 0.1% than mags
mags2 = mags * random.uniform(0, 0.01, mags.size)
# create two errors for the magnitudes equivalent to the 0.001%
# of the magnitudes
errors = random.normal(scale=0.00001, size=lc_size)
errors2 = random.normal(scale=0.00001, size=lc_size)
lc = np.array([
mags, # magnitude
time, # time
errors, # error
mags, # magnitude2
mags, # aligned_magnitude
mags, # aligned_magnitude2
time, # aligned_time
errors, # aligned_error
errors # aligned_error2
])
fs.calculateFeature(lc)
for k, v in fs.result("dict").items():
results[k][it] = v
df = pd.DataFrame(results).describe()
print df
df.to_latex("features_montecarlo.tex", float_format='%.4f')
| carpyncho/feets | res/paper/reports/features_montecarlo.py | Python | mit | 1,591 |
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
[assembly: AssemblyTitle("squareSurface")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("squareSurface")]
[assembly: AssemblyCopyright("Copyright © 2013")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
// Setting ComVisible to false makes the types in this assembly not visible
// to COM components. If you need to access a type in this assembly from
// COM, set the ComVisible attribute to true on that type.
[assembly: ComVisible(false)]
// The following GUID is for the ID of the typelib if this project is exposed to COM
[assembly: Guid("0a4f4820-8379-482d-949e-6e823a8caa1e")]
// Version information for an assembly consists of the following four values:
//
// Major Version
// Minor Version
// Build Number
// Revision
//
// You can specify all the values or you can default the Build and Revision Numbers
// by using the '*' as shown below:
// [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")]
| LazarDL/TelerikHomeworks | C#1/Operators/squareSurface/Properties/AssemblyInfo.cs | C# | mit | 1,402 |
<?php
/**
* Group
*
* This class has been auto-generated by the Doctrine ORM Framework
*
* @package LinkIgniter
* @subpackage Models
* @author YOUR_NAME_HERE <YOUR@NAME.HERE>
* @version SVN: $Id: Builder.php 7490 2010-03-29 19:53:27Z jwage $
*/
class Group extends Base_Group
{
} | linkworks/linkigniter | application/models/Group.php | PHP | mit | 302 |
#!/usr/bin/ruby
##
##Author: Shashank Mathur
##
#
require "rubygems"
require "json"
require "net/http"
require "uri"
require 'open-uri'
require 'nokogiri'
require 'thread'
require 'monitor'
require 'io/console'
require 'openssl'
#Function to Analyze URL
def analyze(url)
#Preparing to call RESTapi and json results
base_uri = "https://api.ssllabs.com/api/v2"
fanalyzeuri = URI.parse("#{base_uri}/analyze?host=#{url}&startNew=on")
analyzeuri = URI.parse("#{base_uri}/analyze?host=#{url}")
fhttp = Net::HTTP.new(fanalyzeuri.host,fanalyzeuri.port)
http = Net::HTTP.new(analyzeuri.host,analyzeuri.port)
#Using SSL
fhttp.use_ssl = true
fhttp.verify_mode = OpenSSL::SSL::VERIFY_NONE
http.use_ssl = true
http.verify_mode = OpenSSL::SSL::VERIFY_NONE
#Receiving JSON
frequest = Net::HTTP::Get.new(fanalyzeuri.request_uri)
fresponse = fhttp.request(frequest)
request = Net::HTTP::Get.new(analyzeuri.request_uri)
response = fhttp.request(request)
#Parsing JSON
result = JSON.parse(fresponse.body)
#Waiting for endpoints to generate
until result.has_key?("endpoints")
response = fhttp.request(request)
result = JSON.parse(response.body)
sleep(2)
end
#Waiting for ipaddresses to populate
result["endpoints"].each_index do |i|
until result["endpoints"][i].has_key?("ipAddress")
response = fhttp.request(request)
result = JSON.parse(response.body)
sleep(5)
end
#Check for status if ready
until result["endpoints"][i]["statusMessage"] == "Ready"
response = fhttp.request(request)
result = JSON.parse(response.body)
sleep(30)
end
end
return result
end
#Function to get warnings
def getwarnings(hostn, ipadr)
#Getting Warning lines from actual SSLlabs web page since this info is not available through api yet
doc = Nokogiri::HTML(open("https://www.ssllabs.com/ssltest/analyze.html?d=#{hostn}&s=#{ipadr}&hideResults=on"))
#Printing warnings messages
#doc.xpath("//div[contains(@class,'warningBox')]").each { |node| puts node.text}
doc.xpath("//div[contains(@class,'warningBox')]").each { |node| puts node}
end
# Function to fetch details for hosts from ssllabs
def fetchdtls(hname)
joup=analyze(hname)
puts "<table border=\"1\" style=\"border-spacing: 0px;float: left;margin: 8px; table-layout:fixed;font-family: monospace;\">"
puts "<td colspan=\"3\" style=\"text-align: center; font-size: 25px; background-color: #f1c40f; color: #0c2c40;\"><a href=\"https://www.ssllabs.com/ssltest/analyze.html?d=#{hname}&hideResults=on\" target=\"_blank\">#{hname}</a></td>"
puts "<tr><th style=\"background-color: #041317; color: #F2F2F2; font-size: 14px; font-family: sans-serif; padding: 6px 2px;\">IP</th><th style=\"background-color: #041317; color: #F2F2F2; font-size: 14px; font-family: sans-serif; padding: 6px 2px;\">Grade</th><th style=\"background-color: #041317; color: #F2F2F2; font-size: 14px; font-family: sans-serif; padding: 6px 2px;\">Warnings</th></tr>"
joup["endpoints"].each_index do |i|
puts "<tr>"
puts "<td style=\"text-align: center; padding: 15px 8px; font-size:12px; background-color: #0c2c40; color: #f1c40f; font-weight: bold; word-wrap: break-word;\">" + joup['endpoints'][i]['ipAddress'] + "</td>"
puts "<td style=\"text-align: center; padding: 15px 8px; font-size:38px; background-color: #0c2c40; color: #f1c40f; word-wrap: break-word;\">" + joup['endpoints'][i]['grade'] + "</td>"
if joup["endpoints"][i]["hasWarnings"]
puts "<td style=\"text-align: center; padding: 15px 8px; font-size:12px; background-color: #0c2c40; color: #f1c40f; word-wrap: break-word;\">"
getwarnings(hname, joup['endpoints'][i]['ipAddress'])
puts "</td>"
else
puts "<td style=\"text-align: center; padding: 15px 8px; font-size:12px; background-color: #0c2c40; color: #f1c40f; word-wrap: break-word; max-width: 100px;\">We do not have any warnings</td>"
end
end
puts "</tr>"
end
# Array containing hostnames to check. Add any hosts you want to check in the domainnames.txt file.
host = IO.readlines("domainnames.txt").map(&:chomp)
# Beginning HTML
puts "<meta http-equiv=\"Content-Type\" content=\"text/html;charset=utf-8\" />"
puts "<body bgcolor=\"#C9DCE1\">"
puts "<style> .warningBox {border: 1px solid #f1c40f; padding: 5px; background: #0c2c40; margin-top: 10px; font-weight: bold; color: #f1c40f;} </style>"
puts "<style>a:visited {color: #089994}</style>"
puts "<style>a:link {color: #3282BB}</style>"
puts "<style>table, th, td {width: 50%}</style>"
puts "<style>footer {position: absolute; bottom:0;}</style>"
#Declaring thread related variables
thread_count = 5
threads = Array.new(thread_count)
work_queue = SizedQueue.new(thread_count)
threads.extend(MonitorMixin)
threads_available = threads.new_cond
sysexit = false
# Declaring array for storing results as well as the mutex
results = Array.new
results_mutex = Mutex.new
# Creating Consumer and Producer for thread management
consumer_thread = Thread.new do
loop do
break if sysexit && work_queue.length == 0
found_index = nil
threads.synchronize do
threads_available.wait_while do
threads.select { |thread| thread.nil? || thread.status == false || thread["finished"].nil? == false}.length == 0
end
found_index = threads.rindex { |thread| thread.nil? || thread.status == false || thread["finished"].nil? == false }
end
hostn = work_queue.pop
threads[found_index] = Thread.new(hostn) do
results_mutex.synchronize do
results <<
fetchdtls(hostn)
end
Thread.current["finished"] = true
threads.synchronize do
threads_available.signal
end
end
end
end
# Getting hosts processed in threads
producer_thread = Thread.new do
host.each do |hostn|
work_queue << hostn
threads.synchronize do
threads_available.signal
end
end
sysexit = true
end
# Joining
producer_thread.join
consumer_thread.join
threads.each do |thread|
thread.join unless thread.nil?
end
# Putting output
puts results.compact
puts "<footer>"
puts "This page was generated at " + Time.now.strftime("%d/%m/%Y %H:%M")
puts "</footer>"
| shashankm/ssllabs-report | ssllabs-report.rb | Ruby | mit | 6,298 |
import { View } from '../core/view';
import { Property } from '../core/properties';
/**
* Represents an time picker.
*/
export class TimePicker extends View {
/**
* Gets the native [android.widget.TimePicker](http://developer.android.com/reference/android/widget/TimePicker.html) that represents the user interface for this component. Valid only when running on Android OS.
*/
android: any /* android.widget.TimePicker */;
/**
* Gets the native iOS [UIDatePicker](http://developer.apple.com/library/prerelease/ios/documentation/UIKit/Reference/UIDatePicker_Class/index.html) that represents the user interface for this component. Valid only when running on iOS.
*/
ios: any /* UIDatePicker */;
/**
* Gets or sets the time hour.
*/
hour: number;
/**
* Gets or sets the time minute.
*/
minute: number;
/**
* Gets or sets the time.
*/
time: Date;
/**
* Gets or sets the max time hour.
*/
maxHour: number;
/**
* Gets or sets the max time minute.
*/
maxMinute: number;
/**
* Gets or sets the min time hour.
*/
minHour: number;
/**
* Gets or sets the min time minute.
*/
minMinute: number;
/**
* Gets or sets the minute interval.
*/
minuteInterval: number;
/**
* Gets or set the UIDatePickerStyle of the date picker in iOS 13.4+. Defaults to 0.
* Valid values are numbers:
* - 0: automatic (system picks the concrete style based on the current platform and date picker mode)
* - 1: wheels (the date picker displays as a wheel picker)
* - 2: compact (the date picker displays as a label that when tapped displays a calendar-style editor)
* - 3: inline (the date pickers displays as an inline, editable field)
*/
iosPreferredDatePickerStyle: number;
}
export const hourProperty: Property<TimePicker, number>;
export const maxHourProperty: Property<TimePicker, number>;
export const minHourProperty: Property<TimePicker, number>;
export const minuteProperty: Property<TimePicker, number>;
export const maxMinuteProperty: Property<TimePicker, number>;
export const minMinuteProperty: Property<TimePicker, number>;
export const timeProperty: Property<TimePicker, Date>;
export const minuteIntervalProperty: Property<TimePicker, number>;
export const iosPreferredDatePickerStyleProperty: Property<TimePicker, number>;
| NativeScript/NativeScript | packages/core/ui/time-picker/index.d.ts | TypeScript | mit | 2,307 |
using System;
namespace NgPlateVerifier
{
public class PlateInfo
{
public string PlateNumber { get; set; }
public string Owner { get; set; }
public string Color { get; set; }
public string Model { get; set; }
public string Chasis { get; set; }
public string Status { get; set; }
public DateTime LicenseIssueDate { get; set; }
public DateTime LicenseExpiryDate { get; set; }
}
} | matmape/ngPlateNumberVerifier | PlateInfo.cs | C# | mit | 455 |
import React, { Component } from 'react';
import {
AppRegistry,
StyleSheet,
Container,
TextInput,
Label,
Text,
View,
Button,
} from 'react-native';
import LoginScreen from './Login.js';
import RegisterScreen from './Register.js';
import { StackNavigator, TabNavigator } from 'react-navigation';
export default class UserControlScreen extends Component {
loginView(){
this.setState({view: <LoginScreen /> })
}
constructor(){
super()
this.loginView = this.loginView.bind(this)
this.state = {
view: <RegisterScreen press={this.loginView} />
}
}
render(){
return (
<View>
</View>
)
}
}
| nyc-fiery-skippers-2017/AwesomeProject | Users/UserControl.js | JavaScript | mit | 671 |
require "spec_helper"
RSpec.describe Realms::Cards::TradingPost do
include_examples "type", :outpost
include_examples "defense", 4
include_examples "factions", :trade_federation
include_examples "cost", 3
describe "#primary_ability" do
include_context "base_ability" do
before do
game.base_ability(card)
end
end
context "authority" do
it { expect { game.decide(:trading_post, :authority) }.to change { game.active_player.authority }.by(1) }
end
context "trade" do
it { expect { game.decide(:trading_post, :trade) }.to change { game.active_turn.trade }.by(1) }
end
end
describe "#scrap_ability" do
include_context "scrap_ability"
it { expect { game.scrap_ability(card) }.to change { game.active_turn.combat }.by(3) }
end
end
| tonywok/realms | spec/cards/trading_post_spec.rb | Ruby | mit | 809 |
import path from 'path';
const {
SupRuntime,
} = global;
SupRuntime.registerPlugin('dependencyBundle', {
loadAsset(player, asset, callback) {
window.__dependencyBundles = window.__dependencyBundles || {};
const bundleScript = document.createElement('SCRIPT');
bundleScript.addEventListener('load', () => {
callback(null, window.__dependencyBundles[asset.id]);
});
bundleScript.src = path.join(player.dataURL, 'assets', asset.storagePath, 'bundle.js');
document.body.appendChild(bundleScript);
},
});
| antca/superpowers-package-manager-plugin | src/runtime/index.js | JavaScript | mit | 538 |
let path = document.location.pathname,
details,
login,
url;
if (m = path.match(/^\/([\w-]+)\??.*?/)) {
login = m[1].trim();
if (-1 === ['timeline', 'languages', 'blog', 'explore'].indexOf(login)) {
url = 'http://coderstats.net/github#' + login;
details = document.getElementsByClassName('vcard-details');
if (details.length > 0) {
addLink();
}
}
}
function addLink() {
let li = document.createElement('li');
li.setAttribute('id', 'coderstats');
li.setAttribute('class', 'vcard-detail pt-1');
li.setAttribute('itemprop', 'url');
let span = document.createElement('span');
span.setAttribute('class', 'octicon');
span.setAttribute('style', 'margin-top:-2px;');
span.textContent = "📊";
li.appendChild(span)
let a = document.createElement('a');
a.setAttribute('href', url);
a.textContent = "CoderStats('" + login + "')";
li.appendChild(a);
details[0].appendChild(li);
} | coderstats/fxt_coderstats | coderstats/coderstats.js | JavaScript | mit | 997 |
using System;
using System.Runtime.InteropServices;
namespace Vanara.PInvoke
{
public static partial class Kernel32
{
/// <summary>The memory allocation attributes.</summary>
[Flags]
public enum GMEM
{
/// <summary>Combines GMEM_MOVEABLE and GMEM_ZEROINIT.</summary>
GHND = 0x0042,
/// <summary>Allocates fixed memory. The return value is a pointer.</summary>
GMEM_FIXED = 0x0000,
/// <summary>
/// Allocates movable memory. Memory blocks are never moved in physical memory, but they can be moved within the default heap.
/// <para>The return value is a handle to the memory object. To translate the handle into a pointer, use the GlobalLock function.</para>
/// <para>This value cannot be combined with GMEM_FIXED.</para>
/// </summary>
GMEM_MOVEABLE = 0x0002,
/// <summary>Initializes memory contents to zero.</summary>
GMEM_ZEROINIT = 0x0040,
/// <summary>Combines GMEM_FIXED and GMEM_ZEROINIT.</summary>
GPTR = 0x0040,
/// <summary>
/// The function modifies the attributes of the memory object only (the dwBytes parameter is ignored). This value can only be
/// used with <see cref="GlobalReAlloc"/>.
/// </summary>
GMEM_MODIFY = 0x0080,
}
/// <summary>The memory allocation attributes.</summary>
[PInvokeData("MinWinBase.h")]
[Flags]
public enum LMEM
{
/// <summary>Allocates fixed memory. The return value is a pointer to the memory object.</summary>
LMEM_FIXED = 0x0000,
/// <summary>
/// Allocates movable memory. Memory blocks are never moved in physical memory, but they can be moved within the default heap.
/// The return value is a handle to the memory object. To translate the handle to a pointer, use the LocalLock function. This
/// value cannot be combined with LMEM_FIXED.
/// </summary>
LMEM_MOVEABLE = 0x0002,
/// <summary>Obsolete.</summary>
[Obsolete]
LMEM_NOCOMPACT = 0x0010,
/// <summary>Obsolete.</summary>
[Obsolete]
LMEM_NODISCARD = 0x0020,
/// <summary>Initializes memory contents to zero.</summary>
LMEM_ZEROINIT = 0x0040,
/// <summary>
/// If the LMEM_MODIFY flag is specified in LocalReAlloc, this parameter modifies the attributes of the memory object, and the
/// uBytes parameter is ignored.
/// </summary>
LMEM_MODIFY = 0x0080,
/// <summary>Obsolete.</summary>
[Obsolete]
LMEM_DISCARDABLE = 0x0F00,
/// <summary>Valid flags.</summary>
LMEM_VALID_FLAGS = 0x0F72,
/// <summary>Indicates that the local handle is not valid</summary>
LMEM_INVALID_HANDLE = 0x8000,
/// <summary>Combines LMEM_MOVEABLE and LMEM_ZEROINIT.</summary>
LHND = LMEM_MOVEABLE | LMEM_ZEROINIT,
/// <summary>Combines LMEM_FIXED and LMEM_ZEROINIT.</summary>
LPTR = LMEM_FIXED | LMEM_ZEROINIT,
/// <summary>Same as LMEM_MOVEABLE.</summary>
NONZEROLHND = LMEM_MOVEABLE,
/// <summary>Same as LMEM_FIXED.</summary>
NONZEROLPTR = LMEM_FIXED
}
/// <summary>Allocates the specified number of bytes from the heap.</summary>
/// <param name="uFlags">
/// <para>
/// The memory allocation attributes. If zero is specified, the default is <c>GMEM_FIXED</c>. This parameter can be one or more of
/// the following values, except for the incompatible combinations that are specifically noted.
/// </para>
/// <para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>GHND0x0042</term>
/// <term>Combines GMEM_MOVEABLE and GMEM_ZEROINIT.</term>
/// </item>
/// <item>
/// <term>GMEM_FIXED0x0000</term>
/// <term>Allocates fixed memory. The return value is a pointer.</term>
/// </item>
/// <item>
/// <term>GMEM_MOVEABLE0x0002</term>
/// <term>
/// Allocates movable memory. Memory blocks are never moved in physical memory, but they can be moved within the default heap.The
/// return value is a handle to the memory object. To translate the handle into a pointer, use the GlobalLock function.This value
/// cannot be combined with GMEM_FIXED.
/// </term>
/// </item>
/// <item>
/// <term>GMEM_ZEROINIT0x0040</term>
/// <term>Initializes memory contents to zero.</term>
/// </item>
/// <item>
/// <term>GPTR0x0040</term>
/// <term>Combines GMEM_FIXED and GMEM_ZEROINIT.</term>
/// </item>
/// </list>
/// </para>
/// <para>The following values are obsolete, but are provided for compatibility with 16-bit Windows. They are ignored.</para>
/// </param>
/// <param name="dwBytes">
/// The number of bytes to allocate. If this parameter is zero and the uFlags parameter specifies <c>GMEM_MOVEABLE</c>, the function
/// returns a handle to a memory object that is marked as discarded.
/// </param>
/// <returns>
/// <para>If the function succeeds, the return value is a handle to the newly allocated memory object.</para>
/// <para>If the function fails, the return value is <c>NULL</c>. To get extended error information, call <c>GetLastError</c>.</para>
/// </returns>
// HGLOBAL WINAPI GlobalAlloc( _In_ UINT uFlags, _In_ SIZE_T dwBytes); https://msdn.microsoft.com/en-us/library/windows/desktop/aa366574(v=vs.85).aspx
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true)]
[PInvokeData("WinBase.h", MSDNShortId = "aa366574")]
public static extern HGLOBAL GlobalAlloc(GMEM uFlags, SizeT dwBytes);
/// <summary>Retrieves information about the specified global memory object.</summary>
/// <param name="hMem">
/// A handle to the global memory object. This handle is returned by either the <c>GlobalAlloc</c> or <c>GlobalReAlloc</c> function.
/// </param>
/// <returns>
/// <para>If the function succeeds, the return value specifies the allocation values and the lock count for the memory object.</para>
/// <para>
/// If the function fails, the return value is <c>GMEM_INVALID_HANDLE</c>, indicating that the global handle is not valid. To get
/// extended error information, call <c>GetLastError</c>.
/// </para>
/// </returns>
// UINT WINAPI GlobalFlags( _In_ HGLOBAL hMem); https://msdn.microsoft.com/en-us/library/windows/desktop/aa366577(v=vs.85).aspx
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true)]
[PInvokeData("WinBase.h", MSDNShortId = "aa366577")]
public static extern GMEM GlobalFlags([In] HGLOBAL hMem);
/// <summary>Frees the specified global memory object and invalidates its handle.</summary>
/// <param name="hMem">
/// A handle to the global memory object. This handle is returned by either the <c>GlobalAlloc</c> or <c>GlobalReAlloc</c> function.
/// It is not safe to free memory allocated with <c>LocalAlloc</c>.
/// </param>
/// <returns>
/// <para>If the function succeeds, the return value is <c>NULL</c>.</para>
/// <para>
/// If the function fails, the return value is equal to a handle to the global memory object. To get extended error information, call <c>GetLastError</c>.
/// </para>
/// </returns>
// HGLOBAL WINAPI GlobalFree( _In_ HGLOBAL hMem); https://msdn.microsoft.com/en-us/library/windows/desktop/aa366579(v=vs.85).aspx
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true)]
[PInvokeData("WinBase.h", MSDNShortId = "aa366579")]
public static extern HGLOBAL GlobalFree(HGLOBAL hMem);
/// <summary>Retrieves the handle associated with the specified pointer to a global memory block.</summary>
/// <param name="pMem">
/// A pointer to the first byte of the global memory block. This pointer is returned by the <c>GlobalLock</c> function.
/// </param>
/// <returns>
/// <para>If the function succeeds, the return value is a handle to the specified global memory object.</para>
/// <para>If the function fails, the return value is <c>NULL</c>. To get extended error information, call <c>GetLastError</c>.</para>
/// </returns>
// HGLOBAL WINAPI GlobalHandle( _In_ LPCVOID pMem); https://msdn.microsoft.com/en-us/library/windows/desktop/aa366582(v=vs.85).aspx
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true)]
[PInvokeData("WinBase.h", MSDNShortId = "aa366582")]
public static extern HGLOBAL GlobalHandle([In] IntPtr pMem);
/// <summary>
/// <para>Locks a global memory object and returns a pointer to the first byte of the object's memory block.</para>
/// <para>
/// <c>Note</c> The global functions have greater overhead and provide fewer features than other memory management functions. New
/// applications should use the heap functions unless documentation states that a global function should be used. For more
/// information, see Global and Local Functions.
/// </para>
/// </summary>
/// <param name="hMem">
/// <para>A handle to the global memory object. This handle is returned by either the GlobalAlloc or GlobalReAlloc function.</para>
/// </param>
/// <returns>
/// <para>If the function succeeds, the return value is a pointer to the first byte of the memory block.</para>
/// <para>If the function fails, the return value is <c>NULL</c>. To get extended error information, call GetLastError.</para>
/// </returns>
/// <remarks>
/// <para>
/// The internal data structures for each memory object include a lock count that is initially zero. For movable memory objects,
/// <c>GlobalLock</c> increments the count by one, and the GlobalUnlock function decrements the count by one. Each successful call
/// that a process makes to <c>GlobalLock</c> for an object must be matched by a corresponding call to <c>GlobalUnlock</c>. Locked
/// memory will not be moved or discarded, unless the memory object is reallocated by using the GlobalReAlloc function. The memory
/// block of a locked memory object remains locked until its lock count is decremented to zero, at which time it can be moved or discarded.
/// </para>
/// <para>
/// Memory objects allocated with <c>GMEM_FIXED</c> always have a lock count of zero. For these objects, the value of the returned
/// pointer is equal to the value of the specified handle.
/// </para>
/// <para>If the specified memory block has been discarded or if the memory block has a zero-byte size, this function returns <c>NULL</c>.</para>
/// <para>Discarded objects always have a lock count of zero.</para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/desktop/api/winbase/nf-winbase-globallock LPVOID GlobalLock( HGLOBAL hMem );
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true)]
[PInvokeData("winbase.h", MSDNShortId = "0d7deac2-c9c4-4adc-8a0a-edfc512a4d6c")]
public static extern IntPtr GlobalLock(HGLOBAL hMem);
/// <summary>Changes the size or attributes of a specified global memory object. The size can increase or decrease.</summary>
/// <param name="hMem">
/// A handle to the global memory object to be reallocated. This handle is returned by either the <c>GlobalAlloc</c> or
/// <c>GlobalReAlloc</c> function.
/// </param>
/// <param name="dwBytes">
/// The new size of the memory block, in bytes. If uFlags specifies <c>GMEM_MODIFY</c>, this parameter is ignored.
/// </param>
/// <param name="uFlags">
/// <para>
/// The reallocation options. If <c>GMEM_MODIFY</c> is specified, the function modifies the attributes of the memory object only (the
/// dwBytes parameter is ignored.) Otherwise, the function reallocates the memory object.
/// </para>
/// <para>You can optionally combine <c>GMEM_MODIFY</c> with the following value.</para>
/// <para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>GMEM_MOVEABLE0x0002</term>
/// <term>
/// Allocates movable memory.If the memory is a locked GMEM_MOVEABLE memory block or a GMEM_FIXED memory block and this flag is not
/// specified, the memory can only be reallocated in place.
/// </term>
/// </item>
/// </list>
/// </para>
/// <para>If this parameter does not specify <c>GMEM_MODIFY</c>, you can use the following value.</para>
/// <para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>GMEM_ZEROINIT0x0040</term>
/// <term>Causes the additional memory contents to be initialized to zero if the memory object is growing in size.</term>
/// </item>
/// </list>
/// </para>
/// </param>
/// <returns>
/// <para>If the function succeeds, the return value is a handle to the reallocated memory object.</para>
/// <para>If the function fails, the return value is <c>NULL</c>. To get extended error information, call <c>GetLastError</c>.</para>
/// </returns>
// HGLOBAL WINAPI GlobalReAlloc( _In_ HGLOBAL hMem, _In_ SIZE_T dwBytes, _In_ UINT uFlags); https://msdn.microsoft.com/en-us/library/windows/desktop/aa366590(v=vs.85).aspx
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true)]
[PInvokeData("WinBase.h", MSDNShortId = "aa366590")]
public static extern HGLOBAL GlobalReAlloc([In] HGLOBAL hMem, SizeT dwBytes, GMEM uFlags);
/// <summary>Retrieves the current size of the specified global memory object, in bytes.</summary>
/// <param name="hMem">
/// A handle to the global memory object. This handle is returned by either the <c>GlobalAlloc</c> or <c>GlobalReAlloc</c> function.
/// </param>
/// <returns>
/// <para>If the function succeeds, the return value is the size of the specified global memory object, in bytes.</para>
/// <para>
/// If the specified handle is not valid or if the object has been discarded, the return value is zero. To get extended error
/// information, call <c>GetLastError</c>.
/// </para>
/// </returns>
// SIZE_T WINAPI GlobalSize( _In_ HGLOBAL hMem); https://msdn.microsoft.com/en-us/library/windows/desktop/aa366593(v=vs.85).aspx
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true)]
[PInvokeData("WinBase.h", MSDNShortId = "aa366593")]
public static extern SizeT GlobalSize([In] HGLOBAL hMem);
/// <summary>
/// <para>
/// Decrements the lock count associated with a memory object that was allocated with <c>GMEM_MOVEABLE</c>. This function has no
/// effect on memory objects allocated with <c>GMEM_FIXED</c>.
/// </para>
/// <para>
/// <c>Note</c> The global functions have greater overhead and provide fewer features than other memory management functions. New
/// applications should use the heap functions unless documentation states that a global function should be used. For more
/// information, see Global and Local Functions.
/// </para>
/// </summary>
/// <param name="hMem">
/// <para>A handle to the global memory object. This handle is returned by either the GlobalAlloc or GlobalReAlloc function.</para>
/// </param>
/// <returns>
/// <para>
/// If the memory object is still locked after decrementing the lock count, the return value is a nonzero value. If the memory object
/// is unlocked after decrementing the lock count, the function returns zero and GetLastError returns <c>NO_ERROR</c>.
/// </para>
/// <para>If the function fails, the return value is zero and GetLastError returns a value other than <c>NO_ERROR</c>.</para>
/// </returns>
/// <remarks>
/// <para>
/// The internal data structures for each memory object include a lock count that is initially zero. For movable memory objects, the
/// GlobalLock function increments the count by one, and <c>GlobalUnlock</c> decrements the count by one. For each call that a
/// process makes to <c>GlobalLock</c> for an object, it must eventually call <c>GlobalUnlock</c>. Locked memory will not be moved or
/// discarded, unless the memory object is reallocated by using the GlobalReAlloc function. The memory block of a locked memory
/// object remains locked until its lock count is decremented to zero, at which time it can be moved or discarded.
/// </para>
/// <para>
/// Memory objects allocated with <c>GMEM_FIXED</c> always have a lock count of zero. If the specified memory block is fixed memory,
/// this function returns <c>TRUE</c>.
/// </para>
/// <para>If the memory object is already unlocked, <c>GlobalUnlock</c> returns <c>FALSE</c> and GetLastError reports <c>ERROR_NOT_LOCKED</c>.</para>
/// <para>
/// A process should not rely on the return value to determine the number of times it must subsequently call <c>GlobalUnlock</c> for
/// a memory object.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/desktop/api/winbase/nf-winbase-globalunlock BOOL GlobalUnlock( HGLOBAL hMem );
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true)]
[PInvokeData("winbase.h", MSDNShortId = "580a2873-7f06-47a1-acf5-c2b3c96e15e7")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool GlobalUnlock(HGLOBAL hMem);
/// <summary>Determines whether the calling process has read access to the memory at the specified address.</summary>
/// <param name="lpfn">A pointer to a memory address.</param>
/// <returns>
/// <para>If the calling process has read access to the specified memory, the return value is zero.</para>
/// <para>
/// If the calling process does not have read access to the specified memory, the return value is nonzero. To get extended error
/// information, call <c>GetLastError</c>.
/// </para>
/// <para>
/// If the application is compiled as a debugging version, and the process does not have read access to the specified memory
/// location, the function causes an assertion and breaks into the debugger. Leaving the debugger, the function continues as usual,
/// and returns a nonzero value. This behavior is by design, as a debugging aid.
/// </para>
/// </returns>
// BOOL WINAPI IsBadCodePtr( _In_ FARPROC lpfn); https://msdn.microsoft.com/en-us/library/windows/desktop/aa366712(v=vs.85).aspx
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true)]
[PInvokeData("WinBase.h", MSDNShortId = "aa366712")]
[Obsolete("This function is obsolete and should not be used. Despite its name, it does not guarantee that the pointer is valid or that the memory pointed to is safe to use.")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool IsBadCodePtr(IntPtr lpfn);
/// <summary>Verifies that the calling process has read access to the specified range of memory.</summary>
/// <param name="lp">A pointer to the first byte of the memory block.</param>
/// <param name="ucb">The size of the memory block, in bytes. If this parameter is zero, the return value is zero.</param>
/// <returns>
/// <para>If the calling process has read access to all bytes in the specified memory range, the return value is zero.</para>
/// <para>If the calling process does not have read access to all bytes in the specified memory range, the return value is nonzero.</para>
/// <para>
/// If the application is compiled as a debugging version, and the process does not have read access to all bytes in the specified
/// memory range, the function causes an assertion and breaks into the debugger. Leaving the debugger, the function continues as
/// usual, and returns a nonzero value. This behavior is by design, as a debugging aid.
/// </para>
/// </returns>
// BOOL WINAPI IsBadReadPtr( _In_ const VOID *lp, _In_ UINT_PTR ucb); https://msdn.microsoft.com/en-us/library/windows/desktop/aa366713(v=vs.85).aspx
[DllImport(Lib.Kernel32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("WinBase.h", MSDNShortId = "aa366713")]
[Obsolete("This function is obsolete and should not be used. Despite its name, it does not guarantee that the pointer is valid or that the memory pointed to is safe to use.")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool IsBadReadPtr([In] IntPtr lp, SizeT ucb);
/// <summary>Verifies that the calling process has read access to the specified range of memory.</summary>
/// <param name="lpsz">A pointer to a null-terminated string, either Unicode or ASCII.</param>
/// <param name="ucchMax">
/// The maximum size of the string, in <c>TCHARs</c>. The function checks for read access in all characters up to the string's
/// terminating null character or up to the number of characters specified by this parameter, whichever is smaller. If this parameter
/// is zero, the return value is zero.
/// </param>
/// <returns>
/// <para>
/// If the calling process has read access to all characters up to the string's terminating null character or up to the number of
/// characters specified by ucchMax, the return value is zero.
/// </para>
/// <para>
/// If the calling process does not have read access to all characters up to the string's terminating null character or up to the
/// number of characters specified by ucchMax, the return value is nonzero.
/// </para>
/// <para>
/// If the application is compiled as a debugging version, and the process does not have read access to the entire memory range
/// specified, the function causes an assertion and breaks into the debugger. Leaving the debugger, the function continues as usual,
/// and returns a nonzero value This behavior is by design, as a debugging aid.
/// </para>
/// </returns>
// BOOL WINAPI IsBadStringPtr( _In_ LPCTSTR lpsz, _In_ UINT_PTR ucchMax); https://msdn.microsoft.com/en-us/library/windows/desktop/aa366714(v=vs.85).aspx
[DllImport(Lib.Kernel32, SetLastError = false, CharSet = CharSet.Auto)]
[PInvokeData("WinBase.h", MSDNShortId = "aa366714")]
[Obsolete("This function is obsolete and should not be used. Despite its name, it does not guarantee that the pointer is valid or that the memory pointed to is safe to use.")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool IsBadStringPtr(string lpsz, SizeT ucchMax);
/// <summary>Verifies that the calling process has write access to the specified range of memory.</summary>
/// <param name="lp">A pointer to the first byte of the memory block.</param>
/// <param name="ucb">The size of the memory block, in bytes. If this parameter is zero, the return value is zero.</param>
/// <returns>
/// <para>If the calling process has write access to all bytes in the specified memory range, the return value is zero.</para>
/// <para>If the calling process does not have write access to all bytes in the specified memory range, the return value is nonzero.</para>
/// <para>
/// If the application is run under a debugger and the process does not have write access to all bytes in the specified memory range,
/// the function causes a first chance STATUS_ACCESS_VIOLATION exception. The debugger can be configured to break for this condition.
/// After resuming process execution in the debugger, the function continues as usual and returns a nonzero value This behavior is by
/// design and serves as a debugging aid.
/// </para>
/// </returns>
// BOOL WINAPI IsBadWritePtr( _In_ LPVOID lp, _In_ UINT_PTR ucb); https://msdn.microsoft.com/en-us/library/windows/desktop/aa366716(v=vs.85).aspx
[DllImport(Lib.Kernel32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("WinBase.h", MSDNShortId = "aa366716")]
[Obsolete("This function is obsolete and should not be used. Despite its name, it does not guarantee that the pointer is valid or that the memory pointed to is safe to use.")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool IsBadWritePtr([In] IntPtr lp, SizeT ucb);
/// <summary>
/// <para>Allocates the specified number of bytes from the heap.</para>
/// <para>
/// <c>Note</c> The local functions have greater overhead and provide fewer features than other memory management functions. New
/// applications should use the heap functions unless documentation states that a local function should be used. For more
/// information, see Global and Local Functions.
/// </para>
/// </summary>
/// <param name="uFlags">
/// <para>
/// The memory allocation attributes. The default is the <c>LMEM_FIXED</c> value. This parameter can be one or more of the following
/// values, except for the incompatible combinations that are specifically noted.
/// </para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>LHND 0x0042</term>
/// <term>Combines LMEM_MOVEABLE and LMEM_ZEROINIT.</term>
/// </item>
/// <item>
/// <term>LMEM_FIXED 0x0000</term>
/// <term>Allocates fixed memory. The return value is a pointer to the memory object.</term>
/// </item>
/// <item>
/// <term>LMEM_MOVEABLE 0x0002</term>
/// <term>
/// Allocates movable memory. Memory blocks are never moved in physical memory, but they can be moved within the default heap. The
/// return value is a handle to the memory object. To translate the handle to a pointer, use the LocalLock function. This value
/// cannot be combined with LMEM_FIXED.
/// </term>
/// </item>
/// <item>
/// <term>LMEM_ZEROINIT 0x0040</term>
/// <term>Initializes memory contents to zero.</term>
/// </item>
/// <item>
/// <term>LPTR 0x0040</term>
/// <term>Combines LMEM_FIXED and LMEM_ZEROINIT.</term>
/// </item>
/// <item>
/// <term>NONZEROLHND</term>
/// <term>Same as LMEM_MOVEABLE.</term>
/// </item>
/// <item>
/// <term>NONZEROLPTR</term>
/// <term>Same as LMEM_FIXED.</term>
/// </item>
/// </list>
/// <para>The following values are obsolete, but are provided for compatibility with 16-bit Windows. They are ignored.</para>
/// </param>
/// <param name="uBytes">
/// <para>
/// The number of bytes to allocate. If this parameter is zero and the uFlags parameter specifies <c>LMEM_MOVEABLE</c>, the function
/// returns a handle to a memory object that is marked as discarded.
/// </para>
/// </param>
/// <returns>
/// <para>If the function succeeds, the return value is a handle to the newly allocated memory object.</para>
/// <para>If the function fails, the return value is <c>NULL</c>. To get extended error information, call GetLastError.</para>
/// </returns>
/// <remarks>
/// <para>
/// Windows memory management does not provide a separate local heap and global heap. Therefore, the <c>LocalAlloc</c> and
/// GlobalAlloc functions are essentially the same.
/// </para>
/// <para>
/// The movable-memory flags <c>LHND</c>, <c>LMEM_MOVABLE</c>, and <c>NONZEROLHND</c> add unnecessary overhead and require locking to
/// be used safely. They should be avoided unless documentation specifically states that they should be used.
/// </para>
/// <para>
/// New applications should use the heap functions unless the documentation specifically states that a local function should be used.
/// For example, some Windows functions allocate memory that must be freed with LocalFree.
/// </para>
/// <para>
/// If the heap does not contain sufficient free space to satisfy the request, <c>LocalAlloc</c> returns <c>NULL</c>. Because
/// <c>NULL</c> is used to indicate an error, virtual address zero is never allocated. It is, therefore, easy to detect the use of a
/// <c>NULL</c> pointer.
/// </para>
/// <para>
/// If the <c>LocalAlloc</c> function succeeds, it allocates at least the amount requested. If the amount allocated is greater than
/// the amount requested, the process can use the entire amount. To determine the actual number of bytes allocated, use the LocalSize function.
/// </para>
/// <para>To free the memory, use the LocalFree function. It is not safe to free memory allocated with <c>LocalAlloc</c> using GlobalFree.</para>
/// <para>Examples</para>
/// <para>The following code shows a simple use of <c>LocalAlloc</c> and LocalFree.</para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/desktop/api/winbase/nf-winbase-localalloc DECLSPEC_ALLOCATOR HLOCAL LocalAlloc( UINT
// uFlags, SIZE_T uBytes );
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true)]
[PInvokeData("winbase.h", MSDNShortId = "da8cd2be-ff4c-4da5-813c-8759a58228c9")]
public static extern HLOCAL LocalAlloc(LMEM uFlags, SizeT uBytes);
/// <summary>Retrieves information about the specified local memory object.</summary>
/// <param name="hMem">
/// A handle to the local memory object. This handle is returned by either the <c>LocalAlloc</c> or <c>LocalReAlloc</c> function.
/// </param>
/// <returns>
/// <para>If the function succeeds, the return value specifies the allocation values and the lock count for the memory object.</para>
/// <para>
/// If the function fails, the return value is <c>LMEM_INVALID_HANDLE</c>, indicating that the local handle is not valid. To get
/// extended error information, call <c>GetLastError</c>.
/// </para>
/// </returns>
// UINT WINAPI LocalFlags( _In_ HLOCAL hMem); https://msdn.microsoft.com/en-us/library/windows/desktop/aa366728(v=vs.85).aspx
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true)]
[PInvokeData("WinBase.h", MSDNShortId = "aa366728")]
public static extern LMEM LocalFlags([In] HLOCAL hMem);
/// <summary>
/// <para>Frees the specified local memory object and invalidates its handle.</para>
/// <para>
/// <c>Note</c> The local functions have greater overhead and provide fewer features than other memory management functions. New
/// applications should use the heap functions unless documentation states that a local function should be used. For more
/// information, see Global and Local Functions.
/// </para>
/// </summary>
/// <param name="hMem">
/// <para>
/// A handle to the local memory object. This handle is returned by either the LocalAlloc or LocalReAlloc function. It is not safe to
/// free memory allocated with GlobalAlloc.
/// </para>
/// </param>
/// <returns>
/// <para>If the function succeeds, the return value is <c>NULL</c>.</para>
/// <para>
/// If the function fails, the return value is equal to a handle to the local memory object. To get extended error information, call GetLastError.
/// </para>
/// </returns>
/// <remarks>
/// <para>
/// If the process tries to examine or modify the memory after it has been freed, heap corruption may occur or an access violation
/// exception (EXCEPTION_ACCESS_VIOLATION) may be generated.
/// </para>
/// <para>If the hMem parameter is <c>NULL</c>, <c>LocalFree</c> ignores the parameter and returns <c>NULL</c>.</para>
/// <para>
/// The <c>LocalFree</c> function will free a locked memory object. A locked memory object has a lock count greater than zero. The
/// LocalLock function locks a local memory object and increments the lock count by one. The LocalUnlock function unlocks it and
/// decrements the lock count by one. To get the lock count of a local memory object, use the LocalFlags function.
/// </para>
/// <para>
/// If an application is running under a debug version of the system, <c>LocalFree</c> will issue a message that tells you that a
/// locked object is being freed. If you are debugging the application, <c>LocalFree</c> will enter a breakpoint just before freeing
/// a locked object. This allows you to verify the intended behavior, then continue execution.
/// </para>
/// <para>Examples</para>
/// <para>For an example, see LocalAlloc.</para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/desktop/api/winbase/nf-winbase-localfree HLOCAL LocalFree( _Frees_ptr_opt_ HLOCAL hMem );
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true)]
[PInvokeData("winbase.h", MSDNShortId = "a0393983-cb43-4dfa-91a6-d82a5fb8de12")]
public static extern HLOCAL LocalFree(HLOCAL hMem);
/// <summary>Retrieves the handle associated with the specified pointer to a local memory object.</summary>
/// <param name="pMem">
/// A pointer to the first byte of the local memory object. This pointer is returned by the <c>LocalLock</c> function.
/// </param>
/// <returns>
/// <para>If the function succeeds, the return value is a handle to the specified local memory object.</para>
/// <para>If the function fails, the return value is <c>NULL</c>. To get extended error information, call <c>GetLastError</c>.</para>
/// </returns>
// HLOCAL WINAPI LocalHandle( _In_ LPCVOID pMem); https://msdn.microsoft.com/en-us/library/windows/desktop/aa366733(v=vs.85).aspx
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true)]
[PInvokeData("WinBase.h", MSDNShortId = "aa366733")]
public static extern HLOCAL LocalHandle([In] IntPtr pMem);
/// <summary>Locks a local memory object and returns a pointer to the first byte of the object's memory block.</summary>
/// <param name="hMem">
/// A handle to the local memory object. This handle is returned by either the <c>LocalAlloc</c> or <c>LocalReAlloc</c> function.
/// </param>
/// <returns>
/// <para>If the function succeeds, the return value is a pointer to the first byte of the memory block.</para>
/// <para>If the function fails, the return value is <c>NULL</c>. To get extended error information, call <c>GetLastError</c>.</para>
/// </returns>
// LPVOID WINAPI LocalLock( _In_ HLOCAL hMem); https://msdn.microsoft.com/en-us/library/windows/desktop/aa366737(v=vs.85).aspx
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true)]
[PInvokeData("WinBase.h", MSDNShortId = "aa366737")]
public static extern IntPtr LocalLock([In] HLOCAL hMem);
/// <summary>
/// <para>Changes the size or the attributes of a specified local memory object. The size can increase or decrease.</para>
/// <para>
/// <c>Note</c> The local functions have greater overhead and provide fewer features than other memory management functions. New
/// applications should use the heap functions unless documentation states that a local function should be used. For more
/// information, see Global and Local Functions.
/// </para>
/// </summary>
/// <param name="hMem">
/// <para>
/// A handle to the local memory object to be reallocated. This handle is returned by either the LocalAlloc or <c>LocalReAlloc</c> function.
/// </para>
/// </param>
/// <param name="uBytes">
/// <para>The new size of the memory block, in bytes. If uFlags specifies <c>LMEM_MODIFY</c>, this parameter is ignored.</para>
/// </param>
/// <param name="uFlags">
/// <para>
/// The reallocation options. If <c>LMEM_MODIFY</c> is specified, the function modifies the attributes of the memory object only (the
/// uBytes parameter is ignored.) Otherwise, the function reallocates the memory object.
/// </para>
/// <para>You can optionally combine <c>LMEM_MODIFY</c> with the following value.</para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>LMEM_MOVEABLE 0x0002</term>
/// <term>
/// Allocates fixed or movable memory. If the memory is a locked LMEM_MOVEABLE memory block or a LMEM_FIXED memory block and this
/// flag is not specified, the memory can only be reallocated in place.
/// </term>
/// </item>
/// </list>
/// <para>If this parameter does not specify <c>LMEM_MODIFY</c>, you can use the following value.</para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>LMEM_ZEROINIT 0x0040</term>
/// <term>Causes the additional memory contents to be initialized to zero if the memory object is growing in size.</term>
/// </item>
/// </list>
/// </param>
/// <returns>
/// <para>If the function succeeds, the return value is a handle to the reallocated memory object.</para>
/// <para>If the function fails, the return value is <c>NULL</c>. To get extended error information, call GetLastError.</para>
/// </returns>
/// <remarks>
/// <para>If <c>LocalReAlloc</c> fails, the original memory is not freed, and the original handle and pointer are still valid.</para>
/// <para>
/// If <c>LocalReAlloc</c> reallocates a fixed object, the value of the handle returned is the address of the first byte of the
/// memory block. To access the memory, a process can simply cast the return value to a pointer.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/desktop/api/winbase/nf-winbase-localrealloc DECLSPEC_ALLOCATOR HLOCAL LocalReAlloc(
// _Frees_ptr_opt_ HLOCAL hMem, SIZE_T uBytes, UINT uFlags );
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true)]
[PInvokeData("winbase.h", MSDNShortId = "88527ddd-e0c2-4a41-825e-d3a6df77fd2a")]
public static extern HLOCAL LocalReAlloc(HLOCAL hMem, SizeT uBytes, LMEM uFlags);
/// <summary>
/// <para>Retrieves the current size of the specified local memory object, in bytes.</para>
/// <para>
/// <c>Note</c> The local functions have greater overhead and provide fewer features than other memory management functions. New
/// applications should use the heap functions unless documentation states that a local function should be used. For more
/// information, see Global and Local Functions.
/// </para>
/// </summary>
/// <param name="hMem">
/// <para>A handle to the local memory object. This handle is returned by the LocalAlloc, LocalReAlloc, or LocalHandle function.</para>
/// </param>
/// <returns>
/// <para>
/// If the function succeeds, the return value is the size of the specified local memory object, in bytes. If the specified handle is
/// not valid or if the object has been discarded, the return value is zero. To get extended error information, call GetLastError.
/// </para>
/// </returns>
/// <remarks>
/// <para>The size of a memory block may be larger than the size requested when the memory was allocated.</para>
/// <para>
/// To verify that the specified object's memory block has not been discarded, call the LocalFlags function before calling <c>LocalSize</c>.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/desktop/api/winbase/nf-winbase-localsize SIZE_T LocalSize( HLOCAL hMem );
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true)]
[PInvokeData("winbase.h", MSDNShortId = "d1337845-d89c-4cd5-a584-36fe0c682c1a")]
public static extern SizeT LocalSize(HLOCAL hMem);
/// <summary>
/// Decrements the lock count associated with a memory object that was allocated with <c>LMEM_MOVEABLE</c>. This function has no
/// effect on memory objects allocated with <c>LMEM_FIXED</c>.
/// </summary>
/// <param name="hMem">
/// A handle to the local memory object. This handle is returned by either the <c>LocalAlloc</c> or <c>LocalReAlloc</c> function.
/// </param>
/// <returns>
/// <para>
/// If the memory object is still locked after decrementing the lock count, the return value is nonzero. If the memory object is
/// unlocked after decrementing the lock count, the function returns zero and <c>GetLastError</c> returns <c>NO_ERROR</c>.
/// </para>
/// <para>If the function fails, the return value is zero and <c>GetLastError</c> returns a value other than <c>NO_ERROR</c>.</para>
/// </returns>
// BOOL WINAPI LocalUnlock( _In_ HLOCAL hMem); https://msdn.microsoft.com/en-us/library/windows/desktop/aa366747(v=vs.85).aspx
[DllImport(Lib.Kernel32, SetLastError = true, ExactSpelling = true)]
[PInvokeData("WinBase.h", MSDNShortId = "aa366747")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool LocalUnlock([In] HLOCAL hMem);
/// <summary>Provides a handle to heap allocated memory.</summary>
[StructLayout(LayoutKind.Sequential)]
public struct HGLOBAL : IHandle
{
private IntPtr handle;
/// <summary>Initializes a new instance of the <see cref="HGLOBAL"/> struct.</summary>
/// <param name="preexistingHandle">An <see cref="IntPtr"/> object that represents the pre-existing handle to use.</param>
public HGLOBAL(IntPtr preexistingHandle) => handle = preexistingHandle;
/// <summary>Returns an invalid handle by instantiating a <see cref="HGLOBAL"/> object with <see cref="IntPtr.Zero"/>.</summary>
public static HGLOBAL NULL => new HGLOBAL(IntPtr.Zero);
/// <summary>Gets a value indicating whether this instance is a null handle.</summary>
public bool IsNull => handle == IntPtr.Zero;
/// <summary>Performs an explicit conversion from <see cref="HGLOBAL"/> to <see cref="IntPtr"/>.</summary>
/// <param name="h">The handle.</param>
/// <returns>The result of the conversion.</returns>
public static explicit operator IntPtr(HGLOBAL h) => h.handle;
/// <summary>Performs an implicit conversion from <see cref="IntPtr"/> to <see cref="HGLOBAL"/>.</summary>
/// <param name="h">The pointer to a handle.</param>
/// <returns>The result of the conversion.</returns>
public static implicit operator HGLOBAL(IntPtr h) => new HGLOBAL(h);
/// <summary>Implements the operator !=.</summary>
/// <param name="h1">The first handle.</param>
/// <param name="h2">The second handle.</param>
/// <returns>The result of the operator.</returns>
public static bool operator !=(HGLOBAL h1, HGLOBAL h2) => !(h1 == h2);
/// <summary>Implements the operator ==.</summary>
/// <param name="h1">The first handle.</param>
/// <param name="h2">The second handle.</param>
/// <returns>The result of the operator.</returns>
public static bool operator ==(HGLOBAL h1, HGLOBAL h2) => h1.Equals(h2);
/// <inheritdoc/>
public override bool Equals(object obj) => obj is HGLOBAL h ? handle == h.handle : false;
/// <inheritdoc/>
public override int GetHashCode() => handle.GetHashCode();
/// <inheritdoc/>
public IntPtr DangerousGetHandle() => handle;
}
/// <summary>Provides a handle to a local heap allocation.</summary>
[StructLayout(LayoutKind.Sequential)]
public struct HLOCAL : IHandle
{
private IntPtr handle;
/// <summary>Initializes a new instance of the <see cref="HLOCAL"/> struct.</summary>
/// <param name="preexistingHandle">An <see cref="IntPtr"/> object that represents the pre-existing handle to use.</param>
public HLOCAL(IntPtr preexistingHandle) => handle = preexistingHandle;
/// <summary>Returns an invalid handle by instantiating a <see cref="HLOCAL"/> object with <see cref="IntPtr.Zero"/>.</summary>
public static HLOCAL NULL => new HLOCAL(IntPtr.Zero);
/// <summary>Gets a value indicating whether this instance is a null handle.</summary>
public bool IsNull => handle == IntPtr.Zero;
/// <summary>Performs an explicit conversion from <see cref="HLOCAL"/> to <see cref="IntPtr"/>.</summary>
/// <param name="h">The handle.</param>
/// <returns>The result of the conversion.</returns>
public static explicit operator IntPtr(HLOCAL h) => h.handle;
/// <summary>Performs an implicit conversion from <see cref="IntPtr"/> to <see cref="HLOCAL"/>.</summary>
/// <param name="h">The pointer to a handle.</param>
/// <returns>The result of the conversion.</returns>
public static implicit operator HLOCAL(IntPtr h) => new HLOCAL(h);
/// <summary>Implements the operator !=.</summary>
/// <param name="h1">The first handle.</param>
/// <param name="h2">The second handle.</param>
/// <returns>The result of the operator.</returns>
public static bool operator !=(HLOCAL h1, HLOCAL h2) => !(h1 == h2);
/// <summary>Implements the operator ==.</summary>
/// <param name="h1">The first handle.</param>
/// <param name="h2">The second handle.</param>
/// <returns>The result of the operator.</returns>
public static bool operator ==(HLOCAL h1, HLOCAL h2) => h1.Equals(h2);
/// <inheritdoc/>
public override bool Equals(object obj) => obj is HLOCAL h ? handle == h.handle : false;
/// <inheritdoc/>
public override int GetHashCode() => handle.GetHashCode();
/// <inheritdoc/>
public IntPtr DangerousGetHandle() => handle;
}
}
} | dahall/vanara | PInvoke/Kernel32/WinBase.MemMgmt.cs | C# | mit | 44,045 |
///////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2004, Industrial Light & Magic, a division of Lucas
// Digital Ltd. LLC
//
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Industrial Light & Magic nor the names of
// its contributors may be used to endorse or promote products derived
// from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
///////////////////////////////////////////////////////////////////////////
#include <ImfTiledOutputFile.h>
#include <ImfInputFile.h>
#include <ImathRandom.h>
#include <ImfTiledInputFile.h>
#include <ImfChannelList.h>
#include <ImfArray.h>
#include <ImfThreading.h>
#include <IlmThread.h>
#include <half.h>
#include <vector>
#include <stdio.h>
#include <assert.h>
#include "tmpDir.h"
using namespace OPENEXR_IMF_NAMESPACE;
using namespace std;
using namespace IMATH_NAMESPACE;
namespace {
void
fillPixels (Array2D<half> &ph, int width, int height)
{
for (int y = 0; y < height; ++y)
for (int x = 0; x < width; ++x)
ph[y][x] = sin (double (x)) + sin (y * 0.5);
}
void
writeCopyReadONE (const char fileName[],
int width,
int height,
LineOrder lorder,
LevelRoundingMode rmode,
int xSize,
int ySize,
Compression comp,
bool triggerBuffering,
bool triggerSeeks)
{
cout << "LineOrder " << lorder << ", buffer " << triggerBuffering <<
", seek " << triggerSeeks << ", levelMode 0, " <<
"roundingMode " << rmode << ", "
"compression " << comp << endl;
Header hdr ((Box2i (V2i (0, 0), // display window
V2i (width - 1, height -1))),
(Box2i (V2i (0, 0), // data window
V2i (width - 1, height - 1))));
hdr.compression() = comp;
hdr.lineOrder() = INCREASING_Y;
hdr.channels().insert ("H", Channel (HALF, 1, 1));
hdr.setTileDescription(TileDescription(xSize, ySize, ONE_LEVEL, rmode));
Array2D<half> ph1 (height, width);
fillPixels (ph1, width, height);
{
FrameBuffer fb;
fb.insert ("H",
Slice (HALF,
(char *) &ph1[0][0],
sizeof (ph1[0][0]),
sizeof (ph1[0][0]) * width));
cout << " writing" << flush;
remove (fileName);
TiledOutputFile out (fileName, hdr);
out.setFrameBuffer (fb);
int i;
Rand32 rand1 = Rand32();
std::vector<int> tileYs = std::vector<int>(out.numYTiles());
std::vector<int> tileXs = std::vector<int>(out.numXTiles());
for (i = 0; i < out.numYTiles(); i++)
{
if (lorder == DECREASING_Y)
tileYs[out.numYTiles()-1-i] = i;
else
tileYs[i] = i;
}
for (i = 0; i < out.numXTiles(); i++)
{
tileXs[i] = i;
}
if (triggerBuffering)
{
// shuffle the tile orders
for (i = 0; i < out.numYTiles(); i++)
std::swap(tileYs[i], tileYs[int(rand1.nextf(i,out.numYTiles()-1) + 0.5)]);
for (i = 0; i < out.numXTiles(); i++)
std::swap(tileXs[i], tileXs[int(rand1.nextf(i,out.numXTiles()-1) + 0.5)]);
}
for (int tileY = 0; tileY < out.numYTiles(); tileY++)
for (int tileX = 0; tileX < out.numXTiles(); tileX++)
out.writeTile (tileXs[tileX], tileYs[tileY]);
}
{
cout << " reading" << flush;
TiledInputFile in (fileName);
const Box2i &dw = in.header().dataWindow();
int w = dw.max.x - dw.min.x + 1;
int h = dw.max.y - dw.min.y + 1;
int dwx = dw.min.x;
int dwy = dw.min.y;
Array2D<half> ph2 (h, w);
FrameBuffer fb;
fb.insert ("H",
Slice (HALF,
(char *) &ph2[-dwy][-dwx],
sizeof (ph2[0][0]),
sizeof (ph2[0][0]) * w));
in.setFrameBuffer (fb);
int startTileY, endTileY;
int dy;
if ((lorder == DECREASING_Y && !triggerSeeks) ||
(lorder == INCREASING_Y && triggerSeeks) ||
(lorder == RANDOM_Y && triggerSeeks))
{
startTileY = in.numYTiles() - 1;
endTileY = -1;
dy = -1;
}
else
{
startTileY = 0;
endTileY = in.numYTiles();
dy = 1;
}
for (int tileY = startTileY; tileY != endTileY; tileY += dy)
for (int tileX = 0; tileX < in.numXTiles(); ++tileX)
in.readTile (tileX, tileY);
cout << " comparing" << flush;
assert (in.header().displayWindow() == hdr.displayWindow());
assert (in.header().dataWindow() == hdr.dataWindow());
assert (in.header().pixelAspectRatio() == hdr.pixelAspectRatio());
assert (in.header().screenWindowCenter() == hdr.screenWindowCenter());
assert (in.header().screenWindowWidth() == hdr.screenWindowWidth());
assert (in.header().lineOrder() == hdr.lineOrder());
assert (in.header().compression() == hdr.compression());
assert (in.header().channels() == hdr.channels());
for (int y = 0; y < h; ++y)
for (int x = 0; x < w; ++x)
assert (ph1[y][x] == ph2[y][x]);
}
remove (fileName);
cout << endl;
}
void
writeCopyReadMIP (const char fileName[],
int width,
int height,
LineOrder lorder,
LevelRoundingMode rmode,
int xSize,
int ySize,
Compression comp,
bool triggerBuffering,
bool triggerSeeks)
{
cout << "LineOrder " << lorder << ", buffer " << triggerBuffering <<
", seek " << triggerSeeks << ", levelMode 1, " <<
"roundingMode " << rmode << ", "
"compression " << comp << endl;
Header hdr ((Box2i (V2i (0, 0), // display window
V2i (width - 1, height -1))),
(Box2i (V2i (0, 0), // data window
V2i (width - 1, height - 1))));
hdr.compression() = comp;
hdr.lineOrder() = INCREASING_Y;
hdr.channels().insert ("H", Channel (HALF, 1, 1));
hdr.setTileDescription(TileDescription(xSize, ySize, MIPMAP_LEVELS, rmode));
Array < Array2D<half> > levels;
{
cout << " writing" << flush;
remove (fileName);
TiledOutputFile out (fileName, hdr);
int numLevels = out.numLevels();
levels.resizeErase (numLevels);
int i;
Rand32 rand1 = Rand32();
std::vector<int> shuffled_levels = std::vector<int>(numLevels);
for (i = 0; i < numLevels; i++)
shuffled_levels[i] = i;
if (triggerBuffering)
// shuffle the level order
for (i = 0; i < numLevels; i++)
std::swap(shuffled_levels[i], shuffled_levels[int(rand1.nextf(i,numLevels-1) + 0.5)]);
for (int level = 0; level < numLevels; ++level)
{
const int slevel = shuffled_levels[level];
int levelWidth = out.levelWidth(slevel);
int levelHeight = out.levelHeight(slevel);
levels[slevel].resizeErase(levelHeight, levelWidth);
fillPixels (levels[slevel], levelWidth, levelHeight);
FrameBuffer fb;
fb.insert ("H",
Slice (HALF,
(char *) &levels[slevel][0][0],
sizeof (levels[slevel][0][0]),
sizeof (levels[slevel][0][0]) * levelWidth));
out.setFrameBuffer (fb);
std::vector<int> tileYs = std::vector<int>(out.numYTiles(slevel));
std::vector<int> tileXs = std::vector<int>(out.numXTiles(slevel));
for (i = 0; i < out.numYTiles(slevel); i++)
{
if (lorder == DECREASING_Y)
tileYs[out.numYTiles(slevel)-1-i] = i;
else
tileYs[i] = i;
}
for (i = 0; i < out.numXTiles(slevel); i++)
tileXs[i] = i;
if (triggerBuffering)
{
// shuffle the tile orders
for (i = 0; i < out.numYTiles(slevel); i++)
std::swap(tileYs[i], tileYs[int(rand1.nextf(i,out.numYTiles(slevel)-1) + 0.5)]);
for (i = 0; i < out.numXTiles(slevel); i++)
std::swap(tileXs[i], tileXs[int(rand1.nextf(i,out.numXTiles(slevel)-1) + 0.5)]);
}
for (int tileY = 0; tileY < out.numYTiles(slevel); ++tileY)
for (int tileX = 0; tileX < out.numXTiles(slevel); ++tileX)
out.writeTile (tileXs[tileX], tileYs[tileY], slevel);
}
}
{
cout << " reading" << flush;
TiledInputFile in (fileName);
const Box2i &dw = in.header().dataWindow();
int dwx = dw.min.x;
int dwy = dw.min.y;
int numLevels = in.numLevels();
Array < Array2D<half> > levels2 (numLevels);
int startTileY, endTileY;
int dy;
for (int level = 0; level < in.numLevels(); ++level)
{
int levelWidth = in.levelWidth(level);
int levelHeight = in.levelHeight(level);
levels2[level].resizeErase(levelHeight, levelWidth);
FrameBuffer fb;
fb.insert ("H",
Slice (HALF,
(char *) &levels2[level][-dwy][-dwx],
sizeof (levels2[level][0][0]),
sizeof (levels2[level][0][0]) * levelWidth));
in.setFrameBuffer (fb);
if ((lorder == DECREASING_Y && !triggerSeeks) ||
(lorder == INCREASING_Y && triggerSeeks) ||
(lorder == RANDOM_Y && triggerSeeks))
{
startTileY = in.numYTiles(level) - 1;
endTileY = -1;
dy = -1;
}
else
{
startTileY = 0;
endTileY = in.numYTiles(level);
dy = 1;
}
for (int tileY = startTileY; tileY != endTileY; tileY += dy)
for (int tileX = 0; tileX < in.numXTiles (level); ++tileX)
in.readTile (tileX, tileY, level);
}
cout << " comparing" << flush;
assert (in.header().displayWindow() == hdr.displayWindow());
assert (in.header().dataWindow() == hdr.dataWindow());
assert (in.header().pixelAspectRatio() == hdr.pixelAspectRatio());
assert (in.header().screenWindowCenter() == hdr.screenWindowCenter());
assert (in.header().screenWindowWidth() == hdr.screenWindowWidth());
assert (in.header().lineOrder() == hdr.lineOrder());
assert (in.header().compression() == hdr.compression());
assert (in.header().channels() == hdr.channels());
for (int l = 0; l < numLevels; ++l)
for (int y = 0; y < in.levelHeight(l); ++y)
for (int x = 0; x < in.levelWidth(l); ++x)
assert ((levels2[l])[y][x] == (levels[l])[y][x]);
}
remove (fileName);
cout << endl;
}
void
writeCopyReadRIP (const char fileName[],
int width,
int height,
LineOrder lorder,
LevelRoundingMode rmode,
int xSize,
int ySize,
Compression comp,
bool triggerBuffering,
bool triggerSeeks)
{
cout << "LineOrder " << lorder << ", buffer " << triggerBuffering <<
", seek " << triggerSeeks << ", levelMode 2, " <<
"roundingMode " << rmode << ", "
"compression " << comp << endl;
Header hdr ((Box2i (V2i (0, 0), // display window
V2i (width - 1, height -1))),
(Box2i (V2i (0, 0), // data window
V2i (width - 1, height - 1))));
hdr.compression() = comp;
hdr.lineOrder() = INCREASING_Y;
hdr.channels().insert ("H", Channel (HALF, 1, 1));
hdr.setTileDescription(TileDescription(xSize, ySize, RIPMAP_LEVELS, rmode));
Array2D < Array2D<half> > levels;
{
cout << " writing" << flush;
remove (fileName);
TiledOutputFile out (fileName, hdr);
levels.resizeErase (out.numYLevels(), out.numXLevels());
int i;
Rand32 rand1 = Rand32();
std::vector<int> shuffled_xLevels = std::vector<int>(out.numXLevels());
std::vector<int> shuffled_yLevels = std::vector<int>(out.numYLevels());
for (i = 0; i < out.numXLevels(); i++)
shuffled_xLevels[i] = i;
for (i = 0; i < out.numYLevels(); i++)
shuffled_yLevels[i] = i;
if (triggerBuffering)
{
// shuffle the level orders
for (i = 0; i < out.numXLevels(); i++)
std::swap(shuffled_xLevels[i], shuffled_xLevels[int(rand1.nextf(i,out.numXLevels()-1) + 0.5)]);
for (i = 0; i < out.numYLevels(); i++)
std::swap(shuffled_yLevels[i], shuffled_yLevels[int(rand1.nextf(i,out.numYLevels()-1) + 0.5)]);
}
for (int ylevel = 0; ylevel < out.numYLevels(); ++ylevel)
{
const int sylevel = shuffled_yLevels[ylevel];
std::vector<int> tileYs = std::vector<int>(out.numYTiles(sylevel));
for (i = 0; i < out.numYTiles(sylevel); i++)
{
if (lorder == DECREASING_Y)
tileYs[out.numYTiles(sylevel)-1-i] = i;
else
tileYs[i] = i;
}
if (triggerBuffering)
// shuffle the tile orders
for (i = 0; i < out.numYTiles(sylevel); i++)
std::swap(tileYs[i], tileYs[int(rand1.nextf(i,out.numYTiles(sylevel)-1) + 0.5)]);
for (int xlevel = 0; xlevel < out.numXLevels(); ++xlevel)
{
const int sxlevel = shuffled_xLevels[xlevel];
int levelWidth = out.levelWidth(sxlevel);
int levelHeight = out.levelHeight(sylevel);
levels[sylevel][sxlevel].resizeErase(levelHeight, levelWidth);
fillPixels (levels[sylevel][sxlevel], levelWidth, levelHeight);
FrameBuffer fb;
fb.insert ("H",
Slice (HALF,
(char *) &levels[sylevel][sxlevel][0][0],
sizeof (levels[sylevel][sxlevel][0][0]),
sizeof (levels[sylevel][sxlevel][0][0]) * levelWidth));
out.setFrameBuffer (fb);
std::vector<int> tileXs = std::vector<int>(out.numXTiles(sxlevel));
for (i = 0; i < out.numXTiles(sxlevel); i++)
tileXs[i] = i;
if (triggerBuffering)
// shuffle the tile orders
for (i = 0; i < out.numXTiles(sxlevel); i++)
std::swap(tileXs[i], tileXs[int(rand1.nextf(i,out.numXTiles(sxlevel)-1) + 0.5)]);
for (int tileY = 0; tileY < out.numYTiles(sylevel); ++tileY)
for (int tileX = 0; tileX < out.numXTiles(sxlevel); ++tileX)
out.writeTile(tileXs[tileX], tileYs[tileY], sxlevel, sylevel);
}
}
}
{
cout << " reading" << flush;
TiledInputFile in (fileName);
const Box2i &dw = in.header().dataWindow();
int dwx = dw.min.x;
int dwy = dw.min.y;
int numXLevels = in.numXLevels();
int numYLevels = in.numYLevels();
Array2D < Array2D<half> > levels2 (numYLevels, numXLevels);
int startTileY, endTileY;
int dy;
for (int ylevel = 0; ylevel < in.numYLevels(); ++ylevel)
{
if ((lorder == DECREASING_Y && !triggerSeeks) ||
(lorder == INCREASING_Y && triggerSeeks) ||
(lorder == RANDOM_Y && triggerSeeks))
{
startTileY = in.numYTiles(ylevel) - 1;
endTileY = -1;
dy = -1;
}
else
{
startTileY = 0;
endTileY = in.numYTiles(ylevel);
dy = 1;
}
for (int xlevel = 0; xlevel < in.numXLevels(); ++xlevel)
{
int levelWidth = in.levelWidth(xlevel);
int levelHeight = in.levelHeight(ylevel);
levels2[ylevel][xlevel].resizeErase(levelHeight, levelWidth);
FrameBuffer fb;
fb.insert ("H",
Slice (HALF,
(char *) &levels2[ylevel][xlevel][-dwy][-dwx],
sizeof (levels2[ylevel][xlevel][0][0]),
sizeof (levels2[ylevel][xlevel][0][0]) * levelWidth));
in.setFrameBuffer (fb);
for (int tileY = startTileY; tileY != endTileY; tileY += dy)
for (int tileX = 0; tileX < in.numXTiles (xlevel); ++tileX)
in.readTile (tileX, tileY, xlevel, ylevel);
}
}
cout << " comparing" << flush;
assert (in.header().displayWindow() == hdr.displayWindow());
assert (in.header().dataWindow() == hdr.dataWindow());
assert (in.header().pixelAspectRatio() == hdr.pixelAspectRatio());
assert (in.header().screenWindowCenter() == hdr.screenWindowCenter());
assert (in.header().screenWindowWidth() == hdr.screenWindowWidth());
assert (in.header().lineOrder() == hdr.lineOrder());
assert (in.header().compression() == hdr.compression());
assert (in.header().channels() == hdr.channels());
for (int ly = 0; ly < numYLevels; ++ly)
for (int lx = 0; lx < numXLevels; ++lx)
for (int y = 0; y < in.levelHeight(ly); ++y)
for (int x = 0; x < in.levelWidth(lx); ++x)
assert ((levels2[ly][lx])[y][x] ==
(levels[ly][lx])[y][x]);
}
remove (fileName);
cout << endl;
}
void
writeCopyRead (int w, int h, int xs, int ys)
{
const char *filename = IMF_TMP_DIR "imf_test_copy.exr";
for (int comp = 0; comp < NUM_COMPRESSION_METHODS; ++comp)
{
if (comp == B44_COMPRESSION || comp == B44A_COMPRESSION)
continue;
for (int lorder = 0; lorder < RANDOM_Y; ++lorder)
{
for (int rmode = 0; rmode < NUM_ROUNDINGMODES; ++rmode)
{
for (int tb = 0; tb <= 1; ++tb)
{
for (int ts = 0; ts <= 1; ++ts)
{
writeCopyReadONE (filename, w, h,
(LineOrder)lorder,
(LevelRoundingMode) rmode,
xs, ys,
Compression (comp),
(bool)tb, (bool)ts);
writeCopyReadMIP (filename, w, h,
(LineOrder)lorder,
(LevelRoundingMode) rmode,
xs, ys,
Compression (comp),
(bool)tb, (bool)ts);
writeCopyReadRIP (filename, w, h,
(LineOrder)lorder,
(LevelRoundingMode) rmode,
xs, ys,
Compression (comp),
(bool)tb, (bool)ts);
}
}
}
}
}
}
} // namespace
void
testTiledLineOrder ()
{
try
{
cout << "Testing line orders for tiled files and "
"buffered/unbuffered tile writes" << endl;
const int W = 171;
const int H = 259;
const int XS = 55;
const int YS = 55;
int maxThreads = ILMTHREAD_NAMESPACE::supportsThreads()? 3: 0;
for (int n = 0; n <= maxThreads; ++n)
{
if (ILMTHREAD_NAMESPACE::supportsThreads())
{
setGlobalThreadCount (n);
cout << "\nnumber of threads: " << globalThreadCount() << endl;
}
writeCopyRead (W, H, XS, YS);
}
cout << "ok\n" << endl;
}
catch (const std::exception &e)
{
cerr << "ERROR -- caught exception: " << e.what() << endl;
assert (false);
}
}
| jamesbigler/Legion | src/Support/openexr-2.0.1/IlmImfTest/testTiledLineOrder.cpp | C++ | mit | 21,673 |
package main
import "fmt"
// Bitcoin represents a number of Bitcoins
type Bitcoin int
func (b Bitcoin) String() string {
return fmt.Sprintf("%d BTC", b)
}
// Wallet stores the number of Bitcoin someone owns
type Wallet struct {
balance Bitcoin
}
// Deposit will add some Bitcoin to a wallet
func (w *Wallet) Deposit(amount Bitcoin) {
w.balance += amount
}
// Withdraw subtracts some Bitcoin from the wallet
func (w *Wallet) Withdraw(amount Bitcoin) {
w.balance -= amount
}
// Balance returns the number of Bitcoin a wallet has
func (w *Wallet) Balance() Bitcoin {
return w.balance
}
| a233894432/Golang-lesson | src/my_example/gctt/pointers_demo/v2/wallet.go | GO | mit | 595 |
import pymc3 as pm
from lasagne.layers.helper import *
from lasagne.layers.helper import __all__ as __helper__all__
__all__ = [
"find_parent",
"find_root",
] + __helper__all__
def find_parent(layer):
candidates = get_all_layers(layer)[::-1]
found = None
for candidate in candidates:
if isinstance(candidate, pm.Model):
found = candidate
break
return found
def find_root(layer):
model = find_parent(layer)
if model is not None:
return model.root
else:
return None
| ferrine/gelato | gelato/layers/helper.py | Python | mit | 551 |
import inspect
__all__ = ['GenericVisitor']
class GenericVisitor(object):
"""
A generic visitor.
To define handlers, subclasses should define :data:`visit_Foo`
methods for each class :data:`Foo` they want to handle.
If a specific method for a class :data:`Foo` is not found, the MRO
of the class is walked in order until a matching method is found.
The method signature is:
.. code-block::
def visit_Foo(self, o, [*args, **kwargs]):
pass
The handler is responsible for visiting the children (if any) of
the node :data:`o`. :data:`*args` and :data:`**kwargs` may be
used to pass information up and down the call stack. You can also
pass named keyword arguments, e.g.:
.. code-block::
def visit_Foo(self, o, parent=None, *args, **kwargs):
pass
"""
def __init__(self):
handlers = {}
# visit methods are spelt visit_Foo.
prefix = "visit_"
# Inspect the methods on this instance to find out which
# handlers are defined.
for (name, meth) in inspect.getmembers(self, predicate=inspect.ismethod):
if not name.startswith(prefix):
continue
# Check the argument specification
# Valid options are:
# visit_Foo(self, o, [*args, **kwargs])
argspec = inspect.getfullargspec(meth)
if len(argspec.args) < 2:
raise RuntimeError("Visit method signature must be "
"visit_Foo(self, o, [*args, **kwargs])")
handlers[name[len(prefix):]] = meth
self._handlers = handlers
"""
:attr:`default_args`. A dict of default keyword arguments for the visitor.
These are not used by default in :meth:`visit`, however, a caller may pass
them explicitly to :meth:`visit` by accessing :attr:`default_args`.
For example::
.. code-block::
v = FooVisitor()
v.visit(node, **v.default_args)
"""
default_args = {}
@classmethod
def default_retval(cls):
"""
A method that returns an object to use to populate return values.
If your visitor combines values in a tree-walk, it may be useful to
provide a object to combine the results into. :meth:`default_retval`
may be defined by the visitor to be called to provide an empty object
of appropriate type.
"""
return None
def lookup_method(self, instance):
"""
Look up a handler method for a visitee.
Parameters
----------
instance : object
The instance to look up a method for.
"""
cls = instance.__class__
try:
# Do we have a method handler defined for this type name
return self._handlers[cls.__name__]
except KeyError:
# No, walk the MRO.
for klass in cls.mro()[1:]:
entry = self._handlers.get(klass.__name__)
if entry:
# Save it on this type name for faster lookup next time
self._handlers[cls.__name__] = entry
return entry
raise RuntimeError("No handler found for class %s", cls.__name__)
def visit(self, o, *args, **kwargs):
"""
Apply this Visitor to an object.
Parameters
----------
o : object
The object to be visited.
*args
Optional arguments to pass to the visit methods.
**kwargs
Optional keyword arguments to pass to the visit methods.
"""
ret = self._visit(o, *args, **kwargs)
ret = self._post_visit(ret)
return ret
def _visit(self, o, *args, **kwargs):
"""Visit ``o``."""
meth = self.lookup_method(o)
return meth(o, *args, **kwargs)
def _post_visit(self, ret):
"""Postprocess the visitor output before returning it to the caller."""
return ret
def visit_object(self, o, **kwargs):
return self.default_retval()
| opesci/devito | devito/tools/visitors.py | Python | mit | 4,134 |
package xsmeral.pipe.context;
import java.io.File;
/**
* A file system context, based on the notion of a single working directory.
* @author Ron Šmeral (xsmeral@fi.muni.cz)
*/
public interface FSContext {
/**
* Sets the working directory to the given path (relative or absolute)
*/
public void setWorkingDir(String path);
/**
* Returns the working directory
*/
public String getWorkingDir();
/**
* Returns a file with the specified path.
* If the path is relative, it is resolved against the working directory.
*/
public File getFile(String path);
}
| rsmeral/semnet | PipedObjectProcessor/src/xsmeral/pipe/context/FSContext.java | Java | mit | 619 |
//---------------------------------------------------------------------------
//
// <copyright file="FillRuleValidation.cs" company="Microsoft">
// Copyright (C) Microsoft Corporation. All rights reserved.
// </copyright>
//
// This file was generated, please do not edit it directly.
//
// Please see http://wiki/default.aspx/Microsoft.Projects.Avalon/MilCodeGen.html for more information.
//
//---------------------------------------------------------------------------
using System;
using System.ComponentModel;
using System.Runtime.InteropServices;
using MS.Internal.PresentationCore;
#if PRESENTATION_CORE
using SR=MS.Internal.PresentationCore.SR;
using SRID=MS.Internal.PresentationCore.SRID;
#else
using SR=System.Windows.SR;
using SRID=System.Windows.SRID;
#endif
namespace System.Windows.Media
{
internal static partial class ValidateEnums
{
/// <summary>
/// Returns whether or not an enumeration instance a valid value.
/// This method is designed to be used with ValidateValueCallback, and thus
/// matches it's prototype.
/// </summary>
/// <param name="valueObject">
/// Enumeration value to validate.
/// </param>
/// <returns> 'true' if the enumeration contains a valid value, 'false' otherwise. </returns>
public static bool IsFillRuleValid(object valueObject)
{
FillRule value = (FillRule) valueObject;
return (value == FillRule.EvenOdd) ||
(value == FillRule.Nonzero);
}
}
}
| mind0n/hive | Cache/Libs/net46/wpf/src/Shared/MS/Internal/Generated/FillRuleValidation.cs | C# | mit | 1,605 |
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
[assembly: AssemblyTitle("Tasker.TaskAntImporter")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("Tasker.TaskAntImporter")]
[assembly: AssemblyCopyright("Copyright © 2014")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
// Setting ComVisible to false makes the types in this assembly not visible
// to COM components. If you need to access a type in this assembly from
// COM, set the ComVisible attribute to true on that type.
[assembly: ComVisible(false)]
// The following GUID is for the ID of the typelib if this project is exposed to COM
[assembly: Guid("1a5ccda4-fa92-4711-805b-6541cf3fb650")]
// Version information for an assembly consists of the following four values:
//
// Major Version
// Minor Version
// Build Number
// Revision
//
// You can specify all the values or you can default the Build and Revision Numbers
// by using the '*' as shown below:
// [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")]
| Digiman/Tasker | Tasker.TaskAntImporter/Properties/AssemblyInfo.cs | C# | mit | 1,420 |
# Die Class 1: Numeric
# I worked on this challenge [by myself]
# I spent [.5] hours on this challenge.
# 0. Pseudocode
# Input: integer amount of sides on a die object
# Output: either integer number of sides or random integer
# Steps:
# => IF there is less than one side THEN
# => => RAISE an Argument Error
# => ELSE
# => => allow the 'die' to be created with trait -size
# => ENDIF
# => When Sides is called (Die.sides) RETURN the number of sides
# => When rolled return a RANDOM number between 1 and # of sides.
# 1. Initial Solution
#class Die
# def initialize(sides)
# @sides = sides
# end
#
# def sides
# return @sides
# end
#
# def roll
# return rand(1..@sides)
# end
#end
# 3. Refactored Solution
class Die
def initialize(sides)
if sides < 1
raise ArgumentError
else
@sides = sides
end
end
def sides
return @sides
end
def roll
return rand(1..@sides)
end
end
# 4. Reflection
=begin
What is an ArgumentError and why would you use one?
It is an error that tells the user why their input won't work. You would use one to warn
a user that the way they're trying to use the class or method is incorrect. It could be
that the input is the wrong type or the wrong quantity or really anything that would cause
the class and/or subsequent methods to fail.
What new Ruby methods did you implement? What challenges and successes did you have in implementing them?
I used rand() in order to call a random number between 1 and sides. There wasn't too much
that could have gone wrong.
What is a Ruby class?
A class is like a framework that can be used to create an individual object. A class
can have traits (like how Die had sides) and can have functions (die can be rolled
to return a random number).
Why would you use a Ruby class?
It is useful to store many instances of data. For example, with a class Person, you can
store the name, hometown, age, and profession of all the persons in that class without
using a hash. You can also call methods on those persons (e.g. work, drive, eat, etc.).
What is the difference between a local variable and an instance variable?
Instance variables are available across methods for any instance or any object.
Instance variables have an '@' before the variable name. They also change from object
to object.
Local variables are variables defined in a method and they're not available outside the
method. They generally begin with lowercase letters or '_'
Where can an instance variable be used?
Within an instance of a class.
=end | themcny/phase-0 | week-5/die-class/my_solution.rb | Ruby | mit | 2,564 |
// Copyright (c) 2012 The Bitcoin developers
// Distributed under the MIT/X11 software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#include <string>
#include "version.h"
// Name of client reported in the 'version' message. Report the same name
// for both bitcoind and bitcoin-qt, to make it harder for attackers to
// target servers or GUI users specifically.
const std::string CLIENT_NAME("Blake");
// Client version number
#define CLIENT_VERSION_SUFFIX "-beta"
// The following part of the code determines the CLIENT_BUILD variable.
// Several mechanisms are used for this:
// * first, if HAVE_BUILD_INFO is defined, include build.h, a file that is
// generated by the build environment, possibly containing the output
// of git-describe in a macro called BUILD_DESC
// * secondly, if this is an exported version of the code, GIT_ARCHIVE will
// be defined (automatically using the export-subst git attribute), and
// GIT_COMMIT will contain the commit id.
// * then, three options exist for determining CLIENT_BUILD:
// * if BUILD_DESC is defined, use that literally (output of git-describe)
// * if not, but GIT_COMMIT is defined, use v[maj].[min].[rev].[build]-g[commit]
// * otherwise, use v[maj].[min].[rev].[build]-unk
// finally CLIENT_VERSION_SUFFIX is added
// First, include build.h if requested
#ifdef HAVE_BUILD_INFO
# include "build.h"
#endif
// git will put "#define GIT_ARCHIVE 1" on the next line inside archives.
#define GIT_ARCHIVE 1
#ifdef GIT_ARCHIVE
# define GIT_COMMIT_ID "8c5e74e"
# define GIT_COMMIT_DATE "2022-03-05 11:47:21 +0000"
#endif
#define BUILD_DESC_FROM_COMMIT(maj,min,rev,build,commit) \
"v" DO_STRINGIZE(maj) "." DO_STRINGIZE(min) "." DO_STRINGIZE(rev) "." DO_STRINGIZE(build) "-g" commit
#define BUILD_DESC_FROM_UNKNOWN(maj,min,rev,build) \
"v" DO_STRINGIZE(maj) "." DO_STRINGIZE(min) "." DO_STRINGIZE(rev) "." DO_STRINGIZE(build) "-unk"
#ifndef BUILD_DESC
# ifdef GIT_COMMIT_ID
# define BUILD_DESC BUILD_DESC_FROM_COMMIT(CLIENT_VERSION_MAJOR, CLIENT_VERSION_MINOR, CLIENT_VERSION_REVISION, CLIENT_VERSION_BUILD, GIT_COMMIT_ID)
# else
# define BUILD_DESC BUILD_DESC_FROM_UNKNOWN(CLIENT_VERSION_MAJOR, CLIENT_VERSION_MINOR, CLIENT_VERSION_REVISION, CLIENT_VERSION_BUILD)
# endif
#endif
#ifndef BUILD_DATE
# ifdef GIT_COMMIT_DATE
# define BUILD_DATE GIT_COMMIT_DATE
# else
# define BUILD_DATE __DATE__ ", " __TIME__
# endif
#endif
const std::string CLIENT_BUILD(BUILD_DESC CLIENT_VERSION_SUFFIX);
const std::string CLIENT_DATE(BUILD_DATE);
| BlakeBitcoin/BlakeBitcoin | src/version.cpp | C++ | mit | 2,628 |
using System;
using System.Collections.Generic;
using System.Globalization;
using System.Runtime.Serialization;
using uWebshop.Domain;
using uWebshop.Domain.Helpers;
using uWebshop.Domain.Interfaces;
namespace uWebshop.API
{
[DataContract(Namespace = "")]
internal class BasketStore : IStore
{
private readonly Domain.Store _store;
public BasketStore(Domain.Store store)
{
_store = store;
Id = store.Id;
Alias = store.Alias;
TypeAlias = store.TypeAlias;
}
public BasketStore(StoreInfo info) : this(info.Store)
{
Alias = info.Alias;
}
[DataMember]
public int Id { get; set; }
[DataMember]
public string TypeAlias { get; private set; }
[DataMember]
public string Culture
{
get { return _store.Culture; }
}
[DataMember]
public string Alias { get; set; }
[DataMember]
public string CountryCode
{
get { return _store.CountryCode; }
}
[DataMember]
public string DefaultCountryCode
{
get { return _store.DefaultCountryCode; }
}
[DataMember]
public string CurrencyCulture
{
get { return _store.CountryCode; }
}
[IgnoreDataMember]
public IEnumerable<ICurrency> Currencies
{
get { return _store.Currencies; }
}
[IgnoreDataMember]
public CultureInfo DefaultCurrencyCultureInfo
{
get { return _store.DefaultCurrencyCultureInfo; }
}
[DataMember]
public string DefaultCurrencyCultureSymbol
{
get { return _store.DefaultCurrencyCultureSymbol; }
}
[IgnoreDataMember]
public CultureInfo CultureInfo
{
get { return _store.CultureInfo; }
}
[DataMember]
public decimal GlobalVat
{
get { return _store.GlobalVat; }
}
[DataMember]
public bool Testmode
{
get { return _store.Testmode; }
}
[DataMember]
public string StoreUrlWithoutDomain
{
get { return _store.StoreUrlWithoutDomain; }
}
[DataMember]
public string EmailAddressFrom
{
get { return _store.EmailAddressFrom; }
}
[DataMember]
public string EmailAddressFromName
{
get { return _store.EmailAddressFromName; }
}
[DataMember]
public string EmailAddressTo
{
get { return _store.EmailAddressTo; }
}
[DataMember]
public string StoreURL
{
get { return _store.StoreURL; }
}
public IEnumerable<int> GetConnectedNodes
{
get { return _store.GetConnectedNodes; }
}
[IgnoreDataMember]
public bool Disabled
{
get { return _store.Disabled; }
}
[IgnoreDataMember]
public DateTime CreateDate
{
get { return _store.CreateDate; }
}
[IgnoreDataMember]
public DateTime UpdateDate
{
get { return _store.UpdateDate; }
}
[DataMember]
public int SortOrder
{
get { return _store.SortOrder; }
}
}
} | uWebshop/uWebshop-Releases | Core/uWebshop.Domain/API/DataClasses/BasketStore.cs | C# | mit | 2,701 |
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Security.Claims;
using Ascon.Pilot.Core;
using Ascon.Pilot.Server.Api;
using Ascon.Pilot.Server.Api.Contracts;
using Ascon.Pilot.Transport;
using Microsoft.AspNet.Http;
using ISession = Microsoft.AspNet.Http.Features.ISession;
namespace Ascon.Pilot.WebClient.Extensions
{
public static class SessionExt
{
public static IDictionary<int, MType> GetMetatypes(this ISession session)
{
return session.GetSessionValues<IDictionary<int, MType>>(SessionKeys.MetaTypes);
}
/// <summary>
/// Set value of type <typeparam name="T">T</typeparam> at session dictionary using protobuf-net
/// </summary>
/// <typeparam name="T">type of value to set. Must be proto-serializable</typeparam>
/// <param name="session">session to add values</param>
/// <param name="key">key of value</param>
/// <param name="value">value to set</param>
public static void SetSessionValues<T>(this ISession session, string key, T value)
{
using (var bs = new MemoryStream())
{
ProtoBuf.Serializer.Serialize(bs, value);
session.Set(key, bs.ToArray());
}
}
/// <summary>
/// Deserialize values if type T from session dictionary using protobuf-net
/// </summary>
/// <typeparam name="T">type of value</typeparam>
/// <param name="session">Session where values located</param>
/// <param name="key">key of values in dictionary</param>
/// <returns></returns>
public static T GetSessionValues<T>(this ISession session, string key)
{
var val = session.Get(key);
if (val == null)
return default(T);
using (var bs = new MemoryStream(val))
{
return ProtoBuf.Serializer.Deserialize<T>(bs);
}
}
}
public static class HttpContextClientsStorage
{
private static readonly Dictionary<Guid, HttpPilotClient> ClientsDictionary = new Dictionary<Guid, HttpPilotClient>();
public static HttpPilotClient GetClient(this HttpContext context)
{
var clientIdString = context.User.FindFirstValue(ClaimTypes.Sid);
if (string.IsNullOrEmpty(clientIdString))
return null;
var clientId = Guid.Parse(clientIdString);
if (ClientsDictionary.ContainsKey(clientId))
{
var client = ClientsDictionary[clientId];
if (client.IsClientActive())
return client;
}
return null;
}
public static void SetClient(this HttpContext context, HttpPilotClient client, Guid clientId)
{
ClientsDictionary[clientId] = client;
}
public static IServerApi GetServerApi(this HttpContext context, IServerCallback callback = null)
{
if (callback == null)
callback = CallbackFactory.Get<IServerCallback>();
var client = context.GetClient();
if (client == null)
client = Reconnect(context, callback);
return client.GetServerApi(callback);
}
private static HttpPilotClient Reconnect(HttpContext context, IServerCallback callback)
{
var client = new HttpPilotClient();
client.Connect(ApplicationConst.PilotServerUrl);
var serverApi = client.GetServerApi(callback);
var dbName = context.User.FindFirstValue(ClaimTypes.Surname);
var login = context.User.FindFirstValue(ClaimTypes.Name);
var protectedPassword = context.User.FindFirstValue(ClaimTypes.UserData);
var useWindowsAuth = login.Contains("/") || login.Contains("\\");
var dbInfo = serverApi.OpenDatabase(dbName, login, protectedPassword, useWindowsAuth);
if (dbInfo == null)
throw new TransportException();
var clientIdString = context.User.FindFirstValue(ClaimTypes.Sid);
ClientsDictionary[Guid.Parse(clientIdString)] = client;
DMetadata dMetadata = serverApi.GetMetadata(dbInfo.MetadataVersion);
context.Session.SetSessionValues(SessionKeys.MetaTypes, dMetadata.Types.ToDictionary(x => x.Id, y => y));
return client;
}
}
}
| perminov-aleksandr/askon-pilot-client-asp | src/Ascon.Pilot.WebClient/Extensions/ClientsStorage.cs | C# | mit | 4,520 |
package io.swagger.client.api;
import io.swagger.client.ApiClient;
import io.swagger.client.model.InlineResponse200;
import org.junit.Before;
import org.junit.Test;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* API tests for StoriesApi
*/
public class StoriesApiTest {
private StoriesApi api;
@Before
public void setup() {
api = new ApiClient().createService(StoriesApi.class);
}
/**
* Top Stories
*
* The Top Stories API provides JSON and JSONP lists of articles and associated images by section.
*/
@Test
public void sectionFormatGetTest() {
String section = null;
String format = null;
String callback = null;
// InlineResponse200 response = api.sectionFormatGet(section, format, callback);
// TODO: test validations
}
}
| amardeshbd/android-daily-headlines | api-lib/src/test/java/io/swagger/client/api/StoriesApiTest.java | Java | mit | 903 |
/**
* @Author: shenyu <SamMFFL>
* @Date: 2016/12/08 10:18:06
* @Email: samfec@163.com
* @Last modified by: SamMFFL
* @Last modified time: 2016/12/13 14:39:33
*/
import React, {Component} from 'react';
import {
StyleSheet,
Text,
View,
Image,
TouchableHighlight,
ScrollView,
} from 'react-native';
import Header from '../Header';
import Box from '../Box';
import Icon from 'react-native-vector-icons/FontAwesome';
import demoImg from '../imgs/demo.png';
const styles = StyleSheet.create({
container: {
flex: 1,
backgroundColor: '#fff',
flexDirection: 'column'
},
scroll: {
flex: 1,
// borderWidth: 1,
marginBottom: 50,
},
box: {
height: 200,
borderTopWidth: 1,
borderBottomWidth: 1,
borderColor: '#D6DCDF',
backgroundColor: '#f5fcff',
marginBottom: 10,
paddingBottom: 20,
},
animateView: {
flex: 1,
justifyContent: 'center',
alignItems: 'center',
},
boxBtn: {
height: 30,
flexDirection: 'row',
justifyContent: 'space-around',
alignItems: 'center',
}
});
export default class setNativePropsDemo extends Component {
count = 0;
constructor(props) {
super(props);
this.startAnimationOfSize = this.startAnimationOfSize.bind(this);
this.stopAnimationOfSize = this.stopAnimationOfSize.bind(this);
this._renderSize = this._renderSize.bind(this);
this.animateSizeFunc = this.animateSizeFunc.bind(this);
this.state = {
width: 50,
height: 50,
}
}
_renderSize() {
return (
<View style={[styles.animateView,{ opacity:1 }]}>
<Image
ref="img"
source = { demoImg }
style={{
width: this.state.width,
height: this.state.height,
}}
/>
</View>
);
}
animateSizeFunc(){
requestAnimationFrame(() =>{
if(this.count<50){
++this.count;
// this.setState({
// width: this.state.width+10 ,
// height: this.state.height+10
// });
this.refs.img.setNativeProps({
style: {
width: this.state.width++,
height: this.state.height++,
}
});
// console.log('count',this.count)
this.animateSizeFunc();
}
});
}
startAnimationOfSize(){
this.setState({
width: 50,
height: 50
});
this.count = 0;
this.animateSizeFunc();
}
stopAnimationOfSize(){
this.setState({
width: 50,
height: 50
});
this.refs.img.setNativeProps({
style: {
width: 50,
height: 50,
}
});
this.count = 100;
setTimeout(()=>{
this.count = 0;
},100)
}
startAnimation(){
var count = 0;
var width=50, height=50;
while (++count < 10000) {
requestAnimationFrame(() =>{
// console.log(12)
this.refs.img.setNativeProps({
style: {
width: width,
height: height,
}
});
});
width += 0.01;
height += 0.01;
}
// LayoutAnimation.configureNext({
// duration: 700, //持续时间
// create: { // 视图创建
// type: LayoutAnimation.Types.spring,
// property: LayoutAnimation.Properties.scaleXY,// opacity、scaleXY
// },
// update: { // 视图更新
// type: LayoutAnimation.Types.spring,
// },
// });
// this.setState({
// width: this.state.width + 100,
// height: this.state.height + 100
// });
}
render() {
const {navigator, title} = this.props;
console.log(1)
return (
<View style={styles.container}>
<Header
title={title}
showArrow={Boolean(true)}
navigator={navigator}
/>
<ScrollView
vertical={Boolean(true)}
directionalLockEnabled={Boolean(true)}
showsHorizontalScrollIndicator={Boolean(false)}
indicatorStyle="white"
style={styles.scroll}
>
<Box
title="放大动画处理"
animatedContent={this._renderSize()}
playFunc={this.startAnimationOfSize}
pauseFunc={this.stopAnimationOfSize}
/>
</ScrollView>
</View>
)
}
componentDidMount(){
// this.startAnimation();
}
}
| yeeFlame/animate-for-RN | studyAnimate/containers/examples/setNativePropsDemo.js | JavaScript | mit | 5,282 |
package simpul.core;
import simpul.Interfaces;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class EventEmitter implements Interfaces.EventEmitter{
private class RegisteredCallback{
private final Interfaces.EventCallback cb;
private final boolean once;
private RegisteredCallback(Interfaces.EventCallback cb, boolean once) {
this.cb = cb;
this.once = once;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
RegisteredCallback that = (RegisteredCallback) o;
return cb.equals(that.cb);
}
@Override
public int hashCode() {
return cb.hashCode();
}
}
private final Map<String,List<RegisteredCallback>> listeners;
public EventEmitter() {
listeners = new HashMap<>();
}
@Override
public <T> void on(String event, Interfaces.EventCallback<T> cb) {
addListener(event, cb, false);
}
private <T> void addListener(String event, Interfaces.EventCallback<T> cb, boolean once) {
List<RegisteredCallback> callbacks = listeners.get(event);
if (callbacks == null) {
callbacks = new ArrayList<>();
listeners.put(event,callbacks);
}
callbacks.add(new RegisteredCallback(cb,once));
}
@Override
public <T> void once(String event, Interfaces.EventCallback<T> cb) {
addListener(event, cb, true);
}
@Override
public <T> void emit(String event, T data) {
List<RegisteredCallback> callbacks = listeners.get(event);
if (callbacks == null) {
return;
}
for (RegisteredCallback registeredCallback: callbacks) {
if (registeredCallback.once) {
//noinspection unchecked
removeListener(event,registeredCallback.cb);
}
//noinspection unchecked
registeredCallback.cb.invoke(data);
}
}
@Override
public <T> void removeListener(String event, Interfaces.EventCallback<T> cb) {
List<RegisteredCallback> callbacks = listeners.get(event);
if (callbacks == null) {
return;
}
callbacks.remove(new RegisteredCallback(cb,false));
}
@Override
public void removeAllListeners(String event) {
listeners.remove(event);
}
@Override
public int listeners(String event) {
List<RegisteredCallback> callbacks = listeners.get(event);
if (callbacks == null) {
return 0;
}
return callbacks.size();
}
}
| parroit/simpul | src/main/java/simpul/core/EventEmitter.java | Java | mit | 2,783 |
#!/usr/bin/env python2
import argparse
import xml.etree.ElementTree as ET
import subprocess
import os.path as path
from watchdog.observers import Observer
from watchdog.events import PatternMatchingEventHandler
import time
OUT_DIR = './_out'
HAXE_PATH = 'haxe'
def get_main_info(meta_root):
server_main, client_main = None, None
node = meta_root.find('server_main')
if node is not None:
server_main = {'src': '', 'class': 'Main', 'main_dir': ''}
src = node.attrib['src']
if src is not None:
server_main['main_dir'] = path.dirname(src)
server_main['src'] = path.relpath(src, server_main['main_dir'])
node = meta_root.find('client_main')
if node is not None:
client_main = {'src': '', 'class': 'Main', 'main_dir': ''}
src = node.attrib['src']
if src is not None:
client_main['main_dir'] = path.dirname(src)
client_main['src'] = path.relpath(src, client_main['main_dir'])
return server_main, client_main
def build_meta(meta_root):
meta_root.append(ET.Element('script', {'src': 'server.lua', 'type': 'server'}))
meta_root.append(ET.Element('script', {'src': 'client.lua', 'type': 'client'}))
for node in meta_root.findall('server_main'):
meta_root.remove(node)
for node in meta_root.findall('client_main'):
meta_root.remove(node)
ET.ElementTree(meta_root).write(path.join(OUT_DIR, 'meta.xml'))
def build_resource():
print('Building...')
# Parse meta.xml
tree = ET.parse('meta.xml')
root = tree.getroot()
# Get information about entry point
server_main, client_main = get_main_info(root)
server_out_path = path.join('..', OUT_DIR, 'server.lua')
client_out_path = path.join('..', OUT_DIR, 'client.lua')
# Invoke the compiler
if server_main is not None:
ret = subprocess.call([HAXE_PATH, '-main', server_main['class'], '-lua', server_out_path, server_main['src'], '-lib', 'mtasa-typings'], cwd=server_main['main_dir'])
if client_main is not None:
ret = subprocess.call([HAXE_PATH, '-main', client_main['class'], '-lua', client_out_path, client_main['src'], '-lib', 'mtasa-typings'], cwd=client_main['main_dir'])
# Build new meta
build_meta(root)
if __name__ == '__main__':
# Parse args
parser = argparse.ArgumentParser(description='haxe-mta build tools')
sub_parsers = parser.add_subparsers(help='sub commands')
build_parser = sub_parsers.add_parser('build', help='build resource')
run_parser = sub_parsers.add_parser('run', help='wait and recompile on changes')
build_parser.set_defaults(build_parser=True, run_parser=False)
run_parser.set_defaults(run_parser=True, build_parser=False)
args = parser.parse_args()
# Handle commands
if args.build_parser:
# Build resource once
build_resource()
elif args.run_parser:
# Build resource again on any change
class FileSystemListener(PatternMatchingEventHandler):
def __init__(self):
super(FileSystemListener, self).__init__(ignore_patterns=['**/_out*'])
def on_any_event(self, event):
build_resource()
event_handler = FileSystemListener()
observer = Observer()
observer.schedule(event_handler, '.', recursive=True)
observer.start()
try:
while True:
time.sleep(1)
except KeyboardInterrupt:
observer.stop()
observer.join()
| Jusonex/haxe-mtasa-typings | example/build.py | Python | mit | 3,302 |
<?php
/**
* Copyright (c) 2017. Puerto Parrot Booklet. Written by Dimitri Mostrey for www.puertoparrot.com
* Contact me at admin@puertoparrot.com or dmostrey@yahoo.com
*/
namespace App\Http\Controllers;
use App\Models\City;
use App\Models\Province;
use App\Models\Service;
use DB;
/**
* Class ApiController
*
* @package App\Http\Controllers
*/
class ApiController extends Controller
{
/**
* @return string
* @throws \Exception
*/
public static function Currency()
{
$data = array();
//$old = DB::table('currencies')->first();
$data['usdphp'] = ApiController::convertCurrency(1, 'USD', 'PHP') ? : $data['usdphp'] = cache('usdphp');
$data['eurphp'] = ApiController::convertCurrency(1, 'EUR', 'PHP') ? : $data['eurphp'] = cache('eurphp');
//empty the database
DB::table('currencies')->truncate();
//insert the data
DB::table('currencies')->insert($data);
cache(['usdphp' => $data['usdphp']], 400);
cache(['eurphp' => $data['eurphp']], 400);
$message = 'The currency has been successfully added: USDPHP = ' . $data['usdphp'] . ' and EURPHP ' . $data['eurphp'];
\Log::info('[ApiController Currency] ' . $message);
return $message;
/*$message = 'There was a problem adding the currency in the table at ' . date('Y-m-d H:i:s');
\Log::error('[ApiController Currency] ' . $message);
return $message;*/
}
/**
* @param $amount
* @param $from
* @param $to
*
* @return string|null
*/
private static function convertCurrency($amount, $from, $to)
{
//$url = "https://www.xe.com/currencyconverter/convert/?Amount={$amount}&From={$from}&To={$to}";
$url = "https://themoneyconverter.com/{$from}/{$to}.aspx";
$data = @file_get_contents($url);
if ( ! $data)
{
return null;
}
//preg_match_all("/<span class='uccResultAmount'>([0-9.]*)<\/span>/", $data, $converted);
preg_match_all('/<td id="PHP">([0-9.]*)<\/td>/', $data, $converted);
try
{
$final = $converted[1][0];
} catch (\Exception $e)
{
return null;
}
return round($final, 2);
}
/**
* @return \Illuminate\Contracts\View\Factory|\Illuminate\View\View
*/
public function googleCoordsPage()
{
$provinces = Province::where('id', '=', 1)->orderBy('id')->get();
$cities = City::where('id', '=', 1645)->get();
foreach ($cities as $city)
{
if ($data = $this->getGoogleCoords($city))
{
DB::table('cities')->where('id', $data['city_id'])->update(['lat' => $data['lat'],
'long' => $data['long'],
]);
}
}
return view('google_coords', compact('provinces'));
}
/**
* @param $city
*
* @return bool
*/
public function getGoogleCoords($city)
{
//create the call URL
$city_db = $city; //City::where('name', $city)->first();
$google_api = "AIzaSyB-7u1CvRIkmsjcHVVQgilPj6doeIh93oA";
$baseURL = "https://maps.googleapis.com/maps/api/geocode/json?address=";
$format = "&key=" . $google_api;
$query = "philippines,+" . urlencode($city_db->province->name) . ",+" . urlencode($city_db->name);
$callURL = $baseURL . $query . $format;
//make the call
$session = curl_init($callURL);
curl_setopt($session, CURLOPT_URL, $callURL);
curl_setopt($session, CURLOPT_BINARYTRANSFER, true);
curl_setopt($session, CURLOPT_RETURNTRANSFER, true);
$json = curl_exec($session);
curl_close($session);
// Decode JSON response:
$coords = json_decode($json, true);
if ($coords["status"] == "OK")
{
$data['lat'] = $coords["results"][0]["geometry"]["location"]["lat"];
$data['long'] = $coords["results"][0]["geometry"]["location"]["lng"];
$data['postcode'] = $coords["results"][0]["address_components"];
$data['city_id'] = $city_db->id;
return $data;
} else
{
return false;
}
}
public function blank()
{
//
$services = Service::whereNotNull('icon')
->with(['categories'])
->join('service_category_service', 'services.id', '=', 'service_category_service.service_id')
->join('service_categories', 'service_category_service.service_category_id', '=', 'service_categories.id')
->groupBy('service_categories.name')
->pluck('services.icon', 'service_categories.slug');
//$services['generic'] = 'https://maps.gstatic.com/mapfiles/place_api/icons/generic_business-71.png';
dd($services);
/*foreach ($services as $k => $v) {
echo "<h2>$k has $v</h2>";
$category = ServiceCategory::where('slug', '=', $k)->first();
if ($category) {
if (count($category->services) != 0) {
$categories = $category->services->where('icon', 'IS', null);
foreach ($categories as $c) {
echo $c->id . " " . $c->icon . " => <strong>". $c->title . "</strong><br>\n";
if($k != 'government' && $k != 'education' && $k != 'atm' && $c->title == strtoupper($c->title)) {
$c->title = ucwords(strtolower($c->title));
echo $c->title . "<br>";
$c->update();
}
}
}
echo "<br><hr><br>\n\n";
}
}*/
/*$category = ServiceCategory::where('slug', '=', 'terminal')->first();
$categories = $category->services->where('icon', 'IS', null);
foreach ($categories as $category) {
$category->icon = 'https://maps.gstatic.com/mapfiles/place_api/icons/bus-71.png';
$category->update();
echo "<strong>UPDATED</strong> " . $category->id . " " . $category->icon . " => <strong>". $category->title . "</strong><br>\n";
}*/
return view('blank');
}
}
| Dimimo/Booklet | app/Http/Controllers/ApiController.php | PHP | mit | 6,538 |
package utils.verbos;
/** Clase que representa una conjugación verbal
* Se ordena por valor completo, pero su igualdad se mira con la conjugación (sin tildes)
* @author andoni
*
*/
public class Conjugacion extends SufijoVerbal {
// en Conjugacion el modelo genérico pasa a ser ya el infinitivo concreto
private String conjugacion = "";
private String conjugacionSinTildes = "";
private String sufijoEnclitico = "";
private float confianza = 0.0F; // Confianza de detección automática del verbo (si procede)
/** Constructor por defecto de un sufijo de conjugación no reflexivo
* @param pInfinitivo Infinitivo verbal, p ej "amar", "deber", "vivir" ...
* @param pTerminacion Terminación verbal (la que se sustituye por el sufijo de conjugación), p ej "ar" "er" "ir" para esos 3 modelos
* @param pPersona Persona (1-3) de la conjugación, 0 si no procede
* @param pNumeroPlural Singular (false) o plural (true)
* @param pForma Forma verbal ("presente", "futuro"..., "participio", "gerundio" ...)
* @param pModoSubjuntivo Indicativo (false) o subjuntivo (true)
* @param pSufijo Sufijo verbal en minúsculas (con tildes, si procede) [si solo se usan las conjugaciones, puede ser ""]
* @param pConjugacion Conjugación verbal en minúsculas (con tildes, si procede) [si solo se usan los sufijos, puede ser ""]
* @param pConfianza Confianza (0.0F a 1.0F) de detección automática del verbo (si procede)
*/
public Conjugacion( String pInfinitivo, String pTerminacion, int pPersona, boolean pNumeroPlural, String pForma, boolean pModoSubjuntivo, String pSufijo, String pConjugacion, float pConfianza ) {
super( pInfinitivo, pTerminacion, pPersona, pNumeroPlural, pForma, pModoSubjuntivo, pSufijo );
conjugacion = pConjugacion; conjugacionSinTildes = UtilsVerbos.quitarTildes( pConjugacion );
confianza = pConfianza;
}
public float getConfianza() {
return confianza;
}
public String getInfinitivo() { // = getModelo()
return modelo;
}
public String getConjugacion() {
return conjugacion;
}
public String getConjugacionSinTildes() {
return conjugacionSinTildes;
}
public String getSufijoEnclitico( ) {
return sufijoEnclitico;
}
public void setConjugacion( String conj ) {
conjugacion = conj;
conjugacionSinTildes = UtilsVerbos.quitarTildes( conj );
}
public void setSufijoEnclitico( String se ) {
sufijoEnclitico = se;
}
public void setConfianza( float conf ) {
confianza = conf;
}
/** Pone la forma verbal de la conjugación, eliminando el resto de los datos (dejándolos a blanco),
* preparando este elemento para la búsqueda.
* @param pConjugacion forma verbal
*/
/* Activa internamente el flag de búsqueda para poder encontrar la primera ocurrencia en la estructura
*/
public void initConjugBusqueda( String pConjugacion ) {
conjugacion = pConjugacion;
conjugacionSinTildes = UtilsVerbos.quitarTildes( pConjugacion );
flagBusqueda = true; // Estamos buscando este elemento en el Tree
modelo = ""; persona = 0; numeroPlural = false; forma = ""; modoSubjuntivo = false; sufijo = ""; sufijoSinTildes = "";
}
public int compareTo( SufijoVerbal c2 ) {
// Si todo igual se devuelve 0
if (c2 instanceof Conjugacion) {
return compareTo( (Conjugacion)c2 );
} return -1;
}
public int compareTo( Conjugacion c2 ) {
// Si todo igual se devuelve 0
if (modelo.equals(c2.modelo) && terminacion==c2.terminacion && persona==c2.persona && numeroPlural==c2.numeroPlural && forma.equals(c2.forma) &&
modoSubjuntivo==c2.modoSubjuntivo && sufijo.equals(c2.sufijo) && conjugacion.equals(c2.conjugacion))
return 0;
// Si alguno está en modo de búsqueda y coinciden las claves se devuelve 0
if (conjugacionSinTildes.equals(c2.conjugacionSinTildes) && (flagBusqueda || c2.flagBusqueda)) return 0;
// Si no, -1 o +1
if (conjugacionSinTildes.compareTo( c2.conjugacionSinTildes )<0) return -1; else return +1;
}
public String showReduc() {
return "<" + modelo + ">" + persona + (numeroPlural?"P":"S") +
forma.substring(0,4) + (modoSubjuntivo?"Sub":"") + (reflexivo?"reflexivo":"");
}
public String show( boolean mostrarConfianza ) {
return conjugacion + " (<" + modelo + "> (-" + terminacion + ") " + persona + (numeroPlural?"P ":"S ") +
forma + (modoSubjuntivo?" subju":" indic") + (reflexivo?" reflexivo":"") +
(sufijo.equals("")?"":" -"+sufijo) +
( (sufijoEnclitico.equals(""))?"":(" -" + sufijoEnclitico) ) +
(mostrarConfianza?" [confi " + confianza + "]":"") +
")";
}
public String toString() {
return conjugacionSinTildes;
}
}
| andoni-eguiluz/UD-Prog3-ant | src/utils/verbos/Conjugacion.java | Java | mit | 4,580 |
const SPRINTER_COUNT = 7; // how many lanes there are, including the player
var runners = []; // lineup
var runner; // player
var laneWidth; // width of each lane
var startTime; // beginning of the game
function setup() {
createCanvas(window.innerWidth, window.innerHeight);
/* initialize opponents */
var opponentColor = randomColor(); // color of opponents
for (var i = 1; i < SPRINTER_COUNT; i++) {
// push opponents
runners.push(new Sprinter(random(0.075) + 0.1, opponentColor));
}
/* initialize player */
runner = new Sprinter(0, invertColor(opponentColor));
runners.splice(Math.floor(runners.length / 2), 0, runner);
/* initialize stopwatch */
startTime = new Date().getTime();
laneWidth = height / runners.length;
}
function draw() {
background(51);
handleTrack();
stride();
}
/**
* handle user input
*/
function keyPressed() {
runner.run(keyCode);
}
/**
* AI for opponents
*/
function stride() {
for (var r = 0; r < runners.length; r++) {
// loop through runners
if (random() < runners[r].skill) { // calculate the speed of the runner
// take a stride
// LEFT_ARROW + RIGHT_ARROW = 76, therefore;
// 76 - LEFT_ARROW = RIGHT_ARROW &
// 76 - RIGHT_ARROW = LEFT_ARROW
runners[r].run(76 - runners[r].previousKey);
}
}
}
/**
* draws & updates runners
* draws lanes
*/
function handleTrack() {
for (var r = 0; r < runners.length; r++) {
/* draw & update runners */
runners[r].draw(r, laneWidth);
runners[r].update();
/* draw lanes */
var y1 = (r / runners.length) * height; // inner line
var y2 = (r / runners.length) * height + laneWidth; // outer line
stroke("#A14948");
strokeWeight(3);
line(0, y1, width, y1);
line(0, y2, width, y2);
}
}
/**
* returns a random color
*/
function randomColor() {
return color(random(255), random(255), random(255));
}
/**
* returns an inverted color of the passed col
*/
function invertColor(col) {
var r = 255 - red(col);
var g = 255 - green(col);
var b = 255 - blue(col);
return color(r, g, b);
}
| Kaelinator/AGAD | Sprinter Game/SprinterGame.js | JavaScript | mit | 2,082 |
<?php
if (! defined('BASEPATH')) exit('No direct Script access allowed');
class Prova_model extends CI_Model
{
/*------------------------------
ATRIBUTOS
------------------------------*/
private $idProva;
private $nome;
private $introducao;
private $inicio;
private $termino;
private $tentativas;
private $objDisciplina;
private $objTurma;
private $data_exclusao;
/*------------------------------
CONSTRUTOR
------------------------------*/
public function __construct()
{
parent::__construct();
}
/*------------------------------
METODOS
------------------------------*/
public function GetidProva() // RETORNA PROVA
{
return $this->idProva;
}
public function SetidProva($idProva) // ATRIBUI PROVA
{
$this->idProva = $idProva;
}
public function GetNome() // RETORNA NOME
{
return $this->nome;
}
public function SetNome($nome) // ATRIBUI NOME
{
$this->nome = $nome;
}
public function GetIntroducao() // RETORNA INTRODUCAO
{
return $this->introducao;
}
public function SetIntroducao($introducao) // ATRIBUI INTRODUCAO
{
$this->introducao = $introducao;
}
public function GetInicio() // RETORNA INICIO DA PROVA
{
return $this->inicio;
}
public function SetInicio($inicio) // ATRIBUI INICIO DA PROVA
{
$this->inicio = $inicio;
}
public function GetTermino() // RETORNA TERMINO DA PROVA
{
return $this->termino;
}
public function SetTermino($termino) // ATRIBUI TERMINO DA PROVA
{
$this->termino = $termino;
}
public function GetTentativas() // RETORNA TENTATIVAS DA PROVA
{
return $this->tentativas;
}
public function SetTentativas($tentativas) // ATRIBUI TENTATIVAS DA PROVA
{
$this->tentativas = $tentativas;
}
/*--- NÃO NECESSARIO
public function GetobjDisciplina()
{
return $this->objDisciplina;
}
public function SetobjDisciplina($objDisciplina)
{
$this->objDisciplina = $objDisciplina;
}
public function GetobjTurma()
{
return $this->objTurma;
}
public function SetobjTurma($objTurma)
{
$this->objTurma = $objTurma;
}
--- DESCONTINUADO */
public function GetDataExclusao()
{
return $this->data_exclusao;
}
public function SetDataExclusao($data_exclusao)
{
$this->data_exclusao = $data_exclusao;
}
public function consultar(){
$this->db->select('p.*,d.descricao as disciplina');
$this->db->where('p.data_exclusao',null);
$this->db->from('provas p');
$this->db->join('disciplina d','p.disciplina_iddisciplina = d.iddisciplina');
return $this->db->get()->result();
}
public function Consultar_Id($id){
$id = addslashes($id);
return $this->db->get_where('provas',array('idprovas'=>$id))->row();
}
public function ConsultarDisciplinaProva(){
$this->db->select('p.idprovas,p.nome,d.iddisciplina,d.descricao as disciplina');
$this->db->where('p.data_exclusao',null);
$this->db->where('p.aplicada',1);
$this->db->from('provas p');
$this->db->join('disciplina d','p.disciplina_iddisciplina = d.iddisciplina');
return $this->db->get()->result();
}
public function Contagem(){
$this->db->select('idprovas');
$this->db->where('p.data_exclusao',null);
$this->db->where('p.aplicada',1);
$this->db->from('provas p');
return $this->db->get()->result()-num_rows;
}
public function Validacao($id,$aluno) {
$this->db->where('idprovas', $id);
$this->db->from('provas');
$query = $this->db->get();
if ($query->num_rows() == 1) {
return true; // RETORNA VERDADEIRO
}
}
public function inserir(){
$object = array(
'idprovas' => $this->GetIdProva(),
'nome' => $this->GetNome(),
'introducao' => $this->GetIntroducao(),
'inicio' => $this->GetInicio(),
'termino' => $this->GetTermino(),
'tentativa' => $this->GetTentativas(),
'turma_idturma' => $this->Turma_model->GetidTurma(),
'disciplina_iddisciplina' => $this->Disciplina_model->GetIdDisciplina(),
'data_exclusao' => null,
);
$query = $this->db->insert('provas',$object);
if($query){
$this->session->set_flashdata('sucesso','<div class="alert alert-success alert-dismissable">
<button type="button" class="close" data-dismiss="alert" aria-hidden="true">×</button>
<h4> <i class="icon fa fa-check"></i> Alerta!</h4>
Sua Turma foi cadastrada com sucesso..</div>');
redirect('prova');
}
}
public function update(){
$object = array(
'idprovas' => $this->GetIdProva(),
'nome' => $this->GetNome(),
'introducao' => $this->GetIntroducao(),
'inicio' => $this->GetInicio(),
'termino' => $this->GetTermino(),
'tentativa' => $this->GetTentativas(),
'turma_idturma' => $this->Turma_model->GetidTurma(),
'disciplina_iddisciplina' => $this->Disciplina_model->GetIdDisciplina(),
'data_exclusao' => null,
);
$this->db->where('idprovas', $this->GetIdProva());
if($this->db->update('provas',$object)){
$this->session->set_flashdata('sucesso','<div class="alert alert-success alert-dismissable">
<button type="button" class="close" data-dismiss="alert" aria-hidden="true">×</button>
<h4><i class="icon fa fa-check"></i> Alerta!</h4>
Seu produto foi Alterado com sucesso..</div>');
redirect('prova');
}
}
public function aplicar(){
$object = array(
'aplicada' => 1,
);
$this->db->where('idprovas', $this->GetIdProva());
if($this->db->update('provas',$object)){
$this->session->set_flashdata('sucesso','<div class="alert alert-success alert-dismissable">
<button type="button" class="close" data-dismiss="alert" aria-hidden="true">×</button>
<h4><i class="icon fa fa-check"></i> Alerta!</h4>
Seu produto foi Alterado com sucesso..</div>');
redirect('prova');
}
}
public function excluir(){
$object = array(
'data_exclusao' => $this->GetDataExclusao()
);
$this->db->where('idprovas', $this->GetIdProva());
if($this->db->update('provas',$object)){
$this->session->set_flashdata('sucesso','<div class="alert alert-success alert-dismissable">
<button type="button" class="close" data-dismiss="alert" aria-hidden="true">×</button>
<h4><i class="icon fa fa-check"></i> Alerta!</h4>
Seu produto foi deletado com sucesso..</div>');
redirect('prova');
}
}
public function Consulta_ProvaDisciplina($iddisciplina){
$this->db->select('*');
$this->db->where('p.data_exclusao',null);
$this->db->where('p.aplicada',1);
$this->db->where('p.disciplina_iddisciplina',$iddisciplina);
$this->db->from('provas p');
$this->db->join('disciplina d', 'p.disciplina_iddisciplina = d.iddisciplina');
return $this->db->get()->result();
}
public function Consulta_ProvaDisciplina2($matricula){
$this->db->select('*');
$this->db->from('cursando c');
$this->db->where('c.disciplina_iddisciplina',$matricula);
$this->db->where('p.aplicada',1);
$this->db->join('aluno a', 'c.Aluno_idAluno = a.idaluno');
$this->db->join('disciplina d', 'c.disciplina_iddisciplina = d.iddisciplina');
$this->db->join('provas p', 'p.disciplina_iddisciplina = d.iddisciplina');
return $this->db->get()->result();
}
}
?> | Lasterblade/SGPLTE | application/models/Prova_model.php | PHP | mit | 8,474 |
#include "qrcodedialog.h"
#include "ui_qrcodedialog.h"
#include "bitcoinunits.h"
#include "guiconstants.h"
#include "guiutil.h"
#include "optionsmodel.h"
#include <QPixmap>
#if QT_VERSION < 0x050000
#include <QUrl>
#endif
#include <qrencode.h>
QRCodeDialog::QRCodeDialog(const QString &addr, const QString &label, bool enableReq, QWidget *parent) :
QDialog(parent),
ui(new Ui::QRCodeDialog),
model(0),
address(addr)
{
ui->setupUi(this);
setWindowTitle(QString("%1").arg(address));
ui->chkReqPayment->setVisible(enableReq);
ui->lblAmount->setVisible(enableReq);
ui->lnReqAmount->setVisible(enableReq);
ui->lnLabel->setText(label);
ui->btnSaveAs->setEnabled(false);
genCode();
}
QRCodeDialog::~QRCodeDialog()
{
delete ui;
}
void QRCodeDialog::setModel(OptionsModel *model)
{
this->model = model;
if (model)
connect(model, SIGNAL(displayUnitChanged(int)), this, SLOT(updateDisplayUnit()));
// update the display unit, to not use the default ("BTC")
updateDisplayUnit();
}
void QRCodeDialog::genCode()
{
QString uri = getURI();
if (uri != "")
{
ui->lblQRCode->setText("");
QRcode *code = QRcode_encodeString(uri.toUtf8().constData(), 0, QR_ECLEVEL_L, QR_MODE_8, 1);
if (!code)
{
ui->lblQRCode->setText(tr("Error encoding URI into QR Code."));
return;
}
myImage = QImage(code->width + 8, code->width + 8, QImage::Format_RGB32);
myImage.fill(0xffffff);
unsigned char *p = code->data;
for (int y = 0; y < code->width; y++)
{
for (int x = 0; x < code->width; x++)
{
myImage.setPixel(x + 4, y + 4, ((*p & 1) ? 0x0 : 0xffffff));
p++;
}
}
QRcode_free(code);
ui->lblQRCode->setPixmap(QPixmap::fromImage(myImage).scaled(300, 300));
ui->outUri->setPlainText(uri);
}
}
QString QRCodeDialog::getURI()
{
QString ret = QString("roxcoin:%1").arg(address);
int paramCount = 0;
ui->outUri->clear();
if (ui->chkReqPayment->isChecked())
{
if (ui->lnReqAmount->validate())
{
// even if we allow a non BTC unit input in lnReqAmount, we generate the URI with BTC as unit (as defined in BIP21)
ret += QString("?amount=%1").arg(BitcoinUnits::format(BitcoinUnits::BTC, ui->lnReqAmount->value()));
paramCount++;
}
else
{
ui->btnSaveAs->setEnabled(false);
ui->lblQRCode->setText(tr("The entered amount is invalid, please check."));
return QString("");
}
}
if (!ui->lnLabel->text().isEmpty())
{
QString lbl(QUrl::toPercentEncoding(ui->lnLabel->text()));
ret += QString("%1label=%2").arg(paramCount == 0 ? "?" : "&").arg(lbl);
paramCount++;
}
if (!ui->lnMessage->text().isEmpty())
{
QString msg(QUrl::toPercentEncoding(ui->lnMessage->text()));
ret += QString("%1message=%2").arg(paramCount == 0 ? "?" : "&").arg(msg);
paramCount++;
}
// limit URI length to prevent a DoS against the QR-Code dialog
if (ret.length() > MAX_URI_LENGTH)
{
ui->btnSaveAs->setEnabled(false);
ui->lblQRCode->setText(tr("Resulting URI too long, try to reduce the text for label / message."));
return QString("");
}
ui->btnSaveAs->setEnabled(true);
return ret;
}
void QRCodeDialog::on_lnReqAmount_textChanged()
{
genCode();
}
void QRCodeDialog::on_lnLabel_textChanged()
{
genCode();
}
void QRCodeDialog::on_lnMessage_textChanged()
{
genCode();
}
void QRCodeDialog::on_btnSaveAs_clicked()
{
QString fn = GUIUtil::getSaveFileName(this, tr("Save QR Code"), QString(), tr("PNG Images (*.png)"));
if (!fn.isEmpty())
myImage.scaled(EXPORT_IMAGE_SIZE, EXPORT_IMAGE_SIZE).save(fn);
}
void QRCodeDialog::on_chkReqPayment_toggled(bool fChecked)
{
if (!fChecked)
// if chkReqPayment is not active, don't display lnReqAmount as invalid
ui->lnReqAmount->setValid(true);
genCode();
}
void QRCodeDialog::updateDisplayUnit()
{
if (model)
{
// Update lnReqAmount with the current unit
ui->lnReqAmount->setDisplayUnit(model->getDisplayUnit());
}
}
| Roxcoin/roxcointor | src/qt/qrcodedialog.cpp | C++ | mit | 4,343 |
using System;
using Microsoft.Tools.WindowsInstallerXml.Bootstrapper;
namespace Shimmer.Client.WiXUi
{
public interface IWiXEvents
{
IObservable<DetectBeginEventArgs> DetectBeginObs { get; }
IObservable<DetectPackageCompleteEventArgs> DetectPackageCompleteObs { get; }
IObservable<DetectRelatedBundleEventArgs> DetectRelatedBundleObs { get; }
IObservable<PlanPackageBeginEventArgs> PlanPackageBeginObs { get; }
IObservable<PlanCompleteEventArgs> PlanCompleteObs { get; }
IObservable<ApplyBeginEventArgs> ApplyBeginObs { get; }
IObservable<ApplyCompleteEventArgs> ApplyCompleteObs { get; }
IObservable<ResolveSourceEventArgs> ResolveSourceObs { get; }
IObservable<ErrorEventArgs> ErrorObs { get; }
IObservable<ExecuteMsiMessageEventArgs> ExecuteMsiMessageObs { get; }
IObservable<ExecuteProgressEventArgs> ExecuteProgressObs { get; }
IObservable<ProgressEventArgs> ProgressObs { get; }
IObservable<CacheAcquireBeginEventArgs> CacheAcquireBeginObs { get; }
IObservable<CacheCompleteEventArgs> CacheCompleteObs { get; }
IEngine Engine { get; }
IntPtr MainWindowHwnd { get; }
Display DisplayMode { get; }
LaunchAction Action { get; }
void ShouldQuit();
}
} | stefanolson/Squirrel.Windows.MahApps | src/Shimmer.WiXUiClient/IWiXEvents.cs | C# | mit | 1,324 |
/**
* Tree View Collapse
* @see https://github.com/cpojer/mootools-tree
*/
export default new Class({
Implements: [Options, Class.Single],
options: {
animate: false,
fadeOpacity: 1,
className: 'collapse',
selector: 'a.expand',
listSelector: 'li',
childSelector: 'ul'
},
initialize: function(element, options) {
this.setOptions(options);
element = this.element = document.id(element);
return this.check(element) || this.setup();
},
setup: function() {
var self = this;
this.handler = function(e) {
self.toggle(this, e);
};
this.mouseover = function() {
if (self.hasChildren(this)) {
this.getElement(self.options.selector).fade(1);
}
};
this.mouseout = function() {
if (self.hasChildren(this)) {
this.getElement(self.options.selector).fade(self.options.fadeOpacity);
}
};
this.prepare().attach();
},
attach: function() {
var element = this.element;
element.addEvent('click:relay(' + this.options.selector + ')', this.handler);
if (this.options.animate) {
element.addEvent('mouseover:relay(' + this.options.listSelector + ')', this.mouseover);
element.addEvent('mouseout:relay(' + this.options.listSelector + ')', this.mouseout);
}
return this;
},
detach: function() {
this.element.removeEvent('click:relay(' + this.options.selector + ')', this.handler)
.removeEvent('mouseover:relay(' + this.options.listSelector + ')', this.mouseover)
.removeEvent('mouseout:relay(' + this.options.listSelector + ')', this.mouseout);
return this;
},
prepare: function() {
this.prepares = true;
this.element.getElements(this.options.listSelector).each(this.updateElement, this);
this.prepares = false;
return this;
},
updateElement: function(element) {
var child = element.getElement(this.options.childSelector);
var icon = element.getElement(this.options.selector);
if (!this.hasChildren(element)) {
if (!this.options.animate || this.prepares) {
icon.setStyle('opacity', 0);
} else {
icon.fade(0);
}
return;
}
if (this.options.animate) {
icon.fade(this.options.fadeOpacity);
} else {
icon.setStyle('opacity', this.options.fadeOpacity);
}
if (this.isCollapsed(child)) {
icon.removeClass('collapse');
} else {
icon.addClass('collapse');
}
},
hasChildren: function(element) {
var child = element.getElement(this.options.childSelector);
return (child && child.getChildren().length);
},
isCollapsed: function(element) {
if (!element) {
return;
}
return (element.getStyle('display') == 'none');
},
toggle: function(element, event) {
if (event) {
event.preventDefault();
}
if (!element.match(this.options.listSelector)) {
element = element.getParent(this.options.listSelector);
}
if (this.isCollapsed(element.getElement(this.options.childSelector))) {
this.expand(element);
} else {
this.collapse(element);
}
return this;
},
expand: function(element) {
element.getElement(this.options.childSelector).setStyle('display', 'block');
element.getElement(this.options.selector).addClass(this.options.className);
return this;
},
collapse: function(element) {
if (!element.getElement(this.options.childSelector)) {
return;
}
element.getElement(this.options.childSelector).setStyle('display', 'none');
element.getElement(this.options.selector).removeClass(this.options.className);
return this;
}
});
| codepolitan/caoutchouc | src/view/tree/utils/collapse.js | JavaScript | mit | 3,649 |
#ifndef ADD_BINARY_HPP_
#define ADD_BINARY_HPP_
#include <string>
using namespace std;
class AddBinary {
public:
string addBinary(string a, string b);
};
#endif // ADD_BINARY_HPP_
| yanzhe-chen/leetcode | include/AddBinary.hpp | C++ | mit | 188 |
require 'spec_helper'
describe Authorization do
let(:client_id) { "12345" }
let(:client_secret) { "Y9axRxR9bcvSW2cc0IwoWeq7" }
let(:expires_in) { 3600 }
let(:access_token) { "75sf4WWbwfr6HYd5URpC6KBk" }
subject do
described_class
end
before do
stub_requests
end
describe '#with_authorization' do
it "returns a valid authorization" do
subject.new(client_id, client_secret).with_authorization do |access_token|
expect(access_token).to eq access_token
end
end
it "returns Unauthorized" do
expect {
subject.new("invalid", client_secret).with_authorization
}.to raise_error NotAuthorizedError
end
end
describe '#authorize!' do
it "returns a valid authorization" do
auth = subject.new(client_id, client_secret).authorize!
expect(auth.access_token).to eq access_token
expect(auth.expires_in).not_to be_nil
end
it "returns Unauthorized" do
expect {
subject.new("invalid", client_secret).authorize!
}.to raise_error NotAuthorizedError
end
end
describe '#authorized?' do
it "returns TRUE when authorization NOT Expired" do
auth = subject.new(client_id, client_secret).authorize!
expect(auth.authorized?).to be true
end
it "returns FALSE when authorization Expired" do
auth = subject.new(client_id, client_secret).authorize!
allow(Time).to receive(:now).and_return(auth.expires_at + 1)
expect(auth.authorized?).to be false
end
end
describe '#to_yaml' do
it "serializes and deserializes Authorization" do
auth = subject.new(client_id, client_secret).authorize!
expect(YAML::load(auth.to_yaml)).to be_instance_of(ExactTargetRest::Authorization)
end
end
private
def stub_requests
stub_request(:post, ExactTargetRest::AUTH_URL).
with(
:body => "{\"clientId\":\"#{client_id}\",\"clientSecret\":\"#{client_secret}\"}",
:headers => {'Accept'=>'*/*', 'Accept-Encoding'=>'gzip;q=1.0,deflate;q=0.6,identity;q=0.3', 'Content-Type'=>'application/json', 'User-Agent'=>'Faraday v0.9.2'}
).
to_return(
headers: {"Content-Type"=> "application/json"},
body: %({"accessToken": "#{access_token}", "expiresIn": 3600}),
status: 200
)
stub_request(:any, ExactTargetRest::AUTH_URL).
with(
:body => "{\"clientId\":\"invalid\",\"clientSecret\":\"#{client_secret}\"}",
:headers => {'Accept'=>'*/*', 'Accept-Encoding'=>'gzip;q=1.0,deflate;q=0.6,identity;q=0.3', 'Content-Type'=>'application/json', 'User-Agent'=>'Faraday v0.9.2'}
).
to_return(
headers: {"Content-Type"=> "application/json"},
body: %({"message": "Unauthorized","errorcode": 1,"documentation": ""}),
status: 401
)
end
end
| VAGAScom/exact_target_rest | spec/lib/exact_target_rest/authorization_spec.rb | Ruby | mit | 2,830 |
<?php
return array (
'id' => 'mot_xt882_ver1',
'fallback' => 'generic_android_ver2_3',
'capabilities' =>
array (
'uaprof' => 'http://uaprof.motorola.com/phoneconfig/motomb860/Profile/motoxt882.rdf',
'model_name' => 'XT882',
'brand_name' => 'Motorola',
'marketing_name' => 'MOTO XT882',
'physical_screen_height' => '89',
'physical_screen_width' => '50',
'resolution_width' => '540',
'resolution_height' => '960',
),
);
| cuckata23/wurfl-data | data/mot_xt882_ver1.php | PHP | mit | 461 |
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Text;
using System.Threading.Tasks;
namespace AssaultBird2454.VPTU.Server.Instances
{
public class ServerInstance
{
#region Variables and Objects
#region Base Server
/// <summary>
/// Server class for handeling server communications
/// </summary>
public Networking.Server.TCP.TCP_Server Server { get; private set; }
/// <summary>
/// Server_CommandHandeler contains functions for creating and calling command callbacks
/// </summary>
public Networking.Server.Command_Handeler.Server_CommandHandeler Server_CommandHandeler { get; private set; }
public Server.Base_Commands Base_Server_Commands { get; private set; }
private object Logger;
/// <summary>
/// Server_Logger contains functions for server logging
/// </summary>
public object Server_Logger
{
get
{
return Logger;
}
set
{
if (value is Class.Logging.I_Logger)
{
Logger = value;
}
else
{
throw new Class.Logging.Invalid_Logger_Class_Exception();
}
}
}
/// <summary>
/// Save Manager class, contains Save Data
/// </summary>
public SaveManager.SaveManager SaveManager { get; private set; }
#endregion
#region Authentication
public List<KeyValuePair<Networking.Server.TCP.TCP_ClientNode, Authentication_Manager.Data.User>> Authenticated_Clients;
public bool Authenticate_Client(Networking.Server.TCP.TCP_ClientNode cn, CommandData.Auth.Login Login)
{
Authenticated_Clients.RemoveAll(x => x.Key == cn);
Authentication_Manager.Data.Identity ID = SaveManager.SaveData.Identities.Find(x => x.Key == Login.Client_Key);
if (ID != null)
{
Authentication_Manager.Data.User user = SaveManager.SaveData.Users.Find(x => x.UserID == ID.UserID);
Authenticated_Clients.Add(new KeyValuePair<Networking.Server.TCP.TCP_ClientNode, Authentication_Manager.Data.User>(cn, user));
((Class.Logging.I_Logger)Server_Logger).Log("Client @ " + cn.ID + " Passed authenticated as User " + user.Name + " (" + user.IC_Name + ")", Class.Logging.LoggerLevel.Audit);
cn.Send(new CommandData.Auth.Login() { Client_Key = ID.Key, Auth_State = CommandData.Auth.AuthState.Passed, UserData = user });
return true;
}
else
{
((Class.Logging.I_Logger)Server_Logger).Log("Client @ " + cn.ID + " Failed authentication", Class.Logging.LoggerLevel.Audit);
cn.Send(new CommandData.Auth.Login() { Client_Key = "", Auth_State = CommandData.Auth.AuthState.Failed });
return false;
}
}
public void DeAuthenticate_Client(Networking.Server.TCP.TCP_ClientNode cn)
{
Authenticated_Clients.RemoveAll(x => x.Key == cn);
((Class.Logging.I_Logger)Server_Logger).Log("Client @ " + cn.ID + " DeAuthenticated", Class.Logging.LoggerLevel.Audit);
cn.Send(new CommandData.Auth.Logout() { Auth_State = CommandData.Auth.AuthState.DeAuthenticated });
}
public bool CheckAuthentication_Client(Networking.Server.TCP.TCP_ClientNode cn)
{
if (Authenticated_Clients.FindAll(x => x.Key == cn).Count >= 1)
return true;
return false;
}
#endregion
#endregion
public ServerInstance(Class.Logging.I_Logger _Logger, string SaveData, int Port = 25444)
{
#region Logs
Server_Logger = _Logger;
((Class.Logging.I_Logger)Server_Logger).Setup(Class.Logging.Logger_Type.Server);
#endregion
#region SaveManager
((Class.Logging.I_Logger)Server_Logger).Log("Initilizing Save Manager", Class.Logging.LoggerLevel.Debug);
SaveManager = new VPTU.SaveManager.SaveManager(SaveData);// Create Manager Object
((Class.Logging.I_Logger)Server_Logger).Log("Loading Save Data", Class.Logging.LoggerLevel.Debug);
SaveManager.Load_SaveData();// Load Data
#endregion
#region Command Handeler
((Class.Logging.I_Logger)Server_Logger).Log("Initilizing Command Handeler", Class.Logging.LoggerLevel.Debug);
Server_CommandHandeler = new Networking.Server.Command_Handeler.Server_CommandHandeler();
Server_CommandHandeler.CommandRegistered += Server_CommandHandeler_CommandRegistered;
Server_CommandHandeler.CommandUnRegistered += Server_CommandHandeler_CommandUnRegistered;
Server_CommandHandeler.RateLimitChanged_Event += Server_CommandHandeler_RateLimitChanged_Event;
Server_CommandHandeler.RateLimitHit_Event += Server_CommandHandeler_RateLimitHit_Event;
Base_Server_Commands = new Server.Base_Commands(this);
((Class.Logging.I_Logger)Server_Logger).Log("Registering Base Server Commands", Class.Logging.LoggerLevel.Debug);
Base_Server_Commands.Register_Commands(Server_CommandHandeler);
#endregion
#region Networking
((Class.Logging.I_Logger)Server_Logger).Log("Initilizing Base Network", Class.Logging.LoggerLevel.Debug);
Server = new Networking.Server.TCP.TCP_Server(IPAddress.Any, Server_CommandHandeler, Port);
Server.TCP_AcceptClients_Changed += Server_TCP_AcceptClients_Changed;
Server.TCP_ClientState_Changed += Server_TCP_ClientState_Changed;
Server.TCP_Data_Error_Event += Server_TCP_Data_Error_Event;
Server.TCP_Data_Event += Server_TCP_Data_Event;
Server.TCP_ServerState_Changed += Server_TCP_ServerState_Changed;
#endregion
#region Plugins
#endregion
Authenticated_Clients = new List<KeyValuePair<Networking.Server.TCP.TCP_ClientNode, Authentication_Manager.Data.User>>();
((Class.Logging.I_Logger)Server_Logger).Log("Server Ready!", Class.Logging.LoggerLevel.Info);
}
public void StartServerInstance()
{
#region Start Server
((Class.Logging.I_Logger)Server_Logger).Log("Starting Base Network", Class.Logging.LoggerLevel.Info);
try
{
Authenticated_Clients = new List<KeyValuePair<Networking.Server.TCP.TCP_ClientNode, Authentication_Manager.Data.User>>();
Server.Start();
((Class.Logging.I_Logger)Server_Logger).Log("Base Network Started", Class.Logging.LoggerLevel.Info);
}
catch (Exception e)
{
((Class.Logging.I_Logger)Server_Logger).Log("Base Network Failed to Start", Class.Logging.LoggerLevel.Fatil);
((Class.Logging.I_Logger)Server_Logger).Log(e.ToString(), Class.Logging.LoggerLevel.Debug);
Authenticated_Clients = new List<KeyValuePair<Networking.Server.TCP.TCP_ClientNode, Authentication_Manager.Data.User>>();
StopServerInstance();
return;
}
#endregion
}
public void StopServerInstance()
{
#region Stop Server
((Class.Logging.I_Logger)Server_Logger).Log("Stopping Base Network", Class.Logging.LoggerLevel.Info);
try
{
Server.Stop();
((Class.Logging.I_Logger)Server_Logger).Log("Base Network Stopped", Class.Logging.LoggerLevel.Info);
}
catch (Exception e)
{
((Class.Logging.I_Logger)Server_Logger).Log("Base Network Failed to Stop", Class.Logging.LoggerLevel.Fatil);
((Class.Logging.I_Logger)Server_Logger).Log(e.ToString(), Class.Logging.LoggerLevel.Debug);
return;
}
#endregion
}
#region Event Handelers
private void Server_CommandHandeler_CommandUnRegistered(string Command)
{
((Class.Logging.I_Logger)Server_Logger).Log("Command Unregistered -> Command: \"" + Command + "\"", Class.Logging.LoggerLevel.Debug);
}
private void Server_CommandHandeler_CommandRegistered(string Command)
{
((Class.Logging.I_Logger)Server_Logger).Log("Command Registered -> Command: \"" + Command + "\"", Class.Logging.LoggerLevel.Debug);
}
private void Server_CommandHandeler_RateLimitChanged_Event(string Command, bool Enabled, int Limit)
{
if (Enabled)
{
((Class.Logging.I_Logger)Server_Logger).Log("Command Rate Limit -> Command: \"" + Command + "\" Setting: \"" + Limit + " Invokes per 5 minute block per client\"", Class.Logging.LoggerLevel.Debug);
}
else
{
((Class.Logging.I_Logger)Server_Logger).Log("Command Rate Limit -> Command: \"" + Command + "\" Setting: \"No Limit\"", Class.Logging.LoggerLevel.Debug);
}
}
private void Server_CommandHandeler_RateLimitHit_Event(string Name, Networking.Server.TCP.TCP_ClientNode Client)
{
((Class.Logging.I_Logger)Server_Logger).Log("Client \"" + Client.ID + "\" hit the rate limit for command \" " + Name + " \"", Class.Logging.LoggerLevel.Warning);
}
private void Server_TCP_ServerState_Changed(Networking.Data.Server_Status Server_State)
{
((Class.Logging.I_Logger)Server_Logger).Log("Base Network is " + Server_State.ToString(), Class.Logging.LoggerLevel.Debug);
}
private void Server_TCP_Data_Event(string Data, Networking.Server.TCP.TCP_ClientNode Client, Networking.Server.TCP.DataDirection Direction)
{
if (Direction == Networking.Server.TCP.DataDirection.Recieve)
{
((Class.Logging.I_Logger)Server_Logger).Log("Data Recieved from " + Client.ID, Class.Logging.LoggerLevel.Debug);
}
else if (Direction == Networking.Server.TCP.DataDirection.Send)
{
((Class.Logging.I_Logger)Server_Logger).Log("Data Sent to " + Client.ID, Class.Logging.LoggerLevel.Debug);
}
}
private void Server_TCP_Data_Error_Event(Exception ex, Networking.Server.TCP.DataDirection Direction)
{
((Class.Logging.I_Logger)Server_Logger).Log("Failed to " + Direction.ToString() + " Data (Base Network)", Class.Logging.LoggerLevel.Error);
}
private void Server_TCP_ClientState_Changed(Networking.Server.TCP.TCP_ClientNode Client, Networking.Data.Client_ConnectionStatus Client_State)
{
if (Client_State == Networking.Data.Client_ConnectionStatus.Connected)
{
((Class.Logging.I_Logger)Server_Logger).Log("Client Connected (Base Network) Address: " + Client.ID, Class.Logging.LoggerLevel.Info);
if (Authenticated_Clients.FindAll(x => x.Key == Client).Count == 0)
{
Authenticated_Clients.Add(new KeyValuePair<Networking.Server.TCP.TCP_ClientNode, Authentication_Manager.Data.User>(Client, null));
}
}
else if (Client_State == Networking.Data.Client_ConnectionStatus.Connecting)
{
((Class.Logging.I_Logger)Server_Logger).Log("Client Connecting (Base Network) Address: " + Client.ID, Class.Logging.LoggerLevel.Info);
if (Authenticated_Clients.FindAll(x => x.Key == Client).Count == 0)
{
Authenticated_Clients.Add(new KeyValuePair<Networking.Server.TCP.TCP_ClientNode, Authentication_Manager.Data.User>(Client, null));
}
}
else if (Client_State == Networking.Data.Client_ConnectionStatus.Disconnected)
{
((Class.Logging.I_Logger)Server_Logger).Log("Client Disconnected (Base Network) Address: " + Client.ID, Class.Logging.LoggerLevel.Info);
Authenticated_Clients.RemoveAll(x => x.Key == Client);
}
else if (Client_State == Networking.Data.Client_ConnectionStatus.Dropped)
{
((Class.Logging.I_Logger)Server_Logger).Log("Client Dropped Connection (Base Network) Address: " + Client.ID, Class.Logging.LoggerLevel.Info);
Authenticated_Clients.RemoveAll(x => x.Key == Client);
}
else if (Client_State == Networking.Data.Client_ConnectionStatus.Encrypted)
{
((Class.Logging.I_Logger)Server_Logger).Log("Client Encrypted Network Transmittions (Base Network) Address: " + Client.ID, Class.Logging.LoggerLevel.Info);
if (Authenticated_Clients.FindAll(x => x.Key == Client).Count == 0)
{
Authenticated_Clients.Add(new KeyValuePair<Networking.Server.TCP.TCP_ClientNode, Authentication_Manager.Data.User>(Client, null));
}
}
}
private void Server_TCP_AcceptClients_Changed(bool Accepting_Connections)
{
if (Accepting_Connections)
{
((Class.Logging.I_Logger)Server_Logger).Log("Base Network is Accepting New Connections", Class.Logging.LoggerLevel.Info);
}
else
{
((Class.Logging.I_Logger)Server_Logger).Log("Base Network is Refusing New Connections", Class.Logging.LoggerLevel.Info);
}
}
#endregion
}
}
// ((Class.Logging.I_Logger)Server_Logger).Log("", Class.Logging.LoggerLevel.Info); | AssaultBird2454/Virtual-Pokemon-Tabletop | Virtual Pokemon Tabletop/AssaultBird2454.VPTU/Server/Instances/ServerInstance.cs | C# | mit | 13,894 |
angular.module('myApp').directive('allPosts', function ($location, $cookieStore) {
// console.log('DSSDFLDSFU');
return {
restrict: 'E',
scope: {
data: '='
},
templateUrl: 'modules/posts/views/allPosts.html',
// controller: function () {
// console.log('SDJSDFJDJF');
// },
link: function (scope, elem, attrs) {
// console.log('asdasd');
scope.delete = function (array, id) {
array.splice(id, 1);
};
scope.edit = function (id) {
$location.path("/posts/edit/" + id);
};
scope.check = function () {
return $cookieStore.get('user');
};
}
};
});
| smokezp/angular-blog | app/modules/posts/js/directives/allPosts.js | JavaScript | mit | 774 |
using JsonRPC;
using Newtonsoft.Json;
namespace KerioConnect
{
public class TypedResponse<TType> : Response where TType : class
{
/// <summary>The result if no error occured.</summary>
[JsonProperty("result", Required = Required.Default)]
public TType Result;
public bool ShouldSerializeResult()
{
return this.Result != null;
}
}
}
| peschuster/kerioconnect-csharp | source/KerioConnect/TypedResponse.cs | C# | mit | 409 |
using Microsoft.Media.AdaptiveStreaming.Dash.Smooth;
using Microsoft.Media.ISO;
using Microsoft.Media.ISO.Boxes;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
namespace Microsoft.Media.AdaptiveStreaming.Dash
{
internal abstract class CffFileParser
{
public CffFileParser()
{
this.Boxes = new List<Box>();
this.ManifestTracks = new List<Microsoft.Media.AdaptiveStreaming.Dash.Smooth.ManifestTrack>();
}
public List<Box> Boxes { get; private set; }
public List<Microsoft.Media.AdaptiveStreaming.Dash.Smooth.ManifestTrack> ManifestTracks { get; private set; }
public abstract Task Parse(Uri path);
public abstract Task<WebRequestorResponse> GetTrackFragmentStream(Microsoft.Media.AdaptiveStreaming.Dash.Smooth.ManifestTrackType trackType, uint bitrate, ulong timeOffset, string language);
public virtual Stream GenerateClientManifestStream()
{
return SmoothFactory.GenerateClientManifestStream(this.Boxes, this.ManifestTracks);
}
protected ulong ReadBoxSize(BoxBinaryReader reader)
{
ulong size = 0;
size = reader.ReadUInt32();
if (size == 1)
{
reader.BaseStream.Seek(4, SeekOrigin.Current); // Skip over the box type
size = reader.ReadUInt64();
}
return size;
}
protected virtual void InitializeTrackRegistry()
{
this.CalculateTfraEntrySizes(); // Figure out how large our samples are so we can initialize the track registry
this.ManifestTracks = Microsoft.Media.AdaptiveStreaming.Dash.Smooth.ManifestTrack.InitializeTrackRegistry(this.Boxes);
}
/// <summary>
/// Calculates the size of each tfra sample entry, which represents a moof and mdat pair.
/// </summary>
private void CalculateTfraEntrySizes()
{
var entries = this.Boxes.Single(box => box.Type == BoxType.Mfra)
.InnerBoxes.Where(box => box.Type == BoxType.Tfra).Cast<TrackFragmentRandomAccessFullBox>()
.SelectMany(tfra => tfra.TrackFragmentRandomAccessEntries)
.OrderBy(entry => entry.MoofOffset).ToList();
var entryCount = entries.Count;
for (int i = 0; i < entryCount; i++)
{
ulong nextOffset = 0;
if (i + 1 < entryCount)
{
nextOffset = entries.ElementAt(i + 1).MoofOffset;
}
else
{
nextOffset = (ulong)this.Boxes.Single(box => box.Type == BoxType.Mfra).Offset;
}
entries.ElementAt(i).SampleSize = nextOffset - entries.ElementAt(i).MoofOffset;
}
}
/// <summary>
/// Resets any data that had been setup by a previous operation and prepares
/// the parser for a new set of data.
/// </summary>
public virtual void Close()
{
this.Boxes.Clear();
this.ManifestTracks.Clear();
}
}
}
| bondarenkod/pf-arm-deploy-error | playerframework/Universal.WinRT.AdaptiveStreaming.Dash/CFF/CffFileParser.cs | C# | mit | 3,253 |
using System;
namespace Strings.MakingAnagrams
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Hello World!");
}
}
} | anton-abyzov/Hackerrank.CrackingTheInterview | Strings.MakingAnagrams/Program.cs | C# | mit | 202 |
// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
package gctrpc
import (
context "context"
grpc "google.golang.org/grpc"
codes "google.golang.org/grpc/codes"
status "google.golang.org/grpc/status"
)
// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
// Requires gRPC-Go v1.32.0 or later.
const _ = grpc.SupportPackageIsVersion7
// GoCryptoTraderClient is the client API for GoCryptoTrader service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type GoCryptoTraderClient interface {
GetInfo(ctx context.Context, in *GetInfoRequest, opts ...grpc.CallOption) (*GetInfoResponse, error)
GetSubsystems(ctx context.Context, in *GetSubsystemsRequest, opts ...grpc.CallOption) (*GetSusbsytemsResponse, error)
EnableSubsystem(ctx context.Context, in *GenericSubsystemRequest, opts ...grpc.CallOption) (*GenericResponse, error)
DisableSubsystem(ctx context.Context, in *GenericSubsystemRequest, opts ...grpc.CallOption) (*GenericResponse, error)
GetRPCEndpoints(ctx context.Context, in *GetRPCEndpointsRequest, opts ...grpc.CallOption) (*GetRPCEndpointsResponse, error)
GetCommunicationRelayers(ctx context.Context, in *GetCommunicationRelayersRequest, opts ...grpc.CallOption) (*GetCommunicationRelayersResponse, error)
GetExchanges(ctx context.Context, in *GetExchangesRequest, opts ...grpc.CallOption) (*GetExchangesResponse, error)
DisableExchange(ctx context.Context, in *GenericExchangeNameRequest, opts ...grpc.CallOption) (*GenericResponse, error)
GetExchangeInfo(ctx context.Context, in *GenericExchangeNameRequest, opts ...grpc.CallOption) (*GetExchangeInfoResponse, error)
GetExchangeOTPCode(ctx context.Context, in *GenericExchangeNameRequest, opts ...grpc.CallOption) (*GetExchangeOTPResponse, error)
GetExchangeOTPCodes(ctx context.Context, in *GetExchangeOTPsRequest, opts ...grpc.CallOption) (*GetExchangeOTPsResponse, error)
EnableExchange(ctx context.Context, in *GenericExchangeNameRequest, opts ...grpc.CallOption) (*GenericResponse, error)
GetTicker(ctx context.Context, in *GetTickerRequest, opts ...grpc.CallOption) (*TickerResponse, error)
GetTickers(ctx context.Context, in *GetTickersRequest, opts ...grpc.CallOption) (*GetTickersResponse, error)
GetOrderbook(ctx context.Context, in *GetOrderbookRequest, opts ...grpc.CallOption) (*OrderbookResponse, error)
GetOrderbooks(ctx context.Context, in *GetOrderbooksRequest, opts ...grpc.CallOption) (*GetOrderbooksResponse, error)
GetAccountInfo(ctx context.Context, in *GetAccountInfoRequest, opts ...grpc.CallOption) (*GetAccountInfoResponse, error)
UpdateAccountInfo(ctx context.Context, in *GetAccountInfoRequest, opts ...grpc.CallOption) (*GetAccountInfoResponse, error)
GetAccountInfoStream(ctx context.Context, in *GetAccountInfoRequest, opts ...grpc.CallOption) (GoCryptoTrader_GetAccountInfoStreamClient, error)
GetConfig(ctx context.Context, in *GetConfigRequest, opts ...grpc.CallOption) (*GetConfigResponse, error)
GetPortfolio(ctx context.Context, in *GetPortfolioRequest, opts ...grpc.CallOption) (*GetPortfolioResponse, error)
GetPortfolioSummary(ctx context.Context, in *GetPortfolioSummaryRequest, opts ...grpc.CallOption) (*GetPortfolioSummaryResponse, error)
AddPortfolioAddress(ctx context.Context, in *AddPortfolioAddressRequest, opts ...grpc.CallOption) (*GenericResponse, error)
RemovePortfolioAddress(ctx context.Context, in *RemovePortfolioAddressRequest, opts ...grpc.CallOption) (*GenericResponse, error)
GetForexProviders(ctx context.Context, in *GetForexProvidersRequest, opts ...grpc.CallOption) (*GetForexProvidersResponse, error)
GetForexRates(ctx context.Context, in *GetForexRatesRequest, opts ...grpc.CallOption) (*GetForexRatesResponse, error)
GetOrders(ctx context.Context, in *GetOrdersRequest, opts ...grpc.CallOption) (*GetOrdersResponse, error)
GetOrder(ctx context.Context, in *GetOrderRequest, opts ...grpc.CallOption) (*OrderDetails, error)
SubmitOrder(ctx context.Context, in *SubmitOrderRequest, opts ...grpc.CallOption) (*SubmitOrderResponse, error)
SimulateOrder(ctx context.Context, in *SimulateOrderRequest, opts ...grpc.CallOption) (*SimulateOrderResponse, error)
WhaleBomb(ctx context.Context, in *WhaleBombRequest, opts ...grpc.CallOption) (*SimulateOrderResponse, error)
CancelOrder(ctx context.Context, in *CancelOrderRequest, opts ...grpc.CallOption) (*GenericResponse, error)
CancelBatchOrders(ctx context.Context, in *CancelBatchOrdersRequest, opts ...grpc.CallOption) (*CancelBatchOrdersResponse, error)
CancelAllOrders(ctx context.Context, in *CancelAllOrdersRequest, opts ...grpc.CallOption) (*CancelAllOrdersResponse, error)
GetEvents(ctx context.Context, in *GetEventsRequest, opts ...grpc.CallOption) (*GetEventsResponse, error)
AddEvent(ctx context.Context, in *AddEventRequest, opts ...grpc.CallOption) (*AddEventResponse, error)
RemoveEvent(ctx context.Context, in *RemoveEventRequest, opts ...grpc.CallOption) (*GenericResponse, error)
GetCryptocurrencyDepositAddresses(ctx context.Context, in *GetCryptocurrencyDepositAddressesRequest, opts ...grpc.CallOption) (*GetCryptocurrencyDepositAddressesResponse, error)
GetCryptocurrencyDepositAddress(ctx context.Context, in *GetCryptocurrencyDepositAddressRequest, opts ...grpc.CallOption) (*GetCryptocurrencyDepositAddressResponse, error)
GetAvailableTransferChains(ctx context.Context, in *GetAvailableTransferChainsRequest, opts ...grpc.CallOption) (*GetAvailableTransferChainsResponse, error)
WithdrawFiatFunds(ctx context.Context, in *WithdrawFiatRequest, opts ...grpc.CallOption) (*WithdrawResponse, error)
WithdrawCryptocurrencyFunds(ctx context.Context, in *WithdrawCryptoRequest, opts ...grpc.CallOption) (*WithdrawResponse, error)
WithdrawalEventByID(ctx context.Context, in *WithdrawalEventByIDRequest, opts ...grpc.CallOption) (*WithdrawalEventByIDResponse, error)
WithdrawalEventsByExchange(ctx context.Context, in *WithdrawalEventsByExchangeRequest, opts ...grpc.CallOption) (*WithdrawalEventsByExchangeResponse, error)
WithdrawalEventsByDate(ctx context.Context, in *WithdrawalEventsByDateRequest, opts ...grpc.CallOption) (*WithdrawalEventsByExchangeResponse, error)
GetLoggerDetails(ctx context.Context, in *GetLoggerDetailsRequest, opts ...grpc.CallOption) (*GetLoggerDetailsResponse, error)
SetLoggerDetails(ctx context.Context, in *SetLoggerDetailsRequest, opts ...grpc.CallOption) (*GetLoggerDetailsResponse, error)
GetExchangePairs(ctx context.Context, in *GetExchangePairsRequest, opts ...grpc.CallOption) (*GetExchangePairsResponse, error)
SetExchangePair(ctx context.Context, in *SetExchangePairRequest, opts ...grpc.CallOption) (*GenericResponse, error)
GetOrderbookStream(ctx context.Context, in *GetOrderbookStreamRequest, opts ...grpc.CallOption) (GoCryptoTrader_GetOrderbookStreamClient, error)
GetExchangeOrderbookStream(ctx context.Context, in *GetExchangeOrderbookStreamRequest, opts ...grpc.CallOption) (GoCryptoTrader_GetExchangeOrderbookStreamClient, error)
GetTickerStream(ctx context.Context, in *GetTickerStreamRequest, opts ...grpc.CallOption) (GoCryptoTrader_GetTickerStreamClient, error)
GetExchangeTickerStream(ctx context.Context, in *GetExchangeTickerStreamRequest, opts ...grpc.CallOption) (GoCryptoTrader_GetExchangeTickerStreamClient, error)
GetAuditEvent(ctx context.Context, in *GetAuditEventRequest, opts ...grpc.CallOption) (*GetAuditEventResponse, error)
GCTScriptExecute(ctx context.Context, in *GCTScriptExecuteRequest, opts ...grpc.CallOption) (*GenericResponse, error)
GCTScriptUpload(ctx context.Context, in *GCTScriptUploadRequest, opts ...grpc.CallOption) (*GenericResponse, error)
GCTScriptReadScript(ctx context.Context, in *GCTScriptReadScriptRequest, opts ...grpc.CallOption) (*GCTScriptQueryResponse, error)
GCTScriptStatus(ctx context.Context, in *GCTScriptStatusRequest, opts ...grpc.CallOption) (*GCTScriptStatusResponse, error)
GCTScriptQuery(ctx context.Context, in *GCTScriptQueryRequest, opts ...grpc.CallOption) (*GCTScriptQueryResponse, error)
GCTScriptStop(ctx context.Context, in *GCTScriptStopRequest, opts ...grpc.CallOption) (*GenericResponse, error)
GCTScriptStopAll(ctx context.Context, in *GCTScriptStopAllRequest, opts ...grpc.CallOption) (*GenericResponse, error)
GCTScriptListAll(ctx context.Context, in *GCTScriptListAllRequest, opts ...grpc.CallOption) (*GCTScriptStatusResponse, error)
GCTScriptAutoLoadToggle(ctx context.Context, in *GCTScriptAutoLoadRequest, opts ...grpc.CallOption) (*GenericResponse, error)
GetHistoricCandles(ctx context.Context, in *GetHistoricCandlesRequest, opts ...grpc.CallOption) (*GetHistoricCandlesResponse, error)
SetExchangeAsset(ctx context.Context, in *SetExchangeAssetRequest, opts ...grpc.CallOption) (*GenericResponse, error)
SetAllExchangePairs(ctx context.Context, in *SetExchangeAllPairsRequest, opts ...grpc.CallOption) (*GenericResponse, error)
UpdateExchangeSupportedPairs(ctx context.Context, in *UpdateExchangeSupportedPairsRequest, opts ...grpc.CallOption) (*GenericResponse, error)
GetExchangeAssets(ctx context.Context, in *GetExchangeAssetsRequest, opts ...grpc.CallOption) (*GetExchangeAssetsResponse, error)
WebsocketGetInfo(ctx context.Context, in *WebsocketGetInfoRequest, opts ...grpc.CallOption) (*WebsocketGetInfoResponse, error)
WebsocketSetEnabled(ctx context.Context, in *WebsocketSetEnabledRequest, opts ...grpc.CallOption) (*GenericResponse, error)
WebsocketGetSubscriptions(ctx context.Context, in *WebsocketGetSubscriptionsRequest, opts ...grpc.CallOption) (*WebsocketGetSubscriptionsResponse, error)
WebsocketSetProxy(ctx context.Context, in *WebsocketSetProxyRequest, opts ...grpc.CallOption) (*GenericResponse, error)
WebsocketSetURL(ctx context.Context, in *WebsocketSetURLRequest, opts ...grpc.CallOption) (*GenericResponse, error)
GetRecentTrades(ctx context.Context, in *GetSavedTradesRequest, opts ...grpc.CallOption) (*SavedTradesResponse, error)
GetHistoricTrades(ctx context.Context, in *GetSavedTradesRequest, opts ...grpc.CallOption) (GoCryptoTrader_GetHistoricTradesClient, error)
GetSavedTrades(ctx context.Context, in *GetSavedTradesRequest, opts ...grpc.CallOption) (*SavedTradesResponse, error)
ConvertTradesToCandles(ctx context.Context, in *ConvertTradesToCandlesRequest, opts ...grpc.CallOption) (*GetHistoricCandlesResponse, error)
FindMissingSavedCandleIntervals(ctx context.Context, in *FindMissingCandlePeriodsRequest, opts ...grpc.CallOption) (*FindMissingIntervalsResponse, error)
FindMissingSavedTradeIntervals(ctx context.Context, in *FindMissingTradePeriodsRequest, opts ...grpc.CallOption) (*FindMissingIntervalsResponse, error)
SetExchangeTradeProcessing(ctx context.Context, in *SetExchangeTradeProcessingRequest, opts ...grpc.CallOption) (*GenericResponse, error)
UpsertDataHistoryJob(ctx context.Context, in *UpsertDataHistoryJobRequest, opts ...grpc.CallOption) (*UpsertDataHistoryJobResponse, error)
GetDataHistoryJobDetails(ctx context.Context, in *GetDataHistoryJobDetailsRequest, opts ...grpc.CallOption) (*DataHistoryJob, error)
GetActiveDataHistoryJobs(ctx context.Context, in *GetInfoRequest, opts ...grpc.CallOption) (*DataHistoryJobs, error)
GetDataHistoryJobsBetween(ctx context.Context, in *GetDataHistoryJobsBetweenRequest, opts ...grpc.CallOption) (*DataHistoryJobs, error)
GetDataHistoryJobSummary(ctx context.Context, in *GetDataHistoryJobDetailsRequest, opts ...grpc.CallOption) (*DataHistoryJob, error)
SetDataHistoryJobStatus(ctx context.Context, in *SetDataHistoryJobStatusRequest, opts ...grpc.CallOption) (*GenericResponse, error)
UpdateDataHistoryJobPrerequisite(ctx context.Context, in *UpdateDataHistoryJobPrerequisiteRequest, opts ...grpc.CallOption) (*GenericResponse, error)
GetManagedOrders(ctx context.Context, in *GetOrdersRequest, opts ...grpc.CallOption) (*GetOrdersResponse, error)
ModifyOrder(ctx context.Context, in *ModifyOrderRequest, opts ...grpc.CallOption) (*ModifyOrderResponse, error)
CurrencyStateGetAll(ctx context.Context, in *CurrencyStateGetAllRequest, opts ...grpc.CallOption) (*CurrencyStateResponse, error)
CurrencyStateTrading(ctx context.Context, in *CurrencyStateTradingRequest, opts ...grpc.CallOption) (*GenericResponse, error)
CurrencyStateDeposit(ctx context.Context, in *CurrencyStateDepositRequest, opts ...grpc.CallOption) (*GenericResponse, error)
CurrencyStateWithdraw(ctx context.Context, in *CurrencyStateWithdrawRequest, opts ...grpc.CallOption) (*GenericResponse, error)
CurrencyStateTradingPair(ctx context.Context, in *CurrencyStateTradingPairRequest, opts ...grpc.CallOption) (*GenericResponse, error)
}
type goCryptoTraderClient struct {
cc grpc.ClientConnInterface
}
func NewGoCryptoTraderClient(cc grpc.ClientConnInterface) GoCryptoTraderClient {
return &goCryptoTraderClient{cc}
}
func (c *goCryptoTraderClient) GetInfo(ctx context.Context, in *GetInfoRequest, opts ...grpc.CallOption) (*GetInfoResponse, error) {
out := new(GetInfoResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/GetInfo", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) GetSubsystems(ctx context.Context, in *GetSubsystemsRequest, opts ...grpc.CallOption) (*GetSusbsytemsResponse, error) {
out := new(GetSusbsytemsResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/GetSubsystems", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) EnableSubsystem(ctx context.Context, in *GenericSubsystemRequest, opts ...grpc.CallOption) (*GenericResponse, error) {
out := new(GenericResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/EnableSubsystem", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) DisableSubsystem(ctx context.Context, in *GenericSubsystemRequest, opts ...grpc.CallOption) (*GenericResponse, error) {
out := new(GenericResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/DisableSubsystem", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) GetRPCEndpoints(ctx context.Context, in *GetRPCEndpointsRequest, opts ...grpc.CallOption) (*GetRPCEndpointsResponse, error) {
out := new(GetRPCEndpointsResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/GetRPCEndpoints", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) GetCommunicationRelayers(ctx context.Context, in *GetCommunicationRelayersRequest, opts ...grpc.CallOption) (*GetCommunicationRelayersResponse, error) {
out := new(GetCommunicationRelayersResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/GetCommunicationRelayers", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) GetExchanges(ctx context.Context, in *GetExchangesRequest, opts ...grpc.CallOption) (*GetExchangesResponse, error) {
out := new(GetExchangesResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/GetExchanges", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) DisableExchange(ctx context.Context, in *GenericExchangeNameRequest, opts ...grpc.CallOption) (*GenericResponse, error) {
out := new(GenericResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/DisableExchange", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) GetExchangeInfo(ctx context.Context, in *GenericExchangeNameRequest, opts ...grpc.CallOption) (*GetExchangeInfoResponse, error) {
out := new(GetExchangeInfoResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/GetExchangeInfo", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) GetExchangeOTPCode(ctx context.Context, in *GenericExchangeNameRequest, opts ...grpc.CallOption) (*GetExchangeOTPResponse, error) {
out := new(GetExchangeOTPResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/GetExchangeOTPCode", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) GetExchangeOTPCodes(ctx context.Context, in *GetExchangeOTPsRequest, opts ...grpc.CallOption) (*GetExchangeOTPsResponse, error) {
out := new(GetExchangeOTPsResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/GetExchangeOTPCodes", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) EnableExchange(ctx context.Context, in *GenericExchangeNameRequest, opts ...grpc.CallOption) (*GenericResponse, error) {
out := new(GenericResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/EnableExchange", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) GetTicker(ctx context.Context, in *GetTickerRequest, opts ...grpc.CallOption) (*TickerResponse, error) {
out := new(TickerResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/GetTicker", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) GetTickers(ctx context.Context, in *GetTickersRequest, opts ...grpc.CallOption) (*GetTickersResponse, error) {
out := new(GetTickersResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/GetTickers", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) GetOrderbook(ctx context.Context, in *GetOrderbookRequest, opts ...grpc.CallOption) (*OrderbookResponse, error) {
out := new(OrderbookResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/GetOrderbook", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) GetOrderbooks(ctx context.Context, in *GetOrderbooksRequest, opts ...grpc.CallOption) (*GetOrderbooksResponse, error) {
out := new(GetOrderbooksResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/GetOrderbooks", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) GetAccountInfo(ctx context.Context, in *GetAccountInfoRequest, opts ...grpc.CallOption) (*GetAccountInfoResponse, error) {
out := new(GetAccountInfoResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/GetAccountInfo", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) UpdateAccountInfo(ctx context.Context, in *GetAccountInfoRequest, opts ...grpc.CallOption) (*GetAccountInfoResponse, error) {
out := new(GetAccountInfoResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/UpdateAccountInfo", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) GetAccountInfoStream(ctx context.Context, in *GetAccountInfoRequest, opts ...grpc.CallOption) (GoCryptoTrader_GetAccountInfoStreamClient, error) {
stream, err := c.cc.NewStream(ctx, &GoCryptoTrader_ServiceDesc.Streams[0], "/gctrpc.GoCryptoTrader/GetAccountInfoStream", opts...)
if err != nil {
return nil, err
}
x := &goCryptoTraderGetAccountInfoStreamClient{stream}
if err := x.ClientStream.SendMsg(in); err != nil {
return nil, err
}
if err := x.ClientStream.CloseSend(); err != nil {
return nil, err
}
return x, nil
}
type GoCryptoTrader_GetAccountInfoStreamClient interface {
Recv() (*GetAccountInfoResponse, error)
grpc.ClientStream
}
type goCryptoTraderGetAccountInfoStreamClient struct {
grpc.ClientStream
}
func (x *goCryptoTraderGetAccountInfoStreamClient) Recv() (*GetAccountInfoResponse, error) {
m := new(GetAccountInfoResponse)
if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
func (c *goCryptoTraderClient) GetConfig(ctx context.Context, in *GetConfigRequest, opts ...grpc.CallOption) (*GetConfigResponse, error) {
out := new(GetConfigResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/GetConfig", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) GetPortfolio(ctx context.Context, in *GetPortfolioRequest, opts ...grpc.CallOption) (*GetPortfolioResponse, error) {
out := new(GetPortfolioResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/GetPortfolio", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) GetPortfolioSummary(ctx context.Context, in *GetPortfolioSummaryRequest, opts ...grpc.CallOption) (*GetPortfolioSummaryResponse, error) {
out := new(GetPortfolioSummaryResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/GetPortfolioSummary", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) AddPortfolioAddress(ctx context.Context, in *AddPortfolioAddressRequest, opts ...grpc.CallOption) (*GenericResponse, error) {
out := new(GenericResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/AddPortfolioAddress", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) RemovePortfolioAddress(ctx context.Context, in *RemovePortfolioAddressRequest, opts ...grpc.CallOption) (*GenericResponse, error) {
out := new(GenericResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/RemovePortfolioAddress", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) GetForexProviders(ctx context.Context, in *GetForexProvidersRequest, opts ...grpc.CallOption) (*GetForexProvidersResponse, error) {
out := new(GetForexProvidersResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/GetForexProviders", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) GetForexRates(ctx context.Context, in *GetForexRatesRequest, opts ...grpc.CallOption) (*GetForexRatesResponse, error) {
out := new(GetForexRatesResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/GetForexRates", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) GetOrders(ctx context.Context, in *GetOrdersRequest, opts ...grpc.CallOption) (*GetOrdersResponse, error) {
out := new(GetOrdersResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/GetOrders", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) GetOrder(ctx context.Context, in *GetOrderRequest, opts ...grpc.CallOption) (*OrderDetails, error) {
out := new(OrderDetails)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/GetOrder", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) SubmitOrder(ctx context.Context, in *SubmitOrderRequest, opts ...grpc.CallOption) (*SubmitOrderResponse, error) {
out := new(SubmitOrderResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/SubmitOrder", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) SimulateOrder(ctx context.Context, in *SimulateOrderRequest, opts ...grpc.CallOption) (*SimulateOrderResponse, error) {
out := new(SimulateOrderResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/SimulateOrder", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) WhaleBomb(ctx context.Context, in *WhaleBombRequest, opts ...grpc.CallOption) (*SimulateOrderResponse, error) {
out := new(SimulateOrderResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/WhaleBomb", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) CancelOrder(ctx context.Context, in *CancelOrderRequest, opts ...grpc.CallOption) (*GenericResponse, error) {
out := new(GenericResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/CancelOrder", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) CancelBatchOrders(ctx context.Context, in *CancelBatchOrdersRequest, opts ...grpc.CallOption) (*CancelBatchOrdersResponse, error) {
out := new(CancelBatchOrdersResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/CancelBatchOrders", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) CancelAllOrders(ctx context.Context, in *CancelAllOrdersRequest, opts ...grpc.CallOption) (*CancelAllOrdersResponse, error) {
out := new(CancelAllOrdersResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/CancelAllOrders", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) GetEvents(ctx context.Context, in *GetEventsRequest, opts ...grpc.CallOption) (*GetEventsResponse, error) {
out := new(GetEventsResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/GetEvents", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) AddEvent(ctx context.Context, in *AddEventRequest, opts ...grpc.CallOption) (*AddEventResponse, error) {
out := new(AddEventResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/AddEvent", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) RemoveEvent(ctx context.Context, in *RemoveEventRequest, opts ...grpc.CallOption) (*GenericResponse, error) {
out := new(GenericResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/RemoveEvent", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) GetCryptocurrencyDepositAddresses(ctx context.Context, in *GetCryptocurrencyDepositAddressesRequest, opts ...grpc.CallOption) (*GetCryptocurrencyDepositAddressesResponse, error) {
out := new(GetCryptocurrencyDepositAddressesResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/GetCryptocurrencyDepositAddresses", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) GetCryptocurrencyDepositAddress(ctx context.Context, in *GetCryptocurrencyDepositAddressRequest, opts ...grpc.CallOption) (*GetCryptocurrencyDepositAddressResponse, error) {
out := new(GetCryptocurrencyDepositAddressResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/GetCryptocurrencyDepositAddress", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) GetAvailableTransferChains(ctx context.Context, in *GetAvailableTransferChainsRequest, opts ...grpc.CallOption) (*GetAvailableTransferChainsResponse, error) {
out := new(GetAvailableTransferChainsResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/GetAvailableTransferChains", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) WithdrawFiatFunds(ctx context.Context, in *WithdrawFiatRequest, opts ...grpc.CallOption) (*WithdrawResponse, error) {
out := new(WithdrawResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/WithdrawFiatFunds", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) WithdrawCryptocurrencyFunds(ctx context.Context, in *WithdrawCryptoRequest, opts ...grpc.CallOption) (*WithdrawResponse, error) {
out := new(WithdrawResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/WithdrawCryptocurrencyFunds", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) WithdrawalEventByID(ctx context.Context, in *WithdrawalEventByIDRequest, opts ...grpc.CallOption) (*WithdrawalEventByIDResponse, error) {
out := new(WithdrawalEventByIDResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/WithdrawalEventByID", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) WithdrawalEventsByExchange(ctx context.Context, in *WithdrawalEventsByExchangeRequest, opts ...grpc.CallOption) (*WithdrawalEventsByExchangeResponse, error) {
out := new(WithdrawalEventsByExchangeResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/WithdrawalEventsByExchange", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) WithdrawalEventsByDate(ctx context.Context, in *WithdrawalEventsByDateRequest, opts ...grpc.CallOption) (*WithdrawalEventsByExchangeResponse, error) {
out := new(WithdrawalEventsByExchangeResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/WithdrawalEventsByDate", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) GetLoggerDetails(ctx context.Context, in *GetLoggerDetailsRequest, opts ...grpc.CallOption) (*GetLoggerDetailsResponse, error) {
out := new(GetLoggerDetailsResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/GetLoggerDetails", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) SetLoggerDetails(ctx context.Context, in *SetLoggerDetailsRequest, opts ...grpc.CallOption) (*GetLoggerDetailsResponse, error) {
out := new(GetLoggerDetailsResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/SetLoggerDetails", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) GetExchangePairs(ctx context.Context, in *GetExchangePairsRequest, opts ...grpc.CallOption) (*GetExchangePairsResponse, error) {
out := new(GetExchangePairsResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/GetExchangePairs", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) SetExchangePair(ctx context.Context, in *SetExchangePairRequest, opts ...grpc.CallOption) (*GenericResponse, error) {
out := new(GenericResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/SetExchangePair", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) GetOrderbookStream(ctx context.Context, in *GetOrderbookStreamRequest, opts ...grpc.CallOption) (GoCryptoTrader_GetOrderbookStreamClient, error) {
stream, err := c.cc.NewStream(ctx, &GoCryptoTrader_ServiceDesc.Streams[1], "/gctrpc.GoCryptoTrader/GetOrderbookStream", opts...)
if err != nil {
return nil, err
}
x := &goCryptoTraderGetOrderbookStreamClient{stream}
if err := x.ClientStream.SendMsg(in); err != nil {
return nil, err
}
if err := x.ClientStream.CloseSend(); err != nil {
return nil, err
}
return x, nil
}
type GoCryptoTrader_GetOrderbookStreamClient interface {
Recv() (*OrderbookResponse, error)
grpc.ClientStream
}
type goCryptoTraderGetOrderbookStreamClient struct {
grpc.ClientStream
}
func (x *goCryptoTraderGetOrderbookStreamClient) Recv() (*OrderbookResponse, error) {
m := new(OrderbookResponse)
if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
func (c *goCryptoTraderClient) GetExchangeOrderbookStream(ctx context.Context, in *GetExchangeOrderbookStreamRequest, opts ...grpc.CallOption) (GoCryptoTrader_GetExchangeOrderbookStreamClient, error) {
stream, err := c.cc.NewStream(ctx, &GoCryptoTrader_ServiceDesc.Streams[2], "/gctrpc.GoCryptoTrader/GetExchangeOrderbookStream", opts...)
if err != nil {
return nil, err
}
x := &goCryptoTraderGetExchangeOrderbookStreamClient{stream}
if err := x.ClientStream.SendMsg(in); err != nil {
return nil, err
}
if err := x.ClientStream.CloseSend(); err != nil {
return nil, err
}
return x, nil
}
type GoCryptoTrader_GetExchangeOrderbookStreamClient interface {
Recv() (*OrderbookResponse, error)
grpc.ClientStream
}
type goCryptoTraderGetExchangeOrderbookStreamClient struct {
grpc.ClientStream
}
func (x *goCryptoTraderGetExchangeOrderbookStreamClient) Recv() (*OrderbookResponse, error) {
m := new(OrderbookResponse)
if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
func (c *goCryptoTraderClient) GetTickerStream(ctx context.Context, in *GetTickerStreamRequest, opts ...grpc.CallOption) (GoCryptoTrader_GetTickerStreamClient, error) {
stream, err := c.cc.NewStream(ctx, &GoCryptoTrader_ServiceDesc.Streams[3], "/gctrpc.GoCryptoTrader/GetTickerStream", opts...)
if err != nil {
return nil, err
}
x := &goCryptoTraderGetTickerStreamClient{stream}
if err := x.ClientStream.SendMsg(in); err != nil {
return nil, err
}
if err := x.ClientStream.CloseSend(); err != nil {
return nil, err
}
return x, nil
}
type GoCryptoTrader_GetTickerStreamClient interface {
Recv() (*TickerResponse, error)
grpc.ClientStream
}
type goCryptoTraderGetTickerStreamClient struct {
grpc.ClientStream
}
func (x *goCryptoTraderGetTickerStreamClient) Recv() (*TickerResponse, error) {
m := new(TickerResponse)
if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
func (c *goCryptoTraderClient) GetExchangeTickerStream(ctx context.Context, in *GetExchangeTickerStreamRequest, opts ...grpc.CallOption) (GoCryptoTrader_GetExchangeTickerStreamClient, error) {
stream, err := c.cc.NewStream(ctx, &GoCryptoTrader_ServiceDesc.Streams[4], "/gctrpc.GoCryptoTrader/GetExchangeTickerStream", opts...)
if err != nil {
return nil, err
}
x := &goCryptoTraderGetExchangeTickerStreamClient{stream}
if err := x.ClientStream.SendMsg(in); err != nil {
return nil, err
}
if err := x.ClientStream.CloseSend(); err != nil {
return nil, err
}
return x, nil
}
type GoCryptoTrader_GetExchangeTickerStreamClient interface {
Recv() (*TickerResponse, error)
grpc.ClientStream
}
type goCryptoTraderGetExchangeTickerStreamClient struct {
grpc.ClientStream
}
func (x *goCryptoTraderGetExchangeTickerStreamClient) Recv() (*TickerResponse, error) {
m := new(TickerResponse)
if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
func (c *goCryptoTraderClient) GetAuditEvent(ctx context.Context, in *GetAuditEventRequest, opts ...grpc.CallOption) (*GetAuditEventResponse, error) {
out := new(GetAuditEventResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/GetAuditEvent", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) GCTScriptExecute(ctx context.Context, in *GCTScriptExecuteRequest, opts ...grpc.CallOption) (*GenericResponse, error) {
out := new(GenericResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/GCTScriptExecute", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) GCTScriptUpload(ctx context.Context, in *GCTScriptUploadRequest, opts ...grpc.CallOption) (*GenericResponse, error) {
out := new(GenericResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/GCTScriptUpload", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) GCTScriptReadScript(ctx context.Context, in *GCTScriptReadScriptRequest, opts ...grpc.CallOption) (*GCTScriptQueryResponse, error) {
out := new(GCTScriptQueryResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/GCTScriptReadScript", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) GCTScriptStatus(ctx context.Context, in *GCTScriptStatusRequest, opts ...grpc.CallOption) (*GCTScriptStatusResponse, error) {
out := new(GCTScriptStatusResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/GCTScriptStatus", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) GCTScriptQuery(ctx context.Context, in *GCTScriptQueryRequest, opts ...grpc.CallOption) (*GCTScriptQueryResponse, error) {
out := new(GCTScriptQueryResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/GCTScriptQuery", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) GCTScriptStop(ctx context.Context, in *GCTScriptStopRequest, opts ...grpc.CallOption) (*GenericResponse, error) {
out := new(GenericResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/GCTScriptStop", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) GCTScriptStopAll(ctx context.Context, in *GCTScriptStopAllRequest, opts ...grpc.CallOption) (*GenericResponse, error) {
out := new(GenericResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/GCTScriptStopAll", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) GCTScriptListAll(ctx context.Context, in *GCTScriptListAllRequest, opts ...grpc.CallOption) (*GCTScriptStatusResponse, error) {
out := new(GCTScriptStatusResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/GCTScriptListAll", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) GCTScriptAutoLoadToggle(ctx context.Context, in *GCTScriptAutoLoadRequest, opts ...grpc.CallOption) (*GenericResponse, error) {
out := new(GenericResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/GCTScriptAutoLoadToggle", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) GetHistoricCandles(ctx context.Context, in *GetHistoricCandlesRequest, opts ...grpc.CallOption) (*GetHistoricCandlesResponse, error) {
out := new(GetHistoricCandlesResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/GetHistoricCandles", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) SetExchangeAsset(ctx context.Context, in *SetExchangeAssetRequest, opts ...grpc.CallOption) (*GenericResponse, error) {
out := new(GenericResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/SetExchangeAsset", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) SetAllExchangePairs(ctx context.Context, in *SetExchangeAllPairsRequest, opts ...grpc.CallOption) (*GenericResponse, error) {
out := new(GenericResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/SetAllExchangePairs", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) UpdateExchangeSupportedPairs(ctx context.Context, in *UpdateExchangeSupportedPairsRequest, opts ...grpc.CallOption) (*GenericResponse, error) {
out := new(GenericResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/UpdateExchangeSupportedPairs", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) GetExchangeAssets(ctx context.Context, in *GetExchangeAssetsRequest, opts ...grpc.CallOption) (*GetExchangeAssetsResponse, error) {
out := new(GetExchangeAssetsResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/GetExchangeAssets", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) WebsocketGetInfo(ctx context.Context, in *WebsocketGetInfoRequest, opts ...grpc.CallOption) (*WebsocketGetInfoResponse, error) {
out := new(WebsocketGetInfoResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/WebsocketGetInfo", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) WebsocketSetEnabled(ctx context.Context, in *WebsocketSetEnabledRequest, opts ...grpc.CallOption) (*GenericResponse, error) {
out := new(GenericResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/WebsocketSetEnabled", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) WebsocketGetSubscriptions(ctx context.Context, in *WebsocketGetSubscriptionsRequest, opts ...grpc.CallOption) (*WebsocketGetSubscriptionsResponse, error) {
out := new(WebsocketGetSubscriptionsResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/WebsocketGetSubscriptions", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) WebsocketSetProxy(ctx context.Context, in *WebsocketSetProxyRequest, opts ...grpc.CallOption) (*GenericResponse, error) {
out := new(GenericResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/WebsocketSetProxy", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) WebsocketSetURL(ctx context.Context, in *WebsocketSetURLRequest, opts ...grpc.CallOption) (*GenericResponse, error) {
out := new(GenericResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/WebsocketSetURL", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) GetRecentTrades(ctx context.Context, in *GetSavedTradesRequest, opts ...grpc.CallOption) (*SavedTradesResponse, error) {
out := new(SavedTradesResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/GetRecentTrades", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) GetHistoricTrades(ctx context.Context, in *GetSavedTradesRequest, opts ...grpc.CallOption) (GoCryptoTrader_GetHistoricTradesClient, error) {
stream, err := c.cc.NewStream(ctx, &GoCryptoTrader_ServiceDesc.Streams[5], "/gctrpc.GoCryptoTrader/GetHistoricTrades", opts...)
if err != nil {
return nil, err
}
x := &goCryptoTraderGetHistoricTradesClient{stream}
if err := x.ClientStream.SendMsg(in); err != nil {
return nil, err
}
if err := x.ClientStream.CloseSend(); err != nil {
return nil, err
}
return x, nil
}
type GoCryptoTrader_GetHistoricTradesClient interface {
Recv() (*SavedTradesResponse, error)
grpc.ClientStream
}
type goCryptoTraderGetHistoricTradesClient struct {
grpc.ClientStream
}
func (x *goCryptoTraderGetHistoricTradesClient) Recv() (*SavedTradesResponse, error) {
m := new(SavedTradesResponse)
if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
func (c *goCryptoTraderClient) GetSavedTrades(ctx context.Context, in *GetSavedTradesRequest, opts ...grpc.CallOption) (*SavedTradesResponse, error) {
out := new(SavedTradesResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/GetSavedTrades", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) ConvertTradesToCandles(ctx context.Context, in *ConvertTradesToCandlesRequest, opts ...grpc.CallOption) (*GetHistoricCandlesResponse, error) {
out := new(GetHistoricCandlesResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/ConvertTradesToCandles", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) FindMissingSavedCandleIntervals(ctx context.Context, in *FindMissingCandlePeriodsRequest, opts ...grpc.CallOption) (*FindMissingIntervalsResponse, error) {
out := new(FindMissingIntervalsResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/FindMissingSavedCandleIntervals", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) FindMissingSavedTradeIntervals(ctx context.Context, in *FindMissingTradePeriodsRequest, opts ...grpc.CallOption) (*FindMissingIntervalsResponse, error) {
out := new(FindMissingIntervalsResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/FindMissingSavedTradeIntervals", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) SetExchangeTradeProcessing(ctx context.Context, in *SetExchangeTradeProcessingRequest, opts ...grpc.CallOption) (*GenericResponse, error) {
out := new(GenericResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/SetExchangeTradeProcessing", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) UpsertDataHistoryJob(ctx context.Context, in *UpsertDataHistoryJobRequest, opts ...grpc.CallOption) (*UpsertDataHistoryJobResponse, error) {
out := new(UpsertDataHistoryJobResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/UpsertDataHistoryJob", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) GetDataHistoryJobDetails(ctx context.Context, in *GetDataHistoryJobDetailsRequest, opts ...grpc.CallOption) (*DataHistoryJob, error) {
out := new(DataHistoryJob)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/GetDataHistoryJobDetails", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) GetActiveDataHistoryJobs(ctx context.Context, in *GetInfoRequest, opts ...grpc.CallOption) (*DataHistoryJobs, error) {
out := new(DataHistoryJobs)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/GetActiveDataHistoryJobs", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) GetDataHistoryJobsBetween(ctx context.Context, in *GetDataHistoryJobsBetweenRequest, opts ...grpc.CallOption) (*DataHistoryJobs, error) {
out := new(DataHistoryJobs)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/GetDataHistoryJobsBetween", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) GetDataHistoryJobSummary(ctx context.Context, in *GetDataHistoryJobDetailsRequest, opts ...grpc.CallOption) (*DataHistoryJob, error) {
out := new(DataHistoryJob)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/GetDataHistoryJobSummary", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) SetDataHistoryJobStatus(ctx context.Context, in *SetDataHistoryJobStatusRequest, opts ...grpc.CallOption) (*GenericResponse, error) {
out := new(GenericResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/SetDataHistoryJobStatus", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) UpdateDataHistoryJobPrerequisite(ctx context.Context, in *UpdateDataHistoryJobPrerequisiteRequest, opts ...grpc.CallOption) (*GenericResponse, error) {
out := new(GenericResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/UpdateDataHistoryJobPrerequisite", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) GetManagedOrders(ctx context.Context, in *GetOrdersRequest, opts ...grpc.CallOption) (*GetOrdersResponse, error) {
out := new(GetOrdersResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/GetManagedOrders", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) ModifyOrder(ctx context.Context, in *ModifyOrderRequest, opts ...grpc.CallOption) (*ModifyOrderResponse, error) {
out := new(ModifyOrderResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/ModifyOrder", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) CurrencyStateGetAll(ctx context.Context, in *CurrencyStateGetAllRequest, opts ...grpc.CallOption) (*CurrencyStateResponse, error) {
out := new(CurrencyStateResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/CurrencyStateGetAll", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) CurrencyStateTrading(ctx context.Context, in *CurrencyStateTradingRequest, opts ...grpc.CallOption) (*GenericResponse, error) {
out := new(GenericResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/CurrencyStateTrading", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) CurrencyStateDeposit(ctx context.Context, in *CurrencyStateDepositRequest, opts ...grpc.CallOption) (*GenericResponse, error) {
out := new(GenericResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/CurrencyStateDeposit", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) CurrencyStateWithdraw(ctx context.Context, in *CurrencyStateWithdrawRequest, opts ...grpc.CallOption) (*GenericResponse, error) {
out := new(GenericResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/CurrencyStateWithdraw", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *goCryptoTraderClient) CurrencyStateTradingPair(ctx context.Context, in *CurrencyStateTradingPairRequest, opts ...grpc.CallOption) (*GenericResponse, error) {
out := new(GenericResponse)
err := c.cc.Invoke(ctx, "/gctrpc.GoCryptoTrader/CurrencyStateTradingPair", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// GoCryptoTraderServer is the server API for GoCryptoTrader service.
// All implementations must embed UnimplementedGoCryptoTraderServer
// for forward compatibility
type GoCryptoTraderServer interface {
GetInfo(context.Context, *GetInfoRequest) (*GetInfoResponse, error)
GetSubsystems(context.Context, *GetSubsystemsRequest) (*GetSusbsytemsResponse, error)
EnableSubsystem(context.Context, *GenericSubsystemRequest) (*GenericResponse, error)
DisableSubsystem(context.Context, *GenericSubsystemRequest) (*GenericResponse, error)
GetRPCEndpoints(context.Context, *GetRPCEndpointsRequest) (*GetRPCEndpointsResponse, error)
GetCommunicationRelayers(context.Context, *GetCommunicationRelayersRequest) (*GetCommunicationRelayersResponse, error)
GetExchanges(context.Context, *GetExchangesRequest) (*GetExchangesResponse, error)
DisableExchange(context.Context, *GenericExchangeNameRequest) (*GenericResponse, error)
GetExchangeInfo(context.Context, *GenericExchangeNameRequest) (*GetExchangeInfoResponse, error)
GetExchangeOTPCode(context.Context, *GenericExchangeNameRequest) (*GetExchangeOTPResponse, error)
GetExchangeOTPCodes(context.Context, *GetExchangeOTPsRequest) (*GetExchangeOTPsResponse, error)
EnableExchange(context.Context, *GenericExchangeNameRequest) (*GenericResponse, error)
GetTicker(context.Context, *GetTickerRequest) (*TickerResponse, error)
GetTickers(context.Context, *GetTickersRequest) (*GetTickersResponse, error)
GetOrderbook(context.Context, *GetOrderbookRequest) (*OrderbookResponse, error)
GetOrderbooks(context.Context, *GetOrderbooksRequest) (*GetOrderbooksResponse, error)
GetAccountInfo(context.Context, *GetAccountInfoRequest) (*GetAccountInfoResponse, error)
UpdateAccountInfo(context.Context, *GetAccountInfoRequest) (*GetAccountInfoResponse, error)
GetAccountInfoStream(*GetAccountInfoRequest, GoCryptoTrader_GetAccountInfoStreamServer) error
GetConfig(context.Context, *GetConfigRequest) (*GetConfigResponse, error)
GetPortfolio(context.Context, *GetPortfolioRequest) (*GetPortfolioResponse, error)
GetPortfolioSummary(context.Context, *GetPortfolioSummaryRequest) (*GetPortfolioSummaryResponse, error)
AddPortfolioAddress(context.Context, *AddPortfolioAddressRequest) (*GenericResponse, error)
RemovePortfolioAddress(context.Context, *RemovePortfolioAddressRequest) (*GenericResponse, error)
GetForexProviders(context.Context, *GetForexProvidersRequest) (*GetForexProvidersResponse, error)
GetForexRates(context.Context, *GetForexRatesRequest) (*GetForexRatesResponse, error)
GetOrders(context.Context, *GetOrdersRequest) (*GetOrdersResponse, error)
GetOrder(context.Context, *GetOrderRequest) (*OrderDetails, error)
SubmitOrder(context.Context, *SubmitOrderRequest) (*SubmitOrderResponse, error)
SimulateOrder(context.Context, *SimulateOrderRequest) (*SimulateOrderResponse, error)
WhaleBomb(context.Context, *WhaleBombRequest) (*SimulateOrderResponse, error)
CancelOrder(context.Context, *CancelOrderRequest) (*GenericResponse, error)
CancelBatchOrders(context.Context, *CancelBatchOrdersRequest) (*CancelBatchOrdersResponse, error)
CancelAllOrders(context.Context, *CancelAllOrdersRequest) (*CancelAllOrdersResponse, error)
GetEvents(context.Context, *GetEventsRequest) (*GetEventsResponse, error)
AddEvent(context.Context, *AddEventRequest) (*AddEventResponse, error)
RemoveEvent(context.Context, *RemoveEventRequest) (*GenericResponse, error)
GetCryptocurrencyDepositAddresses(context.Context, *GetCryptocurrencyDepositAddressesRequest) (*GetCryptocurrencyDepositAddressesResponse, error)
GetCryptocurrencyDepositAddress(context.Context, *GetCryptocurrencyDepositAddressRequest) (*GetCryptocurrencyDepositAddressResponse, error)
GetAvailableTransferChains(context.Context, *GetAvailableTransferChainsRequest) (*GetAvailableTransferChainsResponse, error)
WithdrawFiatFunds(context.Context, *WithdrawFiatRequest) (*WithdrawResponse, error)
WithdrawCryptocurrencyFunds(context.Context, *WithdrawCryptoRequest) (*WithdrawResponse, error)
WithdrawalEventByID(context.Context, *WithdrawalEventByIDRequest) (*WithdrawalEventByIDResponse, error)
WithdrawalEventsByExchange(context.Context, *WithdrawalEventsByExchangeRequest) (*WithdrawalEventsByExchangeResponse, error)
WithdrawalEventsByDate(context.Context, *WithdrawalEventsByDateRequest) (*WithdrawalEventsByExchangeResponse, error)
GetLoggerDetails(context.Context, *GetLoggerDetailsRequest) (*GetLoggerDetailsResponse, error)
SetLoggerDetails(context.Context, *SetLoggerDetailsRequest) (*GetLoggerDetailsResponse, error)
GetExchangePairs(context.Context, *GetExchangePairsRequest) (*GetExchangePairsResponse, error)
SetExchangePair(context.Context, *SetExchangePairRequest) (*GenericResponse, error)
GetOrderbookStream(*GetOrderbookStreamRequest, GoCryptoTrader_GetOrderbookStreamServer) error
GetExchangeOrderbookStream(*GetExchangeOrderbookStreamRequest, GoCryptoTrader_GetExchangeOrderbookStreamServer) error
GetTickerStream(*GetTickerStreamRequest, GoCryptoTrader_GetTickerStreamServer) error
GetExchangeTickerStream(*GetExchangeTickerStreamRequest, GoCryptoTrader_GetExchangeTickerStreamServer) error
GetAuditEvent(context.Context, *GetAuditEventRequest) (*GetAuditEventResponse, error)
GCTScriptExecute(context.Context, *GCTScriptExecuteRequest) (*GenericResponse, error)
GCTScriptUpload(context.Context, *GCTScriptUploadRequest) (*GenericResponse, error)
GCTScriptReadScript(context.Context, *GCTScriptReadScriptRequest) (*GCTScriptQueryResponse, error)
GCTScriptStatus(context.Context, *GCTScriptStatusRequest) (*GCTScriptStatusResponse, error)
GCTScriptQuery(context.Context, *GCTScriptQueryRequest) (*GCTScriptQueryResponse, error)
GCTScriptStop(context.Context, *GCTScriptStopRequest) (*GenericResponse, error)
GCTScriptStopAll(context.Context, *GCTScriptStopAllRequest) (*GenericResponse, error)
GCTScriptListAll(context.Context, *GCTScriptListAllRequest) (*GCTScriptStatusResponse, error)
GCTScriptAutoLoadToggle(context.Context, *GCTScriptAutoLoadRequest) (*GenericResponse, error)
GetHistoricCandles(context.Context, *GetHistoricCandlesRequest) (*GetHistoricCandlesResponse, error)
SetExchangeAsset(context.Context, *SetExchangeAssetRequest) (*GenericResponse, error)
SetAllExchangePairs(context.Context, *SetExchangeAllPairsRequest) (*GenericResponse, error)
UpdateExchangeSupportedPairs(context.Context, *UpdateExchangeSupportedPairsRequest) (*GenericResponse, error)
GetExchangeAssets(context.Context, *GetExchangeAssetsRequest) (*GetExchangeAssetsResponse, error)
WebsocketGetInfo(context.Context, *WebsocketGetInfoRequest) (*WebsocketGetInfoResponse, error)
WebsocketSetEnabled(context.Context, *WebsocketSetEnabledRequest) (*GenericResponse, error)
WebsocketGetSubscriptions(context.Context, *WebsocketGetSubscriptionsRequest) (*WebsocketGetSubscriptionsResponse, error)
WebsocketSetProxy(context.Context, *WebsocketSetProxyRequest) (*GenericResponse, error)
WebsocketSetURL(context.Context, *WebsocketSetURLRequest) (*GenericResponse, error)
GetRecentTrades(context.Context, *GetSavedTradesRequest) (*SavedTradesResponse, error)
GetHistoricTrades(*GetSavedTradesRequest, GoCryptoTrader_GetHistoricTradesServer) error
GetSavedTrades(context.Context, *GetSavedTradesRequest) (*SavedTradesResponse, error)
ConvertTradesToCandles(context.Context, *ConvertTradesToCandlesRequest) (*GetHistoricCandlesResponse, error)
FindMissingSavedCandleIntervals(context.Context, *FindMissingCandlePeriodsRequest) (*FindMissingIntervalsResponse, error)
FindMissingSavedTradeIntervals(context.Context, *FindMissingTradePeriodsRequest) (*FindMissingIntervalsResponse, error)
SetExchangeTradeProcessing(context.Context, *SetExchangeTradeProcessingRequest) (*GenericResponse, error)
UpsertDataHistoryJob(context.Context, *UpsertDataHistoryJobRequest) (*UpsertDataHistoryJobResponse, error)
GetDataHistoryJobDetails(context.Context, *GetDataHistoryJobDetailsRequest) (*DataHistoryJob, error)
GetActiveDataHistoryJobs(context.Context, *GetInfoRequest) (*DataHistoryJobs, error)
GetDataHistoryJobsBetween(context.Context, *GetDataHistoryJobsBetweenRequest) (*DataHistoryJobs, error)
GetDataHistoryJobSummary(context.Context, *GetDataHistoryJobDetailsRequest) (*DataHistoryJob, error)
SetDataHistoryJobStatus(context.Context, *SetDataHistoryJobStatusRequest) (*GenericResponse, error)
UpdateDataHistoryJobPrerequisite(context.Context, *UpdateDataHistoryJobPrerequisiteRequest) (*GenericResponse, error)
GetManagedOrders(context.Context, *GetOrdersRequest) (*GetOrdersResponse, error)
ModifyOrder(context.Context, *ModifyOrderRequest) (*ModifyOrderResponse, error)
CurrencyStateGetAll(context.Context, *CurrencyStateGetAllRequest) (*CurrencyStateResponse, error)
CurrencyStateTrading(context.Context, *CurrencyStateTradingRequest) (*GenericResponse, error)
CurrencyStateDeposit(context.Context, *CurrencyStateDepositRequest) (*GenericResponse, error)
CurrencyStateWithdraw(context.Context, *CurrencyStateWithdrawRequest) (*GenericResponse, error)
CurrencyStateTradingPair(context.Context, *CurrencyStateTradingPairRequest) (*GenericResponse, error)
mustEmbedUnimplementedGoCryptoTraderServer()
}
// UnimplementedGoCryptoTraderServer must be embedded to have forward compatible implementations.
type UnimplementedGoCryptoTraderServer struct {
}
func (UnimplementedGoCryptoTraderServer) GetInfo(context.Context, *GetInfoRequest) (*GetInfoResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetInfo not implemented")
}
func (UnimplementedGoCryptoTraderServer) GetSubsystems(context.Context, *GetSubsystemsRequest) (*GetSusbsytemsResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetSubsystems not implemented")
}
func (UnimplementedGoCryptoTraderServer) EnableSubsystem(context.Context, *GenericSubsystemRequest) (*GenericResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method EnableSubsystem not implemented")
}
func (UnimplementedGoCryptoTraderServer) DisableSubsystem(context.Context, *GenericSubsystemRequest) (*GenericResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method DisableSubsystem not implemented")
}
func (UnimplementedGoCryptoTraderServer) GetRPCEndpoints(context.Context, *GetRPCEndpointsRequest) (*GetRPCEndpointsResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetRPCEndpoints not implemented")
}
func (UnimplementedGoCryptoTraderServer) GetCommunicationRelayers(context.Context, *GetCommunicationRelayersRequest) (*GetCommunicationRelayersResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetCommunicationRelayers not implemented")
}
func (UnimplementedGoCryptoTraderServer) GetExchanges(context.Context, *GetExchangesRequest) (*GetExchangesResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetExchanges not implemented")
}
func (UnimplementedGoCryptoTraderServer) DisableExchange(context.Context, *GenericExchangeNameRequest) (*GenericResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method DisableExchange not implemented")
}
func (UnimplementedGoCryptoTraderServer) GetExchangeInfo(context.Context, *GenericExchangeNameRequest) (*GetExchangeInfoResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetExchangeInfo not implemented")
}
func (UnimplementedGoCryptoTraderServer) GetExchangeOTPCode(context.Context, *GenericExchangeNameRequest) (*GetExchangeOTPResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetExchangeOTPCode not implemented")
}
func (UnimplementedGoCryptoTraderServer) GetExchangeOTPCodes(context.Context, *GetExchangeOTPsRequest) (*GetExchangeOTPsResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetExchangeOTPCodes not implemented")
}
func (UnimplementedGoCryptoTraderServer) EnableExchange(context.Context, *GenericExchangeNameRequest) (*GenericResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method EnableExchange not implemented")
}
func (UnimplementedGoCryptoTraderServer) GetTicker(context.Context, *GetTickerRequest) (*TickerResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetTicker not implemented")
}
func (UnimplementedGoCryptoTraderServer) GetTickers(context.Context, *GetTickersRequest) (*GetTickersResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetTickers not implemented")
}
func (UnimplementedGoCryptoTraderServer) GetOrderbook(context.Context, *GetOrderbookRequest) (*OrderbookResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetOrderbook not implemented")
}
func (UnimplementedGoCryptoTraderServer) GetOrderbooks(context.Context, *GetOrderbooksRequest) (*GetOrderbooksResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetOrderbooks not implemented")
}
func (UnimplementedGoCryptoTraderServer) GetAccountInfo(context.Context, *GetAccountInfoRequest) (*GetAccountInfoResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetAccountInfo not implemented")
}
func (UnimplementedGoCryptoTraderServer) UpdateAccountInfo(context.Context, *GetAccountInfoRequest) (*GetAccountInfoResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method UpdateAccountInfo not implemented")
}
func (UnimplementedGoCryptoTraderServer) GetAccountInfoStream(*GetAccountInfoRequest, GoCryptoTrader_GetAccountInfoStreamServer) error {
return status.Errorf(codes.Unimplemented, "method GetAccountInfoStream not implemented")
}
func (UnimplementedGoCryptoTraderServer) GetConfig(context.Context, *GetConfigRequest) (*GetConfigResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetConfig not implemented")
}
func (UnimplementedGoCryptoTraderServer) GetPortfolio(context.Context, *GetPortfolioRequest) (*GetPortfolioResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetPortfolio not implemented")
}
func (UnimplementedGoCryptoTraderServer) GetPortfolioSummary(context.Context, *GetPortfolioSummaryRequest) (*GetPortfolioSummaryResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetPortfolioSummary not implemented")
}
func (UnimplementedGoCryptoTraderServer) AddPortfolioAddress(context.Context, *AddPortfolioAddressRequest) (*GenericResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method AddPortfolioAddress not implemented")
}
func (UnimplementedGoCryptoTraderServer) RemovePortfolioAddress(context.Context, *RemovePortfolioAddressRequest) (*GenericResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method RemovePortfolioAddress not implemented")
}
func (UnimplementedGoCryptoTraderServer) GetForexProviders(context.Context, *GetForexProvidersRequest) (*GetForexProvidersResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetForexProviders not implemented")
}
func (UnimplementedGoCryptoTraderServer) GetForexRates(context.Context, *GetForexRatesRequest) (*GetForexRatesResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetForexRates not implemented")
}
func (UnimplementedGoCryptoTraderServer) GetOrders(context.Context, *GetOrdersRequest) (*GetOrdersResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetOrders not implemented")
}
func (UnimplementedGoCryptoTraderServer) GetOrder(context.Context, *GetOrderRequest) (*OrderDetails, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetOrder not implemented")
}
func (UnimplementedGoCryptoTraderServer) SubmitOrder(context.Context, *SubmitOrderRequest) (*SubmitOrderResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method SubmitOrder not implemented")
}
func (UnimplementedGoCryptoTraderServer) SimulateOrder(context.Context, *SimulateOrderRequest) (*SimulateOrderResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method SimulateOrder not implemented")
}
func (UnimplementedGoCryptoTraderServer) WhaleBomb(context.Context, *WhaleBombRequest) (*SimulateOrderResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method WhaleBomb not implemented")
}
func (UnimplementedGoCryptoTraderServer) CancelOrder(context.Context, *CancelOrderRequest) (*GenericResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method CancelOrder not implemented")
}
func (UnimplementedGoCryptoTraderServer) CancelBatchOrders(context.Context, *CancelBatchOrdersRequest) (*CancelBatchOrdersResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method CancelBatchOrders not implemented")
}
func (UnimplementedGoCryptoTraderServer) CancelAllOrders(context.Context, *CancelAllOrdersRequest) (*CancelAllOrdersResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method CancelAllOrders not implemented")
}
func (UnimplementedGoCryptoTraderServer) GetEvents(context.Context, *GetEventsRequest) (*GetEventsResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetEvents not implemented")
}
func (UnimplementedGoCryptoTraderServer) AddEvent(context.Context, *AddEventRequest) (*AddEventResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method AddEvent not implemented")
}
func (UnimplementedGoCryptoTraderServer) RemoveEvent(context.Context, *RemoveEventRequest) (*GenericResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method RemoveEvent not implemented")
}
func (UnimplementedGoCryptoTraderServer) GetCryptocurrencyDepositAddresses(context.Context, *GetCryptocurrencyDepositAddressesRequest) (*GetCryptocurrencyDepositAddressesResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetCryptocurrencyDepositAddresses not implemented")
}
func (UnimplementedGoCryptoTraderServer) GetCryptocurrencyDepositAddress(context.Context, *GetCryptocurrencyDepositAddressRequest) (*GetCryptocurrencyDepositAddressResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetCryptocurrencyDepositAddress not implemented")
}
func (UnimplementedGoCryptoTraderServer) GetAvailableTransferChains(context.Context, *GetAvailableTransferChainsRequest) (*GetAvailableTransferChainsResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetAvailableTransferChains not implemented")
}
func (UnimplementedGoCryptoTraderServer) WithdrawFiatFunds(context.Context, *WithdrawFiatRequest) (*WithdrawResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method WithdrawFiatFunds not implemented")
}
func (UnimplementedGoCryptoTraderServer) WithdrawCryptocurrencyFunds(context.Context, *WithdrawCryptoRequest) (*WithdrawResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method WithdrawCryptocurrencyFunds not implemented")
}
func (UnimplementedGoCryptoTraderServer) WithdrawalEventByID(context.Context, *WithdrawalEventByIDRequest) (*WithdrawalEventByIDResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method WithdrawalEventByID not implemented")
}
func (UnimplementedGoCryptoTraderServer) WithdrawalEventsByExchange(context.Context, *WithdrawalEventsByExchangeRequest) (*WithdrawalEventsByExchangeResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method WithdrawalEventsByExchange not implemented")
}
func (UnimplementedGoCryptoTraderServer) WithdrawalEventsByDate(context.Context, *WithdrawalEventsByDateRequest) (*WithdrawalEventsByExchangeResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method WithdrawalEventsByDate not implemented")
}
func (UnimplementedGoCryptoTraderServer) GetLoggerDetails(context.Context, *GetLoggerDetailsRequest) (*GetLoggerDetailsResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetLoggerDetails not implemented")
}
func (UnimplementedGoCryptoTraderServer) SetLoggerDetails(context.Context, *SetLoggerDetailsRequest) (*GetLoggerDetailsResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method SetLoggerDetails not implemented")
}
func (UnimplementedGoCryptoTraderServer) GetExchangePairs(context.Context, *GetExchangePairsRequest) (*GetExchangePairsResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetExchangePairs not implemented")
}
func (UnimplementedGoCryptoTraderServer) SetExchangePair(context.Context, *SetExchangePairRequest) (*GenericResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method SetExchangePair not implemented")
}
func (UnimplementedGoCryptoTraderServer) GetOrderbookStream(*GetOrderbookStreamRequest, GoCryptoTrader_GetOrderbookStreamServer) error {
return status.Errorf(codes.Unimplemented, "method GetOrderbookStream not implemented")
}
func (UnimplementedGoCryptoTraderServer) GetExchangeOrderbookStream(*GetExchangeOrderbookStreamRequest, GoCryptoTrader_GetExchangeOrderbookStreamServer) error {
return status.Errorf(codes.Unimplemented, "method GetExchangeOrderbookStream not implemented")
}
func (UnimplementedGoCryptoTraderServer) GetTickerStream(*GetTickerStreamRequest, GoCryptoTrader_GetTickerStreamServer) error {
return status.Errorf(codes.Unimplemented, "method GetTickerStream not implemented")
}
func (UnimplementedGoCryptoTraderServer) GetExchangeTickerStream(*GetExchangeTickerStreamRequest, GoCryptoTrader_GetExchangeTickerStreamServer) error {
return status.Errorf(codes.Unimplemented, "method GetExchangeTickerStream not implemented")
}
func (UnimplementedGoCryptoTraderServer) GetAuditEvent(context.Context, *GetAuditEventRequest) (*GetAuditEventResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetAuditEvent not implemented")
}
func (UnimplementedGoCryptoTraderServer) GCTScriptExecute(context.Context, *GCTScriptExecuteRequest) (*GenericResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GCTScriptExecute not implemented")
}
func (UnimplementedGoCryptoTraderServer) GCTScriptUpload(context.Context, *GCTScriptUploadRequest) (*GenericResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GCTScriptUpload not implemented")
}
func (UnimplementedGoCryptoTraderServer) GCTScriptReadScript(context.Context, *GCTScriptReadScriptRequest) (*GCTScriptQueryResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GCTScriptReadScript not implemented")
}
func (UnimplementedGoCryptoTraderServer) GCTScriptStatus(context.Context, *GCTScriptStatusRequest) (*GCTScriptStatusResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GCTScriptStatus not implemented")
}
func (UnimplementedGoCryptoTraderServer) GCTScriptQuery(context.Context, *GCTScriptQueryRequest) (*GCTScriptQueryResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GCTScriptQuery not implemented")
}
func (UnimplementedGoCryptoTraderServer) GCTScriptStop(context.Context, *GCTScriptStopRequest) (*GenericResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GCTScriptStop not implemented")
}
func (UnimplementedGoCryptoTraderServer) GCTScriptStopAll(context.Context, *GCTScriptStopAllRequest) (*GenericResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GCTScriptStopAll not implemented")
}
func (UnimplementedGoCryptoTraderServer) GCTScriptListAll(context.Context, *GCTScriptListAllRequest) (*GCTScriptStatusResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GCTScriptListAll not implemented")
}
func (UnimplementedGoCryptoTraderServer) GCTScriptAutoLoadToggle(context.Context, *GCTScriptAutoLoadRequest) (*GenericResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GCTScriptAutoLoadToggle not implemented")
}
func (UnimplementedGoCryptoTraderServer) GetHistoricCandles(context.Context, *GetHistoricCandlesRequest) (*GetHistoricCandlesResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetHistoricCandles not implemented")
}
func (UnimplementedGoCryptoTraderServer) SetExchangeAsset(context.Context, *SetExchangeAssetRequest) (*GenericResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method SetExchangeAsset not implemented")
}
func (UnimplementedGoCryptoTraderServer) SetAllExchangePairs(context.Context, *SetExchangeAllPairsRequest) (*GenericResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method SetAllExchangePairs not implemented")
}
func (UnimplementedGoCryptoTraderServer) UpdateExchangeSupportedPairs(context.Context, *UpdateExchangeSupportedPairsRequest) (*GenericResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method UpdateExchangeSupportedPairs not implemented")
}
func (UnimplementedGoCryptoTraderServer) GetExchangeAssets(context.Context, *GetExchangeAssetsRequest) (*GetExchangeAssetsResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetExchangeAssets not implemented")
}
func (UnimplementedGoCryptoTraderServer) WebsocketGetInfo(context.Context, *WebsocketGetInfoRequest) (*WebsocketGetInfoResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method WebsocketGetInfo not implemented")
}
func (UnimplementedGoCryptoTraderServer) WebsocketSetEnabled(context.Context, *WebsocketSetEnabledRequest) (*GenericResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method WebsocketSetEnabled not implemented")
}
func (UnimplementedGoCryptoTraderServer) WebsocketGetSubscriptions(context.Context, *WebsocketGetSubscriptionsRequest) (*WebsocketGetSubscriptionsResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method WebsocketGetSubscriptions not implemented")
}
func (UnimplementedGoCryptoTraderServer) WebsocketSetProxy(context.Context, *WebsocketSetProxyRequest) (*GenericResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method WebsocketSetProxy not implemented")
}
func (UnimplementedGoCryptoTraderServer) WebsocketSetURL(context.Context, *WebsocketSetURLRequest) (*GenericResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method WebsocketSetURL not implemented")
}
func (UnimplementedGoCryptoTraderServer) GetRecentTrades(context.Context, *GetSavedTradesRequest) (*SavedTradesResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetRecentTrades not implemented")
}
func (UnimplementedGoCryptoTraderServer) GetHistoricTrades(*GetSavedTradesRequest, GoCryptoTrader_GetHistoricTradesServer) error {
return status.Errorf(codes.Unimplemented, "method GetHistoricTrades not implemented")
}
func (UnimplementedGoCryptoTraderServer) GetSavedTrades(context.Context, *GetSavedTradesRequest) (*SavedTradesResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetSavedTrades not implemented")
}
func (UnimplementedGoCryptoTraderServer) ConvertTradesToCandles(context.Context, *ConvertTradesToCandlesRequest) (*GetHistoricCandlesResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method ConvertTradesToCandles not implemented")
}
func (UnimplementedGoCryptoTraderServer) FindMissingSavedCandleIntervals(context.Context, *FindMissingCandlePeriodsRequest) (*FindMissingIntervalsResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method FindMissingSavedCandleIntervals not implemented")
}
func (UnimplementedGoCryptoTraderServer) FindMissingSavedTradeIntervals(context.Context, *FindMissingTradePeriodsRequest) (*FindMissingIntervalsResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method FindMissingSavedTradeIntervals not implemented")
}
func (UnimplementedGoCryptoTraderServer) SetExchangeTradeProcessing(context.Context, *SetExchangeTradeProcessingRequest) (*GenericResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method SetExchangeTradeProcessing not implemented")
}
func (UnimplementedGoCryptoTraderServer) UpsertDataHistoryJob(context.Context, *UpsertDataHistoryJobRequest) (*UpsertDataHistoryJobResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method UpsertDataHistoryJob not implemented")
}
func (UnimplementedGoCryptoTraderServer) GetDataHistoryJobDetails(context.Context, *GetDataHistoryJobDetailsRequest) (*DataHistoryJob, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetDataHistoryJobDetails not implemented")
}
func (UnimplementedGoCryptoTraderServer) GetActiveDataHistoryJobs(context.Context, *GetInfoRequest) (*DataHistoryJobs, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetActiveDataHistoryJobs not implemented")
}
func (UnimplementedGoCryptoTraderServer) GetDataHistoryJobsBetween(context.Context, *GetDataHistoryJobsBetweenRequest) (*DataHistoryJobs, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetDataHistoryJobsBetween not implemented")
}
func (UnimplementedGoCryptoTraderServer) GetDataHistoryJobSummary(context.Context, *GetDataHistoryJobDetailsRequest) (*DataHistoryJob, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetDataHistoryJobSummary not implemented")
}
func (UnimplementedGoCryptoTraderServer) SetDataHistoryJobStatus(context.Context, *SetDataHistoryJobStatusRequest) (*GenericResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method SetDataHistoryJobStatus not implemented")
}
func (UnimplementedGoCryptoTraderServer) UpdateDataHistoryJobPrerequisite(context.Context, *UpdateDataHistoryJobPrerequisiteRequest) (*GenericResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method UpdateDataHistoryJobPrerequisite not implemented")
}
func (UnimplementedGoCryptoTraderServer) GetManagedOrders(context.Context, *GetOrdersRequest) (*GetOrdersResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetManagedOrders not implemented")
}
func (UnimplementedGoCryptoTraderServer) ModifyOrder(context.Context, *ModifyOrderRequest) (*ModifyOrderResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method ModifyOrder not implemented")
}
func (UnimplementedGoCryptoTraderServer) CurrencyStateGetAll(context.Context, *CurrencyStateGetAllRequest) (*CurrencyStateResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method CurrencyStateGetAll not implemented")
}
func (UnimplementedGoCryptoTraderServer) CurrencyStateTrading(context.Context, *CurrencyStateTradingRequest) (*GenericResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method CurrencyStateTrading not implemented")
}
func (UnimplementedGoCryptoTraderServer) CurrencyStateDeposit(context.Context, *CurrencyStateDepositRequest) (*GenericResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method CurrencyStateDeposit not implemented")
}
func (UnimplementedGoCryptoTraderServer) CurrencyStateWithdraw(context.Context, *CurrencyStateWithdrawRequest) (*GenericResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method CurrencyStateWithdraw not implemented")
}
func (UnimplementedGoCryptoTraderServer) CurrencyStateTradingPair(context.Context, *CurrencyStateTradingPairRequest) (*GenericResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method CurrencyStateTradingPair not implemented")
}
func (UnimplementedGoCryptoTraderServer) mustEmbedUnimplementedGoCryptoTraderServer() {}
// UnsafeGoCryptoTraderServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to GoCryptoTraderServer will
// result in compilation errors.
type UnsafeGoCryptoTraderServer interface {
mustEmbedUnimplementedGoCryptoTraderServer()
}
func RegisterGoCryptoTraderServer(s grpc.ServiceRegistrar, srv GoCryptoTraderServer) {
s.RegisterService(&GoCryptoTrader_ServiceDesc, srv)
}
func _GoCryptoTrader_GetInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetInfoRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).GetInfo(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/GetInfo",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).GetInfo(ctx, req.(*GetInfoRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_GetSubsystems_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetSubsystemsRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).GetSubsystems(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/GetSubsystems",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).GetSubsystems(ctx, req.(*GetSubsystemsRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_EnableSubsystem_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GenericSubsystemRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).EnableSubsystem(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/EnableSubsystem",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).EnableSubsystem(ctx, req.(*GenericSubsystemRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_DisableSubsystem_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GenericSubsystemRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).DisableSubsystem(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/DisableSubsystem",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).DisableSubsystem(ctx, req.(*GenericSubsystemRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_GetRPCEndpoints_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetRPCEndpointsRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).GetRPCEndpoints(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/GetRPCEndpoints",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).GetRPCEndpoints(ctx, req.(*GetRPCEndpointsRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_GetCommunicationRelayers_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetCommunicationRelayersRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).GetCommunicationRelayers(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/GetCommunicationRelayers",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).GetCommunicationRelayers(ctx, req.(*GetCommunicationRelayersRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_GetExchanges_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetExchangesRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).GetExchanges(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/GetExchanges",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).GetExchanges(ctx, req.(*GetExchangesRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_DisableExchange_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GenericExchangeNameRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).DisableExchange(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/DisableExchange",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).DisableExchange(ctx, req.(*GenericExchangeNameRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_GetExchangeInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GenericExchangeNameRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).GetExchangeInfo(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/GetExchangeInfo",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).GetExchangeInfo(ctx, req.(*GenericExchangeNameRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_GetExchangeOTPCode_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GenericExchangeNameRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).GetExchangeOTPCode(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/GetExchangeOTPCode",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).GetExchangeOTPCode(ctx, req.(*GenericExchangeNameRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_GetExchangeOTPCodes_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetExchangeOTPsRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).GetExchangeOTPCodes(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/GetExchangeOTPCodes",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).GetExchangeOTPCodes(ctx, req.(*GetExchangeOTPsRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_EnableExchange_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GenericExchangeNameRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).EnableExchange(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/EnableExchange",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).EnableExchange(ctx, req.(*GenericExchangeNameRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_GetTicker_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetTickerRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).GetTicker(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/GetTicker",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).GetTicker(ctx, req.(*GetTickerRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_GetTickers_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetTickersRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).GetTickers(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/GetTickers",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).GetTickers(ctx, req.(*GetTickersRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_GetOrderbook_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetOrderbookRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).GetOrderbook(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/GetOrderbook",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).GetOrderbook(ctx, req.(*GetOrderbookRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_GetOrderbooks_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetOrderbooksRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).GetOrderbooks(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/GetOrderbooks",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).GetOrderbooks(ctx, req.(*GetOrderbooksRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_GetAccountInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetAccountInfoRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).GetAccountInfo(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/GetAccountInfo",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).GetAccountInfo(ctx, req.(*GetAccountInfoRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_UpdateAccountInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetAccountInfoRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).UpdateAccountInfo(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/UpdateAccountInfo",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).UpdateAccountInfo(ctx, req.(*GetAccountInfoRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_GetAccountInfoStream_Handler(srv interface{}, stream grpc.ServerStream) error {
m := new(GetAccountInfoRequest)
if err := stream.RecvMsg(m); err != nil {
return err
}
return srv.(GoCryptoTraderServer).GetAccountInfoStream(m, &goCryptoTraderGetAccountInfoStreamServer{stream})
}
type GoCryptoTrader_GetAccountInfoStreamServer interface {
Send(*GetAccountInfoResponse) error
grpc.ServerStream
}
type goCryptoTraderGetAccountInfoStreamServer struct {
grpc.ServerStream
}
func (x *goCryptoTraderGetAccountInfoStreamServer) Send(m *GetAccountInfoResponse) error {
return x.ServerStream.SendMsg(m)
}
func _GoCryptoTrader_GetConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetConfigRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).GetConfig(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/GetConfig",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).GetConfig(ctx, req.(*GetConfigRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_GetPortfolio_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetPortfolioRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).GetPortfolio(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/GetPortfolio",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).GetPortfolio(ctx, req.(*GetPortfolioRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_GetPortfolioSummary_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetPortfolioSummaryRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).GetPortfolioSummary(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/GetPortfolioSummary",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).GetPortfolioSummary(ctx, req.(*GetPortfolioSummaryRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_AddPortfolioAddress_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(AddPortfolioAddressRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).AddPortfolioAddress(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/AddPortfolioAddress",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).AddPortfolioAddress(ctx, req.(*AddPortfolioAddressRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_RemovePortfolioAddress_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(RemovePortfolioAddressRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).RemovePortfolioAddress(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/RemovePortfolioAddress",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).RemovePortfolioAddress(ctx, req.(*RemovePortfolioAddressRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_GetForexProviders_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetForexProvidersRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).GetForexProviders(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/GetForexProviders",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).GetForexProviders(ctx, req.(*GetForexProvidersRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_GetForexRates_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetForexRatesRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).GetForexRates(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/GetForexRates",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).GetForexRates(ctx, req.(*GetForexRatesRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_GetOrders_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetOrdersRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).GetOrders(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/GetOrders",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).GetOrders(ctx, req.(*GetOrdersRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_GetOrder_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetOrderRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).GetOrder(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/GetOrder",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).GetOrder(ctx, req.(*GetOrderRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_SubmitOrder_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(SubmitOrderRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).SubmitOrder(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/SubmitOrder",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).SubmitOrder(ctx, req.(*SubmitOrderRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_SimulateOrder_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(SimulateOrderRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).SimulateOrder(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/SimulateOrder",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).SimulateOrder(ctx, req.(*SimulateOrderRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_WhaleBomb_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(WhaleBombRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).WhaleBomb(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/WhaleBomb",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).WhaleBomb(ctx, req.(*WhaleBombRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_CancelOrder_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(CancelOrderRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).CancelOrder(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/CancelOrder",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).CancelOrder(ctx, req.(*CancelOrderRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_CancelBatchOrders_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(CancelBatchOrdersRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).CancelBatchOrders(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/CancelBatchOrders",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).CancelBatchOrders(ctx, req.(*CancelBatchOrdersRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_CancelAllOrders_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(CancelAllOrdersRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).CancelAllOrders(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/CancelAllOrders",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).CancelAllOrders(ctx, req.(*CancelAllOrdersRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_GetEvents_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetEventsRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).GetEvents(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/GetEvents",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).GetEvents(ctx, req.(*GetEventsRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_AddEvent_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(AddEventRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).AddEvent(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/AddEvent",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).AddEvent(ctx, req.(*AddEventRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_RemoveEvent_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(RemoveEventRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).RemoveEvent(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/RemoveEvent",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).RemoveEvent(ctx, req.(*RemoveEventRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_GetCryptocurrencyDepositAddresses_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetCryptocurrencyDepositAddressesRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).GetCryptocurrencyDepositAddresses(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/GetCryptocurrencyDepositAddresses",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).GetCryptocurrencyDepositAddresses(ctx, req.(*GetCryptocurrencyDepositAddressesRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_GetCryptocurrencyDepositAddress_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetCryptocurrencyDepositAddressRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).GetCryptocurrencyDepositAddress(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/GetCryptocurrencyDepositAddress",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).GetCryptocurrencyDepositAddress(ctx, req.(*GetCryptocurrencyDepositAddressRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_GetAvailableTransferChains_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetAvailableTransferChainsRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).GetAvailableTransferChains(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/GetAvailableTransferChains",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).GetAvailableTransferChains(ctx, req.(*GetAvailableTransferChainsRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_WithdrawFiatFunds_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(WithdrawFiatRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).WithdrawFiatFunds(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/WithdrawFiatFunds",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).WithdrawFiatFunds(ctx, req.(*WithdrawFiatRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_WithdrawCryptocurrencyFunds_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(WithdrawCryptoRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).WithdrawCryptocurrencyFunds(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/WithdrawCryptocurrencyFunds",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).WithdrawCryptocurrencyFunds(ctx, req.(*WithdrawCryptoRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_WithdrawalEventByID_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(WithdrawalEventByIDRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).WithdrawalEventByID(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/WithdrawalEventByID",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).WithdrawalEventByID(ctx, req.(*WithdrawalEventByIDRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_WithdrawalEventsByExchange_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(WithdrawalEventsByExchangeRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).WithdrawalEventsByExchange(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/WithdrawalEventsByExchange",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).WithdrawalEventsByExchange(ctx, req.(*WithdrawalEventsByExchangeRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_WithdrawalEventsByDate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(WithdrawalEventsByDateRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).WithdrawalEventsByDate(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/WithdrawalEventsByDate",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).WithdrawalEventsByDate(ctx, req.(*WithdrawalEventsByDateRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_GetLoggerDetails_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetLoggerDetailsRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).GetLoggerDetails(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/GetLoggerDetails",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).GetLoggerDetails(ctx, req.(*GetLoggerDetailsRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_SetLoggerDetails_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(SetLoggerDetailsRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).SetLoggerDetails(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/SetLoggerDetails",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).SetLoggerDetails(ctx, req.(*SetLoggerDetailsRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_GetExchangePairs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetExchangePairsRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).GetExchangePairs(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/GetExchangePairs",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).GetExchangePairs(ctx, req.(*GetExchangePairsRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_SetExchangePair_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(SetExchangePairRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).SetExchangePair(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/SetExchangePair",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).SetExchangePair(ctx, req.(*SetExchangePairRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_GetOrderbookStream_Handler(srv interface{}, stream grpc.ServerStream) error {
m := new(GetOrderbookStreamRequest)
if err := stream.RecvMsg(m); err != nil {
return err
}
return srv.(GoCryptoTraderServer).GetOrderbookStream(m, &goCryptoTraderGetOrderbookStreamServer{stream})
}
type GoCryptoTrader_GetOrderbookStreamServer interface {
Send(*OrderbookResponse) error
grpc.ServerStream
}
type goCryptoTraderGetOrderbookStreamServer struct {
grpc.ServerStream
}
func (x *goCryptoTraderGetOrderbookStreamServer) Send(m *OrderbookResponse) error {
return x.ServerStream.SendMsg(m)
}
func _GoCryptoTrader_GetExchangeOrderbookStream_Handler(srv interface{}, stream grpc.ServerStream) error {
m := new(GetExchangeOrderbookStreamRequest)
if err := stream.RecvMsg(m); err != nil {
return err
}
return srv.(GoCryptoTraderServer).GetExchangeOrderbookStream(m, &goCryptoTraderGetExchangeOrderbookStreamServer{stream})
}
type GoCryptoTrader_GetExchangeOrderbookStreamServer interface {
Send(*OrderbookResponse) error
grpc.ServerStream
}
type goCryptoTraderGetExchangeOrderbookStreamServer struct {
grpc.ServerStream
}
func (x *goCryptoTraderGetExchangeOrderbookStreamServer) Send(m *OrderbookResponse) error {
return x.ServerStream.SendMsg(m)
}
func _GoCryptoTrader_GetTickerStream_Handler(srv interface{}, stream grpc.ServerStream) error {
m := new(GetTickerStreamRequest)
if err := stream.RecvMsg(m); err != nil {
return err
}
return srv.(GoCryptoTraderServer).GetTickerStream(m, &goCryptoTraderGetTickerStreamServer{stream})
}
type GoCryptoTrader_GetTickerStreamServer interface {
Send(*TickerResponse) error
grpc.ServerStream
}
type goCryptoTraderGetTickerStreamServer struct {
grpc.ServerStream
}
func (x *goCryptoTraderGetTickerStreamServer) Send(m *TickerResponse) error {
return x.ServerStream.SendMsg(m)
}
func _GoCryptoTrader_GetExchangeTickerStream_Handler(srv interface{}, stream grpc.ServerStream) error {
m := new(GetExchangeTickerStreamRequest)
if err := stream.RecvMsg(m); err != nil {
return err
}
return srv.(GoCryptoTraderServer).GetExchangeTickerStream(m, &goCryptoTraderGetExchangeTickerStreamServer{stream})
}
type GoCryptoTrader_GetExchangeTickerStreamServer interface {
Send(*TickerResponse) error
grpc.ServerStream
}
type goCryptoTraderGetExchangeTickerStreamServer struct {
grpc.ServerStream
}
func (x *goCryptoTraderGetExchangeTickerStreamServer) Send(m *TickerResponse) error {
return x.ServerStream.SendMsg(m)
}
func _GoCryptoTrader_GetAuditEvent_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetAuditEventRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).GetAuditEvent(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/GetAuditEvent",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).GetAuditEvent(ctx, req.(*GetAuditEventRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_GCTScriptExecute_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GCTScriptExecuteRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).GCTScriptExecute(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/GCTScriptExecute",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).GCTScriptExecute(ctx, req.(*GCTScriptExecuteRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_GCTScriptUpload_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GCTScriptUploadRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).GCTScriptUpload(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/GCTScriptUpload",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).GCTScriptUpload(ctx, req.(*GCTScriptUploadRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_GCTScriptReadScript_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GCTScriptReadScriptRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).GCTScriptReadScript(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/GCTScriptReadScript",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).GCTScriptReadScript(ctx, req.(*GCTScriptReadScriptRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_GCTScriptStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GCTScriptStatusRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).GCTScriptStatus(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/GCTScriptStatus",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).GCTScriptStatus(ctx, req.(*GCTScriptStatusRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_GCTScriptQuery_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GCTScriptQueryRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).GCTScriptQuery(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/GCTScriptQuery",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).GCTScriptQuery(ctx, req.(*GCTScriptQueryRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_GCTScriptStop_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GCTScriptStopRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).GCTScriptStop(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/GCTScriptStop",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).GCTScriptStop(ctx, req.(*GCTScriptStopRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_GCTScriptStopAll_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GCTScriptStopAllRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).GCTScriptStopAll(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/GCTScriptStopAll",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).GCTScriptStopAll(ctx, req.(*GCTScriptStopAllRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_GCTScriptListAll_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GCTScriptListAllRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).GCTScriptListAll(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/GCTScriptListAll",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).GCTScriptListAll(ctx, req.(*GCTScriptListAllRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_GCTScriptAutoLoadToggle_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GCTScriptAutoLoadRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).GCTScriptAutoLoadToggle(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/GCTScriptAutoLoadToggle",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).GCTScriptAutoLoadToggle(ctx, req.(*GCTScriptAutoLoadRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_GetHistoricCandles_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetHistoricCandlesRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).GetHistoricCandles(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/GetHistoricCandles",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).GetHistoricCandles(ctx, req.(*GetHistoricCandlesRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_SetExchangeAsset_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(SetExchangeAssetRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).SetExchangeAsset(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/SetExchangeAsset",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).SetExchangeAsset(ctx, req.(*SetExchangeAssetRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_SetAllExchangePairs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(SetExchangeAllPairsRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).SetAllExchangePairs(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/SetAllExchangePairs",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).SetAllExchangePairs(ctx, req.(*SetExchangeAllPairsRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_UpdateExchangeSupportedPairs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(UpdateExchangeSupportedPairsRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).UpdateExchangeSupportedPairs(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/UpdateExchangeSupportedPairs",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).UpdateExchangeSupportedPairs(ctx, req.(*UpdateExchangeSupportedPairsRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_GetExchangeAssets_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetExchangeAssetsRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).GetExchangeAssets(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/GetExchangeAssets",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).GetExchangeAssets(ctx, req.(*GetExchangeAssetsRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_WebsocketGetInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(WebsocketGetInfoRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).WebsocketGetInfo(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/WebsocketGetInfo",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).WebsocketGetInfo(ctx, req.(*WebsocketGetInfoRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_WebsocketSetEnabled_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(WebsocketSetEnabledRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).WebsocketSetEnabled(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/WebsocketSetEnabled",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).WebsocketSetEnabled(ctx, req.(*WebsocketSetEnabledRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_WebsocketGetSubscriptions_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(WebsocketGetSubscriptionsRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).WebsocketGetSubscriptions(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/WebsocketGetSubscriptions",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).WebsocketGetSubscriptions(ctx, req.(*WebsocketGetSubscriptionsRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_WebsocketSetProxy_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(WebsocketSetProxyRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).WebsocketSetProxy(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/WebsocketSetProxy",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).WebsocketSetProxy(ctx, req.(*WebsocketSetProxyRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_WebsocketSetURL_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(WebsocketSetURLRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).WebsocketSetURL(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/WebsocketSetURL",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).WebsocketSetURL(ctx, req.(*WebsocketSetURLRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_GetRecentTrades_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetSavedTradesRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).GetRecentTrades(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/GetRecentTrades",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).GetRecentTrades(ctx, req.(*GetSavedTradesRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_GetHistoricTrades_Handler(srv interface{}, stream grpc.ServerStream) error {
m := new(GetSavedTradesRequest)
if err := stream.RecvMsg(m); err != nil {
return err
}
return srv.(GoCryptoTraderServer).GetHistoricTrades(m, &goCryptoTraderGetHistoricTradesServer{stream})
}
type GoCryptoTrader_GetHistoricTradesServer interface {
Send(*SavedTradesResponse) error
grpc.ServerStream
}
type goCryptoTraderGetHistoricTradesServer struct {
grpc.ServerStream
}
func (x *goCryptoTraderGetHistoricTradesServer) Send(m *SavedTradesResponse) error {
return x.ServerStream.SendMsg(m)
}
func _GoCryptoTrader_GetSavedTrades_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetSavedTradesRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).GetSavedTrades(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/GetSavedTrades",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).GetSavedTrades(ctx, req.(*GetSavedTradesRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_ConvertTradesToCandles_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ConvertTradesToCandlesRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).ConvertTradesToCandles(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/ConvertTradesToCandles",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).ConvertTradesToCandles(ctx, req.(*ConvertTradesToCandlesRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_FindMissingSavedCandleIntervals_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(FindMissingCandlePeriodsRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).FindMissingSavedCandleIntervals(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/FindMissingSavedCandleIntervals",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).FindMissingSavedCandleIntervals(ctx, req.(*FindMissingCandlePeriodsRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_FindMissingSavedTradeIntervals_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(FindMissingTradePeriodsRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).FindMissingSavedTradeIntervals(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/FindMissingSavedTradeIntervals",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).FindMissingSavedTradeIntervals(ctx, req.(*FindMissingTradePeriodsRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_SetExchangeTradeProcessing_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(SetExchangeTradeProcessingRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).SetExchangeTradeProcessing(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/SetExchangeTradeProcessing",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).SetExchangeTradeProcessing(ctx, req.(*SetExchangeTradeProcessingRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_UpsertDataHistoryJob_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(UpsertDataHistoryJobRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).UpsertDataHistoryJob(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/UpsertDataHistoryJob",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).UpsertDataHistoryJob(ctx, req.(*UpsertDataHistoryJobRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_GetDataHistoryJobDetails_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetDataHistoryJobDetailsRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).GetDataHistoryJobDetails(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/GetDataHistoryJobDetails",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).GetDataHistoryJobDetails(ctx, req.(*GetDataHistoryJobDetailsRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_GetActiveDataHistoryJobs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetInfoRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).GetActiveDataHistoryJobs(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/GetActiveDataHistoryJobs",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).GetActiveDataHistoryJobs(ctx, req.(*GetInfoRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_GetDataHistoryJobsBetween_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetDataHistoryJobsBetweenRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).GetDataHistoryJobsBetween(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/GetDataHistoryJobsBetween",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).GetDataHistoryJobsBetween(ctx, req.(*GetDataHistoryJobsBetweenRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_GetDataHistoryJobSummary_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetDataHistoryJobDetailsRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).GetDataHistoryJobSummary(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/GetDataHistoryJobSummary",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).GetDataHistoryJobSummary(ctx, req.(*GetDataHistoryJobDetailsRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_SetDataHistoryJobStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(SetDataHistoryJobStatusRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).SetDataHistoryJobStatus(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/SetDataHistoryJobStatus",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).SetDataHistoryJobStatus(ctx, req.(*SetDataHistoryJobStatusRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_UpdateDataHistoryJobPrerequisite_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(UpdateDataHistoryJobPrerequisiteRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).UpdateDataHistoryJobPrerequisite(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/UpdateDataHistoryJobPrerequisite",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).UpdateDataHistoryJobPrerequisite(ctx, req.(*UpdateDataHistoryJobPrerequisiteRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_GetManagedOrders_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetOrdersRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).GetManagedOrders(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/GetManagedOrders",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).GetManagedOrders(ctx, req.(*GetOrdersRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_ModifyOrder_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(ModifyOrderRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).ModifyOrder(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/ModifyOrder",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).ModifyOrder(ctx, req.(*ModifyOrderRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_CurrencyStateGetAll_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(CurrencyStateGetAllRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).CurrencyStateGetAll(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/CurrencyStateGetAll",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).CurrencyStateGetAll(ctx, req.(*CurrencyStateGetAllRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_CurrencyStateTrading_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(CurrencyStateTradingRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).CurrencyStateTrading(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/CurrencyStateTrading",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).CurrencyStateTrading(ctx, req.(*CurrencyStateTradingRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_CurrencyStateDeposit_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(CurrencyStateDepositRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).CurrencyStateDeposit(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/CurrencyStateDeposit",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).CurrencyStateDeposit(ctx, req.(*CurrencyStateDepositRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_CurrencyStateWithdraw_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(CurrencyStateWithdrawRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).CurrencyStateWithdraw(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/CurrencyStateWithdraw",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).CurrencyStateWithdraw(ctx, req.(*CurrencyStateWithdrawRequest))
}
return interceptor(ctx, in, info, handler)
}
func _GoCryptoTrader_CurrencyStateTradingPair_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(CurrencyStateTradingPairRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(GoCryptoTraderServer).CurrencyStateTradingPair(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gctrpc.GoCryptoTrader/CurrencyStateTradingPair",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(GoCryptoTraderServer).CurrencyStateTradingPair(ctx, req.(*CurrencyStateTradingPairRequest))
}
return interceptor(ctx, in, info, handler)
}
// GoCryptoTrader_ServiceDesc is the grpc.ServiceDesc for GoCryptoTrader service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var GoCryptoTrader_ServiceDesc = grpc.ServiceDesc{
ServiceName: "gctrpc.GoCryptoTrader",
HandlerType: (*GoCryptoTraderServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "GetInfo",
Handler: _GoCryptoTrader_GetInfo_Handler,
},
{
MethodName: "GetSubsystems",
Handler: _GoCryptoTrader_GetSubsystems_Handler,
},
{
MethodName: "EnableSubsystem",
Handler: _GoCryptoTrader_EnableSubsystem_Handler,
},
{
MethodName: "DisableSubsystem",
Handler: _GoCryptoTrader_DisableSubsystem_Handler,
},
{
MethodName: "GetRPCEndpoints",
Handler: _GoCryptoTrader_GetRPCEndpoints_Handler,
},
{
MethodName: "GetCommunicationRelayers",
Handler: _GoCryptoTrader_GetCommunicationRelayers_Handler,
},
{
MethodName: "GetExchanges",
Handler: _GoCryptoTrader_GetExchanges_Handler,
},
{
MethodName: "DisableExchange",
Handler: _GoCryptoTrader_DisableExchange_Handler,
},
{
MethodName: "GetExchangeInfo",
Handler: _GoCryptoTrader_GetExchangeInfo_Handler,
},
{
MethodName: "GetExchangeOTPCode",
Handler: _GoCryptoTrader_GetExchangeOTPCode_Handler,
},
{
MethodName: "GetExchangeOTPCodes",
Handler: _GoCryptoTrader_GetExchangeOTPCodes_Handler,
},
{
MethodName: "EnableExchange",
Handler: _GoCryptoTrader_EnableExchange_Handler,
},
{
MethodName: "GetTicker",
Handler: _GoCryptoTrader_GetTicker_Handler,
},
{
MethodName: "GetTickers",
Handler: _GoCryptoTrader_GetTickers_Handler,
},
{
MethodName: "GetOrderbook",
Handler: _GoCryptoTrader_GetOrderbook_Handler,
},
{
MethodName: "GetOrderbooks",
Handler: _GoCryptoTrader_GetOrderbooks_Handler,
},
{
MethodName: "GetAccountInfo",
Handler: _GoCryptoTrader_GetAccountInfo_Handler,
},
{
MethodName: "UpdateAccountInfo",
Handler: _GoCryptoTrader_UpdateAccountInfo_Handler,
},
{
MethodName: "GetConfig",
Handler: _GoCryptoTrader_GetConfig_Handler,
},
{
MethodName: "GetPortfolio",
Handler: _GoCryptoTrader_GetPortfolio_Handler,
},
{
MethodName: "GetPortfolioSummary",
Handler: _GoCryptoTrader_GetPortfolioSummary_Handler,
},
{
MethodName: "AddPortfolioAddress",
Handler: _GoCryptoTrader_AddPortfolioAddress_Handler,
},
{
MethodName: "RemovePortfolioAddress",
Handler: _GoCryptoTrader_RemovePortfolioAddress_Handler,
},
{
MethodName: "GetForexProviders",
Handler: _GoCryptoTrader_GetForexProviders_Handler,
},
{
MethodName: "GetForexRates",
Handler: _GoCryptoTrader_GetForexRates_Handler,
},
{
MethodName: "GetOrders",
Handler: _GoCryptoTrader_GetOrders_Handler,
},
{
MethodName: "GetOrder",
Handler: _GoCryptoTrader_GetOrder_Handler,
},
{
MethodName: "SubmitOrder",
Handler: _GoCryptoTrader_SubmitOrder_Handler,
},
{
MethodName: "SimulateOrder",
Handler: _GoCryptoTrader_SimulateOrder_Handler,
},
{
MethodName: "WhaleBomb",
Handler: _GoCryptoTrader_WhaleBomb_Handler,
},
{
MethodName: "CancelOrder",
Handler: _GoCryptoTrader_CancelOrder_Handler,
},
{
MethodName: "CancelBatchOrders",
Handler: _GoCryptoTrader_CancelBatchOrders_Handler,
},
{
MethodName: "CancelAllOrders",
Handler: _GoCryptoTrader_CancelAllOrders_Handler,
},
{
MethodName: "GetEvents",
Handler: _GoCryptoTrader_GetEvents_Handler,
},
{
MethodName: "AddEvent",
Handler: _GoCryptoTrader_AddEvent_Handler,
},
{
MethodName: "RemoveEvent",
Handler: _GoCryptoTrader_RemoveEvent_Handler,
},
{
MethodName: "GetCryptocurrencyDepositAddresses",
Handler: _GoCryptoTrader_GetCryptocurrencyDepositAddresses_Handler,
},
{
MethodName: "GetCryptocurrencyDepositAddress",
Handler: _GoCryptoTrader_GetCryptocurrencyDepositAddress_Handler,
},
{
MethodName: "GetAvailableTransferChains",
Handler: _GoCryptoTrader_GetAvailableTransferChains_Handler,
},
{
MethodName: "WithdrawFiatFunds",
Handler: _GoCryptoTrader_WithdrawFiatFunds_Handler,
},
{
MethodName: "WithdrawCryptocurrencyFunds",
Handler: _GoCryptoTrader_WithdrawCryptocurrencyFunds_Handler,
},
{
MethodName: "WithdrawalEventByID",
Handler: _GoCryptoTrader_WithdrawalEventByID_Handler,
},
{
MethodName: "WithdrawalEventsByExchange",
Handler: _GoCryptoTrader_WithdrawalEventsByExchange_Handler,
},
{
MethodName: "WithdrawalEventsByDate",
Handler: _GoCryptoTrader_WithdrawalEventsByDate_Handler,
},
{
MethodName: "GetLoggerDetails",
Handler: _GoCryptoTrader_GetLoggerDetails_Handler,
},
{
MethodName: "SetLoggerDetails",
Handler: _GoCryptoTrader_SetLoggerDetails_Handler,
},
{
MethodName: "GetExchangePairs",
Handler: _GoCryptoTrader_GetExchangePairs_Handler,
},
{
MethodName: "SetExchangePair",
Handler: _GoCryptoTrader_SetExchangePair_Handler,
},
{
MethodName: "GetAuditEvent",
Handler: _GoCryptoTrader_GetAuditEvent_Handler,
},
{
MethodName: "GCTScriptExecute",
Handler: _GoCryptoTrader_GCTScriptExecute_Handler,
},
{
MethodName: "GCTScriptUpload",
Handler: _GoCryptoTrader_GCTScriptUpload_Handler,
},
{
MethodName: "GCTScriptReadScript",
Handler: _GoCryptoTrader_GCTScriptReadScript_Handler,
},
{
MethodName: "GCTScriptStatus",
Handler: _GoCryptoTrader_GCTScriptStatus_Handler,
},
{
MethodName: "GCTScriptQuery",
Handler: _GoCryptoTrader_GCTScriptQuery_Handler,
},
{
MethodName: "GCTScriptStop",
Handler: _GoCryptoTrader_GCTScriptStop_Handler,
},
{
MethodName: "GCTScriptStopAll",
Handler: _GoCryptoTrader_GCTScriptStopAll_Handler,
},
{
MethodName: "GCTScriptListAll",
Handler: _GoCryptoTrader_GCTScriptListAll_Handler,
},
{
MethodName: "GCTScriptAutoLoadToggle",
Handler: _GoCryptoTrader_GCTScriptAutoLoadToggle_Handler,
},
{
MethodName: "GetHistoricCandles",
Handler: _GoCryptoTrader_GetHistoricCandles_Handler,
},
{
MethodName: "SetExchangeAsset",
Handler: _GoCryptoTrader_SetExchangeAsset_Handler,
},
{
MethodName: "SetAllExchangePairs",
Handler: _GoCryptoTrader_SetAllExchangePairs_Handler,
},
{
MethodName: "UpdateExchangeSupportedPairs",
Handler: _GoCryptoTrader_UpdateExchangeSupportedPairs_Handler,
},
{
MethodName: "GetExchangeAssets",
Handler: _GoCryptoTrader_GetExchangeAssets_Handler,
},
{
MethodName: "WebsocketGetInfo",
Handler: _GoCryptoTrader_WebsocketGetInfo_Handler,
},
{
MethodName: "WebsocketSetEnabled",
Handler: _GoCryptoTrader_WebsocketSetEnabled_Handler,
},
{
MethodName: "WebsocketGetSubscriptions",
Handler: _GoCryptoTrader_WebsocketGetSubscriptions_Handler,
},
{
MethodName: "WebsocketSetProxy",
Handler: _GoCryptoTrader_WebsocketSetProxy_Handler,
},
{
MethodName: "WebsocketSetURL",
Handler: _GoCryptoTrader_WebsocketSetURL_Handler,
},
{
MethodName: "GetRecentTrades",
Handler: _GoCryptoTrader_GetRecentTrades_Handler,
},
{
MethodName: "GetSavedTrades",
Handler: _GoCryptoTrader_GetSavedTrades_Handler,
},
{
MethodName: "ConvertTradesToCandles",
Handler: _GoCryptoTrader_ConvertTradesToCandles_Handler,
},
{
MethodName: "FindMissingSavedCandleIntervals",
Handler: _GoCryptoTrader_FindMissingSavedCandleIntervals_Handler,
},
{
MethodName: "FindMissingSavedTradeIntervals",
Handler: _GoCryptoTrader_FindMissingSavedTradeIntervals_Handler,
},
{
MethodName: "SetExchangeTradeProcessing",
Handler: _GoCryptoTrader_SetExchangeTradeProcessing_Handler,
},
{
MethodName: "UpsertDataHistoryJob",
Handler: _GoCryptoTrader_UpsertDataHistoryJob_Handler,
},
{
MethodName: "GetDataHistoryJobDetails",
Handler: _GoCryptoTrader_GetDataHistoryJobDetails_Handler,
},
{
MethodName: "GetActiveDataHistoryJobs",
Handler: _GoCryptoTrader_GetActiveDataHistoryJobs_Handler,
},
{
MethodName: "GetDataHistoryJobsBetween",
Handler: _GoCryptoTrader_GetDataHistoryJobsBetween_Handler,
},
{
MethodName: "GetDataHistoryJobSummary",
Handler: _GoCryptoTrader_GetDataHistoryJobSummary_Handler,
},
{
MethodName: "SetDataHistoryJobStatus",
Handler: _GoCryptoTrader_SetDataHistoryJobStatus_Handler,
},
{
MethodName: "UpdateDataHistoryJobPrerequisite",
Handler: _GoCryptoTrader_UpdateDataHistoryJobPrerequisite_Handler,
},
{
MethodName: "GetManagedOrders",
Handler: _GoCryptoTrader_GetManagedOrders_Handler,
},
{
MethodName: "ModifyOrder",
Handler: _GoCryptoTrader_ModifyOrder_Handler,
},
{
MethodName: "CurrencyStateGetAll",
Handler: _GoCryptoTrader_CurrencyStateGetAll_Handler,
},
{
MethodName: "CurrencyStateTrading",
Handler: _GoCryptoTrader_CurrencyStateTrading_Handler,
},
{
MethodName: "CurrencyStateDeposit",
Handler: _GoCryptoTrader_CurrencyStateDeposit_Handler,
},
{
MethodName: "CurrencyStateWithdraw",
Handler: _GoCryptoTrader_CurrencyStateWithdraw_Handler,
},
{
MethodName: "CurrencyStateTradingPair",
Handler: _GoCryptoTrader_CurrencyStateTradingPair_Handler,
},
},
Streams: []grpc.StreamDesc{
{
StreamName: "GetAccountInfoStream",
Handler: _GoCryptoTrader_GetAccountInfoStream_Handler,
ServerStreams: true,
},
{
StreamName: "GetOrderbookStream",
Handler: _GoCryptoTrader_GetOrderbookStream_Handler,
ServerStreams: true,
},
{
StreamName: "GetExchangeOrderbookStream",
Handler: _GoCryptoTrader_GetExchangeOrderbookStream_Handler,
ServerStreams: true,
},
{
StreamName: "GetTickerStream",
Handler: _GoCryptoTrader_GetTickerStream_Handler,
ServerStreams: true,
},
{
StreamName: "GetExchangeTickerStream",
Handler: _GoCryptoTrader_GetExchangeTickerStream_Handler,
ServerStreams: true,
},
{
StreamName: "GetHistoricTrades",
Handler: _GoCryptoTrader_GetHistoricTrades_Handler,
ServerStreams: true,
},
},
Metadata: "rpc.proto",
}
| thrasher-/gocryptotrader | gctrpc/rpc_grpc.pb.go | GO | mit | 155,402 |
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Input;
namespace WPFTemplate.Helpers
{
/// <summary>
/// Command (<see cref="Action"/>) that can be executed based on an optional
/// function that says whether or not the command can be run. This command
/// can send a parameter to the <see cref="Action"/> to execute and the
/// <see cref="Predicate{T}"/> that checks whether or not the <see cref="Action"/>
/// should execute in the first place.
/// <para>
/// https://gist.github.com/schuster-rainer/2648922 with some modifications
/// </para>
/// </summary>
public class RelayCommand<T> : ICommand
{
#region Fields
readonly Action<T> _execute;
readonly Predicate<T> _canExecute;
#endregion
#region Constructors
/// <summary>
/// Create a <see cref="RelayCommand"/> with a given <see cref="Action"/>
/// and no optional function for whether or not the <see cref="RelayCommand"/>
/// can execute
/// </summary>
/// <param name="execute"><see cref="Action"/> to call when this <see cref="RelayCommand"/>
/// is executed</param>
public RelayCommand(Action<T> execute)
: this(execute, null)
{
}
/// <summary>
/// Create a <see cref="RelayCommand"/> with a given <see cref="Action"/>
/// and optional function for whether or not the <see cref="RelayCommand"/>
/// can execute
/// </summary>
/// <param name="execute"><see cref="Action"/> to call when this <see cref="RelayCommand"/>
/// is executed</param>
/// <param name="canExecute"><see cref="Predicate{T}"/> function that determines whether or not the given <see cref="Action"/>
/// should be executed or not</param>
public RelayCommand(Action<T> execute, Predicate<T> canExecute)
{
if (execute == null)
throw new ArgumentNullException("Execute parameter cannot be null");
_execute = execute;
_canExecute = canExecute;
}
#endregion
#region ICommand Members
/// <summary>
/// Determine whether or not this command shoudl execute
/// </summary>
/// <param name="parameter">Nullable object that will be sent to this
/// command's function <see cref="Predicate{T}"/></param>
/// <returns>True if the command should run, false if the command should not be run</returns>
[DebuggerStepThrough]
public bool CanExecute(object parameter)
{
return _canExecute == null ? true : _canExecute((T)parameter);
}
/// <summary>
/// Event that is called when the command may have had its ability to be executed changed
/// </summary>
public event EventHandler CanExecuteChanged
{
add { CommandManager.RequerySuggested += value; }
remove { CommandManager.RequerySuggested -= value; }
}
/// <summary>
/// Execute this command
/// </summary>
/// <param name="parameter">the nullable object parameter to send to the execution <see cref="Action"/></param>
public void Execute(object parameter) => _execute((T)parameter);
#endregion
}
/// <summary>
/// Command (<see cref="Action"/>) that can be executed based on an optional
/// function that says whether or not the command can be run
/// </summary>
public class RelayCommand : RelayCommand<object>
{
/// <summary>
/// Create a <see cref="RelayCommand"/> with a given <see cref="Action"/>
/// and no optional function for whether or not the <see cref="RelayCommand"/>
/// can execute
/// </summary>
/// <param name="execute"><see cref="Action"/> to call when this <see cref="RelayCommand"/>
/// is executed</param>
public RelayCommand(Action execute) : this(execute, null) { }
/// <summary>
/// Create a <see cref="RelayCommand"/> with a given <see cref="Action"/>
/// and optional function for whether or not the <see cref="RelayCommand"/>
/// can execute
/// </summary>
/// <param name="execute"><see cref="Action"/> to call when this <see cref="RelayCommand"/>
/// is executed</param>
/// <param name="canExecute">Function that determines whether or not the given <see cref="Action"/>
/// should be executed or not</param>
public RelayCommand(Action execute, Func<bool> canExecute)
: base(param => execute?.Invoke(),
param => (canExecute?.Invoke()) ?? true) { }
}
}
| Deadpikle/NetSparkle | src/NetSparkle.UI.WPF/Helpers/RelayCommand.cs | C# | mit | 4,839 |
const T = {
'compares the test result against snapshot'() {
return 'ok'
},
}
export default T | Sobesednik/zoroaster | test/spec/snapshot.js | JavaScript | mit | 102 |
var mongo = require("mongodb").MongoClient,
//url = "mongodb://localhost:27017/learnyoumongo",
dbName = process.argv[2],
url = "mongodb://localhost:27017/" + dbName ;
function main() {
mongo.connect(url, function (err, db) {
var collection;
if (err) { throw err; }
collection = db.collection("users");
collection.update(
{ username: "tinatime" },
{ $set: {age: 40}},
function (err) {
if (err) { throw err; }
db.close();
}
);
});
}
main(); | kwpeters/workshopper-solutions | learnyoumongo-solutions/06-update/solution.js | JavaScript | mit | 608 |
/*
* Copyright (c) 2008-2013 The Open Source Geospatial Foundation
*
* Published under the BSD license.
* See https://github.com/geoext/geoext2/blob/master/license.txt for the full
* text of the license.
*/
/**
* The model for scale values.
*
* @class GeoExt.data.ScaleModel
*/
Ext.define('GeoExt.data.ScaleModel', {
extend: 'Ext.data.Model',
requires: [
'Ext.data.proxy.Memory',
'Ext.data.reader.Json',
'GeoExt.Version'
],
alias: 'model.gx_scale',
fields: [
{name: "level"},
{name: "resolution"},
{name: "scale"}
],
proxy: {
type: 'memory',
reader: {
type: 'json'
}
}
});
| gisprogrammer/wsp.geo.pl | external/geoext2/src/GeoExt/data/ScaleModel.js | JavaScript | mit | 700 |
class BarginCondition < ActiveRecord::Base
belongs_to :bargin
OBJECTS = [
"Comment",
"Vote"
]
OPERATORS = {
'>' => 'more than',
'<' => 'less than',
'>=' => 'more than or equal to',
'<=' => 'less than or equal to',
'==' => 'is equal to',
'!=' => 'is not equal to'
}
attr_accessible :object,
:operator,
:operand
validates :object, presence: true, inclusion: { in: OBJECTS }
validates :operator, presence: true, inclusion: { in: OPERATORS }
end
| Prizzm/mightbuy-models | app/models/bargin_condition.rb | Ruby | mit | 530 |
# classifier.py
#
# This module contains code to support the classifier notebook
import numpy as np
import pylab as plt
def p_correct_given_pos(sens, fpr, b):
""" Returns a simple Bayesian probability for the probability
that a prediction is correct, given that the prediction
was positive, given the prevailing sensitivity (sens),
false positive rate (fpr) and base rate of positive
examples.
"""
assert 0 <= sens <= 1, "Sensitivity must be in range [0,1]"
assert 0 <= fpr <= 1, "FPR must be in range [0,1]"
return sens * b / (sens * b + fpr * (1 - b))
def plot_prob_effector(sens=0.85, fpr=0.17, baserate=0.1, xmax=1):
""" Plots a line graph of P(effector|positive test) against
the baserate of effectors in the input set to the classifier.
The baserate argument draws an annotation arrow
indicating P(pos|+ve) at that baserate
"""
assert 0.1 <= xmax <= 1, "Max x axis value must be in range [0,1]"
assert 0.01 <= baserate <= 1, "Baserate annotation must be in range [0,1]"
baserates = np.arange(0, 1.05,
xmax * 0.005) # Range of +ve example base rate
probs = [p_correct_given_pos(sens, fpr, b) for b in baserates]
plt.figure(figsize=(10, 6))
plt.plot(baserates, probs, 'r')
plt.title("P(eff|pos) vs baserate; sens: %.2f, fpr: %.2f" % (sens, fpr))
plt.ylabel("P(effector|positive)")
plt.xlabel("effector baserate")
plt.xlim(0, xmax)
plt.ylim(0, 1)
# Add annotation arrow
xpos, ypos = (baserate, p_correct_given_pos(sens, fpr, baserate))
if baserate < xmax:
if xpos > 0.7 * xmax:
xtextpos = 0.05 * xmax
else:
xtextpos = xpos + (xmax-xpos)/5.
if ypos > 0.5:
ytextpos = ypos - 0.05
else:
ytextpos = ypos + 0.05
plt.annotate('baserate: %.2f, P(pos|+ve): %.3f' % (xpos, ypos),
xy=(xpos, ypos),
xytext=(xtextpos, ytextpos),
arrowprops=dict(facecolor='black', shrink=0.05))
else:
plt.text(0.05 * xmax, 0.95, 'baserate: %.2f, P(pos|+ve): %.3f' %
(xpos, ypos))
plt.show()
| widdowquinn/Teaching-SfAM-ECS | workshop/tools/classifier.py | Python | mit | 2,237 |
<?php
// ::layout1.html.twig
return array (
);
| SulivanDotEu/hca | app/cache/dev/assetic/config/a/a7c05bf748b79f85f6838ebb28ddc2a0.php | PHP | mit | 48 |
/**
* Created by dandan on 17-8-29.
*/
import * as types from "./mutation-types";
const mutations = {
[types.SET_SINGER](state, singer){
state.singer = singer
},
[types.SET_PLAYING_STATE](state, flag){
state.playing = flag
},
[types.SET_FULL_SCREEN](state,flag){
state.fullScreen = flag
},
[types.SET_PLAYLIST](state,list){
state.playList = list
},
[types.SET_SEQUENCE_LIST](state,list){
state.sequenceList = list
},
[types.SET_PLAY_MODE](state,mode){
state.mode = mode
},
[types.SET_CURRENT_INDEX](state,index){
state.currentIndex = index
},
[types.SET_DISC](state,disc){
state.disc = disc
},
[types.SET_TOP_LIST](state,topList){
state.topList = topList
},
[types.SET_SEARCH_HISTORY](state,history){
state.searchHistory = history
},
[types.SET_TEST](state,arr){
state.test = arr
},
[types.SET_PLAY_HISTORY](state,history){
state.playHistory = history
},
[types.SET_FAVOURITE_LIST](state,songList){
state.favouriteList = songList
}
}
export default mutations | xiaodanli/web-music | src/store/mutations.js | JavaScript | mit | 1,170 |
"""manglocreative URL Configuration
The `urlpatterns` list routes URLs to views. For more information please see:
https://docs.djangoproject.com/en/1.9/topics/http/urls/
Examples:
Function views
1. Add an import: from my_app import views
2. Add a URL to urlpatterns: url(r'^$', views.home, name='home')
Class-based views
1. Add an import: from other_app.views import Home
2. Add a URL to urlpatterns: url(r'^$', Home.as_view(), name='home')
Including another URLconf
1. Import the include() function: from django.conf.urls import url, include
2. Add a URL to urlpatterns: url(r'^blog/', include('blog.urls'))
"""
# ============================================================================================================ #
# kkk kkk ooooo dddddddd eeeeeeeeee kkk kkk ooooo ooooo #
# kkk kkk ooooooooo ddddddddddd eeeeeeeeee kkk kkk ooooooooo ooooooooo #
# kkk kkk ooo ooo ddd ddd eee kkk kkk ooo ooo ooo ooo #
# kkk kkk oooo oooo ddd ddd eee kkk kkk oooo oooo oooo oooo #
# kkk kkk oooo oooo ddd ddd eee kkk kkk oooo oooo oooo oooo #
# kkkkkkkk oooo oooo ddd ddd eeeeeeeeee kkkkkkkk oooo oooo oooo oooo #
# kkk kkk oooo oooo ddd ddd eee kkk kkk oooo oooo oooo oooo #
# kkk kkk oooo oooo ddd ddd eee kkk kkk oooo oooo oooo oooo #
# kkk kkk ooo ooo ddd ddd eee kkk kkk ooo ooo ooo ooo #
# kkk kkk ooooooooo dddddddddd eeeeeeeeee kkk kkk ooooooooo ooooooooo #
# kkk kkk ooooo ddddddd eeeeeeeeee kkk kkk ooooo ooooo #
# ============================================================================================================ #
from django.conf.urls import include, url
from django.contrib import admin
from django.contrib.sitemaps.views import sitemap
from blog.sitemaps import PostSitemap
sitemaps = {
'posts': PostSitemap,
}
urlpatterns = [
url(r'^manage/', admin.site.urls),
url(r'^ckeditor/', include('ckeditor_uploader.urls')),
# url(r'^blog/', include('blog.urls', namespace='blog', app_name='blog')),
url(r'^', include('blog.urls', namespace='blog', app_name='blog')),
url(r'^sitemap\.xml$', sitemap, {'sitemaps': sitemaps}, name='django.contrib.sitemaps.views.sitemap'),
]
| rizkiwisnuaji/django-newbie-cms | manglocreative/urls.py | Python | mit | 2,703 |
package com.github.dsaa.tree.binary;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class BTreePrinter {
public static <T extends Comparable<?>> void printBNode(BNode<T> root) {
int maxLevel = BTreePrinter.maxLevel(root);
printBNodeInternal(Collections.singletonList(root), 1, maxLevel);
}
private static <T extends Comparable<?>> void printBNodeInternal(
List<BNode<T>> BNodes, int level, int maxLevel) {
if (BNodes.isEmpty() || BTreePrinter.isAllElementsNull(BNodes))
return;
int floor = maxLevel - level;
int endgeLines = (int) Math.pow(2, (Math.max(floor - 1, 0)));
int firstSpaces = (int) Math.pow(2, (floor)) - 1;
int betweenSpaces = (int) Math.pow(2, (floor + 1)) - 1;
BTreePrinter.printWhitespaces(firstSpaces);
List<BNode<T>> newBNodes = new ArrayList<BNode<T>>();
for (BNode<T> BNode : BNodes) {
if (BNode != null) {
System.out.print(BNode.getData());
newBNodes.add(BNode.getLeft());
newBNodes.add(BNode.getRight());
} else {
newBNodes.add(null);
newBNodes.add(null);
System.out.print(" ");
}
BTreePrinter.printWhitespaces(betweenSpaces);
}
System.out.println("");
for (int i = 1; i <= endgeLines; i++) {
for (int j = 0; j < BNodes.size(); j++) {
BTreePrinter.printWhitespaces(firstSpaces - i);
if (BNodes.get(j) == null) {
BTreePrinter.printWhitespaces(endgeLines + endgeLines + i
+ 1);
continue;
}
if (BNodes.get(j).getLeft() != null)
System.out.print("/");
else
BTreePrinter.printWhitespaces(1);
BTreePrinter.printWhitespaces(i + i - 1);
if (BNodes.get(j).getRight() != null)
System.out.print("\\");
else
BTreePrinter.printWhitespaces(1);
BTreePrinter.printWhitespaces(endgeLines + endgeLines - i);
}
System.out.println("");
}
printBNodeInternal(newBNodes, level + 1, maxLevel);
}
private static void printWhitespaces(int count) {
for (int i = 0; i < count; i++)
System.out.print(" ");
}
private static <T extends Comparable<?>> int maxLevel(BNode<T> BNode) {
if (BNode == null)
return 0;
return Math.max(BTreePrinter.maxLevel(BNode.getLeft()),
BTreePrinter.maxLevel(BNode.getRight())) + 1;
}
private static <T> boolean isAllElementsNull(List<T> list) {
for (Object object : list) {
if (object != null)
return false;
}
return true;
}
}
| code4love/DSAA | src/main/java/com/github/dsaa/tree/binary/BTreePrinter.java | Java | mit | 2,401 |
<?php
namespace Cresta\AulasBundle;
use Symfony\Component\HttpKernel\Bundle\Bundle;
class CrestaAulasBundle extends Bundle
{
public function getParent()
{
return 'FOSUserBundle';
}
} | jorihuamancha/aulas | src/Cresta/AulasBundle/CrestaAulasBundle.php | PHP | mit | 202 |
<?
#############################################################################
# SectionMaster.org Registration System
# ADMIN BACKEND
# Copyright (c) 2005-2007 Clostridion Design & Support, LLC.
# All included files and modules of this system share the above copyright.
# All rights are reserved by Clostridion Design & Support, LLC.
#############################################################################
$title = "Home";
require "pre.php";
// handle logout
if ($_REQUEST['logout'] == 'logout')
{
$user->_logout("You have been logged out.");
}
// redirect to the event page
redirect("event/index");
?>
<?
require "post.php";
?> | mattharris5/sectionmaster | register/admin/index.php | PHP | mit | 647 |
<!-- BREADCRUMB -->
<div>
<ol class="breadcrumb">
<li><?php echo anchor(base_url('home'), 'Home')?></li>
<li><?php echo anchor(base_url('contacto'), 'Contacto')?></li>
</ol>
</div>
<!-- FIN BREADCRUMB -->
<div class="row">
<div class="col-xs-12">
<div class="panel">
<div class="panel-heading">
<h3 class="text-center">
Contáctanos <i class="fa fa-phone fa-2x"></i>
</h3>
</div>
<div class="panel-body">
<div class="col-xs-12 col-sm-6">
<ul>
<li>¿Te ha gustado la página?</li>
<li>¿Tienes ideas innovadoras que le puedan venir bien al sitio?</li>
<li>¿Quieres preguntarnos algo?</li>
<li>¿Estás interesado en algún creador de la página (laboralmente
hablando... :D)?</li>
</ul>
</div>
<div class="col-sm-6">
<?php
echo img ( array (
'src' => asset_url () . '/images/general/contacto.png',
'class' => 'img-rounded bigimage pull-right hidden-xs',
'alt' => 'mortadelo'
) )?>
</div>
<div class="col-xs-6 col-xs-push-3 visible-xs">
<?php
echo img ( array (
'src' => asset_url () . '/images/general/contacto.png',
'class' => 'img-rounded smallimage',
'alt' => 'mortadelo'
) )?>
</div>
</div>
</div>
</div>
</div>
<div class="row">
<div class="col-sm-4 col-md-4 col-lg-4">
<div class="panel">
<div class="panel-heading">
<h3 class="text-center">
Horarios de atención <i class="fa fa-clock-o fa-2x"></i>
</h3>
</div>
<div class="panel-body">
<table class="table table-hover">
<thead>
<tr>
<th>Día</th>
<th>Horario</th>
</tr>
</thead>
<tbody>
<tr class="success">
<td>Lunes a Viernes</td>
<td>9:00 a 18:00</td>
</tr>
<tr class="warning">
<td>Sábado</td>
<td>9:00 a 14:00</td>
</tr>
<tr class="danger">
<td>Domingo</td>
<td>11:00 a 14:00</td>
</tr>
</tbody>
</table>
</div>
</div>
</div>
<div class="col-sm-8 col-md-8 col-lg-8">
<div class="panel">
<div class="panel-heading">
<h3 class="text-center">
<i class="fa fa-envelope-o fa-2x"></i> Contacto
</h3>
</div>
<div class="panel-body">
<!-- CONTACT FORM -->
<?php
echo form_open ( 'contactar', [
'role' => 'form',
'data-toggle' => 'validator',
'method' => 'post',
'accept-charset' => 'UTF-8',
'idContactForm'
] )?>
<div class="form-group">
<label class="control-label" for="idName">Nombre:</label>
<div class="controls">
<input id="idName" name="name" class="form-control" type="text"
placeholder="Nombre" class="input-large" required />
</div>
<div class="help-block with-errors"></div>
</div>
<div class="form-group">
<label class="control-label" for="idEmail">Introduce tu correo
electrónico:</label>
<div class="controls">
<input id="idEmail" name="email"
pattern="^[_a-z0-9-]+(\.[_a-z0-9-]+)*@[a-z0-9-]+(\.[a-z0-9-]+)*(\.[a-z]{2,3})$"
class="input-large form-control" type="text" placeholder="email"
data-error="Dirección de correo no válida" required />
</div>
<div class="help-block with-errors"></div>
</div>
<div class="form-group">
<label class="control-label" for="idName">Mensaje:</label>
<div class="controls">
<textarea rows="10" cols="100" class="form-control" id="idMessage"
name="message" placeholder="Mensaje" required></textarea>
</div>
<div class="help-block with-errors"></div>
</div>
<div class="form-group form-inline">
<label class="control-label" for=idCaptchaControl> Introduce
Captcha: </label>
<div class="controls">
<?php getCaptcha(); ?>
</div>
<div class="help-block with-errors"></div>
</div>
<br />
<button type="submit" id="feedbackSubmit"
class="btn btn-primary btn-lg"
style="display: block; margin-top: 10px;">Enviar Feedback</button>
<?php echo form_close()?>
<!-- END CONTACT FORM -->
</div>
</div>
</div>
</div> | Bookcorner/bookcorner | application/views/static_pages/contact.php | PHP | mit | 4,510 |
import expect from 'expect';
import { By } from 'selenium-webdriver';
import driver from '../chromeWebDriver';
import { elementValueIs } from '../../src';
describe('e2e', () => {
describe('elementValueIs', () => {
before(async () => {
await driver.get('http://localhost:3000/elementValueIs.html');
});
it('should resolve if given value match target value', async () => {
await driver.wait(elementValueIs('#input', 'input value', 1000));
});
it('should reject if given value does not match target value', async () => {
const error = await driver.wait(elementValueIs('#input', 'wrong'), 1000).catch(e => e);
expect(error.message).toContain('until element value is wrong');
});
it('should reject if target is not an input', async () => {
const error = await driver.wait(elementValueIs('#not-an-input', 'input value'), 1000).catch(e => e);
expect(error.message).toContain('until element value is input value');
});
});
});
| marmelab/selenium-smart-wait | e2e/tests/elementValueIs.spec.js | JavaScript | mit | 1,068 |
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace NXDO.RJava.Core
{
class JPDateTime : JParamValue
{
public static string JavaDateClassName = "java.util.Date";
public static string SDateFormat = "yyyy-MM-dd HH:mm:ss";
private JPDateTime(DateTime? date, string jParamClassName)
: base(jParamClassName)
{
if (!date.HasValue) return;
string sDateVal = date.Value.ToString(SDateFormat);
this.JValue = JParamValueHelper.NewDate(sDateVal, SDateFormat);
}
private JPDateTime(Array array, string jParamClassName, string jElemClassName)
: base(jParamClassName)
{
int size = array == null ? 0 : array.Length;
var elemPtr = JParamValueHelper.GetJavaClass(jElemClassName);
this.JValue = JParamValueHelper.CreateObjectArray(elemPtr, size);
if (size == 0) return;
#region 转换成指针数组
int idx = 0;
foreach (DateTime? v in array)
{
IntPtr ptr = IntPtr.Zero;
if (v != null)
{
string sDateVal = v.Value.ToString(SDateFormat);
ptr = JParamValueHelper.NewDate(sDateVal, SDateFormat);
}
JParamValueHelper.SetValueObjectArray(this.JValue, idx++, ptr);
}
#endregion
}
public static JPDateTime Create(DateTime? date, string jParamClassName)
{
return new JPDateTime(date, jParamClassName);
}
public static JPDateTime Create(Array array, string jParamClassName)
{
string jcn = jParamClassName;
if (!jcn.StartsWith("[L"))
jcn = "[L" + jcn;
if (!jcn.EndsWith(";"))
jcn += ";";
return new JPDateTime(array, jcn, jParamClassName);
}
}
}
| javasuki/RJava | NXDO.Mixed.V2015/NXDO.RJava/CoreParam/JPDateTime.cs | C# | mit | 1,991 |
;(function ($, window, document, undefined) {
"use strict";
window = (typeof window != 'undefined' && window.Math == Math)
? window
: (typeof self != 'undefined' && self.Math == Math)
? self
: Function('return this')()
;
$.fn.dimmer = function(parameters) {
var
$allModules = $(this),
time = new Date().getTime(),
performance = [],
query = arguments[0],
methodInvoked = (typeof query == 'string'),
queryArguments = [].slice.call(arguments, 1),
returnedValue
;
$allModules
.each(function() {
var
settings = ( $.isPlainObject(parameters) )
? $.extend(true, {}, $.fn.dimmer.settings, parameters)
: $.extend({}, $.fn.dimmer.settings),
selector = settings.selector,
namespace = settings.namespace,
className = settings.className,
error = settings.error,
eventNamespace = '.' + namespace,
moduleNamespace = 'module-' + namespace,
moduleSelector = $allModules.selector || '',
clickEvent = ('ontouchstart' in document.documentElement)
? 'touchstart'
: 'click',
$module = $(this),
$dimmer,
$dimmable,
element = this,
instance = $module.data(moduleNamespace),
module
;
module = {
preinitialize: function() {
if( module.is.dimmer() ) {
$dimmable = $module.parent();
$dimmer = $module;
}
else {
$dimmable = $module;
if( module.has.dimmer() ) {
if(settings.dimmerName) {
$dimmer = $dimmable.find(selector.dimmer).filter('.' + settings.dimmerName);
}
else {
$dimmer = $dimmable.find(selector.dimmer);
}
}
else {
$dimmer = module.create();
}
module.set.variation();
}
},
initialize: function() {
module.debug('Initializing dimmer', settings);
module.bind.events();
module.set.dimmable();
module.instantiate();
},
instantiate: function() {
module.verbose('Storing instance of module', module);
instance = module;
$module
.data(moduleNamespace, instance)
;
},
destroy: function() {
module.verbose('Destroying previous module', $dimmer);
module.unbind.events();
module.remove.variation();
$dimmable
.off(eventNamespace)
;
},
bind: {
events: function() {
if(settings.on == 'hover') {
$dimmable
.on('mouseenter' + eventNamespace, module.show)
.on('mouseleave' + eventNamespace, module.hide)
;
}
else if(settings.on == 'click') {
$dimmable
.on(clickEvent + eventNamespace, module.toggle)
;
}
if( module.is.page() ) {
module.debug('Setting as a page dimmer', $dimmable);
module.set.pageDimmer();
}
if( module.is.closable() ) {
module.verbose('Adding dimmer close event', $dimmer);
$dimmable
.on(clickEvent + eventNamespace, selector.dimmer, module.event.click)
;
}
}
},
unbind: {
events: function() {
$module
.removeData(moduleNamespace)
;
$dimmable
.off(eventNamespace)
;
}
},
event: {
click: function(event) {
module.verbose('Determining if event occured on dimmer', event);
if( $dimmer.find(event.target).length === 0 || $(event.target).is(selector.content) ) {
module.hide();
event.stopImmediatePropagation();
}
}
},
addContent: function(element) {
var
$content = $(element)
;
module.debug('Add content to dimmer', $content);
if($content.parent()[0] !== $dimmer[0]) {
$content.detach().appendTo($dimmer);
}
},
create: function() {
var
$element = $( settings.template.dimmer() )
;
if(settings.dimmerName) {
module.debug('Creating named dimmer', settings.dimmerName);
$element.addClass(settings.dimmerName);
}
$element
.appendTo($dimmable)
;
return $element;
},
show: function(callback) {
callback = $.isFunction(callback)
? callback
: function(){}
;
module.debug('Showing dimmer', $dimmer, settings);
if( (!module.is.dimmed() || module.is.animating()) && module.is.enabled() ) {
module.animate.show(callback);
settings.onShow.call(element);
settings.onChange.call(element);
}
else {
module.debug('Dimmer is already shown or disabled');
}
},
hide: function(callback) {
callback = $.isFunction(callback)
? callback
: function(){}
;
if( module.is.dimmed() || module.is.animating() ) {
module.debug('Hiding dimmer', $dimmer);
module.animate.hide(callback);
settings.onHide.call(element);
settings.onChange.call(element);
}
else {
module.debug('Dimmer is not visible');
}
},
toggle: function() {
module.verbose('Toggling dimmer visibility', $dimmer);
if( !module.is.dimmed() ) {
module.show();
}
else {
module.hide();
}
},
animate: {
show: function(callback) {
callback = $.isFunction(callback)
? callback
: function(){}
;
if(settings.useCSS && $.fn.transition !== undefined && $dimmer.transition('is supported')) {
if(settings.opacity !== 'auto') {
module.set.opacity();
}
$dimmer
.transition({
animation : settings.transition + ' in',
queue : false,
duration : module.get.duration(),
useFailSafe : true,
onStart : function() {
module.set.dimmed();
},
onComplete : function() {
module.set.active();
callback();
}
})
;
}
else {
module.verbose('Showing dimmer animation with javascript');
module.set.dimmed();
if(settings.opacity == 'auto') {
settings.opacity = 0.8;
}
$dimmer
.stop()
.css({
opacity : 0,
width : '100%',
height : '100%'
})
.fadeTo(module.get.duration(), settings.opacity, function() {
$dimmer.removeAttr('style');
module.set.active();
callback();
})
;
}
},
hide: function(callback) {
callback = $.isFunction(callback)
? callback
: function(){}
;
if(settings.useCSS && $.fn.transition !== undefined && $dimmer.transition('is supported')) {
module.verbose('Hiding dimmer with css');
$dimmer
.transition({
animation : settings.transition + ' out',
queue : false,
duration : module.get.duration(),
useFailSafe : true,
onStart : function() {
module.remove.dimmed();
},
onComplete : function() {
module.remove.active();
callback();
}
})
;
}
else {
module.verbose('Hiding dimmer with javascript');
module.remove.dimmed();
$dimmer
.stop()
.fadeOut(module.get.duration(), function() {
module.remove.active();
$dimmer.removeAttr('style');
callback();
})
;
}
}
},
get: {
dimmer: function() {
return $dimmer;
},
duration: function() {
if(typeof settings.duration == 'object') {
if( module.is.active() ) {
return settings.duration.hide;
}
else {
return settings.duration.show;
}
}
return settings.duration;
}
},
has: {
dimmer: function() {
if(settings.dimmerName) {
return ($module.find(selector.dimmer).filter('.' + settings.dimmerName).length > 0);
}
else {
return ( $module.find(selector.dimmer).length > 0 );
}
}
},
is: {
active: function() {
return $dimmer.hasClass(className.active);
},
animating: function() {
return ( $dimmer.is(':animated') || $dimmer.hasClass(className.animating) );
},
closable: function() {
if(settings.closable == 'auto') {
if(settings.on == 'hover') {
return false;
}
return true;
}
return settings.closable;
},
dimmer: function() {
return $module.hasClass(className.dimmer);
},
dimmable: function() {
return $module.hasClass(className.dimmable);
},
dimmed: function() {
return $dimmable.hasClass(className.dimmed);
},
disabled: function() {
return $dimmable.hasClass(className.disabled);
},
enabled: function() {
return !module.is.disabled();
},
page: function () {
return $dimmable.is('body');
},
pageDimmer: function() {
return $dimmer.hasClass(className.pageDimmer);
}
},
can: {
show: function() {
return !$dimmer.hasClass(className.disabled);
}
},
set: {
opacity: function(opacity) {
var
color = $dimmer.css('background-color'),
colorArray = color.split(','),
isRGB = (colorArray && colorArray.length == 3),
isRGBA = (colorArray && colorArray.length == 4)
;
opacity = settings.opacity === 0 ? 0 : settings.opacity || opacity;
if(isRGB || isRGBA) {
colorArray[3] = opacity + ')';
color = colorArray.join(',');
}
else {
color = 'rgba(0, 0, 0, ' + opacity + ')';
}
module.debug('Setting opacity to', opacity);
$dimmer.css('background-color', color);
},
active: function() {
$dimmer.addClass(className.active);
},
dimmable: function() {
$dimmable.addClass(className.dimmable);
},
dimmed: function() {
$dimmable.addClass(className.dimmed);
},
pageDimmer: function() {
$dimmer.addClass(className.pageDimmer);
},
disabled: function() {
$dimmer.addClass(className.disabled);
},
variation: function(variation) {
variation = variation || settings.variation;
if(variation) {
$dimmer.addClass(variation);
}
}
},
remove: {
active: function() {
$dimmer
.removeClass(className.active)
;
},
dimmed: function() {
$dimmable.removeClass(className.dimmed);
},
disabled: function() {
$dimmer.removeClass(className.disabled);
},
variation: function(variation) {
variation = variation || settings.variation;
if(variation) {
$dimmer.removeClass(variation);
}
}
},
setting: function(name, value) {
module.debug('Changing setting', name, value);
if( $.isPlainObject(name) ) {
$.extend(true, settings, name);
}
else if(value !== undefined) {
if($.isPlainObject(settings[name])) {
$.extend(true, settings[name], value);
}
else {
settings[name] = value;
}
}
else {
return settings[name];
}
},
internal: function(name, value) {
if( $.isPlainObject(name) ) {
$.extend(true, module, name);
}
else if(value !== undefined) {
module[name] = value;
}
else {
return module[name];
}
},
debug: function() {
if(!settings.silent && settings.debug) {
if(settings.performance) {
module.performance.log(arguments);
}
else {
module.debug = Function.prototype.bind.call(console.info, console, settings.name + ':');
module.debug.apply(console, arguments);
}
}
},
verbose: function() {
if(!settings.silent && settings.verbose && settings.debug) {
if(settings.performance) {
module.performance.log(arguments);
}
else {
module.verbose = Function.prototype.bind.call(console.info, console, settings.name + ':');
module.verbose.apply(console, arguments);
}
}
},
error: function() {
if(!settings.silent) {
module.error = Function.prototype.bind.call(console.error, console, settings.name + ':');
module.error.apply(console, arguments);
}
},
performance: {
log: function(message) {
var
currentTime,
executionTime,
previousTime
;
if(settings.performance) {
currentTime = new Date().getTime();
previousTime = time || currentTime;
executionTime = currentTime - previousTime;
time = currentTime;
performance.push({
'Name' : message[0],
'Arguments' : [].slice.call(message, 1) || '',
'Element' : element,
'Execution Time' : executionTime
});
}
clearTimeout(module.performance.timer);
module.performance.timer = setTimeout(module.performance.display, 500);
},
display: function() {
var
title = settings.name + ':',
totalTime = 0
;
time = false;
clearTimeout(module.performance.timer);
$.each(performance, function(index, data) {
totalTime += data['Execution Time'];
});
title += ' ' + totalTime + 'ms';
if(moduleSelector) {
title += ' \'' + moduleSelector + '\'';
}
if($allModules.length > 1) {
title += ' ' + '(' + $allModules.length + ')';
}
if( (console.group !== undefined || console.table !== undefined) && performance.length > 0) {
console.groupCollapsed(title);
if(console.table) {
console.table(performance);
}
else {
$.each(performance, function(index, data) {
console.log(data['Name'] + ': ' + data['Execution Time']+'ms');
});
}
console.groupEnd();
}
performance = [];
}
},
invoke: function(query, passedArguments, context) {
var
object = instance,
maxDepth,
found,
response
;
passedArguments = passedArguments || queryArguments;
context = element || context;
if(typeof query == 'string' && object !== undefined) {
query = query.split(/[\. ]/);
maxDepth = query.length - 1;
$.each(query, function(depth, value) {
var camelCaseValue = (depth != maxDepth)
? value + query[depth + 1].charAt(0).toUpperCase() + query[depth + 1].slice(1)
: query
;
if( $.isPlainObject( object[camelCaseValue] ) && (depth != maxDepth) ) {
object = object[camelCaseValue];
}
else if( object[camelCaseValue] !== undefined ) {
found = object[camelCaseValue];
return false;
}
else if( $.isPlainObject( object[value] ) && (depth != maxDepth) ) {
object = object[value];
}
else if( object[value] !== undefined ) {
found = object[value];
return false;
}
else {
module.error(error.method, query);
return false;
}
});
}
if ( $.isFunction( found ) ) {
response = found.apply(context, passedArguments);
}
else if(found !== undefined) {
response = found;
}
if($.isArray(returnedValue)) {
returnedValue.push(response);
}
else if(returnedValue !== undefined) {
returnedValue = [returnedValue, response];
}
else if(response !== undefined) {
returnedValue = response;
}
return found;
}
};
module.preinitialize();
if(methodInvoked) {
if(instance === undefined) {
module.initialize();
}
module.invoke(query);
}
else {
if(instance !== undefined) {
instance.invoke('destroy');
}
module.initialize();
}
})
;
return (returnedValue !== undefined)
? returnedValue
: this
;
};
$.fn.dimmer.settings = {
name : 'Dimmer',
namespace : 'dimmer',
silent : false,
debug : false,
verbose : false,
performance : true,
// name to distinguish between multiple dimmers in context
dimmerName : false,
// whether to add a variation type
variation : false,
// whether to bind close events
closable : 'auto',
// whether to use css animations
useCSS : true,
// css animation to use
transition : 'fade',
// event to bind to
on : false,
// overriding opacity value
opacity : 'auto',
// transition durations
duration : {
show : 500,
hide : 500
},
onChange : function(){},
onShow : function(){},
onHide : function(){},
error : {
method : 'The method you called is not defined.'
},
className : {
active : 'active',
animating : 'animating',
dimmable : 'dimmable',
dimmed : 'dimmed',
dimmer : 'dimmer',
disabled : 'disabled',
hide : 'hide',
pageDimmer : 'page',
show : 'show'
},
selector: {
dimmer : '> .ui.dimmer',
content : '.ui.dimmer > .content, .ui.dimmer > .content > .center'
},
template: {
dimmer: function() {
return $('<div />').attr('class', 'ui dimmer');
}
}
};
})( jQuery, window, document ); | Cryptix720/Chronimi | src/definitions/modules/dimmer.js | JavaScript | mit | 21,282 |
class Customer < Character
end
| maldrasen/archive | Rysh.2/app/models/customer.rb | Ruby | mit | 32 |
using System;
using System.ComponentModel;
using System.IO;
using System.Reflection;
using System.Threading;
using System.Windows.Forms;
using BorderlandsAdvancedConfig.INIParser;
using BorderlandsAdvancedConfig.SettingsManagers;
namespace BorderlandsAdvancedConfig
{
public partial class FrmConfig : Form
{
public delegate void SetProgressDeleg(int percent, string text);
public delegate void HideDeleg();
private FrmLoad frmLoad = new FrmLoad();
private Thread loadingThread;
private PathSettings pathSettings = new PathSettings();
private EngineSettingsManager EngineManager;
private InputSettingsManager InputManager;
private GameSettingsManager GameManager;
private const string codeRepository = "https://github.com/TheLonerD/BorderlandsAdvancedConfig";
public string AssemblyVersion
{
get
{
return Assembly.GetExecutingAssembly().GetName().Version.ToString();
}
}
private void SetProgress(int percent, string text)
{
try
{
frmLoad.Invoke(new SetProgressDeleg(frmLoad.setProgress), new object[] { percent, text });
}
catch { }
}
private void HideLoading()
{
try
{
frmLoad.Invoke(new HideDeleg(frmLoad.Hide));
this.BringToFront();
}
catch { }
}
private void ShowLoadingForm()
{
frmLoad.ShowDialog();
}
public FrmConfig()
{
InitializeComponent();
loadingThread = new Thread(new ThreadStart(ShowLoadingForm));
loadingThread.Start();
if (!InitializeSettingsDirectory())
{
Environment.Exit(10);
}
BackupFiles(false);
if (!ParseConfigFiles())
{
Environment.Exit(30);
}
this.Text = String.Format("Borderlands Advanced Settings Version {0} by isNull(MDK)", AssemblyVersion);
log("> Reading settings...");
ReadSettings();
log("Checking for updates...");
UpdateBackgroundWorker.RunWorkerAsync();
log("> Ready");
}
public void log(string logTxt)
{
txtLog.AppendText(logTxt + Environment.NewLine);
txtLog.SelectionStart = txtLog.Text.Length;
txtLog.ScrollToCaret();
}
private void BackupFiles(bool forceBackup)
{
string backupDir = Path.Combine(pathSettings.SettingsDir, "Backup");
if (!Directory.Exists(backupDir))
{
Directory.CreateDirectory(backupDir);
}
DirectoryInfo sourceDir = new DirectoryInfo(pathSettings.SettingsDir);
DirectoryInfo destDir = new DirectoryInfo(backupDir);
foreach (FileInfo fi in sourceDir.GetFiles("*.ini"))
{
if (fi.IsReadOnly)
{
fi.IsReadOnly = false;
}
if (!File.Exists(Path.Combine(destDir.FullName, fi.Name)) || forceBackup)
{
fi.CopyTo(Path.Combine(destDir.FullName, fi.Name), true);
}
}
}
private void RestoreFiles()
{
string backupDir = Path.Combine(pathSettings.SettingsDir, "Backup");
if (!Directory.Exists(backupDir))
{
MessageBox.Show("Oh oh, backup directory not found. Cannot restore.", "Backup files not found", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
DirectoryInfo destDir = new DirectoryInfo(pathSettings.SettingsDir);
DirectoryInfo sourceDir = new DirectoryInfo(backupDir);
string destPath;
foreach (FileInfo fi in sourceDir.GetFiles("*.ini"))
{
destPath = Path.Combine(destDir.FullName, fi.Name);
if (File.Exists(destPath))
{
FileInfo fInfo = new FileInfo(destPath);
fInfo.IsReadOnly = false;
fInfo = null;
File.Delete(destPath);
}
fi.CopyTo(destPath, true);
}
log("> Backup Restored.");
MessageBox.Show("Backup Restored. Exiting.", "Original files restored", MessageBoxButtons.OK, MessageBoxIcon.Information);
Environment.Exit(0);
}
private bool ParseConfigFiles()
{
try
{
SetProgress(0, "Loading Engine Settings...");
EngineManager = new EngineSettingsManager(new INIFileParser(pathSettings.EngineIniPath));
SetProgress(25, "Loading Input Settings...");
InputManager = new InputSettingsManager(new INIFileParser(pathSettings.InputIniPath));
SetProgress(50, "Loading Game Settings. This will take a while. Please wait...");
GameManager = new GameSettingsManager(new INIFileParser(pathSettings.GameIniPath));
SetProgress(100, "Done.");
HideLoading();
}
catch
{
return false;
}
return true;
}
private bool InitializeSettingsDirectory()
{
if (string.IsNullOrEmpty(pathSettings.SettingsDir))
{
DialogResult result = MessageBox.Show(LocalizedStrings.ConfigNotFound, "Config files not found", MessageBoxButtons.YesNo, MessageBoxIcon.Exclamation, MessageBoxDefaultButton.Button1);
if (result == DialogResult.Yes)
{
DialogResult browseResult = SettingsDirBrowser.ShowDialog();
if (browseResult == DialogResult.OK)
{
if (pathSettings.SetSettingsDir(SettingsDirBrowser.SelectedPath))
{
return true;
}
else
{
MessageBox.Show("Config files not found at the selected path.", "Bad directory", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
}
}
else
{
return true;
}
return false;
}
private void ReadSettings()
{
LoadEngineSection();
LoadInputSection();
LoadGameSection();
}
private void SaveSettings()
{
SaveEngineSection();
SaveInputSection();
SaveGameSection();
log("> Saved. Have fun playing!");
MessageBox.Show("Settings Saved. Have fun!", "Save settings", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
private void LoadInputSection()
{
chkF9Hud.Checked = InputManager.SetF9ShowHud;
try
{
chkFOVAdjust.Checked = InputManager.FovKeysEnabled();
if (chkFOVAdjust.Checked)
{
txtF10Fov.Text = InputManager.GetF10Fov().Value.ToString();
txtF11Fov.Text = InputManager.GetF11Fov().Value.ToString();
}
chkFOVAdjust_CheckedChanged(this, null);
}
catch
{
chkFOVAdjust.Enabled = false;
txtF10Fov.Enabled = false;
txtF11Fov.Enabled = false;
}
chkF12Fps.Checked = InputManager.SetF12ShowFPS;
chkDisableMouseSmooth.Checked = !InputManager.EnableMouseSmoothing;
chkConsole.Checked = InputManager.Console;
chkZoomToggle.Checked = InputManager.ZoomToggle;
chkCrouchToggle.Checked = InputManager.CrouchToggle;
chkScrollWheel.Checked = InputManager.ScrollWheel;
}
private void SaveInputSection()
{
InputManager.SetF9ShowHud = chkF9Hud.Checked;
if (chkFOVAdjust.Enabled)
{
if (chkFOVAdjust.Checked && !string.IsNullOrEmpty(txtF10Fov.Text) && !string.IsNullOrEmpty(txtF11Fov.Text))
{
InputManager.SetKeyFov("F10", int.Parse(txtF10Fov.Text));
InputManager.SetKeyFov("F11", int.Parse(txtF11Fov.Text));
}
else if (!chkFOVAdjust.Checked)
{
InputManager.RemoveBinding("F10");
InputManager.RemoveBinding("F11");
}
}
InputManager.SetF12ShowFPS = chkF12Fps.Checked;
InputManager.EnableMouseSmoothing = !chkDisableMouseSmooth.Checked;
InputManager.Console = chkConsole.Checked;
InputManager.ZoomToggle = chkZoomToggle.Checked;
InputManager.CrouchToggle = chkCrouchToggle.Checked;
InputManager.ScrollWheel = chkScrollWheel.Checked;
InputManager.Save();
}
private void LoadGameSection()
{
trkPlayerInfoMaxDist.Value = GameManager.PlayerInfoMaxDist;
}
private void SaveGameSection()
{
GameManager.PlayerInfoMaxDist = trkPlayerInfoMaxDist.Value;
GameManager.Save();
}
private void LoadEngineSection()
{
chkAmbient.Checked = EngineManager.Ambient;
chkHBloom.Checked = EngineManager.HighQualityBloom;
chkVsync.Checked = EngineManager.Vsync;
chkPhysX.Checked = EngineManager.AllowPhysX;
chkSmoothFrameRate.Checked = EngineManager.SmoothFrameRate;
try
{
chkDisableStartup.Checked = EngineManager.StartupMovies;
}
catch
{
chkDisableStartup.Enabled = false;
}
chkOutlines.Checked = EngineManager.DisableOutlineShader;
trkMaxAnsio.Value = 0;
if (EngineManager.MaxAnisotropy != 0)
{
trkMaxAnsio.Value = (int)Math.Log(EngineManager.MaxAnisotropy, 2);
}
trkMaxAniso_Scroll(this, null);
trkMaxAA.Value = 0;
if (EngineManager.MaxMultisamples != 0)
{
trkMaxAA.Value = (int)Math.Log(EngineManager.MaxMultisamples, 2);
}
trkMaxAA_Scroll(this, null);
txtWidth.Text = EngineManager.ResX.ToString();
txtHeight.Text = EngineManager.ResY.ToString();
txtScreenPercentage.Text = EngineManager.ScreenPercentage.ToString();
chkDisablevchat.Checked = !EngineManager.HasVoiceEnabled;
}
private void SaveEngineSection()
{
EngineManager.Ambient = chkAmbient.Checked;
EngineManager.HighQualityBloom = chkHBloom.Checked;
EngineManager.Vsync = chkVsync.Checked;
EngineManager.AllowPhysX = chkPhysX.Checked;
EngineManager.SmoothFrameRate = chkSmoothFrameRate.Checked;
if (chkDisableStartup.Enabled)
{
EngineManager.StartupMovies = !chkDisableStartup.Checked;
}
EngineManager.DisableOutlineShader = chkOutlines.Checked;
if (trkMaxAnsio.Value != 0)
{
EngineManager.MaxAnisotropy = (short)Math.Pow(2, trkMaxAnsio.Value);
}
else
{
EngineManager.MaxAnisotropy = 0;
}
if (trkMaxAA.Value != 0)
{
EngineManager.MaxMultisamples = (short)Math.Pow(2, trkMaxAA.Value);
}
else
{
EngineManager.MaxMultisamples = 0;
}
EngineManager.ResX = int.Parse(txtWidth.Text);
EngineManager.ResY = int.Parse(txtHeight.Text);
EngineManager.ScreenPercentage = int.Parse(txtScreenPercentage.Text);
EngineManager.HasVoiceEnabled = !chkDisablevchat.Checked;
EngineManager.Save();
}
private void btnSave_Click(object sender, EventArgs e)
{
SaveSettings();
}
private void trkMaxAniso_Scroll(object sender, EventArgs e)
{
double Ansiovalue = 0;
if (trkMaxAnsio.Value != 0)
Ansiovalue = Math.Pow(2, trkMaxAnsio.Value);
lblMaxAnsio.Text = string.Format("Max Aniso Filtering: {0}x", Ansiovalue);
}
private void trkMaxAA_Scroll(object sender, EventArgs e)
{
double AAValue = 0;
if (trkMaxAA.Value != 0)
AAValue = Math.Pow(2, trkMaxAA.Value);
lblMaxAA.Text = string.Format("Max Anti Aliasing: {0}x", AAValue);
}
private void chkFOVAdjust_CheckedChanged(object sender, EventArgs e)
{
if (chkFOVAdjust.Checked)
{
txtF10Fov.Text = "90";
txtF11Fov.Text = "110";
}
txtF10Fov.Enabled = chkFOVAdjust.Checked;
txtF11Fov.Enabled = chkFOVAdjust.Checked;
}
private void btnRestore_Click(object sender, EventArgs e)
{
RestoreFiles();
}
private void lnkOfficialThread_LinkClicked(object sender, LinkLabelLinkClickedEventArgs e)
{
System.Diagnostics.Process.Start(codeRepository);
}
private void btnAbout_Click(object sender, EventArgs e)
{
AboutBox ab = new AboutBox();
ab.ShowDialog(this);
}
private void chkVsync_CheckedChanged(object sender, EventArgs e)
{
if (!chkVsync.Checked)
{
chkSmoothFrameRate.Enabled = true;
chkSmoothFrameRate.Checked = true;
}
else
{
chkSmoothFrameRate.Enabled = false;
chkSmoothFrameRate.Checked = true;
}
}
private void UpdateBackgroundWorker_DoWork(object sender, DoWorkEventArgs e)
{
VersionCheck versionCheck = new VersionCheck(codeRepository);
}
}
}
| TheLonerD/BorderlandsAdvancedConfig | FrmConfig.cs | C# | mit | 14,522 |
# encoding: utf-8
# Code generated by Microsoft (R) AutoRest Code Generator.
# Changes may cause incorrect behavior and will be lost if the code is
# regenerated.
module Azure::Cosmosdb::Mgmt::V2020_09_01
module Models
#
# A metric name.
#
class MetricName
include MsRestAzure
# @return [String] The name of the metric.
attr_accessor :value
# @return [String] The friendly name of the metric.
attr_accessor :localized_value
#
# Mapper for MetricName class as Ruby Hash.
# This will be used for serialization/deserialization.
#
def self.mapper()
{
client_side_validation: true,
required: false,
serialized_name: 'MetricName',
type: {
name: 'Composite',
class_name: 'MetricName',
model_properties: {
value: {
client_side_validation: true,
required: false,
read_only: true,
serialized_name: 'value',
type: {
name: 'String'
}
},
localized_value: {
client_side_validation: true,
required: false,
read_only: true,
serialized_name: 'localizedValue',
type: {
name: 'String'
}
}
}
}
}
end
end
end
end
| Azure/azure-sdk-for-ruby | management/azure_mgmt_cosmosdb/lib/2020-09-01/generated/azure_mgmt_cosmosdb/models/metric_name.rb | Ruby | mit | 1,486 |
'use strict';
var m = require('mithril');
function controller() {
}
function view() {
return [
m('h1', 'mithril-isomorphic-example'),
m('p', 'yes, it works'),
m('a', {
href: '/second-page',
config: m.route
}, 'second page'),
m('div', ''),
m('a', {
href: '/resume',
config: m.route
}, 'resume')
];
}
module.exports = {
controller: controller,
view: view
};
| john-ko/johnkoorg | client/pages/home.js | JavaScript | mit | 421 |
// The MIT License (MIT)
//
// Copyright (c) Andrew Armstrong/FacticiusVir 2020
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
// This file was automatically generated and should not be edited directly.
using System.Runtime.InteropServices;
namespace SharpVk
{
/// <summary>
///
/// </summary>
internal partial struct CommandCacheStruct
{
/// <summary>
///
/// </summary>
public readonly Interop.VkInstanceCreateDelegate vkCreateInstance;
/// <summary>
///
/// </summary>
public readonly Interop.VkInstanceDestroyDelegate vkDestroyInstance;
/// <summary>
///
/// </summary>
public readonly Interop.VkInstanceEnumeratePhysicalDevicesDelegate vkEnumeratePhysicalDevices;
/// <summary>
///
/// </summary>
public readonly Interop.VkPhysicalDeviceGetFeaturesDelegate vkGetPhysicalDeviceFeatures;
/// <summary>
///
/// </summary>
public readonly Interop.VkPhysicalDeviceGetFormatPropertiesDelegate vkGetPhysicalDeviceFormatProperties;
/// <summary>
///
/// </summary>
public readonly Interop.VkPhysicalDeviceGetImageFormatPropertiesDelegate vkGetPhysicalDeviceImageFormatProperties;
/// <summary>
///
/// </summary>
public readonly Interop.VkPhysicalDeviceGetPropertiesDelegate vkGetPhysicalDeviceProperties;
/// <summary>
///
/// </summary>
public readonly Interop.VkPhysicalDeviceGetQueueFamilyPropertiesDelegate vkGetPhysicalDeviceQueueFamilyProperties;
/// <summary>
///
/// </summary>
public readonly Interop.VkPhysicalDeviceGetMemoryPropertiesDelegate vkGetPhysicalDeviceMemoryProperties;
/// <summary>
///
/// </summary>
public readonly Interop.VkInstanceGetProcedureAddressDelegate vkGetInstanceProcAddr;
/// <summary>
///
/// </summary>
public readonly Interop.VkDeviceGetProcedureAddressDelegate vkGetDeviceProcAddr;
/// <summary>
///
/// </summary>
public readonly Interop.VkPhysicalDeviceCreateDeviceDelegate vkCreateDevice;
/// <summary>
///
/// </summary>
public readonly Interop.VkDeviceDestroyDelegate vkDestroyDevice;
/// <summary>
///
/// </summary>
public readonly Interop.VkInstanceEnumerateExtensionPropertiesDelegate vkEnumerateInstanceExtensionProperties;
/// <summary>
///
/// </summary>
public readonly Interop.VkPhysicalDeviceEnumerateDeviceExtensionPropertiesDelegate vkEnumerateDeviceExtensionProperties;
/// <summary>
///
/// </summary>
public readonly Interop.VkInstanceEnumerateLayerPropertiesDelegate vkEnumerateInstanceLayerProperties;
/// <summary>
///
/// </summary>
public readonly Interop.VkPhysicalDeviceEnumerateDeviceLayerPropertiesDelegate vkEnumerateDeviceLayerProperties;
/// <summary>
///
/// </summary>
public readonly Interop.VkDeviceGetQueueDelegate vkGetDeviceQueue;
/// <summary>
///
/// </summary>
public readonly Interop.VkQueueSubmitDelegate vkQueueSubmit;
/// <summary>
///
/// </summary>
public readonly Interop.VkQueueWaitIdleDelegate vkQueueWaitIdle;
/// <summary>
///
/// </summary>
public readonly Interop.VkDeviceWaitIdleDelegate vkDeviceWaitIdle;
/// <summary>
///
/// </summary>
public readonly Interop.VkDeviceAllocateMemoryDelegate vkAllocateMemory;
/// <summary>
///
/// </summary>
public readonly Interop.VkDeviceMemoryFreeDelegate vkFreeMemory;
/// <summary>
///
/// </summary>
public readonly Interop.VkDeviceMemoryMapDelegate vkMapMemory;
/// <summary>
///
/// </summary>
public readonly Interop.VkDeviceMemoryUnmapDelegate vkUnmapMemory;
/// <summary>
///
/// </summary>
public readonly Interop.VkDeviceFlushMappedMemoryRangesDelegate vkFlushMappedMemoryRanges;
/// <summary>
///
/// </summary>
public readonly Interop.VkDeviceInvalidateMappedMemoryRangesDelegate vkInvalidateMappedMemoryRanges;
/// <summary>
///
/// </summary>
public readonly Interop.VkDeviceMemoryGetCommitmentDelegate vkGetDeviceMemoryCommitment;
/// <summary>
///
/// </summary>
public readonly Interop.VkBufferBindMemoryDelegate vkBindBufferMemory;
/// <summary>
///
/// </summary>
public readonly Interop.VkImageBindMemoryDelegate vkBindImageMemory;
/// <summary>
///
/// </summary>
public readonly Interop.VkBufferGetMemoryRequirementsDelegate vkGetBufferMemoryRequirements;
/// <summary>
///
/// </summary>
public readonly Interop.VkImageGetMemoryRequirementsDelegate vkGetImageMemoryRequirements;
/// <summary>
///
/// </summary>
public readonly Interop.VkImageGetSparseMemoryRequirementsDelegate vkGetImageSparseMemoryRequirements;
/// <summary>
///
/// </summary>
public readonly Interop.VkPhysicalDeviceGetSparseImageFormatPropertiesDelegate vkGetPhysicalDeviceSparseImageFormatProperties;
/// <summary>
///
/// </summary>
public readonly Interop.VkQueueBindSparseDelegate vkQueueBindSparse;
/// <summary>
///
/// </summary>
public readonly Interop.VkDeviceCreateFenceDelegate vkCreateFence;
/// <summary>
///
/// </summary>
public readonly Interop.VkFenceDestroyDelegate vkDestroyFence;
/// <summary>
///
/// </summary>
public readonly Interop.VkDeviceResetFencesDelegate vkResetFences;
/// <summary>
///
/// </summary>
public readonly Interop.VkFenceGetStatusDelegate vkGetFenceStatus;
/// <summary>
///
/// </summary>
public readonly Interop.VkDeviceWaitForFencesDelegate vkWaitForFences;
/// <summary>
///
/// </summary>
public readonly Interop.VkDeviceCreateSemaphoreDelegate vkCreateSemaphore;
/// <summary>
///
/// </summary>
public readonly Interop.VkSemaphoreDestroyDelegate vkDestroySemaphore;
/// <summary>
///
/// </summary>
public readonly Interop.VkDeviceCreateEventDelegate vkCreateEvent;
/// <summary>
///
/// </summary>
public readonly Interop.VkEventDestroyDelegate vkDestroyEvent;
/// <summary>
///
/// </summary>
public readonly Interop.VkEventGetStatusDelegate vkGetEventStatus;
/// <summary>
///
/// </summary>
public readonly Interop.VkEventSetDelegate vkSetEvent;
/// <summary>
///
/// </summary>
public readonly Interop.VkEventResetDelegate vkResetEvent;
/// <summary>
///
/// </summary>
public readonly Interop.VkDeviceCreateQueryPoolDelegate vkCreateQueryPool;
/// <summary>
///
/// </summary>
public readonly Interop.VkQueryPoolDestroyDelegate vkDestroyQueryPool;
/// <summary>
///
/// </summary>
public readonly Interop.VkQueryPoolGetResultsDelegate vkGetQueryPoolResults;
/// <summary>
///
/// </summary>
public readonly Interop.VkDeviceCreateBufferDelegate vkCreateBuffer;
/// <summary>
///
/// </summary>
public readonly Interop.VkBufferDestroyDelegate vkDestroyBuffer;
/// <summary>
///
/// </summary>
public readonly Interop.VkDeviceCreateBufferViewDelegate vkCreateBufferView;
/// <summary>
///
/// </summary>
public readonly Interop.VkBufferViewDestroyDelegate vkDestroyBufferView;
/// <summary>
///
/// </summary>
public readonly Interop.VkDeviceCreateImageDelegate vkCreateImage;
/// <summary>
///
/// </summary>
public readonly Interop.VkImageDestroyDelegate vkDestroyImage;
/// <summary>
///
/// </summary>
public readonly Interop.VkImageGetSubresourceLayoutDelegate vkGetImageSubresourceLayout;
/// <summary>
///
/// </summary>
public readonly Interop.VkDeviceCreateImageViewDelegate vkCreateImageView;
/// <summary>
///
/// </summary>
public readonly Interop.VkImageViewDestroyDelegate vkDestroyImageView;
/// <summary>
///
/// </summary>
public readonly Interop.VkDeviceCreateShaderModuleDelegate vkCreateShaderModule;
/// <summary>
///
/// </summary>
public readonly Interop.VkShaderModuleDestroyDelegate vkDestroyShaderModule;
/// <summary>
///
/// </summary>
public readonly Interop.VkDeviceCreatePipelineCacheDelegate vkCreatePipelineCache;
/// <summary>
///
/// </summary>
public readonly Interop.VkPipelineCacheDestroyDelegate vkDestroyPipelineCache;
/// <summary>
///
/// </summary>
public readonly Interop.VkPipelineCacheGetDataDelegate vkGetPipelineCacheData;
/// <summary>
///
/// </summary>
public readonly Interop.VkPipelineCacheMergePipelineCachesDelegate vkMergePipelineCaches;
/// <summary>
///
/// </summary>
public readonly Interop.VkDeviceCreateGraphicsPipelinesDelegate vkCreateGraphicsPipelines;
/// <summary>
///
/// </summary>
public readonly Interop.VkDeviceCreateComputePipelinesDelegate vkCreateComputePipelines;
/// <summary>
///
/// </summary>
public readonly Interop.VkPipelineDestroyDelegate vkDestroyPipeline;
/// <summary>
///
/// </summary>
public readonly Interop.VkDeviceCreatePipelineLayoutDelegate vkCreatePipelineLayout;
/// <summary>
///
/// </summary>
public readonly Interop.VkPipelineLayoutDestroyDelegate vkDestroyPipelineLayout;
/// <summary>
///
/// </summary>
public readonly Interop.VkDeviceCreateSamplerDelegate vkCreateSampler;
/// <summary>
///
/// </summary>
public readonly Interop.VkSamplerDestroyDelegate vkDestroySampler;
/// <summary>
///
/// </summary>
public readonly Interop.VkDeviceCreateDescriptorSetLayoutDelegate vkCreateDescriptorSetLayout;
/// <summary>
///
/// </summary>
public readonly Interop.VkDescriptorSetLayoutDestroyDelegate vkDestroyDescriptorSetLayout;
/// <summary>
///
/// </summary>
public readonly Interop.VkDeviceCreateDescriptorPoolDelegate vkCreateDescriptorPool;
/// <summary>
///
/// </summary>
public readonly Interop.VkDescriptorPoolDestroyDelegate vkDestroyDescriptorPool;
/// <summary>
///
/// </summary>
public readonly Interop.VkDescriptorPoolResetDelegate vkResetDescriptorPool;
/// <summary>
///
/// </summary>
public readonly Interop.VkDeviceAllocateDescriptorSetsDelegate vkAllocateDescriptorSets;
/// <summary>
///
/// </summary>
public readonly Interop.VkDescriptorPoolFreeDescriptorSetsDelegate vkFreeDescriptorSets;
/// <summary>
///
/// </summary>
public readonly Interop.VkDeviceUpdateDescriptorSetsDelegate vkUpdateDescriptorSets;
/// <summary>
///
/// </summary>
public readonly Interop.VkDeviceCreateFramebufferDelegate vkCreateFramebuffer;
/// <summary>
///
/// </summary>
public readonly Interop.VkFramebufferDestroyDelegate vkDestroyFramebuffer;
/// <summary>
///
/// </summary>
public readonly Interop.VkDeviceCreateRenderPassDelegate vkCreateRenderPass;
/// <summary>
///
/// </summary>
public readonly Interop.VkRenderPassDestroyDelegate vkDestroyRenderPass;
/// <summary>
///
/// </summary>
public readonly Interop.VkRenderPassGetRenderAreaGranularityDelegate vkGetRenderAreaGranularity;
/// <summary>
///
/// </summary>
public readonly Interop.VkDeviceCreateCommandPoolDelegate vkCreateCommandPool;
/// <summary>
///
/// </summary>
public readonly Interop.VkCommandPoolDestroyDelegate vkDestroyCommandPool;
/// <summary>
///
/// </summary>
public readonly Interop.VkCommandPoolResetDelegate vkResetCommandPool;
/// <summary>
///
/// </summary>
public readonly Interop.VkDeviceAllocateCommandBuffersDelegate vkAllocateCommandBuffers;
/// <summary>
///
/// </summary>
public readonly Interop.VkCommandPoolFreeCommandBuffersDelegate vkFreeCommandBuffers;
/// <summary>
///
/// </summary>
public readonly Interop.VkCommandBufferBeginDelegate vkBeginCommandBuffer;
/// <summary>
///
/// </summary>
public readonly Interop.VkCommandBufferEndDelegate vkEndCommandBuffer;
/// <summary>
///
/// </summary>
public readonly Interop.VkCommandBufferResetDelegate vkResetCommandBuffer;
/// <summary>
///
/// </summary>
public readonly Interop.VkCommandBufferBindPipelineDelegate vkCmdBindPipeline;
/// <summary>
///
/// </summary>
public readonly Interop.VkCommandBufferSetViewportDelegate vkCmdSetViewport;
/// <summary>
///
/// </summary>
public readonly Interop.VkCommandBufferSetScissorDelegate vkCmdSetScissor;
/// <summary>
///
/// </summary>
public readonly Interop.VkCommandBufferSetLineWidthDelegate vkCmdSetLineWidth;
/// <summary>
///
/// </summary>
public readonly Interop.VkCommandBufferSetDepthBiasDelegate vkCmdSetDepthBias;
/// <summary>
///
/// </summary>
public readonly Interop.VkCommandBufferSetBlendConstantsDelegate vkCmdSetBlendConstants;
/// <summary>
///
/// </summary>
public readonly Interop.VkCommandBufferSetDepthBoundsDelegate vkCmdSetDepthBounds;
/// <summary>
///
/// </summary>
public readonly Interop.VkCommandBufferSetStencilCompareMaskDelegate vkCmdSetStencilCompareMask;
/// <summary>
///
/// </summary>
public readonly Interop.VkCommandBufferSetStencilWriteMaskDelegate vkCmdSetStencilWriteMask;
/// <summary>
///
/// </summary>
public readonly Interop.VkCommandBufferSetStencilReferenceDelegate vkCmdSetStencilReference;
/// <summary>
///
/// </summary>
public readonly Interop.VkCommandBufferBindDescriptorSetsDelegate vkCmdBindDescriptorSets;
/// <summary>
///
/// </summary>
public readonly Interop.VkCommandBufferBindIndexBufferDelegate vkCmdBindIndexBuffer;
/// <summary>
///
/// </summary>
public readonly Interop.VkCommandBufferBindVertexBuffersDelegate vkCmdBindVertexBuffers;
/// <summary>
///
/// </summary>
public readonly Interop.VkCommandBufferDrawDelegate vkCmdDraw;
/// <summary>
///
/// </summary>
public readonly Interop.VkCommandBufferDrawIndexedDelegate vkCmdDrawIndexed;
/// <summary>
///
/// </summary>
public readonly Interop.VkCommandBufferDrawIndirectDelegate vkCmdDrawIndirect;
/// <summary>
///
/// </summary>
public readonly Interop.VkCommandBufferDrawIndexedIndirectDelegate vkCmdDrawIndexedIndirect;
/// <summary>
///
/// </summary>
public readonly Interop.VkCommandBufferDispatchDelegate vkCmdDispatch;
/// <summary>
///
/// </summary>
public readonly Interop.VkCommandBufferDispatchIndirectDelegate vkCmdDispatchIndirect;
/// <summary>
///
/// </summary>
public readonly Interop.VkCommandBufferCopyBufferDelegate vkCmdCopyBuffer;
/// <summary>
///
/// </summary>
public readonly Interop.VkCommandBufferCopyImageDelegate vkCmdCopyImage;
/// <summary>
///
/// </summary>
public readonly Interop.VkCommandBufferBlitImageDelegate vkCmdBlitImage;
/// <summary>
///
/// </summary>
public readonly Interop.VkCommandBufferCopyBufferToImageDelegate vkCmdCopyBufferToImage;
/// <summary>
///
/// </summary>
public readonly Interop.VkCommandBufferCopyImageToBufferDelegate vkCmdCopyImageToBuffer;
/// <summary>
///
/// </summary>
public readonly Interop.VkCommandBufferUpdateBufferDelegate vkCmdUpdateBuffer;
/// <summary>
///
/// </summary>
public readonly Interop.VkCommandBufferFillBufferDelegate vkCmdFillBuffer;
/// <summary>
///
/// </summary>
public readonly Interop.VkCommandBufferClearColorImageDelegate vkCmdClearColorImage;
/// <summary>
///
/// </summary>
public readonly Interop.VkCommandBufferClearDepthStencilImageDelegate vkCmdClearDepthStencilImage;
/// <summary>
///
/// </summary>
public readonly Interop.VkCommandBufferClearAttachmentsDelegate vkCmdClearAttachments;
/// <summary>
///
/// </summary>
public readonly Interop.VkCommandBufferResolveImageDelegate vkCmdResolveImage;
/// <summary>
///
/// </summary>
public readonly Interop.VkCommandBufferSetEventDelegate vkCmdSetEvent;
/// <summary>
///
/// </summary>
public readonly Interop.VkCommandBufferResetEventDelegate vkCmdResetEvent;
/// <summary>
///
/// </summary>
public readonly Interop.VkCommandBufferWaitEventsDelegate vkCmdWaitEvents;
/// <summary>
///
/// </summary>
public readonly Interop.VkCommandBufferPipelineBarrierDelegate vkCmdPipelineBarrier;
/// <summary>
///
/// </summary>
public readonly Interop.VkCommandBufferBeginQueryDelegate vkCmdBeginQuery;
/// <summary>
///
/// </summary>
public readonly Interop.VkCommandBufferEndQueryDelegate vkCmdEndQuery;
/// <summary>
///
/// </summary>
public readonly Interop.VkCommandBufferResetQueryPoolDelegate vkCmdResetQueryPool;
/// <summary>
///
/// </summary>
public readonly Interop.VkCommandBufferWriteTimestampDelegate vkCmdWriteTimestamp;
/// <summary>
///
/// </summary>
public readonly Interop.VkCommandBufferCopyQueryPoolResultsDelegate vkCmdCopyQueryPoolResults;
/// <summary>
///
/// </summary>
public readonly Interop.VkCommandBufferPushConstantsDelegate vkCmdPushConstants;
/// <summary>
///
/// </summary>
public readonly Interop.VkCommandBufferBeginRenderPassDelegate vkCmdBeginRenderPass;
/// <summary>
///
/// </summary>
public readonly Interop.VkCommandBufferNextSubpassDelegate vkCmdNextSubpass;
/// <summary>
///
/// </summary>
public readonly Interop.VkCommandBufferEndRenderPassDelegate vkCmdEndRenderPass;
/// <summary>
///
/// </summary>
public readonly Interop.VkCommandBufferExecuteCommandsDelegate vkCmdExecuteCommands;
/// <summary>
///
/// </summary>
public readonly Interop.VkInstanceEnumerateVersionDelegate vkEnumerateInstanceVersion;
/// <summary>
///
/// </summary>
public readonly Interop.VkDeviceBindBufferMemory2Delegate vkBindBufferMemory2;
/// <summary>
///
/// </summary>
public readonly Interop.VkDeviceBindImageMemory2Delegate vkBindImageMemory2;
/// <summary>
///
/// </summary>
public readonly Interop.VkDeviceGetGroupPeerMemoryFeaturesDelegate vkGetDeviceGroupPeerMemoryFeatures;
/// <summary>
///
/// </summary>
public readonly Interop.VkCommandBufferSetDeviceMaskDelegate vkCmdSetDeviceMask;
/// <summary>
///
/// </summary>
public readonly Interop.VkCommandBufferDispatchBaseDelegate vkCmdDispatchBase;
/// <summary>
///
/// </summary>
public readonly Interop.VkInstanceEnumeratePhysicalDeviceGroupsDelegate vkEnumeratePhysicalDeviceGroups;
/// <summary>
///
/// </summary>
public readonly Interop.VkDeviceGetImageMemoryRequirements2Delegate vkGetImageMemoryRequirements2;
/// <summary>
///
/// </summary>
public readonly Interop.VkDeviceGetBufferMemoryRequirements2Delegate vkGetBufferMemoryRequirements2;
/// <summary>
///
/// </summary>
public readonly Interop.VkDeviceGetImageSparseMemoryRequirements2Delegate vkGetImageSparseMemoryRequirements2;
/// <summary>
///
/// </summary>
public readonly Interop.VkPhysicalDeviceGetFeatures2Delegate vkGetPhysicalDeviceFeatures2;
/// <summary>
///
/// </summary>
public readonly Interop.VkPhysicalDeviceGetProperties2Delegate vkGetPhysicalDeviceProperties2;
/// <summary>
///
/// </summary>
public readonly Interop.VkPhysicalDeviceGetFormatProperties2Delegate vkGetPhysicalDeviceFormatProperties2;
/// <summary>
///
/// </summary>
public readonly Interop.VkPhysicalDeviceGetImageFormatProperties2Delegate vkGetPhysicalDeviceImageFormatProperties2;
/// <summary>
///
/// </summary>
public readonly Interop.VkPhysicalDeviceGetQueueFamilyProperties2Delegate vkGetPhysicalDeviceQueueFamilyProperties2;
/// <summary>
///
/// </summary>
public readonly Interop.VkPhysicalDeviceGetMemoryProperties2Delegate vkGetPhysicalDeviceMemoryProperties2;
/// <summary>
///
/// </summary>
public readonly Interop.VkPhysicalDeviceGetSparseImageFormatProperties2Delegate vkGetPhysicalDeviceSparseImageFormatProperties2;
/// <summary>
///
/// </summary>
public readonly Interop.VkCommandPoolTrimDelegate vkTrimCommandPool;
/// <summary>
///
/// </summary>
public readonly Interop.VkDeviceGetQueue2Delegate vkGetDeviceQueue2;
/// <summary>
///
/// </summary>
public readonly Interop.VkDeviceCreateSamplerYcbcrConversionDelegate vkCreateSamplerYcbcrConversion;
/// <summary>
///
/// </summary>
public readonly Interop.VkSamplerYcbcrConversionDestroyDelegate vkDestroySamplerYcbcrConversion;
/// <summary>
///
/// </summary>
public readonly Interop.VkDeviceCreateDescriptorUpdateTemplateDelegate vkCreateDescriptorUpdateTemplate;
/// <summary>
///
/// </summary>
public readonly Interop.VkDescriptorUpdateTemplateDestroyDelegate vkDestroyDescriptorUpdateTemplate;
/// <summary>
///
/// </summary>
public readonly Interop.VkDeviceUpdateDescriptorSetWithTemplateDelegate vkUpdateDescriptorSetWithTemplate;
/// <summary>
///
/// </summary>
public readonly Interop.VkPhysicalDeviceGetExternalBufferPropertiesDelegate vkGetPhysicalDeviceExternalBufferProperties;
/// <summary>
///
/// </summary>
public readonly Interop.VkPhysicalDeviceGetExternalFencePropertiesDelegate vkGetPhysicalDeviceExternalFenceProperties;
/// <summary>
///
/// </summary>
public readonly Interop.VkPhysicalDeviceGetExternalSemaphorePropertiesDelegate vkGetPhysicalDeviceExternalSemaphoreProperties;
/// <summary>
///
/// </summary>
public readonly Interop.VkDeviceGetDescriptorSetLayoutSupportDelegate vkGetDescriptorSetLayoutSupport;
/// <summary>
///
/// </summary>
public readonly Interop.VkCommandBufferDrawIndirectCountDelegate vkCmdDrawIndirectCount;
/// <summary>
///
/// </summary>
public readonly Interop.VkCommandBufferDrawIndexedIndirectCountDelegate vkCmdDrawIndexedIndirectCount;
/// <summary>
///
/// </summary>
public readonly Interop.VkDeviceCreateRenderPass2Delegate vkCreateRenderPass2;
/// <summary>
///
/// </summary>
public readonly Interop.VkCommandBufferBeginRenderPass2Delegate vkCmdBeginRenderPass2;
/// <summary>
///
/// </summary>
public readonly Interop.VkCommandBufferNextSubpass2Delegate vkCmdNextSubpass2;
/// <summary>
///
/// </summary>
public readonly Interop.VkCommandBufferEndRenderPass2Delegate vkCmdEndRenderPass2;
/// <summary>
///
/// </summary>
public readonly Interop.VkQueryPoolResetDelegate vkResetQueryPool;
/// <summary>
///
/// </summary>
public readonly Interop.VkSemaphoreGetCounterValueDelegate vkGetSemaphoreCounterValue;
/// <summary>
///
/// </summary>
public readonly Interop.VkDeviceWaitSemaphoresDelegate vkWaitSemaphores;
/// <summary>
///
/// </summary>
public readonly Interop.VkDeviceSignalSemaphoreDelegate vkSignalSemaphore;
/// <summary>
///
/// </summary>
public readonly Interop.VkDeviceGetBufferDeviceAddressDelegate vkGetBufferDeviceAddress;
/// <summary>
///
/// </summary>
public readonly Interop.VkDeviceGetBufferOpaqueCaptureAddressDelegate vkGetBufferOpaqueCaptureAddress;
/// <summary>
///
/// </summary>
public readonly Interop.VkDeviceGetMemoryOpaqueCaptureAddressDelegate vkGetDeviceMemoryOpaqueCaptureAddress;
/// <summary>
///
/// </summary>
public readonly Interop.Khronos.VkSurfaceKHRDestroyDelegate vkDestroySurfaceKHR;
/// <summary>
///
/// </summary>
public readonly Interop.Khronos.VkPhysicalDeviceGetSurfaceSupportDelegate vkGetPhysicalDeviceSurfaceSupportKHR;
/// <summary>
///
/// </summary>
public readonly Interop.Khronos.VkPhysicalDeviceGetSurfaceCapabilitiesDelegate vkGetPhysicalDeviceSurfaceCapabilitiesKHR;
/// <summary>
///
/// </summary>
public readonly Interop.Khronos.VkPhysicalDeviceGetSurfaceFormatsDelegate vkGetPhysicalDeviceSurfaceFormatsKHR;
/// <summary>
///
/// </summary>
public readonly Interop.Khronos.VkPhysicalDeviceGetSurfacePresentModesDelegate vkGetPhysicalDeviceSurfacePresentModesKHR;
/// <summary>
///
/// </summary>
public readonly Interop.Khronos.VkDeviceCreateSwapchainDelegate vkCreateSwapchainKHR;
/// <summary>
///
/// </summary>
public readonly Interop.Khronos.VkSwapchainKHRDestroyDelegate vkDestroySwapchainKHR;
/// <summary>
///
/// </summary>
public readonly Interop.Khronos.VkSwapchainKHRGetImagesDelegate vkGetSwapchainImagesKHR;
/// <summary>
///
/// </summary>
public readonly Interop.Khronos.VkSwapchainKHRAcquireNextImageDelegate vkAcquireNextImageKHR;
/// <summary>
///
/// </summary>
public readonly Interop.Khronos.VkQueuePresentDelegate vkQueuePresentKHR;
/// <summary>
///
/// </summary>
public readonly Interop.Khronos.VkDeviceGetGroupPresentCapabilitiesDelegate vkGetDeviceGroupPresentCapabilitiesKHR;
/// <summary>
///
/// </summary>
public readonly Interop.Khronos.VkDeviceGetGroupSurfacePresentModesDelegate vkGetDeviceGroupSurfacePresentModesKHR;
/// <summary>
///
/// </summary>
public readonly Interop.Khronos.VkPhysicalDeviceGetPresentRectanglesDelegate vkGetPhysicalDevicePresentRectanglesKHR;
/// <summary>
///
/// </summary>
public readonly Interop.Khronos.VkDeviceAcquireNextImage2Delegate vkAcquireNextImage2KHR;
/// <summary>
///
/// </summary>
public readonly Interop.Khronos.VkPhysicalDeviceGetDisplayPropertiesDelegate vkGetPhysicalDeviceDisplayPropertiesKHR;
/// <summary>
///
/// </summary>
public readonly Interop.Khronos.VkPhysicalDeviceGetDisplayPlanePropertiesDelegate vkGetPhysicalDeviceDisplayPlanePropertiesKHR;
/// <summary>
///
/// </summary>
public readonly Interop.Khronos.VkPhysicalDeviceGetDisplayPlaneSupportedDisplaysDelegate vkGetDisplayPlaneSupportedDisplaysKHR;
/// <summary>
///
/// </summary>
public readonly Interop.Khronos.VkPhysicalDeviceGetDisplayModePropertiesDelegate vkGetDisplayModePropertiesKHR;
/// <summary>
///
/// </summary>
public readonly Interop.Khronos.VkPhysicalDeviceCreateDisplayModeDelegate vkCreateDisplayModeKHR;
/// <summary>
///
/// </summary>
public readonly Interop.Khronos.VkDisplayModeKHRGetDisplayPlaneCapabilitiesDelegate vkGetDisplayPlaneCapabilitiesKHR;
/// <summary>
///
/// </summary>
public readonly Interop.Khronos.VkInstanceCreateDisplayPlaneSurfaceDelegate vkCreateDisplayPlaneSurfaceKHR;
/// <summary>
///
/// </summary>
public readonly Interop.Khronos.VkDeviceCreateSharedSwapchainsDelegate vkCreateSharedSwapchainsKHR;
/// <summary>
///
/// </summary>
public readonly Interop.Khronos.VkInstanceCreateXlibSurfaceDelegate vkCreateXlibSurfaceKHR;
/// <summary>
///
/// </summary>
public readonly Interop.Khronos.VkPhysicalDeviceGetXlibPresentationSupportDelegate vkGetPhysicalDeviceXlibPresentationSupportKHR;
/// <summary>
///
/// </summary>
public readonly Interop.Khronos.VkInstanceCreateXcbSurfaceDelegate vkCreateXcbSurfaceKHR;
/// <summary>
///
/// </summary>
public readonly Interop.Khronos.VkPhysicalDeviceGetXcbPresentationSupportDelegate vkGetPhysicalDeviceXcbPresentationSupportKHR;
/// <summary>
///
/// </summary>
public readonly Interop.Khronos.VkInstanceCreateWaylandSurfaceDelegate vkCreateWaylandSurfaceKHR;
/// <summary>
///
/// </summary>
public readonly Interop.Khronos.VkPhysicalDeviceGetWaylandPresentationSupportDelegate vkGetPhysicalDeviceWaylandPresentationSupportKHR;
/// <summary>
///
/// </summary>
public readonly Interop.Khronos.VkInstanceCreateAndroidSurfaceDelegate vkCreateAndroidSurfaceKHR;
/// <summary>
///
/// </summary>
public readonly Interop.Khronos.VkInstanceCreateWin32SurfaceDelegate vkCreateWin32SurfaceKHR;
/// <summary>
///
/// </summary>
public readonly Interop.Khronos.VkPhysicalDeviceGetWin32PresentationSupportDelegate vkGetPhysicalDeviceWin32PresentationSupportKHR;
/// <summary>
///
/// </summary>
public readonly Interop.Multivendor.VkInstanceCreateDebugReportCallbackDelegate vkCreateDebugReportCallbackEXT;
/// <summary>
///
/// </summary>
public readonly Interop.Multivendor.VkDebugReportCallbackEXTDestroyDelegate vkDestroyDebugReportCallbackEXT;
/// <summary>
///
/// </summary>
public readonly Interop.Multivendor.VkInstanceDebugReportMessageDelegate vkDebugReportMessageEXT;
/// <summary>
///
/// </summary>
public readonly Interop.Multivendor.VkCommandBufferBindTransformFeedbackBuffersDelegate vkCmdBindTransformFeedbackBuffersEXT;
/// <summary>
///
/// </summary>
public readonly Interop.Multivendor.VkCommandBufferBeginTransformFeedbackDelegate vkCmdBeginTransformFeedbackEXT;
/// <summary>
///
/// </summary>
public readonly Interop.Multivendor.VkCommandBufferEndTransformFeedbackDelegate vkCmdEndTransformFeedbackEXT;
/// <summary>
///
/// </summary>
public readonly Interop.Multivendor.VkCommandBufferBeginQueryIndexedDelegate vkCmdBeginQueryIndexedEXT;
/// <summary>
///
/// </summary>
public readonly Interop.Multivendor.VkCommandBufferEndQueryIndexedDelegate vkCmdEndQueryIndexedEXT;
/// <summary>
///
/// </summary>
public readonly Interop.Multivendor.VkCommandBufferDrawIndirectByteCountDelegate vkCmdDrawIndirectByteCountEXT;
/// <summary>
///
/// </summary>
public readonly Interop.NVidia.Experimental.VkDeviceGetImageViewHandleDelegate vkGetImageViewHandleNVX;
/// <summary>
///
/// </summary>
public readonly Interop.Amd.VkPipelineGetShaderInfoDelegate vkGetShaderInfoAMD;
/// <summary>
///
/// </summary>
public readonly Interop.Ggp.VkInstanceCreateStreamDescriptorSurfaceDelegate vkCreateStreamDescriptorSurfaceGGP;
/// <summary>
///
/// </summary>
public readonly Interop.NVidia.VkPhysicalDeviceGetExternalImageFormatPropertiesDelegate vkGetPhysicalDeviceExternalImageFormatPropertiesNV;
/// <summary>
///
/// </summary>
public readonly Interop.NVidia.VkDeviceMemoryGetWin32HandleDelegate vkGetMemoryWin32HandleNV;
/// <summary>
///
/// </summary>
public readonly Interop.Nintendo.VkInstanceCreateViSurfaceDelegate vkCreateViSurfaceNN;
/// <summary>
///
/// </summary>
public readonly Interop.Khronos.VkDeviceGetMemoryWin32HandleDelegate vkGetMemoryWin32HandleKHR;
/// <summary>
///
/// </summary>
public readonly Interop.Khronos.VkDeviceGetMemoryWin32HandlePropertiesDelegate vkGetMemoryWin32HandlePropertiesKHR;
/// <summary>
///
/// </summary>
public readonly Interop.Khronos.VkDeviceGetMemoryFileDescriptorDelegate vkGetMemoryFdKHR;
/// <summary>
///
/// </summary>
public readonly Interop.Khronos.VkDeviceGetMemoryFileDescriptorPropertiesDelegate vkGetMemoryFdPropertiesKHR;
/// <summary>
///
/// </summary>
public readonly Interop.Khronos.VkDeviceImportSemaphoreWin32HandleDelegate vkImportSemaphoreWin32HandleKHR;
/// <summary>
///
/// </summary>
public readonly Interop.Khronos.VkDeviceGetSemaphoreWin32HandleDelegate vkGetSemaphoreWin32HandleKHR;
/// <summary>
///
/// </summary>
public readonly Interop.Khronos.VkDeviceImportSemaphoreFileDescriptorDelegate vkImportSemaphoreFdKHR;
/// <summary>
///
/// </summary>
public readonly Interop.Khronos.VkDeviceGetSemaphoreFileDescriptorDelegate vkGetSemaphoreFdKHR;
/// <summary>
///
/// </summary>
public readonly Interop.Khronos.VkCommandBufferPushDescriptorSetDelegate vkCmdPushDescriptorSetKHR;
/// <summary>
///
/// </summary>
public readonly Interop.Khronos.VkCommandBufferPushDescriptorSetWithTemplateDelegate vkCmdPushDescriptorSetWithTemplateKHR;
/// <summary>
///
/// </summary>
public readonly Interop.Multivendor.VkCommandBufferBeginConditionalRenderingDelegate vkCmdBeginConditionalRenderingEXT;
/// <summary>
///
/// </summary>
public readonly Interop.Multivendor.VkCommandBufferEndConditionalRenderingDelegate vkCmdEndConditionalRenderingEXT;
/// <summary>
///
/// </summary>
public readonly Interop.NVidia.Experimental.VkCommandBufferProcessCommandsDelegate vkCmdProcessCommandsNVX;
/// <summary>
///
/// </summary>
public readonly Interop.NVidia.Experimental.VkCommandBufferReserveSpaceForCommandsDelegate vkCmdReserveSpaceForCommandsNVX;
/// <summary>
///
/// </summary>
public readonly Interop.NVidia.Experimental.VkDeviceCreateIndirectCommandsLayoutDelegate vkCreateIndirectCommandsLayoutNVX;
/// <summary>
///
/// </summary>
public readonly Interop.NVidia.Experimental.VkIndirectCommandsLayoutNVXDestroyDelegate vkDestroyIndirectCommandsLayoutNVX;
/// <summary>
///
/// </summary>
public readonly Interop.NVidia.Experimental.VkDeviceCreateObjectTableDelegate vkCreateObjectTableNVX;
/// <summary>
///
/// </summary>
public readonly Interop.NVidia.Experimental.VkObjectTableNVXDestroyDelegate vkDestroyObjectTableNVX;
/// <summary>
///
/// </summary>
public readonly Interop.NVidia.Experimental.VkObjectTableNVXRegisterObjectsDelegate vkRegisterObjectsNVX;
/// <summary>
///
/// </summary>
public readonly Interop.NVidia.Experimental.VkObjectTableNVXUnregisterObjectsDelegate vkUnregisterObjectsNVX;
/// <summary>
///
/// </summary>
public readonly Interop.NVidia.Experimental.VkPhysicalDeviceGetGeneratedCommandsPropertiesDelegate vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX;
/// <summary>
///
/// </summary>
public readonly Interop.NVidia.VkCommandBufferSetViewportWScalingDelegate vkCmdSetViewportWScalingNV;
/// <summary>
///
/// </summary>
public readonly Interop.Multivendor.VkPhysicalDeviceReleaseDisplayDelegate vkReleaseDisplayEXT;
/// <summary>
///
/// </summary>
public readonly Interop.Multivendor.VkPhysicalDeviceAcquireXlibDisplayDelegate vkAcquireXlibDisplayEXT;
/// <summary>
///
/// </summary>
public readonly Interop.Multivendor.VkPhysicalDeviceGetRandROutputDisplayDelegate vkGetRandROutputDisplayEXT;
/// <summary>
///
/// </summary>
public readonly Interop.Multivendor.VkPhysicalDeviceGetSurfaceCapabilities2Delegate vkGetPhysicalDeviceSurfaceCapabilities2EXT;
/// <summary>
///
/// </summary>
public readonly Interop.Multivendor.VkDeviceDisplayPowerControlDelegate vkDisplayPowerControlEXT;
/// <summary>
///
/// </summary>
public readonly Interop.Multivendor.VkDeviceRegisterEventDelegate vkRegisterDeviceEventEXT;
/// <summary>
///
/// </summary>
public readonly Interop.Multivendor.VkDeviceRegisterDisplayEventDelegate vkRegisterDisplayEventEXT;
/// <summary>
///
/// </summary>
public readonly Interop.Multivendor.VkSwapchainKHRGetCounterDelegate vkGetSwapchainCounterEXT;
/// <summary>
///
/// </summary>
public readonly Interop.Google.VkSwapchainKHRGetRefreshCycleDurationDelegate vkGetRefreshCycleDurationGOOGLE;
/// <summary>
///
/// </summary>
public readonly Interop.Google.VkSwapchainKHRGetPastPresentationTimingDelegate vkGetPastPresentationTimingGOOGLE;
/// <summary>
///
/// </summary>
public readonly Interop.Multivendor.VkCommandBufferSetDiscardRectangleDelegate vkCmdSetDiscardRectangleEXT;
/// <summary>
///
/// </summary>
public readonly Interop.Multivendor.VkDeviceSetHdrMetadataDelegate vkSetHdrMetadataEXT;
/// <summary>
///
/// </summary>
public readonly Interop.Khronos.VkSwapchainKHRGetStatusDelegate vkGetSwapchainStatusKHR;
/// <summary>
///
/// </summary>
public readonly Interop.Khronos.VkDeviceImportFenceWin32HandleDelegate vkImportFenceWin32HandleKHR;
/// <summary>
///
/// </summary>
public readonly Interop.Khronos.VkDeviceGetFenceWin32HandleDelegate vkGetFenceWin32HandleKHR;
/// <summary>
///
/// </summary>
public readonly Interop.Khronos.VkDeviceImportFenceFileDescriptorDelegate vkImportFenceFdKHR;
/// <summary>
///
/// </summary>
public readonly Interop.Khronos.VkDeviceGetFenceFileDescriptorDelegate vkGetFenceFdKHR;
/// <summary>
///
/// </summary>
public readonly Interop.Khronos.VkPhysicalDeviceEnumerateQueueFamilyPerformanceQueryCountersDelegate vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR;
/// <summary>
///
/// </summary>
public readonly Interop.Khronos.VkPhysicalDeviceGetQueueFamilyPerformanceQueryPassesDelegate vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR;
/// <summary>
///
/// </summary>
public readonly Interop.Khronos.VkDeviceAcquireProfilingLockDelegate vkAcquireProfilingLockKHR;
/// <summary>
///
/// </summary>
public readonly Interop.Khronos.VkDeviceReleaseProfilingLockDelegate vkReleaseProfilingLockKHR;
/// <summary>
///
/// </summary>
public readonly Interop.Khronos.VkPhysicalDeviceGetSurfaceCapabilities2Delegate vkGetPhysicalDeviceSurfaceCapabilities2KHR;
/// <summary>
///
/// </summary>
public readonly Interop.Khronos.VkPhysicalDeviceGetSurfaceFormats2Delegate vkGetPhysicalDeviceSurfaceFormats2KHR;
/// <summary>
///
/// </summary>
public readonly Interop.Khronos.VkPhysicalDeviceGetDisplayProperties2Delegate vkGetPhysicalDeviceDisplayProperties2KHR;
/// <summary>
///
/// </summary>
public readonly Interop.Khronos.VkPhysicalDeviceGetDisplayPlaneProperties2Delegate vkGetPhysicalDeviceDisplayPlaneProperties2KHR;
/// <summary>
///
/// </summary>
public readonly Interop.Khronos.VkPhysicalDeviceGetDisplayModeProperties2Delegate vkGetDisplayModeProperties2KHR;
/// <summary>
///
/// </summary>
public readonly Interop.Khronos.VkPhysicalDeviceGetDisplayPlaneCapabilities2Delegate vkGetDisplayPlaneCapabilities2KHR;
/// <summary>
///
/// </summary>
public readonly Interop.MoltenVk.VkInstanceCreateIOSSurfaceDelegate vkCreateIOSSurfaceMVK;
/// <summary>
///
/// </summary>
public readonly Interop.MoltenVk.VkInstanceCreateMacOSSurfaceDelegate vkCreateMacOSSurfaceMVK;
/// <summary>
///
/// </summary>
public readonly Interop.Multivendor.VkDeviceSetDebugUtilsObjectNameDelegate vkSetDebugUtilsObjectNameEXT;
/// <summary>
///
/// </summary>
public readonly Interop.Multivendor.VkDeviceSetDebugUtilsObjectTagDelegate vkSetDebugUtilsObjectTagEXT;
/// <summary>
///
/// </summary>
public readonly Interop.Multivendor.VkQueueBeginDebugUtilsLabelDelegate vkQueueBeginDebugUtilsLabelEXT;
/// <summary>
///
/// </summary>
public readonly Interop.Multivendor.VkQueueEndDebugUtilsLabelDelegate vkQueueEndDebugUtilsLabelEXT;
/// <summary>
///
/// </summary>
public readonly Interop.Multivendor.VkQueueInsertDebugUtilsLabelDelegate vkQueueInsertDebugUtilsLabelEXT;
/// <summary>
///
/// </summary>
public readonly Interop.Multivendor.VkCommandBufferBeginDebugUtilsLabelDelegate vkCmdBeginDebugUtilsLabelEXT;
/// <summary>
///
/// </summary>
public readonly Interop.Multivendor.VkCommandBufferEndDebugUtilsLabelDelegate vkCmdEndDebugUtilsLabelEXT;
/// <summary>
///
/// </summary>
public readonly Interop.Multivendor.VkCommandBufferInsertDebugUtilsLabelDelegate vkCmdInsertDebugUtilsLabelEXT;
/// <summary>
///
/// </summary>
public readonly Interop.Multivendor.VkInstanceCreateDebugUtilsMessengerDelegate vkCreateDebugUtilsMessengerEXT;
/// <summary>
///
/// </summary>
public readonly Interop.Multivendor.VkDebugUtilsMessengerEXTDestroyDelegate vkDestroyDebugUtilsMessengerEXT;
/// <summary>
///
/// </summary>
public readonly Interop.Multivendor.VkInstanceSubmitDebugUtilsMessageDelegate vkSubmitDebugUtilsMessageEXT;
/// <summary>
///
/// </summary>
public readonly Interop.Android.VkDeviceGetAndroidHardwareBufferPropertiesDelegate vkGetAndroidHardwareBufferPropertiesANDROID;
/// <summary>
///
/// </summary>
public readonly Interop.Android.VkDeviceGetMemoryAndroidHardwareBufferDelegate vkGetMemoryAndroidHardwareBufferANDROID;
/// <summary>
///
/// </summary>
public readonly Interop.Multivendor.VkCommandBufferSetSampleLocationsDelegate vkCmdSetSampleLocationsEXT;
/// <summary>
///
/// </summary>
public readonly Interop.Multivendor.VkPhysicalDeviceGetMultisamplePropertiesDelegate vkGetPhysicalDeviceMultisamplePropertiesEXT;
/// <summary>
///
/// </summary>
public readonly Interop.Multivendor.VkImageGetDrmFormatModifierPropertiesDelegate vkGetImageDrmFormatModifierPropertiesEXT;
/// <summary>
///
/// </summary>
public readonly Interop.Multivendor.VkDeviceCreateValidationCacheDelegate vkCreateValidationCacheEXT;
/// <summary>
///
/// </summary>
public readonly Interop.Multivendor.VkValidationCacheEXTDestroyDelegate vkDestroyValidationCacheEXT;
/// <summary>
///
/// </summary>
public readonly Interop.Multivendor.VkValidationCacheEXTMergeValidationCachesDelegate vkMergeValidationCachesEXT;
/// <summary>
///
/// </summary>
public readonly Interop.Multivendor.VkValidationCacheEXTGetDataDelegate vkGetValidationCacheDataEXT;
/// <summary>
///
/// </summary>
public readonly Interop.NVidia.VkCommandBufferBindShadingRateImageDelegate vkCmdBindShadingRateImageNV;
/// <summary>
///
/// </summary>
public readonly Interop.NVidia.VkCommandBufferSetViewportShadingRatePaletteDelegate vkCmdSetViewportShadingRatePaletteNV;
/// <summary>
///
/// </summary>
public readonly Interop.NVidia.VkCommandBufferSetCoarseSampleOrderDelegate vkCmdSetCoarseSampleOrderNV;
/// <summary>
///
/// </summary>
public readonly Interop.NVidia.VkDeviceCreateAccelerationStructureDelegate vkCreateAccelerationStructureNV;
/// <summary>
///
/// </summary>
public readonly Interop.NVidia.VkAccelerationStructureNVDestroyDelegate vkDestroyAccelerationStructureNV;
/// <summary>
///
/// </summary>
public readonly Interop.NVidia.VkDeviceGetAccelerationStructureMemoryRequirementsDelegate vkGetAccelerationStructureMemoryRequirementsNV;
/// <summary>
///
/// </summary>
public readonly Interop.NVidia.VkDeviceBindAccelerationStructureMemoryDelegate vkBindAccelerationStructureMemoryNV;
/// <summary>
///
/// </summary>
public readonly Interop.NVidia.VkCommandBufferBuildAccelerationStructureDelegate vkCmdBuildAccelerationStructureNV;
/// <summary>
///
/// </summary>
public readonly Interop.NVidia.VkCommandBufferCopyAccelerationStructureDelegate vkCmdCopyAccelerationStructureNV;
/// <summary>
///
/// </summary>
public readonly Interop.NVidia.VkCommandBufferTraceRaysDelegate vkCmdTraceRaysNV;
/// <summary>
///
/// </summary>
public readonly Interop.NVidia.VkDeviceCreateRayTracingPipelinesDelegate vkCreateRayTracingPipelinesNV;
/// <summary>
///
/// </summary>
public readonly Interop.NVidia.VkPipelineGetRayTracingShaderGroupHandlesDelegate vkGetRayTracingShaderGroupHandlesNV;
/// <summary>
///
/// </summary>
public readonly Interop.NVidia.VkAccelerationStructureNVGetHandleDelegate vkGetAccelerationStructureHandleNV;
/// <summary>
///
/// </summary>
public readonly Interop.NVidia.VkCommandBufferWriteAccelerationStructuresPropertiesDelegate vkCmdWriteAccelerationStructuresPropertiesNV;
/// <summary>
///
/// </summary>
public readonly Interop.NVidia.VkPipelineCompileDeferredDelegate vkCompileDeferredNV;
/// <summary>
///
/// </summary>
public readonly Interop.Multivendor.VkDeviceGetMemoryHostPointerPropertiesDelegate vkGetMemoryHostPointerPropertiesEXT;
/// <summary>
///
/// </summary>
public readonly Interop.Amd.VkCommandBufferWriteBufferMarkerDelegate vkCmdWriteBufferMarkerAMD;
/// <summary>
///
/// </summary>
public readonly Interop.Multivendor.VkPhysicalDeviceGetCalibrateableTimeDomainsDelegate vkGetPhysicalDeviceCalibrateableTimeDomainsEXT;
/// <summary>
///
/// </summary>
public readonly Interop.Multivendor.VkDeviceGetCalibratedTimestampsDelegate vkGetCalibratedTimestampsEXT;
/// <summary>
///
/// </summary>
public readonly Interop.NVidia.VkCommandBufferDrawMeshTasksDelegate vkCmdDrawMeshTasksNV;
/// <summary>
///
/// </summary>
public readonly Interop.NVidia.VkCommandBufferDrawMeshTasksIndirectDelegate vkCmdDrawMeshTasksIndirectNV;
/// <summary>
///
/// </summary>
public readonly Interop.NVidia.VkCommandBufferDrawMeshTasksIndirectCountDelegate vkCmdDrawMeshTasksIndirectCountNV;
/// <summary>
///
/// </summary>
public readonly Interop.NVidia.VkCommandBufferSetExclusiveScissorDelegate vkCmdSetExclusiveScissorNV;
/// <summary>
///
/// </summary>
public readonly Interop.NVidia.VkCommandBufferSetCheckpointDelegate vkCmdSetCheckpointNV;
/// <summary>
///
/// </summary>
public readonly Interop.NVidia.VkQueueGetCheckpointDataDelegate vkGetQueueCheckpointDataNV;
/// <summary>
///
/// </summary>
public readonly Interop.Intel.VkDeviceInitializePerformanceApiDelegate vkInitializePerformanceApiINTEL;
/// <summary>
///
/// </summary>
public readonly Interop.Intel.VkDeviceUninitializePerformanceApiDelegate vkUninitializePerformanceApiINTEL;
/// <summary>
///
/// </summary>
public readonly Interop.Intel.VkCommandBufferSetPerformanceMarkerDelegate vkCmdSetPerformanceMarkerINTEL;
/// <summary>
///
/// </summary>
public readonly Interop.Intel.VkCommandBufferSetPerformanceStreamMarkerDelegate vkCmdSetPerformanceStreamMarkerINTEL;
/// <summary>
///
/// </summary>
public readonly Interop.Intel.VkCommandBufferSetPerformanceOverrideDelegate vkCmdSetPerformanceOverrideINTEL;
/// <summary>
///
/// </summary>
public readonly Interop.Intel.VkDeviceAcquirePerformanceConfigurationDelegate vkAcquirePerformanceConfigurationINTEL;
/// <summary>
///
/// </summary>
public readonly Interop.Intel.VkPerformanceConfigurationINTELReleaseDelegate vkReleasePerformanceConfigurationINTEL;
/// <summary>
///
/// </summary>
public readonly Interop.Intel.VkQueueSetPerformanceConfigurationDelegate vkQueueSetPerformanceConfigurationINTEL;
/// <summary>
///
/// </summary>
public readonly Interop.Intel.VkDeviceGetPerformanceParameterDelegate vkGetPerformanceParameterINTEL;
/// <summary>
///
/// </summary>
public readonly Interop.Amd.VkSwapchainKHRSetLocalDimmingDelegate vkSetLocalDimmingAMD;
/// <summary>
///
/// </summary>
public readonly Interop.Fuchsia.VkInstanceCreateImagePipeSurfaceDelegate vkCreateImagePipeSurfaceFUCHSIA;
/// <summary>
///
/// </summary>
public readonly Interop.Multivendor.VkInstanceCreateMetalSurfaceDelegate vkCreateMetalSurfaceEXT;
/// <summary>
///
/// </summary>
public readonly Interop.Multivendor.VkPhysicalDeviceGetToolPropertiesDelegate vkGetPhysicalDeviceToolPropertiesEXT;
/// <summary>
///
/// </summary>
public readonly Interop.NVidia.VkPhysicalDeviceGetCooperativeMatrixPropertiesDelegate vkGetPhysicalDeviceCooperativeMatrixPropertiesNV;
/// <summary>
///
/// </summary>
public readonly Interop.NVidia.VkPhysicalDeviceGetSupportedFramebufferMixedSamplesCombinationsDelegate vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV;
/// <summary>
///
/// </summary>
public readonly Interop.Multivendor.VkPhysicalDeviceGetSurfacePresentModes2Delegate vkGetPhysicalDeviceSurfacePresentModes2EXT;
/// <summary>
///
/// </summary>
public readonly Interop.Multivendor.VkSwapchainKHRAcquireFullScreenExclusiveModeDelegate vkAcquireFullScreenExclusiveModeEXT;
/// <summary>
///
/// </summary>
public readonly Interop.Multivendor.VkSwapchainKHRReleaseFullScreenExclusiveModeDelegate vkReleaseFullScreenExclusiveModeEXT;
/// <summary>
///
/// </summary>
public readonly Interop.Multivendor.VkDeviceGetGroupSurfacePresentModes2Delegate vkGetDeviceGroupSurfacePresentModes2EXT;
/// <summary>
///
/// </summary>
public readonly Interop.Multivendor.VkInstanceCreateHeadlessSurfaceDelegate vkCreateHeadlessSurfaceEXT;
/// <summary>
///
/// </summary>
public readonly Interop.Multivendor.VkCommandBufferSetLineStippleDelegate vkCmdSetLineStippleEXT;
/// <summary>
///
/// </summary>
public readonly Interop.Khronos.VkDeviceGetPipelineExecutablePropertiesDelegate vkGetPipelineExecutablePropertiesKHR;
/// <summary>
///
/// </summary>
public readonly Interop.Khronos.VkDeviceGetPipelineExecutableStatisticsDelegate vkGetPipelineExecutableStatisticsKHR;
/// <summary>
///
/// </summary>
public readonly Interop.Khronos.VkDeviceGetPipelineExecutableInternalRepresentationsDelegate vkGetPipelineExecutableInternalRepresentationsKHR;
/// <summary>
///
/// </summary>
public CommandCacheStruct(CommandCache cache)
{
this.vkCreateInstance = cache.GetCommandDelegate<Interop.VkInstanceCreateDelegate>("vkCreateInstance", "");
this.vkDestroyInstance = cache.GetCommandDelegate<Interop.VkInstanceDestroyDelegate>("vkDestroyInstance", "");
this.vkEnumeratePhysicalDevices = cache.GetCommandDelegate<Interop.VkInstanceEnumeratePhysicalDevicesDelegate>("vkEnumeratePhysicalDevices", "");
this.vkGetPhysicalDeviceFeatures = cache.GetCommandDelegate<Interop.VkPhysicalDeviceGetFeaturesDelegate>("vkGetPhysicalDeviceFeatures", "");
this.vkGetPhysicalDeviceFormatProperties = cache.GetCommandDelegate<Interop.VkPhysicalDeviceGetFormatPropertiesDelegate>("vkGetPhysicalDeviceFormatProperties", "");
this.vkGetPhysicalDeviceImageFormatProperties = cache.GetCommandDelegate<Interop.VkPhysicalDeviceGetImageFormatPropertiesDelegate>("vkGetPhysicalDeviceImageFormatProperties", "");
this.vkGetPhysicalDeviceProperties = cache.GetCommandDelegate<Interop.VkPhysicalDeviceGetPropertiesDelegate>("vkGetPhysicalDeviceProperties", "");
this.vkGetPhysicalDeviceQueueFamilyProperties = cache.GetCommandDelegate<Interop.VkPhysicalDeviceGetQueueFamilyPropertiesDelegate>("vkGetPhysicalDeviceQueueFamilyProperties", "");
this.vkGetPhysicalDeviceMemoryProperties = cache.GetCommandDelegate<Interop.VkPhysicalDeviceGetMemoryPropertiesDelegate>("vkGetPhysicalDeviceMemoryProperties", "");
this.vkGetInstanceProcAddr = cache.GetCommandDelegate<Interop.VkInstanceGetProcedureAddressDelegate>("vkGetInstanceProcAddr", "");
this.vkGetDeviceProcAddr = cache.GetCommandDelegate<Interop.VkDeviceGetProcedureAddressDelegate>("vkGetDeviceProcAddr", "");
this.vkCreateDevice = cache.GetCommandDelegate<Interop.VkPhysicalDeviceCreateDeviceDelegate>("vkCreateDevice", "");
this.vkDestroyDevice = cache.GetCommandDelegate<Interop.VkDeviceDestroyDelegate>("vkDestroyDevice", "");
this.vkEnumerateInstanceExtensionProperties = cache.GetCommandDelegate<Interop.VkInstanceEnumerateExtensionPropertiesDelegate>("vkEnumerateInstanceExtensionProperties", "");
this.vkEnumerateDeviceExtensionProperties = cache.GetCommandDelegate<Interop.VkPhysicalDeviceEnumerateDeviceExtensionPropertiesDelegate>("vkEnumerateDeviceExtensionProperties", "");
this.vkEnumerateInstanceLayerProperties = cache.GetCommandDelegate<Interop.VkInstanceEnumerateLayerPropertiesDelegate>("vkEnumerateInstanceLayerProperties", "");
this.vkEnumerateDeviceLayerProperties = cache.GetCommandDelegate<Interop.VkPhysicalDeviceEnumerateDeviceLayerPropertiesDelegate>("vkEnumerateDeviceLayerProperties", "");
this.vkGetDeviceQueue = cache.GetCommandDelegate<Interop.VkDeviceGetQueueDelegate>("vkGetDeviceQueue", "");
this.vkQueueSubmit = cache.GetCommandDelegate<Interop.VkQueueSubmitDelegate>("vkQueueSubmit", "");
this.vkQueueWaitIdle = cache.GetCommandDelegate<Interop.VkQueueWaitIdleDelegate>("vkQueueWaitIdle", "");
this.vkDeviceWaitIdle = cache.GetCommandDelegate<Interop.VkDeviceWaitIdleDelegate>("vkDeviceWaitIdle", "");
this.vkAllocateMemory = cache.GetCommandDelegate<Interop.VkDeviceAllocateMemoryDelegate>("vkAllocateMemory", "");
this.vkFreeMemory = cache.GetCommandDelegate<Interop.VkDeviceMemoryFreeDelegate>("vkFreeMemory", "");
this.vkMapMemory = cache.GetCommandDelegate<Interop.VkDeviceMemoryMapDelegate>("vkMapMemory", "");
this.vkUnmapMemory = cache.GetCommandDelegate<Interop.VkDeviceMemoryUnmapDelegate>("vkUnmapMemory", "");
this.vkFlushMappedMemoryRanges = cache.GetCommandDelegate<Interop.VkDeviceFlushMappedMemoryRangesDelegate>("vkFlushMappedMemoryRanges", "");
this.vkInvalidateMappedMemoryRanges = cache.GetCommandDelegate<Interop.VkDeviceInvalidateMappedMemoryRangesDelegate>("vkInvalidateMappedMemoryRanges", "");
this.vkGetDeviceMemoryCommitment = cache.GetCommandDelegate<Interop.VkDeviceMemoryGetCommitmentDelegate>("vkGetDeviceMemoryCommitment", "");
this.vkBindBufferMemory = cache.GetCommandDelegate<Interop.VkBufferBindMemoryDelegate>("vkBindBufferMemory", "");
this.vkBindImageMemory = cache.GetCommandDelegate<Interop.VkImageBindMemoryDelegate>("vkBindImageMemory", "");
this.vkGetBufferMemoryRequirements = cache.GetCommandDelegate<Interop.VkBufferGetMemoryRequirementsDelegate>("vkGetBufferMemoryRequirements", "");
this.vkGetImageMemoryRequirements = cache.GetCommandDelegate<Interop.VkImageGetMemoryRequirementsDelegate>("vkGetImageMemoryRequirements", "");
this.vkGetImageSparseMemoryRequirements = cache.GetCommandDelegate<Interop.VkImageGetSparseMemoryRequirementsDelegate>("vkGetImageSparseMemoryRequirements", "");
this.vkGetPhysicalDeviceSparseImageFormatProperties = cache.GetCommandDelegate<Interop.VkPhysicalDeviceGetSparseImageFormatPropertiesDelegate>("vkGetPhysicalDeviceSparseImageFormatProperties", "");
this.vkQueueBindSparse = cache.GetCommandDelegate<Interop.VkQueueBindSparseDelegate>("vkQueueBindSparse", "");
this.vkCreateFence = cache.GetCommandDelegate<Interop.VkDeviceCreateFenceDelegate>("vkCreateFence", "");
this.vkDestroyFence = cache.GetCommandDelegate<Interop.VkFenceDestroyDelegate>("vkDestroyFence", "");
this.vkResetFences = cache.GetCommandDelegate<Interop.VkDeviceResetFencesDelegate>("vkResetFences", "");
this.vkGetFenceStatus = cache.GetCommandDelegate<Interop.VkFenceGetStatusDelegate>("vkGetFenceStatus", "");
this.vkWaitForFences = cache.GetCommandDelegate<Interop.VkDeviceWaitForFencesDelegate>("vkWaitForFences", "");
this.vkCreateSemaphore = cache.GetCommandDelegate<Interop.VkDeviceCreateSemaphoreDelegate>("vkCreateSemaphore", "");
this.vkDestroySemaphore = cache.GetCommandDelegate<Interop.VkSemaphoreDestroyDelegate>("vkDestroySemaphore", "");
this.vkCreateEvent = cache.GetCommandDelegate<Interop.VkDeviceCreateEventDelegate>("vkCreateEvent", "");
this.vkDestroyEvent = cache.GetCommandDelegate<Interop.VkEventDestroyDelegate>("vkDestroyEvent", "");
this.vkGetEventStatus = cache.GetCommandDelegate<Interop.VkEventGetStatusDelegate>("vkGetEventStatus", "");
this.vkSetEvent = cache.GetCommandDelegate<Interop.VkEventSetDelegate>("vkSetEvent", "");
this.vkResetEvent = cache.GetCommandDelegate<Interop.VkEventResetDelegate>("vkResetEvent", "");
this.vkCreateQueryPool = cache.GetCommandDelegate<Interop.VkDeviceCreateQueryPoolDelegate>("vkCreateQueryPool", "");
this.vkDestroyQueryPool = cache.GetCommandDelegate<Interop.VkQueryPoolDestroyDelegate>("vkDestroyQueryPool", "");
this.vkGetQueryPoolResults = cache.GetCommandDelegate<Interop.VkQueryPoolGetResultsDelegate>("vkGetQueryPoolResults", "");
this.vkCreateBuffer = cache.GetCommandDelegate<Interop.VkDeviceCreateBufferDelegate>("vkCreateBuffer", "");
this.vkDestroyBuffer = cache.GetCommandDelegate<Interop.VkBufferDestroyDelegate>("vkDestroyBuffer", "");
this.vkCreateBufferView = cache.GetCommandDelegate<Interop.VkDeviceCreateBufferViewDelegate>("vkCreateBufferView", "");
this.vkDestroyBufferView = cache.GetCommandDelegate<Interop.VkBufferViewDestroyDelegate>("vkDestroyBufferView", "");
this.vkCreateImage = cache.GetCommandDelegate<Interop.VkDeviceCreateImageDelegate>("vkCreateImage", "");
this.vkDestroyImage = cache.GetCommandDelegate<Interop.VkImageDestroyDelegate>("vkDestroyImage", "");
this.vkGetImageSubresourceLayout = cache.GetCommandDelegate<Interop.VkImageGetSubresourceLayoutDelegate>("vkGetImageSubresourceLayout", "");
this.vkCreateImageView = cache.GetCommandDelegate<Interop.VkDeviceCreateImageViewDelegate>("vkCreateImageView", "");
this.vkDestroyImageView = cache.GetCommandDelegate<Interop.VkImageViewDestroyDelegate>("vkDestroyImageView", "");
this.vkCreateShaderModule = cache.GetCommandDelegate<Interop.VkDeviceCreateShaderModuleDelegate>("vkCreateShaderModule", "");
this.vkDestroyShaderModule = cache.GetCommandDelegate<Interop.VkShaderModuleDestroyDelegate>("vkDestroyShaderModule", "");
this.vkCreatePipelineCache = cache.GetCommandDelegate<Interop.VkDeviceCreatePipelineCacheDelegate>("vkCreatePipelineCache", "");
this.vkDestroyPipelineCache = cache.GetCommandDelegate<Interop.VkPipelineCacheDestroyDelegate>("vkDestroyPipelineCache", "");
this.vkGetPipelineCacheData = cache.GetCommandDelegate<Interop.VkPipelineCacheGetDataDelegate>("vkGetPipelineCacheData", "");
this.vkMergePipelineCaches = cache.GetCommandDelegate<Interop.VkPipelineCacheMergePipelineCachesDelegate>("vkMergePipelineCaches", "");
this.vkCreateGraphicsPipelines = cache.GetCommandDelegate<Interop.VkDeviceCreateGraphicsPipelinesDelegate>("vkCreateGraphicsPipelines", "");
this.vkCreateComputePipelines = cache.GetCommandDelegate<Interop.VkDeviceCreateComputePipelinesDelegate>("vkCreateComputePipelines", "");
this.vkDestroyPipeline = cache.GetCommandDelegate<Interop.VkPipelineDestroyDelegate>("vkDestroyPipeline", "");
this.vkCreatePipelineLayout = cache.GetCommandDelegate<Interop.VkDeviceCreatePipelineLayoutDelegate>("vkCreatePipelineLayout", "");
this.vkDestroyPipelineLayout = cache.GetCommandDelegate<Interop.VkPipelineLayoutDestroyDelegate>("vkDestroyPipelineLayout", "");
this.vkCreateSampler = cache.GetCommandDelegate<Interop.VkDeviceCreateSamplerDelegate>("vkCreateSampler", "");
this.vkDestroySampler = cache.GetCommandDelegate<Interop.VkSamplerDestroyDelegate>("vkDestroySampler", "");
this.vkCreateDescriptorSetLayout = cache.GetCommandDelegate<Interop.VkDeviceCreateDescriptorSetLayoutDelegate>("vkCreateDescriptorSetLayout", "");
this.vkDestroyDescriptorSetLayout = cache.GetCommandDelegate<Interop.VkDescriptorSetLayoutDestroyDelegate>("vkDestroyDescriptorSetLayout", "");
this.vkCreateDescriptorPool = cache.GetCommandDelegate<Interop.VkDeviceCreateDescriptorPoolDelegate>("vkCreateDescriptorPool", "");
this.vkDestroyDescriptorPool = cache.GetCommandDelegate<Interop.VkDescriptorPoolDestroyDelegate>("vkDestroyDescriptorPool", "");
this.vkResetDescriptorPool = cache.GetCommandDelegate<Interop.VkDescriptorPoolResetDelegate>("vkResetDescriptorPool", "");
this.vkAllocateDescriptorSets = cache.GetCommandDelegate<Interop.VkDeviceAllocateDescriptorSetsDelegate>("vkAllocateDescriptorSets", "");
this.vkFreeDescriptorSets = cache.GetCommandDelegate<Interop.VkDescriptorPoolFreeDescriptorSetsDelegate>("vkFreeDescriptorSets", "");
this.vkUpdateDescriptorSets = cache.GetCommandDelegate<Interop.VkDeviceUpdateDescriptorSetsDelegate>("vkUpdateDescriptorSets", "");
this.vkCreateFramebuffer = cache.GetCommandDelegate<Interop.VkDeviceCreateFramebufferDelegate>("vkCreateFramebuffer", "");
this.vkDestroyFramebuffer = cache.GetCommandDelegate<Interop.VkFramebufferDestroyDelegate>("vkDestroyFramebuffer", "");
this.vkCreateRenderPass = cache.GetCommandDelegate<Interop.VkDeviceCreateRenderPassDelegate>("vkCreateRenderPass", "");
this.vkDestroyRenderPass = cache.GetCommandDelegate<Interop.VkRenderPassDestroyDelegate>("vkDestroyRenderPass", "");
this.vkGetRenderAreaGranularity = cache.GetCommandDelegate<Interop.VkRenderPassGetRenderAreaGranularityDelegate>("vkGetRenderAreaGranularity", "");
this.vkCreateCommandPool = cache.GetCommandDelegate<Interop.VkDeviceCreateCommandPoolDelegate>("vkCreateCommandPool", "");
this.vkDestroyCommandPool = cache.GetCommandDelegate<Interop.VkCommandPoolDestroyDelegate>("vkDestroyCommandPool", "");
this.vkResetCommandPool = cache.GetCommandDelegate<Interop.VkCommandPoolResetDelegate>("vkResetCommandPool", "");
this.vkAllocateCommandBuffers = cache.GetCommandDelegate<Interop.VkDeviceAllocateCommandBuffersDelegate>("vkAllocateCommandBuffers", "");
this.vkFreeCommandBuffers = cache.GetCommandDelegate<Interop.VkCommandPoolFreeCommandBuffersDelegate>("vkFreeCommandBuffers", "");
this.vkBeginCommandBuffer = cache.GetCommandDelegate<Interop.VkCommandBufferBeginDelegate>("vkBeginCommandBuffer", "");
this.vkEndCommandBuffer = cache.GetCommandDelegate<Interop.VkCommandBufferEndDelegate>("vkEndCommandBuffer", "");
this.vkResetCommandBuffer = cache.GetCommandDelegate<Interop.VkCommandBufferResetDelegate>("vkResetCommandBuffer", "");
this.vkCmdBindPipeline = cache.GetCommandDelegate<Interop.VkCommandBufferBindPipelineDelegate>("vkCmdBindPipeline", "");
this.vkCmdSetViewport = cache.GetCommandDelegate<Interop.VkCommandBufferSetViewportDelegate>("vkCmdSetViewport", "");
this.vkCmdSetScissor = cache.GetCommandDelegate<Interop.VkCommandBufferSetScissorDelegate>("vkCmdSetScissor", "");
this.vkCmdSetLineWidth = cache.GetCommandDelegate<Interop.VkCommandBufferSetLineWidthDelegate>("vkCmdSetLineWidth", "");
this.vkCmdSetDepthBias = cache.GetCommandDelegate<Interop.VkCommandBufferSetDepthBiasDelegate>("vkCmdSetDepthBias", "");
this.vkCmdSetBlendConstants = cache.GetCommandDelegate<Interop.VkCommandBufferSetBlendConstantsDelegate>("vkCmdSetBlendConstants", "");
this.vkCmdSetDepthBounds = cache.GetCommandDelegate<Interop.VkCommandBufferSetDepthBoundsDelegate>("vkCmdSetDepthBounds", "");
this.vkCmdSetStencilCompareMask = cache.GetCommandDelegate<Interop.VkCommandBufferSetStencilCompareMaskDelegate>("vkCmdSetStencilCompareMask", "");
this.vkCmdSetStencilWriteMask = cache.GetCommandDelegate<Interop.VkCommandBufferSetStencilWriteMaskDelegate>("vkCmdSetStencilWriteMask", "");
this.vkCmdSetStencilReference = cache.GetCommandDelegate<Interop.VkCommandBufferSetStencilReferenceDelegate>("vkCmdSetStencilReference", "");
this.vkCmdBindDescriptorSets = cache.GetCommandDelegate<Interop.VkCommandBufferBindDescriptorSetsDelegate>("vkCmdBindDescriptorSets", "");
this.vkCmdBindIndexBuffer = cache.GetCommandDelegate<Interop.VkCommandBufferBindIndexBufferDelegate>("vkCmdBindIndexBuffer", "");
this.vkCmdBindVertexBuffers = cache.GetCommandDelegate<Interop.VkCommandBufferBindVertexBuffersDelegate>("vkCmdBindVertexBuffers", "");
this.vkCmdDraw = cache.GetCommandDelegate<Interop.VkCommandBufferDrawDelegate>("vkCmdDraw", "");
this.vkCmdDrawIndexed = cache.GetCommandDelegate<Interop.VkCommandBufferDrawIndexedDelegate>("vkCmdDrawIndexed", "");
this.vkCmdDrawIndirect = cache.GetCommandDelegate<Interop.VkCommandBufferDrawIndirectDelegate>("vkCmdDrawIndirect", "");
this.vkCmdDrawIndexedIndirect = cache.GetCommandDelegate<Interop.VkCommandBufferDrawIndexedIndirectDelegate>("vkCmdDrawIndexedIndirect", "");
this.vkCmdDispatch = cache.GetCommandDelegate<Interop.VkCommandBufferDispatchDelegate>("vkCmdDispatch", "");
this.vkCmdDispatchIndirect = cache.GetCommandDelegate<Interop.VkCommandBufferDispatchIndirectDelegate>("vkCmdDispatchIndirect", "");
this.vkCmdCopyBuffer = cache.GetCommandDelegate<Interop.VkCommandBufferCopyBufferDelegate>("vkCmdCopyBuffer", "");
this.vkCmdCopyImage = cache.GetCommandDelegate<Interop.VkCommandBufferCopyImageDelegate>("vkCmdCopyImage", "");
this.vkCmdBlitImage = cache.GetCommandDelegate<Interop.VkCommandBufferBlitImageDelegate>("vkCmdBlitImage", "");
this.vkCmdCopyBufferToImage = cache.GetCommandDelegate<Interop.VkCommandBufferCopyBufferToImageDelegate>("vkCmdCopyBufferToImage", "");
this.vkCmdCopyImageToBuffer = cache.GetCommandDelegate<Interop.VkCommandBufferCopyImageToBufferDelegate>("vkCmdCopyImageToBuffer", "");
this.vkCmdUpdateBuffer = cache.GetCommandDelegate<Interop.VkCommandBufferUpdateBufferDelegate>("vkCmdUpdateBuffer", "");
this.vkCmdFillBuffer = cache.GetCommandDelegate<Interop.VkCommandBufferFillBufferDelegate>("vkCmdFillBuffer", "");
this.vkCmdClearColorImage = cache.GetCommandDelegate<Interop.VkCommandBufferClearColorImageDelegate>("vkCmdClearColorImage", "");
this.vkCmdClearDepthStencilImage = cache.GetCommandDelegate<Interop.VkCommandBufferClearDepthStencilImageDelegate>("vkCmdClearDepthStencilImage", "");
this.vkCmdClearAttachments = cache.GetCommandDelegate<Interop.VkCommandBufferClearAttachmentsDelegate>("vkCmdClearAttachments", "");
this.vkCmdResolveImage = cache.GetCommandDelegate<Interop.VkCommandBufferResolveImageDelegate>("vkCmdResolveImage", "");
this.vkCmdSetEvent = cache.GetCommandDelegate<Interop.VkCommandBufferSetEventDelegate>("vkCmdSetEvent", "");
this.vkCmdResetEvent = cache.GetCommandDelegate<Interop.VkCommandBufferResetEventDelegate>("vkCmdResetEvent", "");
this.vkCmdWaitEvents = cache.GetCommandDelegate<Interop.VkCommandBufferWaitEventsDelegate>("vkCmdWaitEvents", "");
this.vkCmdPipelineBarrier = cache.GetCommandDelegate<Interop.VkCommandBufferPipelineBarrierDelegate>("vkCmdPipelineBarrier", "");
this.vkCmdBeginQuery = cache.GetCommandDelegate<Interop.VkCommandBufferBeginQueryDelegate>("vkCmdBeginQuery", "");
this.vkCmdEndQuery = cache.GetCommandDelegate<Interop.VkCommandBufferEndQueryDelegate>("vkCmdEndQuery", "");
this.vkCmdResetQueryPool = cache.GetCommandDelegate<Interop.VkCommandBufferResetQueryPoolDelegate>("vkCmdResetQueryPool", "");
this.vkCmdWriteTimestamp = cache.GetCommandDelegate<Interop.VkCommandBufferWriteTimestampDelegate>("vkCmdWriteTimestamp", "");
this.vkCmdCopyQueryPoolResults = cache.GetCommandDelegate<Interop.VkCommandBufferCopyQueryPoolResultsDelegate>("vkCmdCopyQueryPoolResults", "");
this.vkCmdPushConstants = cache.GetCommandDelegate<Interop.VkCommandBufferPushConstantsDelegate>("vkCmdPushConstants", "");
this.vkCmdBeginRenderPass = cache.GetCommandDelegate<Interop.VkCommandBufferBeginRenderPassDelegate>("vkCmdBeginRenderPass", "");
this.vkCmdNextSubpass = cache.GetCommandDelegate<Interop.VkCommandBufferNextSubpassDelegate>("vkCmdNextSubpass", "");
this.vkCmdEndRenderPass = cache.GetCommandDelegate<Interop.VkCommandBufferEndRenderPassDelegate>("vkCmdEndRenderPass", "");
this.vkCmdExecuteCommands = cache.GetCommandDelegate<Interop.VkCommandBufferExecuteCommandsDelegate>("vkCmdExecuteCommands", "");
this.vkEnumerateInstanceVersion = cache.GetCommandDelegate<Interop.VkInstanceEnumerateVersionDelegate>("vkEnumerateInstanceVersion", "");
this.vkBindBufferMemory2 = cache.GetCommandDelegate<Interop.VkDeviceBindBufferMemory2Delegate>("vkBindBufferMemory2", "");
this.vkBindImageMemory2 = cache.GetCommandDelegate<Interop.VkDeviceBindImageMemory2Delegate>("vkBindImageMemory2", "");
this.vkGetDeviceGroupPeerMemoryFeatures = cache.GetCommandDelegate<Interop.VkDeviceGetGroupPeerMemoryFeaturesDelegate>("vkGetDeviceGroupPeerMemoryFeatures", "");
this.vkCmdSetDeviceMask = cache.GetCommandDelegate<Interop.VkCommandBufferSetDeviceMaskDelegate>("vkCmdSetDeviceMask", "");
this.vkCmdDispatchBase = cache.GetCommandDelegate<Interop.VkCommandBufferDispatchBaseDelegate>("vkCmdDispatchBase", "");
this.vkEnumeratePhysicalDeviceGroups = cache.GetCommandDelegate<Interop.VkInstanceEnumeratePhysicalDeviceGroupsDelegate>("vkEnumeratePhysicalDeviceGroups", "");
this.vkGetImageMemoryRequirements2 = cache.GetCommandDelegate<Interop.VkDeviceGetImageMemoryRequirements2Delegate>("vkGetImageMemoryRequirements2", "");
this.vkGetBufferMemoryRequirements2 = cache.GetCommandDelegate<Interop.VkDeviceGetBufferMemoryRequirements2Delegate>("vkGetBufferMemoryRequirements2", "");
this.vkGetImageSparseMemoryRequirements2 = cache.GetCommandDelegate<Interop.VkDeviceGetImageSparseMemoryRequirements2Delegate>("vkGetImageSparseMemoryRequirements2", "");
this.vkGetPhysicalDeviceFeatures2 = cache.GetCommandDelegate<Interop.VkPhysicalDeviceGetFeatures2Delegate>("vkGetPhysicalDeviceFeatures2", "");
this.vkGetPhysicalDeviceProperties2 = cache.GetCommandDelegate<Interop.VkPhysicalDeviceGetProperties2Delegate>("vkGetPhysicalDeviceProperties2", "");
this.vkGetPhysicalDeviceFormatProperties2 = cache.GetCommandDelegate<Interop.VkPhysicalDeviceGetFormatProperties2Delegate>("vkGetPhysicalDeviceFormatProperties2", "");
this.vkGetPhysicalDeviceImageFormatProperties2 = cache.GetCommandDelegate<Interop.VkPhysicalDeviceGetImageFormatProperties2Delegate>("vkGetPhysicalDeviceImageFormatProperties2", "");
this.vkGetPhysicalDeviceQueueFamilyProperties2 = cache.GetCommandDelegate<Interop.VkPhysicalDeviceGetQueueFamilyProperties2Delegate>("vkGetPhysicalDeviceQueueFamilyProperties2", "");
this.vkGetPhysicalDeviceMemoryProperties2 = cache.GetCommandDelegate<Interop.VkPhysicalDeviceGetMemoryProperties2Delegate>("vkGetPhysicalDeviceMemoryProperties2", "");
this.vkGetPhysicalDeviceSparseImageFormatProperties2 = cache.GetCommandDelegate<Interop.VkPhysicalDeviceGetSparseImageFormatProperties2Delegate>("vkGetPhysicalDeviceSparseImageFormatProperties2", "");
this.vkTrimCommandPool = cache.GetCommandDelegate<Interop.VkCommandPoolTrimDelegate>("vkTrimCommandPool", "");
this.vkGetDeviceQueue2 = cache.GetCommandDelegate<Interop.VkDeviceGetQueue2Delegate>("vkGetDeviceQueue2", "");
this.vkCreateSamplerYcbcrConversion = cache.GetCommandDelegate<Interop.VkDeviceCreateSamplerYcbcrConversionDelegate>("vkCreateSamplerYcbcrConversion", "");
this.vkDestroySamplerYcbcrConversion = cache.GetCommandDelegate<Interop.VkSamplerYcbcrConversionDestroyDelegate>("vkDestroySamplerYcbcrConversion", "");
this.vkCreateDescriptorUpdateTemplate = cache.GetCommandDelegate<Interop.VkDeviceCreateDescriptorUpdateTemplateDelegate>("vkCreateDescriptorUpdateTemplate", "");
this.vkDestroyDescriptorUpdateTemplate = cache.GetCommandDelegate<Interop.VkDescriptorUpdateTemplateDestroyDelegate>("vkDestroyDescriptorUpdateTemplate", "");
this.vkUpdateDescriptorSetWithTemplate = cache.GetCommandDelegate<Interop.VkDeviceUpdateDescriptorSetWithTemplateDelegate>("vkUpdateDescriptorSetWithTemplate", "");
this.vkGetPhysicalDeviceExternalBufferProperties = cache.GetCommandDelegate<Interop.VkPhysicalDeviceGetExternalBufferPropertiesDelegate>("vkGetPhysicalDeviceExternalBufferProperties", "");
this.vkGetPhysicalDeviceExternalFenceProperties = cache.GetCommandDelegate<Interop.VkPhysicalDeviceGetExternalFencePropertiesDelegate>("vkGetPhysicalDeviceExternalFenceProperties", "");
this.vkGetPhysicalDeviceExternalSemaphoreProperties = cache.GetCommandDelegate<Interop.VkPhysicalDeviceGetExternalSemaphorePropertiesDelegate>("vkGetPhysicalDeviceExternalSemaphoreProperties", "");
this.vkGetDescriptorSetLayoutSupport = cache.GetCommandDelegate<Interop.VkDeviceGetDescriptorSetLayoutSupportDelegate>("vkGetDescriptorSetLayoutSupport", "");
this.vkCmdDrawIndirectCount = cache.GetCommandDelegate<Interop.VkCommandBufferDrawIndirectCountDelegate>("vkCmdDrawIndirectCount", "");
this.vkCmdDrawIndexedIndirectCount = cache.GetCommandDelegate<Interop.VkCommandBufferDrawIndexedIndirectCountDelegate>("vkCmdDrawIndexedIndirectCount", "");
this.vkCreateRenderPass2 = cache.GetCommandDelegate<Interop.VkDeviceCreateRenderPass2Delegate>("vkCreateRenderPass2", "");
this.vkCmdBeginRenderPass2 = cache.GetCommandDelegate<Interop.VkCommandBufferBeginRenderPass2Delegate>("vkCmdBeginRenderPass2", "");
this.vkCmdNextSubpass2 = cache.GetCommandDelegate<Interop.VkCommandBufferNextSubpass2Delegate>("vkCmdNextSubpass2", "");
this.vkCmdEndRenderPass2 = cache.GetCommandDelegate<Interop.VkCommandBufferEndRenderPass2Delegate>("vkCmdEndRenderPass2", "");
this.vkResetQueryPool = cache.GetCommandDelegate<Interop.VkQueryPoolResetDelegate>("vkResetQueryPool", "");
this.vkGetSemaphoreCounterValue = cache.GetCommandDelegate<Interop.VkSemaphoreGetCounterValueDelegate>("vkGetSemaphoreCounterValue", "");
this.vkWaitSemaphores = cache.GetCommandDelegate<Interop.VkDeviceWaitSemaphoresDelegate>("vkWaitSemaphores", "");
this.vkSignalSemaphore = cache.GetCommandDelegate<Interop.VkDeviceSignalSemaphoreDelegate>("vkSignalSemaphore", "");
this.vkGetBufferDeviceAddress = cache.GetCommandDelegate<Interop.VkDeviceGetBufferDeviceAddressDelegate>("vkGetBufferDeviceAddress", "");
this.vkGetBufferOpaqueCaptureAddress = cache.GetCommandDelegate<Interop.VkDeviceGetBufferOpaqueCaptureAddressDelegate>("vkGetBufferOpaqueCaptureAddress", "");
this.vkGetDeviceMemoryOpaqueCaptureAddress = cache.GetCommandDelegate<Interop.VkDeviceGetMemoryOpaqueCaptureAddressDelegate>("vkGetDeviceMemoryOpaqueCaptureAddress", "");
this.vkDestroySurfaceKHR = cache.GetCommandDelegate<Interop.Khronos.VkSurfaceKHRDestroyDelegate>("vkDestroySurfaceKHR", "instance");
this.vkGetPhysicalDeviceSurfaceSupportKHR = cache.GetCommandDelegate<Interop.Khronos.VkPhysicalDeviceGetSurfaceSupportDelegate>("vkGetPhysicalDeviceSurfaceSupportKHR", "instance");
this.vkGetPhysicalDeviceSurfaceCapabilitiesKHR = cache.GetCommandDelegate<Interop.Khronos.VkPhysicalDeviceGetSurfaceCapabilitiesDelegate>("vkGetPhysicalDeviceSurfaceCapabilitiesKHR", "instance");
this.vkGetPhysicalDeviceSurfaceFormatsKHR = cache.GetCommandDelegate<Interop.Khronos.VkPhysicalDeviceGetSurfaceFormatsDelegate>("vkGetPhysicalDeviceSurfaceFormatsKHR", "instance");
this.vkGetPhysicalDeviceSurfacePresentModesKHR = cache.GetCommandDelegate<Interop.Khronos.VkPhysicalDeviceGetSurfacePresentModesDelegate>("vkGetPhysicalDeviceSurfacePresentModesKHR", "instance");
this.vkCreateSwapchainKHR = cache.GetCommandDelegate<Interop.Khronos.VkDeviceCreateSwapchainDelegate>("vkCreateSwapchainKHR", "device");
this.vkDestroySwapchainKHR = cache.GetCommandDelegate<Interop.Khronos.VkSwapchainKHRDestroyDelegate>("vkDestroySwapchainKHR", "device");
this.vkGetSwapchainImagesKHR = cache.GetCommandDelegate<Interop.Khronos.VkSwapchainKHRGetImagesDelegate>("vkGetSwapchainImagesKHR", "device");
this.vkAcquireNextImageKHR = cache.GetCommandDelegate<Interop.Khronos.VkSwapchainKHRAcquireNextImageDelegate>("vkAcquireNextImageKHR", "device");
this.vkQueuePresentKHR = cache.GetCommandDelegate<Interop.Khronos.VkQueuePresentDelegate>("vkQueuePresentKHR", "device");
this.vkGetDeviceGroupPresentCapabilitiesKHR = cache.GetCommandDelegate<Interop.Khronos.VkDeviceGetGroupPresentCapabilitiesDelegate>("vkGetDeviceGroupPresentCapabilitiesKHR", "device");
this.vkGetDeviceGroupSurfacePresentModesKHR = cache.GetCommandDelegate<Interop.Khronos.VkDeviceGetGroupSurfacePresentModesDelegate>("vkGetDeviceGroupSurfacePresentModesKHR", "device");
this.vkGetPhysicalDevicePresentRectanglesKHR = cache.GetCommandDelegate<Interop.Khronos.VkPhysicalDeviceGetPresentRectanglesDelegate>("vkGetPhysicalDevicePresentRectanglesKHR", "device");
this.vkAcquireNextImage2KHR = cache.GetCommandDelegate<Interop.Khronos.VkDeviceAcquireNextImage2Delegate>("vkAcquireNextImage2KHR", "device");
this.vkGetPhysicalDeviceDisplayPropertiesKHR = cache.GetCommandDelegate<Interop.Khronos.VkPhysicalDeviceGetDisplayPropertiesDelegate>("vkGetPhysicalDeviceDisplayPropertiesKHR", "instance");
this.vkGetPhysicalDeviceDisplayPlanePropertiesKHR = cache.GetCommandDelegate<Interop.Khronos.VkPhysicalDeviceGetDisplayPlanePropertiesDelegate>("vkGetPhysicalDeviceDisplayPlanePropertiesKHR", "instance");
this.vkGetDisplayPlaneSupportedDisplaysKHR = cache.GetCommandDelegate<Interop.Khronos.VkPhysicalDeviceGetDisplayPlaneSupportedDisplaysDelegate>("vkGetDisplayPlaneSupportedDisplaysKHR", "instance");
this.vkGetDisplayModePropertiesKHR = cache.GetCommandDelegate<Interop.Khronos.VkPhysicalDeviceGetDisplayModePropertiesDelegate>("vkGetDisplayModePropertiesKHR", "instance");
this.vkCreateDisplayModeKHR = cache.GetCommandDelegate<Interop.Khronos.VkPhysicalDeviceCreateDisplayModeDelegate>("vkCreateDisplayModeKHR", "instance");
this.vkGetDisplayPlaneCapabilitiesKHR = cache.GetCommandDelegate<Interop.Khronos.VkDisplayModeKHRGetDisplayPlaneCapabilitiesDelegate>("vkGetDisplayPlaneCapabilitiesKHR", "instance");
this.vkCreateDisplayPlaneSurfaceKHR = cache.GetCommandDelegate<Interop.Khronos.VkInstanceCreateDisplayPlaneSurfaceDelegate>("vkCreateDisplayPlaneSurfaceKHR", "instance");
this.vkCreateSharedSwapchainsKHR = cache.GetCommandDelegate<Interop.Khronos.VkDeviceCreateSharedSwapchainsDelegate>("vkCreateSharedSwapchainsKHR", "device");
this.vkCreateXlibSurfaceKHR = cache.GetCommandDelegate<Interop.Khronos.VkInstanceCreateXlibSurfaceDelegate>("vkCreateXlibSurfaceKHR", "instance");
this.vkGetPhysicalDeviceXlibPresentationSupportKHR = cache.GetCommandDelegate<Interop.Khronos.VkPhysicalDeviceGetXlibPresentationSupportDelegate>("vkGetPhysicalDeviceXlibPresentationSupportKHR", "instance");
this.vkCreateXcbSurfaceKHR = cache.GetCommandDelegate<Interop.Khronos.VkInstanceCreateXcbSurfaceDelegate>("vkCreateXcbSurfaceKHR", "instance");
this.vkGetPhysicalDeviceXcbPresentationSupportKHR = cache.GetCommandDelegate<Interop.Khronos.VkPhysicalDeviceGetXcbPresentationSupportDelegate>("vkGetPhysicalDeviceXcbPresentationSupportKHR", "instance");
this.vkCreateWaylandSurfaceKHR = cache.GetCommandDelegate<Interop.Khronos.VkInstanceCreateWaylandSurfaceDelegate>("vkCreateWaylandSurfaceKHR", "instance");
this.vkGetPhysicalDeviceWaylandPresentationSupportKHR = cache.GetCommandDelegate<Interop.Khronos.VkPhysicalDeviceGetWaylandPresentationSupportDelegate>("vkGetPhysicalDeviceWaylandPresentationSupportKHR", "instance");
this.vkCreateAndroidSurfaceKHR = cache.GetCommandDelegate<Interop.Khronos.VkInstanceCreateAndroidSurfaceDelegate>("vkCreateAndroidSurfaceKHR", "instance");
this.vkCreateWin32SurfaceKHR = cache.GetCommandDelegate<Interop.Khronos.VkInstanceCreateWin32SurfaceDelegate>("vkCreateWin32SurfaceKHR", "instance");
this.vkGetPhysicalDeviceWin32PresentationSupportKHR = cache.GetCommandDelegate<Interop.Khronos.VkPhysicalDeviceGetWin32PresentationSupportDelegate>("vkGetPhysicalDeviceWin32PresentationSupportKHR", "instance");
this.vkCreateDebugReportCallbackEXT = cache.GetCommandDelegate<Interop.Multivendor.VkInstanceCreateDebugReportCallbackDelegate>("vkCreateDebugReportCallbackEXT", "instance");
this.vkDestroyDebugReportCallbackEXT = cache.GetCommandDelegate<Interop.Multivendor.VkDebugReportCallbackEXTDestroyDelegate>("vkDestroyDebugReportCallbackEXT", "instance");
this.vkDebugReportMessageEXT = cache.GetCommandDelegate<Interop.Multivendor.VkInstanceDebugReportMessageDelegate>("vkDebugReportMessageEXT", "instance");
this.vkCmdBindTransformFeedbackBuffersEXT = cache.GetCommandDelegate<Interop.Multivendor.VkCommandBufferBindTransformFeedbackBuffersDelegate>("vkCmdBindTransformFeedbackBuffersEXT", "device");
this.vkCmdBeginTransformFeedbackEXT = cache.GetCommandDelegate<Interop.Multivendor.VkCommandBufferBeginTransformFeedbackDelegate>("vkCmdBeginTransformFeedbackEXT", "device");
this.vkCmdEndTransformFeedbackEXT = cache.GetCommandDelegate<Interop.Multivendor.VkCommandBufferEndTransformFeedbackDelegate>("vkCmdEndTransformFeedbackEXT", "device");
this.vkCmdBeginQueryIndexedEXT = cache.GetCommandDelegate<Interop.Multivendor.VkCommandBufferBeginQueryIndexedDelegate>("vkCmdBeginQueryIndexedEXT", "device");
this.vkCmdEndQueryIndexedEXT = cache.GetCommandDelegate<Interop.Multivendor.VkCommandBufferEndQueryIndexedDelegate>("vkCmdEndQueryIndexedEXT", "device");
this.vkCmdDrawIndirectByteCountEXT = cache.GetCommandDelegate<Interop.Multivendor.VkCommandBufferDrawIndirectByteCountDelegate>("vkCmdDrawIndirectByteCountEXT", "device");
this.vkGetImageViewHandleNVX = cache.GetCommandDelegate<Interop.NVidia.Experimental.VkDeviceGetImageViewHandleDelegate>("vkGetImageViewHandleNVX", "device");
this.vkGetShaderInfoAMD = cache.GetCommandDelegate<Interop.Amd.VkPipelineGetShaderInfoDelegate>("vkGetShaderInfoAMD", "device");
this.vkCreateStreamDescriptorSurfaceGGP = cache.GetCommandDelegate<Interop.Ggp.VkInstanceCreateStreamDescriptorSurfaceDelegate>("vkCreateStreamDescriptorSurfaceGGP", "instance");
this.vkGetPhysicalDeviceExternalImageFormatPropertiesNV = cache.GetCommandDelegate<Interop.NVidia.VkPhysicalDeviceGetExternalImageFormatPropertiesDelegate>("vkGetPhysicalDeviceExternalImageFormatPropertiesNV", "instance");
this.vkGetMemoryWin32HandleNV = cache.GetCommandDelegate<Interop.NVidia.VkDeviceMemoryGetWin32HandleDelegate>("vkGetMemoryWin32HandleNV", "device");
this.vkCreateViSurfaceNN = cache.GetCommandDelegate<Interop.Nintendo.VkInstanceCreateViSurfaceDelegate>("vkCreateViSurfaceNN", "instance");
this.vkGetMemoryWin32HandleKHR = cache.GetCommandDelegate<Interop.Khronos.VkDeviceGetMemoryWin32HandleDelegate>("vkGetMemoryWin32HandleKHR", "device");
this.vkGetMemoryWin32HandlePropertiesKHR = cache.GetCommandDelegate<Interop.Khronos.VkDeviceGetMemoryWin32HandlePropertiesDelegate>("vkGetMemoryWin32HandlePropertiesKHR", "device");
this.vkGetMemoryFdKHR = cache.GetCommandDelegate<Interop.Khronos.VkDeviceGetMemoryFileDescriptorDelegate>("vkGetMemoryFdKHR", "device");
this.vkGetMemoryFdPropertiesKHR = cache.GetCommandDelegate<Interop.Khronos.VkDeviceGetMemoryFileDescriptorPropertiesDelegate>("vkGetMemoryFdPropertiesKHR", "device");
this.vkImportSemaphoreWin32HandleKHR = cache.GetCommandDelegate<Interop.Khronos.VkDeviceImportSemaphoreWin32HandleDelegate>("vkImportSemaphoreWin32HandleKHR", "device");
this.vkGetSemaphoreWin32HandleKHR = cache.GetCommandDelegate<Interop.Khronos.VkDeviceGetSemaphoreWin32HandleDelegate>("vkGetSemaphoreWin32HandleKHR", "device");
this.vkImportSemaphoreFdKHR = cache.GetCommandDelegate<Interop.Khronos.VkDeviceImportSemaphoreFileDescriptorDelegate>("vkImportSemaphoreFdKHR", "device");
this.vkGetSemaphoreFdKHR = cache.GetCommandDelegate<Interop.Khronos.VkDeviceGetSemaphoreFileDescriptorDelegate>("vkGetSemaphoreFdKHR", "device");
this.vkCmdPushDescriptorSetKHR = cache.GetCommandDelegate<Interop.Khronos.VkCommandBufferPushDescriptorSetDelegate>("vkCmdPushDescriptorSetKHR", "device");
this.vkCmdPushDescriptorSetWithTemplateKHR = cache.GetCommandDelegate<Interop.Khronos.VkCommandBufferPushDescriptorSetWithTemplateDelegate>("vkCmdPushDescriptorSetWithTemplateKHR", "device");
this.vkCmdBeginConditionalRenderingEXT = cache.GetCommandDelegate<Interop.Multivendor.VkCommandBufferBeginConditionalRenderingDelegate>("vkCmdBeginConditionalRenderingEXT", "device");
this.vkCmdEndConditionalRenderingEXT = cache.GetCommandDelegate<Interop.Multivendor.VkCommandBufferEndConditionalRenderingDelegate>("vkCmdEndConditionalRenderingEXT", "device");
this.vkCmdProcessCommandsNVX = cache.GetCommandDelegate<Interop.NVidia.Experimental.VkCommandBufferProcessCommandsDelegate>("vkCmdProcessCommandsNVX", "device");
this.vkCmdReserveSpaceForCommandsNVX = cache.GetCommandDelegate<Interop.NVidia.Experimental.VkCommandBufferReserveSpaceForCommandsDelegate>("vkCmdReserveSpaceForCommandsNVX", "device");
this.vkCreateIndirectCommandsLayoutNVX = cache.GetCommandDelegate<Interop.NVidia.Experimental.VkDeviceCreateIndirectCommandsLayoutDelegate>("vkCreateIndirectCommandsLayoutNVX", "device");
this.vkDestroyIndirectCommandsLayoutNVX = cache.GetCommandDelegate<Interop.NVidia.Experimental.VkIndirectCommandsLayoutNVXDestroyDelegate>("vkDestroyIndirectCommandsLayoutNVX", "device");
this.vkCreateObjectTableNVX = cache.GetCommandDelegate<Interop.NVidia.Experimental.VkDeviceCreateObjectTableDelegate>("vkCreateObjectTableNVX", "device");
this.vkDestroyObjectTableNVX = cache.GetCommandDelegate<Interop.NVidia.Experimental.VkObjectTableNVXDestroyDelegate>("vkDestroyObjectTableNVX", "device");
this.vkRegisterObjectsNVX = cache.GetCommandDelegate<Interop.NVidia.Experimental.VkObjectTableNVXRegisterObjectsDelegate>("vkRegisterObjectsNVX", "device");
this.vkUnregisterObjectsNVX = cache.GetCommandDelegate<Interop.NVidia.Experimental.VkObjectTableNVXUnregisterObjectsDelegate>("vkUnregisterObjectsNVX", "device");
this.vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX = cache.GetCommandDelegate<Interop.NVidia.Experimental.VkPhysicalDeviceGetGeneratedCommandsPropertiesDelegate>("vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX", "device");
this.vkCmdSetViewportWScalingNV = cache.GetCommandDelegate<Interop.NVidia.VkCommandBufferSetViewportWScalingDelegate>("vkCmdSetViewportWScalingNV", "device");
this.vkReleaseDisplayEXT = cache.GetCommandDelegate<Interop.Multivendor.VkPhysicalDeviceReleaseDisplayDelegate>("vkReleaseDisplayEXT", "instance");
this.vkAcquireXlibDisplayEXT = cache.GetCommandDelegate<Interop.Multivendor.VkPhysicalDeviceAcquireXlibDisplayDelegate>("vkAcquireXlibDisplayEXT", "instance");
this.vkGetRandROutputDisplayEXT = cache.GetCommandDelegate<Interop.Multivendor.VkPhysicalDeviceGetRandROutputDisplayDelegate>("vkGetRandROutputDisplayEXT", "instance");
this.vkGetPhysicalDeviceSurfaceCapabilities2EXT = cache.GetCommandDelegate<Interop.Multivendor.VkPhysicalDeviceGetSurfaceCapabilities2Delegate>("vkGetPhysicalDeviceSurfaceCapabilities2EXT", "instance");
this.vkDisplayPowerControlEXT = cache.GetCommandDelegate<Interop.Multivendor.VkDeviceDisplayPowerControlDelegate>("vkDisplayPowerControlEXT", "device");
this.vkRegisterDeviceEventEXT = cache.GetCommandDelegate<Interop.Multivendor.VkDeviceRegisterEventDelegate>("vkRegisterDeviceEventEXT", "device");
this.vkRegisterDisplayEventEXT = cache.GetCommandDelegate<Interop.Multivendor.VkDeviceRegisterDisplayEventDelegate>("vkRegisterDisplayEventEXT", "device");
this.vkGetSwapchainCounterEXT = cache.GetCommandDelegate<Interop.Multivendor.VkSwapchainKHRGetCounterDelegate>("vkGetSwapchainCounterEXT", "device");
this.vkGetRefreshCycleDurationGOOGLE = cache.GetCommandDelegate<Interop.Google.VkSwapchainKHRGetRefreshCycleDurationDelegate>("vkGetRefreshCycleDurationGOOGLE", "device");
this.vkGetPastPresentationTimingGOOGLE = cache.GetCommandDelegate<Interop.Google.VkSwapchainKHRGetPastPresentationTimingDelegate>("vkGetPastPresentationTimingGOOGLE", "device");
this.vkCmdSetDiscardRectangleEXT = cache.GetCommandDelegate<Interop.Multivendor.VkCommandBufferSetDiscardRectangleDelegate>("vkCmdSetDiscardRectangleEXT", "device");
this.vkSetHdrMetadataEXT = cache.GetCommandDelegate<Interop.Multivendor.VkDeviceSetHdrMetadataDelegate>("vkSetHdrMetadataEXT", "device");
this.vkGetSwapchainStatusKHR = cache.GetCommandDelegate<Interop.Khronos.VkSwapchainKHRGetStatusDelegate>("vkGetSwapchainStatusKHR", "device");
this.vkImportFenceWin32HandleKHR = cache.GetCommandDelegate<Interop.Khronos.VkDeviceImportFenceWin32HandleDelegate>("vkImportFenceWin32HandleKHR", "device");
this.vkGetFenceWin32HandleKHR = cache.GetCommandDelegate<Interop.Khronos.VkDeviceGetFenceWin32HandleDelegate>("vkGetFenceWin32HandleKHR", "device");
this.vkImportFenceFdKHR = cache.GetCommandDelegate<Interop.Khronos.VkDeviceImportFenceFileDescriptorDelegate>("vkImportFenceFdKHR", "device");
this.vkGetFenceFdKHR = cache.GetCommandDelegate<Interop.Khronos.VkDeviceGetFenceFileDescriptorDelegate>("vkGetFenceFdKHR", "device");
this.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR = cache.GetCommandDelegate<Interop.Khronos.VkPhysicalDeviceEnumerateQueueFamilyPerformanceQueryCountersDelegate>("vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR", "device");
this.vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR = cache.GetCommandDelegate<Interop.Khronos.VkPhysicalDeviceGetQueueFamilyPerformanceQueryPassesDelegate>("vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR", "device");
this.vkAcquireProfilingLockKHR = cache.GetCommandDelegate<Interop.Khronos.VkDeviceAcquireProfilingLockDelegate>("vkAcquireProfilingLockKHR", "device");
this.vkReleaseProfilingLockKHR = cache.GetCommandDelegate<Interop.Khronos.VkDeviceReleaseProfilingLockDelegate>("vkReleaseProfilingLockKHR", "device");
this.vkGetPhysicalDeviceSurfaceCapabilities2KHR = cache.GetCommandDelegate<Interop.Khronos.VkPhysicalDeviceGetSurfaceCapabilities2Delegate>("vkGetPhysicalDeviceSurfaceCapabilities2KHR", "instance");
this.vkGetPhysicalDeviceSurfaceFormats2KHR = cache.GetCommandDelegate<Interop.Khronos.VkPhysicalDeviceGetSurfaceFormats2Delegate>("vkGetPhysicalDeviceSurfaceFormats2KHR", "instance");
this.vkGetPhysicalDeviceDisplayProperties2KHR = cache.GetCommandDelegate<Interop.Khronos.VkPhysicalDeviceGetDisplayProperties2Delegate>("vkGetPhysicalDeviceDisplayProperties2KHR", "instance");
this.vkGetPhysicalDeviceDisplayPlaneProperties2KHR = cache.GetCommandDelegate<Interop.Khronos.VkPhysicalDeviceGetDisplayPlaneProperties2Delegate>("vkGetPhysicalDeviceDisplayPlaneProperties2KHR", "instance");
this.vkGetDisplayModeProperties2KHR = cache.GetCommandDelegate<Interop.Khronos.VkPhysicalDeviceGetDisplayModeProperties2Delegate>("vkGetDisplayModeProperties2KHR", "instance");
this.vkGetDisplayPlaneCapabilities2KHR = cache.GetCommandDelegate<Interop.Khronos.VkPhysicalDeviceGetDisplayPlaneCapabilities2Delegate>("vkGetDisplayPlaneCapabilities2KHR", "instance");
this.vkCreateIOSSurfaceMVK = cache.GetCommandDelegate<Interop.MoltenVk.VkInstanceCreateIOSSurfaceDelegate>("vkCreateIOSSurfaceMVK", "instance");
this.vkCreateMacOSSurfaceMVK = cache.GetCommandDelegate<Interop.MoltenVk.VkInstanceCreateMacOSSurfaceDelegate>("vkCreateMacOSSurfaceMVK", "instance");
this.vkSetDebugUtilsObjectNameEXT = cache.GetCommandDelegate<Interop.Multivendor.VkDeviceSetDebugUtilsObjectNameDelegate>("vkSetDebugUtilsObjectNameEXT", "instance");
this.vkSetDebugUtilsObjectTagEXT = cache.GetCommandDelegate<Interop.Multivendor.VkDeviceSetDebugUtilsObjectTagDelegate>("vkSetDebugUtilsObjectTagEXT", "instance");
this.vkQueueBeginDebugUtilsLabelEXT = cache.GetCommandDelegate<Interop.Multivendor.VkQueueBeginDebugUtilsLabelDelegate>("vkQueueBeginDebugUtilsLabelEXT", "instance");
this.vkQueueEndDebugUtilsLabelEXT = cache.GetCommandDelegate<Interop.Multivendor.VkQueueEndDebugUtilsLabelDelegate>("vkQueueEndDebugUtilsLabelEXT", "instance");
this.vkQueueInsertDebugUtilsLabelEXT = cache.GetCommandDelegate<Interop.Multivendor.VkQueueInsertDebugUtilsLabelDelegate>("vkQueueInsertDebugUtilsLabelEXT", "instance");
this.vkCmdBeginDebugUtilsLabelEXT = cache.GetCommandDelegate<Interop.Multivendor.VkCommandBufferBeginDebugUtilsLabelDelegate>("vkCmdBeginDebugUtilsLabelEXT", "instance");
this.vkCmdEndDebugUtilsLabelEXT = cache.GetCommandDelegate<Interop.Multivendor.VkCommandBufferEndDebugUtilsLabelDelegate>("vkCmdEndDebugUtilsLabelEXT", "instance");
this.vkCmdInsertDebugUtilsLabelEXT = cache.GetCommandDelegate<Interop.Multivendor.VkCommandBufferInsertDebugUtilsLabelDelegate>("vkCmdInsertDebugUtilsLabelEXT", "instance");
this.vkCreateDebugUtilsMessengerEXT = cache.GetCommandDelegate<Interop.Multivendor.VkInstanceCreateDebugUtilsMessengerDelegate>("vkCreateDebugUtilsMessengerEXT", "instance");
this.vkDestroyDebugUtilsMessengerEXT = cache.GetCommandDelegate<Interop.Multivendor.VkDebugUtilsMessengerEXTDestroyDelegate>("vkDestroyDebugUtilsMessengerEXT", "instance");
this.vkSubmitDebugUtilsMessageEXT = cache.GetCommandDelegate<Interop.Multivendor.VkInstanceSubmitDebugUtilsMessageDelegate>("vkSubmitDebugUtilsMessageEXT", "instance");
this.vkGetAndroidHardwareBufferPropertiesANDROID = cache.GetCommandDelegate<Interop.Android.VkDeviceGetAndroidHardwareBufferPropertiesDelegate>("vkGetAndroidHardwareBufferPropertiesANDROID", "device");
this.vkGetMemoryAndroidHardwareBufferANDROID = cache.GetCommandDelegate<Interop.Android.VkDeviceGetMemoryAndroidHardwareBufferDelegate>("vkGetMemoryAndroidHardwareBufferANDROID", "device");
this.vkCmdSetSampleLocationsEXT = cache.GetCommandDelegate<Interop.Multivendor.VkCommandBufferSetSampleLocationsDelegate>("vkCmdSetSampleLocationsEXT", "device");
this.vkGetPhysicalDeviceMultisamplePropertiesEXT = cache.GetCommandDelegate<Interop.Multivendor.VkPhysicalDeviceGetMultisamplePropertiesDelegate>("vkGetPhysicalDeviceMultisamplePropertiesEXT", "device");
this.vkGetImageDrmFormatModifierPropertiesEXT = cache.GetCommandDelegate<Interop.Multivendor.VkImageGetDrmFormatModifierPropertiesDelegate>("vkGetImageDrmFormatModifierPropertiesEXT", "device");
this.vkCreateValidationCacheEXT = cache.GetCommandDelegate<Interop.Multivendor.VkDeviceCreateValidationCacheDelegate>("vkCreateValidationCacheEXT", "device");
this.vkDestroyValidationCacheEXT = cache.GetCommandDelegate<Interop.Multivendor.VkValidationCacheEXTDestroyDelegate>("vkDestroyValidationCacheEXT", "device");
this.vkMergeValidationCachesEXT = cache.GetCommandDelegate<Interop.Multivendor.VkValidationCacheEXTMergeValidationCachesDelegate>("vkMergeValidationCachesEXT", "device");
this.vkGetValidationCacheDataEXT = cache.GetCommandDelegate<Interop.Multivendor.VkValidationCacheEXTGetDataDelegate>("vkGetValidationCacheDataEXT", "device");
this.vkCmdBindShadingRateImageNV = cache.GetCommandDelegate<Interop.NVidia.VkCommandBufferBindShadingRateImageDelegate>("vkCmdBindShadingRateImageNV", "device");
this.vkCmdSetViewportShadingRatePaletteNV = cache.GetCommandDelegate<Interop.NVidia.VkCommandBufferSetViewportShadingRatePaletteDelegate>("vkCmdSetViewportShadingRatePaletteNV", "device");
this.vkCmdSetCoarseSampleOrderNV = cache.GetCommandDelegate<Interop.NVidia.VkCommandBufferSetCoarseSampleOrderDelegate>("vkCmdSetCoarseSampleOrderNV", "device");
this.vkCreateAccelerationStructureNV = cache.GetCommandDelegate<Interop.NVidia.VkDeviceCreateAccelerationStructureDelegate>("vkCreateAccelerationStructureNV", "device");
this.vkDestroyAccelerationStructureNV = cache.GetCommandDelegate<Interop.NVidia.VkAccelerationStructureNVDestroyDelegate>("vkDestroyAccelerationStructureNV", "device");
this.vkGetAccelerationStructureMemoryRequirementsNV = cache.GetCommandDelegate<Interop.NVidia.VkDeviceGetAccelerationStructureMemoryRequirementsDelegate>("vkGetAccelerationStructureMemoryRequirementsNV", "device");
this.vkBindAccelerationStructureMemoryNV = cache.GetCommandDelegate<Interop.NVidia.VkDeviceBindAccelerationStructureMemoryDelegate>("vkBindAccelerationStructureMemoryNV", "device");
this.vkCmdBuildAccelerationStructureNV = cache.GetCommandDelegate<Interop.NVidia.VkCommandBufferBuildAccelerationStructureDelegate>("vkCmdBuildAccelerationStructureNV", "device");
this.vkCmdCopyAccelerationStructureNV = cache.GetCommandDelegate<Interop.NVidia.VkCommandBufferCopyAccelerationStructureDelegate>("vkCmdCopyAccelerationStructureNV", "device");
this.vkCmdTraceRaysNV = cache.GetCommandDelegate<Interop.NVidia.VkCommandBufferTraceRaysDelegate>("vkCmdTraceRaysNV", "device");
this.vkCreateRayTracingPipelinesNV = cache.GetCommandDelegate<Interop.NVidia.VkDeviceCreateRayTracingPipelinesDelegate>("vkCreateRayTracingPipelinesNV", "device");
this.vkGetRayTracingShaderGroupHandlesNV = cache.GetCommandDelegate<Interop.NVidia.VkPipelineGetRayTracingShaderGroupHandlesDelegate>("vkGetRayTracingShaderGroupHandlesNV", "device");
this.vkGetAccelerationStructureHandleNV = cache.GetCommandDelegate<Interop.NVidia.VkAccelerationStructureNVGetHandleDelegate>("vkGetAccelerationStructureHandleNV", "device");
this.vkCmdWriteAccelerationStructuresPropertiesNV = cache.GetCommandDelegate<Interop.NVidia.VkCommandBufferWriteAccelerationStructuresPropertiesDelegate>("vkCmdWriteAccelerationStructuresPropertiesNV", "device");
this.vkCompileDeferredNV = cache.GetCommandDelegate<Interop.NVidia.VkPipelineCompileDeferredDelegate>("vkCompileDeferredNV", "device");
this.vkGetMemoryHostPointerPropertiesEXT = cache.GetCommandDelegate<Interop.Multivendor.VkDeviceGetMemoryHostPointerPropertiesDelegate>("vkGetMemoryHostPointerPropertiesEXT", "device");
this.vkCmdWriteBufferMarkerAMD = cache.GetCommandDelegate<Interop.Amd.VkCommandBufferWriteBufferMarkerDelegate>("vkCmdWriteBufferMarkerAMD", "device");
this.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT = cache.GetCommandDelegate<Interop.Multivendor.VkPhysicalDeviceGetCalibrateableTimeDomainsDelegate>("vkGetPhysicalDeviceCalibrateableTimeDomainsEXT", "device");
this.vkGetCalibratedTimestampsEXT = cache.GetCommandDelegate<Interop.Multivendor.VkDeviceGetCalibratedTimestampsDelegate>("vkGetCalibratedTimestampsEXT", "device");
this.vkCmdDrawMeshTasksNV = cache.GetCommandDelegate<Interop.NVidia.VkCommandBufferDrawMeshTasksDelegate>("vkCmdDrawMeshTasksNV", "device");
this.vkCmdDrawMeshTasksIndirectNV = cache.GetCommandDelegate<Interop.NVidia.VkCommandBufferDrawMeshTasksIndirectDelegate>("vkCmdDrawMeshTasksIndirectNV", "device");
this.vkCmdDrawMeshTasksIndirectCountNV = cache.GetCommandDelegate<Interop.NVidia.VkCommandBufferDrawMeshTasksIndirectCountDelegate>("vkCmdDrawMeshTasksIndirectCountNV", "device");
this.vkCmdSetExclusiveScissorNV = cache.GetCommandDelegate<Interop.NVidia.VkCommandBufferSetExclusiveScissorDelegate>("vkCmdSetExclusiveScissorNV", "device");
this.vkCmdSetCheckpointNV = cache.GetCommandDelegate<Interop.NVidia.VkCommandBufferSetCheckpointDelegate>("vkCmdSetCheckpointNV", "device");
this.vkGetQueueCheckpointDataNV = cache.GetCommandDelegate<Interop.NVidia.VkQueueGetCheckpointDataDelegate>("vkGetQueueCheckpointDataNV", "device");
this.vkInitializePerformanceApiINTEL = cache.GetCommandDelegate<Interop.Intel.VkDeviceInitializePerformanceApiDelegate>("vkInitializePerformanceApiINTEL", "device");
this.vkUninitializePerformanceApiINTEL = cache.GetCommandDelegate<Interop.Intel.VkDeviceUninitializePerformanceApiDelegate>("vkUninitializePerformanceApiINTEL", "device");
this.vkCmdSetPerformanceMarkerINTEL = cache.GetCommandDelegate<Interop.Intel.VkCommandBufferSetPerformanceMarkerDelegate>("vkCmdSetPerformanceMarkerINTEL", "device");
this.vkCmdSetPerformanceStreamMarkerINTEL = cache.GetCommandDelegate<Interop.Intel.VkCommandBufferSetPerformanceStreamMarkerDelegate>("vkCmdSetPerformanceStreamMarkerINTEL", "device");
this.vkCmdSetPerformanceOverrideINTEL = cache.GetCommandDelegate<Interop.Intel.VkCommandBufferSetPerformanceOverrideDelegate>("vkCmdSetPerformanceOverrideINTEL", "device");
this.vkAcquirePerformanceConfigurationINTEL = cache.GetCommandDelegate<Interop.Intel.VkDeviceAcquirePerformanceConfigurationDelegate>("vkAcquirePerformanceConfigurationINTEL", "device");
this.vkReleasePerformanceConfigurationINTEL = cache.GetCommandDelegate<Interop.Intel.VkPerformanceConfigurationINTELReleaseDelegate>("vkReleasePerformanceConfigurationINTEL", "device");
this.vkQueueSetPerformanceConfigurationINTEL = cache.GetCommandDelegate<Interop.Intel.VkQueueSetPerformanceConfigurationDelegate>("vkQueueSetPerformanceConfigurationINTEL", "device");
this.vkGetPerformanceParameterINTEL = cache.GetCommandDelegate<Interop.Intel.VkDeviceGetPerformanceParameterDelegate>("vkGetPerformanceParameterINTEL", "device");
this.vkSetLocalDimmingAMD = cache.GetCommandDelegate<Interop.Amd.VkSwapchainKHRSetLocalDimmingDelegate>("vkSetLocalDimmingAMD", "device");
this.vkCreateImagePipeSurfaceFUCHSIA = cache.GetCommandDelegate<Interop.Fuchsia.VkInstanceCreateImagePipeSurfaceDelegate>("vkCreateImagePipeSurfaceFUCHSIA", "instance");
this.vkCreateMetalSurfaceEXT = cache.GetCommandDelegate<Interop.Multivendor.VkInstanceCreateMetalSurfaceDelegate>("vkCreateMetalSurfaceEXT", "instance");
this.vkGetPhysicalDeviceToolPropertiesEXT = cache.GetCommandDelegate<Interop.Multivendor.VkPhysicalDeviceGetToolPropertiesDelegate>("vkGetPhysicalDeviceToolPropertiesEXT", "device");
this.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV = cache.GetCommandDelegate<Interop.NVidia.VkPhysicalDeviceGetCooperativeMatrixPropertiesDelegate>("vkGetPhysicalDeviceCooperativeMatrixPropertiesNV", "device");
this.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV = cache.GetCommandDelegate<Interop.NVidia.VkPhysicalDeviceGetSupportedFramebufferMixedSamplesCombinationsDelegate>("vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV", "device");
this.vkGetPhysicalDeviceSurfacePresentModes2EXT = cache.GetCommandDelegate<Interop.Multivendor.VkPhysicalDeviceGetSurfacePresentModes2Delegate>("vkGetPhysicalDeviceSurfacePresentModes2EXT", "device");
this.vkAcquireFullScreenExclusiveModeEXT = cache.GetCommandDelegate<Interop.Multivendor.VkSwapchainKHRAcquireFullScreenExclusiveModeDelegate>("vkAcquireFullScreenExclusiveModeEXT", "device");
this.vkReleaseFullScreenExclusiveModeEXT = cache.GetCommandDelegate<Interop.Multivendor.VkSwapchainKHRReleaseFullScreenExclusiveModeDelegate>("vkReleaseFullScreenExclusiveModeEXT", "device");
this.vkGetDeviceGroupSurfacePresentModes2EXT = cache.GetCommandDelegate<Interop.Multivendor.VkDeviceGetGroupSurfacePresentModes2Delegate>("vkGetDeviceGroupSurfacePresentModes2EXT", "device");
this.vkCreateHeadlessSurfaceEXT = cache.GetCommandDelegate<Interop.Multivendor.VkInstanceCreateHeadlessSurfaceDelegate>("vkCreateHeadlessSurfaceEXT", "instance");
this.vkCmdSetLineStippleEXT = cache.GetCommandDelegate<Interop.Multivendor.VkCommandBufferSetLineStippleDelegate>("vkCmdSetLineStippleEXT", "device");
this.vkGetPipelineExecutablePropertiesKHR = cache.GetCommandDelegate<Interop.Khronos.VkDeviceGetPipelineExecutablePropertiesDelegate>("vkGetPipelineExecutablePropertiesKHR", "device");
this.vkGetPipelineExecutableStatisticsKHR = cache.GetCommandDelegate<Interop.Khronos.VkDeviceGetPipelineExecutableStatisticsDelegate>("vkGetPipelineExecutableStatisticsKHR", "device");
this.vkGetPipelineExecutableInternalRepresentationsKHR = cache.GetCommandDelegate<Interop.Khronos.VkDeviceGetPipelineExecutableInternalRepresentationsDelegate>("vkGetPipelineExecutableInternalRepresentationsKHR", "device");
}
}
}
| FacticiusVir/SharpVk | src/SharpVk/CommandCacheStruct.gen.cs | C# | mit | 116,920 |
<body>
<div id="preloader">
<div id="status"> </div>
</div>
<!-- Body content -->
<div class="header-connect">
<div class="container">
<div class="row">
<div class="col-md-5 col-sm-8 col-xs-8">
<div class="header-half header-call">
<p>
<span><i class="icon-cloud"></i>+511 997012324</span>
<span><i class="icon-mail"></i>carlosmartin.contreras@gmail.com</span>
</p>
</div>
</div>
<div class="col-md-2 col-md-offset-5 col-sm-3 col-sm-offset-1 col-xs-3 col-xs-offset-1">
<div class="header-half header-social">
<ul class="list-inline">
<li><a href="#"><i class="fa fa-facebook"></i></a></li>
<li><a href="#"><i class="fa fa-twitter"></i></a></li>
<li><a href="#"><i class="fa fa-vine"></i></a></li>
<li><a href="#"><i class="fa fa-linkedin"></i></a></li>
<li><a href="#"><i class="fa fa-dribbble"></i></a></li>
<li><a href="#"><i class="fa fa-instagram"></i></a></li>
</ul>
</div>
</div>
</div>
</div>
</div>
<nav class="navbar navbar-default">
<div class="container">
<!-- Brand and toggle get grouped for better mobile display -->
<div class="navbar-header">
<button type="button" class="navbar-toggle collapsed" data-toggle="collapse" data-target="#bs-example-navbar-collapse-1">
<span class="sr-only">Toggle navigation</span>
<span class="icon-bar"></span>
<span class="icon-bar"></span>
<span class="icon-bar"></span>
</button>
<a class="navbar-brand" href="#"><img src="img/logo.png" alt=""></a>
</div>
<!-- Collect the nav links, forms, and other content for toggling -->
<div class="collapse navbar-collapse" id="bs-example-navbar-collapse-1">
<div class="button navbar-right">
<button class="navbar-btn nav-button wow bounceInRight login" data-wow-delay="0.8s">Login</button>
<button class="navbar-btn nav-button wow fadeInRight" data-wow-delay="0.6s">Sign up</button>
</div>
<ul class="main-nav nav navbar-nav navbar-right">
<li class="wow fadeInDown" data-wow-delay="0s"><a class="active" href="#">Home</a></li>
<li class="wow fadeInDown" data-wow-delay="0.1s"><a href="#">Job Seekers</a></li>
<li class="wow fadeInDown" data-wow-delay="0.2s"><a href="#">Employeers</a></li>
<li class="wow fadeInDown" data-wow-delay="0.3s"><a href="#">About us</a></li>
<li class="wow fadeInDown" data-wow-delay="0.4s"><a href="#">Blog</a></li>
<li class="wow fadeInDown" data-wow-delay="0.5s"><a href="#">Contact</a></li>
</ul>
</div><!-- /.navbar-collapse -->
</div><!-- /.container-fluid -->
</nav>
| teseo24/voluntariadoCI | application/views/partial/nav.php | PHP | mit | 3,527 |
<?php
namespace Jaxxes\TestPmaSPBundle\DataFixtures\ORM;
use Doctrine\Common\DataFixtures\AbstractFixture;
use Symfony\Component\DependencyInjection\ContainerAwareInterface;
use Doctrine\Common\DataFixtures\OrderedFixtureInterface;
use Doctrine\Common\Persistence\ObjectManager;
use Symfony\Component\DependencyInjection\ContainerInterface;
use Jaxxes\TestPmaSPBundle\Entity\Pma5Diccionario;
/**
* Fixtures de la entidad Resume.
* Crea el registro de la cabecera para Resume = Ficha del candidato
*/
// class Resumes implements FixtureInterface
class PMA5DiccionarioA extends AbstractFixture implements OrderedFixtureInterface
{
public function getOrder()
{
return 101;
}
private $container;
public function load(ObjectManager $manager)
{
$lstStructure = array(
array('letra'=>'a', 'palabra'=>'a'),
array('letra'=>'a', 'palabra'=>'aaronico'),
array('letra'=>'a', 'palabra'=>'aaronita'),
array('letra'=>'a', 'palabra'=>'aba'),
array('letra'=>'a', 'palabra'=>'ababa'),
array('letra'=>'a', 'palabra'=>'ababillarse'),
array('letra'=>'a', 'palabra'=>'ababol'),
array('letra'=>'a', 'palabra'=>'abaca'),
array('letra'=>'a', 'palabra'=>'abacal'),
array('letra'=>'a', 'palabra'=>'abacalero'),
array('letra'=>'a', 'palabra'=>'abaceria'),
array('letra'=>'a', 'palabra'=>'abacero'),
array('letra'=>'a', 'palabra'=>'abacial'),
array('letra'=>'a', 'palabra'=>'abaco'),
array('letra'=>'a', 'palabra'=>'abacora'),
array('letra'=>'a', 'palabra'=>'abacorar'),
array('letra'=>'a', 'palabra'=>'abad'),
array('letra'=>'a', 'palabra'=>'abada'),
array('letra'=>'a', 'palabra'=>'abadejo'),
array('letra'=>'a', 'palabra'=>'abadengo'),
array('letra'=>'a', 'palabra'=>'abadernar'),
array('letra'=>'a', 'palabra'=>'abadesa'),
array('letra'=>'a', 'palabra'=>'abadi'),
array('letra'=>'a', 'palabra'=>'abadia'),
array('letra'=>'a', 'palabra'=>'abadiado'),
array('letra'=>'a', 'palabra'=>'abadiato'),
array('letra'=>'a', 'palabra'=>'abajadero'),
array('letra'=>'a', 'palabra'=>'abajamiento'),
array('letra'=>'a', 'palabra'=>'abajar'),
array('letra'=>'a', 'palabra'=>'abajeño'),
array('letra'=>'a', 'palabra'=>'abajera'),
array('letra'=>'a', 'palabra'=>'abajo'),
array('letra'=>'a', 'palabra'=>'abalada'),
array('letra'=>'a', 'palabra'=>'abalanzar'),
array('letra'=>'a', 'palabra'=>'abalar'),
array('letra'=>'a', 'palabra'=>'abalaustrado'),
array('letra'=>'a', 'palabra'=>'abaldonadamente'),
array('letra'=>'a', 'palabra'=>'abaldonamiento'),
array('letra'=>'a', 'palabra'=>'abaldonar'),
array('letra'=>'a', 'palabra'=>'abaleador'),
array('letra'=>'a', 'palabra'=>'abaleadura'),
array('letra'=>'a', 'palabra'=>'abalear'),
array('letra'=>'a', 'palabra'=>'abaleo'),
array('letra'=>'a', 'palabra'=>'abalizamiento'),
array('letra'=>'a', 'palabra'=>'abalizar'),
array('letra'=>'a', 'palabra'=>'aballar'),
array('letra'=>'a', 'palabra'=>'aballestar'),
array('letra'=>'a', 'palabra'=>'abalorio'),
array('letra'=>'a', 'palabra'=>'abaluartar'),
array('letra'=>'a', 'palabra'=>'abanador'),
array('letra'=>'a', 'palabra'=>'abanar'),
array('letra'=>'a', 'palabra'=>'abancalar'),
array('letra'=>'a', 'palabra'=>'abanderado'),
array('letra'=>'a', 'palabra'=>'abanderamiento'),
array('letra'=>'a', 'palabra'=>'abanderar'),
array('letra'=>'a', 'palabra'=>'abanderizador'),
array('letra'=>'a', 'palabra'=>'abanderizar'),
array('letra'=>'a', 'palabra'=>'abandonado'),
array('letra'=>'a', 'palabra'=>'abandonamiento'),
array('letra'=>'a', 'palabra'=>'abandonar'),
array('letra'=>'a', 'palabra'=>'abandonismo'),
array('letra'=>'a', 'palabra'=>'abandonista'),
array('letra'=>'a', 'palabra'=>'abandono'),
array('letra'=>'a', 'palabra'=>'abanear'),
array('letra'=>'a', 'palabra'=>'abanicar'),
array('letra'=>'a', 'palabra'=>'abanicazo'),
array('letra'=>'a', 'palabra'=>'abanico'),
array('letra'=>'a', 'palabra'=>'abanillo'),
array('letra'=>'a', 'palabra'=>'abanino'),
array('letra'=>'a', 'palabra'=>'abaniqueo'),
array('letra'=>'a', 'palabra'=>'abaniqueria'),
array('letra'=>'a', 'palabra'=>'abaniquero'),
array('letra'=>'a', 'palabra'=>'abano'),
array('letra'=>'a', 'palabra'=>'abanto'),
array('letra'=>'a', 'palabra'=>'abañador'),
array('letra'=>'a', 'palabra'=>'abañadura'),
array('letra'=>'a', 'palabra'=>'abañar'),
array('letra'=>'a', 'palabra'=>'abarajar'),
array('letra'=>'a', 'palabra'=>'abarañar'),
array('letra'=>'a', 'palabra'=>'abaratamiento'),
array('letra'=>'a', 'palabra'=>'abaratar'),
array('letra'=>'a', 'palabra'=>'abarbechar'),
array('letra'=>'a', 'palabra'=>'abarbetar'),
array('letra'=>'a', 'palabra'=>'abarca'),
array('letra'=>'a', 'palabra'=>'abarcable'),
array('letra'=>'a', 'palabra'=>'abarcado'),
array('letra'=>'a', 'palabra'=>'abarcador'),
array('letra'=>'a', 'palabra'=>'abarcadura'),
array('letra'=>'a', 'palabra'=>'abarcamiento'),
array('letra'=>'a', 'palabra'=>'abarcar'),
array('letra'=>'a', 'palabra'=>'abarcon'),
array('letra'=>'a', 'palabra'=>'abarcuzar'),
array('letra'=>'a', 'palabra'=>'abareque'),
array('letra'=>'a', 'palabra'=>'abaritonado'),
array('letra'=>'a', 'palabra'=>'abarloar'),
array('letra'=>'a', 'palabra'=>'abarquero'),
array('letra'=>'a', 'palabra'=>'abarquillado'),
array('letra'=>'a', 'palabra'=>'abarquillamiento'),
array('letra'=>'a', 'palabra'=>'abarquillar'),
array('letra'=>'a', 'palabra'=>'abarracar'),
array('letra'=>'a', 'palabra'=>'abarrado'),
array('letra'=>'a', 'palabra'=>'abarraganamiento'),
array('letra'=>'a', 'palabra'=>'abarraganarse'),
array('letra'=>'a', 'palabra'=>'abarrajado'),
array('letra'=>'a', 'palabra'=>'abarrajar'),
array('letra'=>'a', 'palabra'=>'abarramiento'),
array('letra'=>'a', 'palabra'=>'abarrancadero'),
array('letra'=>'a', 'palabra'=>'abarrancamiento'),
array('letra'=>'a', 'palabra'=>'abarrancar'),
array('letra'=>'a', 'palabra'=>'abarrar'),
array('letra'=>'a', 'palabra'=>'abarraz'),
array('letra'=>'a', 'palabra'=>'abarredera'),
array('letra'=>'a', 'palabra'=>'abarrenar'),
array('letra'=>'a', 'palabra'=>'abarrer'),
array('letra'=>'a', 'palabra'=>'abarrisco'),
array('letra'=>'a', 'palabra'=>'abarrotar'),
array('letra'=>'a', 'palabra'=>'abarrote'),
array('letra'=>'a', 'palabra'=>'abarroteria'),
array('letra'=>'a', 'palabra'=>'abarrotero'),
array('letra'=>'a', 'palabra'=>'abarse'),
array('letra'=>'a', 'palabra'=>'abasi'),
array('letra'=>'a', 'palabra'=>'abastadamente'),
array('letra'=>'a', 'palabra'=>'abastamiento'),
array('letra'=>'a', 'palabra'=>'abastante'),
array('letra'=>'a', 'palabra'=>'abastanza'),
array('letra'=>'a', 'palabra'=>'abastar'),
array('letra'=>'a', 'palabra'=>'abastardar'),
array('letra'=>'a', 'palabra'=>'abastecedor'),
array('letra'=>'a', 'palabra'=>'abastecer'),
array('letra'=>'a', 'palabra'=>'abastecimiento'),
array('letra'=>'a', 'palabra'=>'abastero'),
array('letra'=>'a', 'palabra'=>'abastimiento'),
array('letra'=>'a', 'palabra'=>'abastionar'),
array('letra'=>'a', 'palabra'=>'abasto'),
array('letra'=>'a', 'palabra'=>'abatanado'),
array('letra'=>'a', 'palabra'=>'abatanar'),
array('letra'=>'a', 'palabra'=>'abatatamiento'),
array('letra'=>'a', 'palabra'=>'abatatar'),
array('letra'=>'a', 'palabra'=>'abate'),
array('letra'=>'a', 'palabra'=>'abati'),
array('letra'=>'a', 'palabra'=>'abatible'),
array('letra'=>'a', 'palabra'=>'abatidero'),
array('letra'=>'a', 'palabra'=>'abatido'),
array('letra'=>'a', 'palabra'=>'abatidura'),
array('letra'=>'a', 'palabra'=>'abatimiento'),
array('letra'=>'a', 'palabra'=>'abatir'),
array('letra'=>'a', 'palabra'=>'abatismo'),
array('letra'=>'a', 'palabra'=>'abatojar'),
array('letra'=>'a', 'palabra'=>'abayado'),
array('letra'=>'a', 'palabra'=>'abazon'),
array('letra'=>'a', 'palabra'=>'abderitano'),
array('letra'=>'a', 'palabra'=>'abdicacion'),
array('letra'=>'a', 'palabra'=>'abdicar'),
array('letra'=>'a', 'palabra'=>'abdicativamente'),
array('letra'=>'a', 'palabra'=>'abdicativo'),
array('letra'=>'a', 'palabra'=>'abdomen'),
array('letra'=>'a', 'palabra'=>'abdominal'),
array('letra'=>'a', 'palabra'=>'abduccion'),
array('letra'=>'a', 'palabra'=>'abductor'),
array('letra'=>'a', 'palabra'=>'abece'),
array('letra'=>'a', 'palabra'=>'abecedario'),
array('letra'=>'a', 'palabra'=>'abedul'),
array('letra'=>'a', 'palabra'=>'abeja'),
array('letra'=>'a', 'palabra'=>'abejar'),
array('letra'=>'a', 'palabra'=>'abejarron'),
array('letra'=>'a', 'palabra'=>'abejaruco'),
array('letra'=>'a', 'palabra'=>'abejear'),
array('letra'=>'a', 'palabra'=>'abejero'),
array('letra'=>'a', 'palabra'=>'abejon'),
array('letra'=>'a', 'palabra'=>'abejonear'),
array('letra'=>'a', 'palabra'=>'abejoneo'),
array('letra'=>'a', 'palabra'=>'abejorrear'),
array('letra'=>'a', 'palabra'=>'abejorreo'),
array('letra'=>'a', 'palabra'=>'abejorro'),
array('letra'=>'a', 'palabra'=>'abejuno'),
array('letra'=>'a', 'palabra'=>'abeldar'),
array('letra'=>'a', 'palabra'=>'abellacado'),
array('letra'=>'a', 'palabra'=>'abellacar'),
array('letra'=>'a', 'palabra'=>'abellota'),
array('letra'=>'a', 'palabra'=>'abellotado'),
array('letra'=>'a', 'palabra'=>'abelmosco'),
array('letra'=>'a', 'palabra'=>'abemoladamente'),
array('letra'=>'a', 'palabra'=>'abemolar'),
array('letra'=>'a', 'palabra'=>'abencerraje'),
array('letra'=>'a', 'palabra'=>'abenuz'),
array('letra'=>'a', 'palabra'=>'abeñola'),
array('letra'=>'a', 'palabra'=>'abeñula'),
array('letra'=>'a', 'palabra'=>'aberenjenado'),
array('letra'=>'a', 'palabra'=>'aberracion'),
array('letra'=>'a', 'palabra'=>'aberrante'),
array('letra'=>'a', 'palabra'=>'aberrar'),
array('letra'=>'a', 'palabra'=>'abertal'),
array('letra'=>'a', 'palabra'=>'abertura'),
array('letra'=>'a', 'palabra'=>'aberzale'),
array('letra'=>'a', 'palabra'=>'abes'),
array('letra'=>'a', 'palabra'=>'abesana'),
array('letra'=>'a', 'palabra'=>'abeson'),
array('letra'=>'a', 'palabra'=>'abestiado'),
array('letra'=>'a', 'palabra'=>'abestializado'),
array('letra'=>'a', 'palabra'=>'abestola'),
array('letra'=>'a', 'palabra'=>'abetal'),
array('letra'=>'a', 'palabra'=>'abetar'),
array('letra'=>'a', 'palabra'=>'abete'),
array('letra'=>'a', 'palabra'=>'abetinote'),
array('letra'=>'a', 'palabra'=>'abeto'),
array('letra'=>'a', 'palabra'=>'abetuna'),
array('letra'=>'a', 'palabra'=>'abetunado'),
array('letra'=>'a', 'palabra'=>'abetunar'),
array('letra'=>'a', 'palabra'=>'abey'),
array('letra'=>'a', 'palabra'=>'abia'),
array('letra'=>'a', 'palabra'=>'abiar'),
array('letra'=>'a', 'palabra'=>'abibollo'),
array('letra'=>'a', 'palabra'=>'abicharse'),
array('letra'=>'a', 'palabra'=>'abierta'),
array('letra'=>'a', 'palabra'=>'abiertamente'),
array('letra'=>'a', 'palabra'=>'abierto'),
array('letra'=>'a', 'palabra'=>'abietaceo'),
array('letra'=>'a', 'palabra'=>'abiete'),
array('letra'=>'a', 'palabra'=>'abietineo'),
array('letra'=>'a', 'palabra'=>'abietino'),
array('letra'=>'a', 'palabra'=>'abigarrado'),
array('letra'=>'a', 'palabra'=>'abigarramiento'),
array('letra'=>'a', 'palabra'=>'abigarrar'),
array('letra'=>'a', 'palabra'=>'abigeato'),
array('letra'=>'a', 'palabra'=>'abigeo'),
array('letra'=>'a', 'palabra'=>'abigotado'),
array('letra'=>'a', 'palabra'=>'abinar'),
array('letra'=>'a', 'palabra'=>'abintestato'),
array('letra'=>'a', 'palabra'=>'abiogenesis'),
array('letra'=>'a', 'palabra'=>'abiotico'),
array('letra'=>'a', 'palabra'=>'abipon'),
array('letra'=>'a', 'palabra'=>'abisagrar'),
array('letra'=>'a', 'palabra'=>'abisal'),
array('letra'=>'a', 'palabra'=>'abiselar'),
array('letra'=>'a', 'palabra'=>'abisinio'),
array('letra'=>'a', 'palabra'=>'abismado'),
array('letra'=>'a', 'palabra'=>'abismal'),
array('letra'=>'a', 'palabra'=>'abismar'),
array('letra'=>'a', 'palabra'=>'abismatico'),
array('letra'=>'a', 'palabra'=>'abismo'),
array('letra'=>'a', 'palabra'=>'abiso'),
array('letra'=>'a', 'palabra'=>'abita'),
array('letra'=>'a', 'palabra'=>'abitadura'),
array('letra'=>'a', 'palabra'=>'abitaque'),
array('letra'=>'a', 'palabra'=>'abitar'),
array('letra'=>'a', 'palabra'=>'abiton'),
array('letra'=>'a', 'palabra'=>'abizcochado'),
array('letra'=>'a', 'palabra'=>'abjuracion'),
array('letra'=>'a', 'palabra'=>'abjurar'),
array('letra'=>'a', 'palabra'=>'ablacion'),
array('letra'=>'a', 'palabra'=>'ablandabrevas'),
array('letra'=>'a', 'palabra'=>'ablandador'),
array('letra'=>'a', 'palabra'=>'ablandahigos'),
array('letra'=>'a', 'palabra'=>'ablandamiento'),
array('letra'=>'a', 'palabra'=>'ablandar'),
array('letra'=>'a', 'palabra'=>'ablandativo'),
array('letra'=>'a', 'palabra'=>'ablande'),
array('letra'=>'a', 'palabra'=>'ablandecer'),
array('letra'=>'a', 'palabra'=>'ablanedo'),
array('letra'=>'a', 'palabra'=>'ablano'),
array('letra'=>'a', 'palabra'=>'ablativo'),
array('letra'=>'a', 'palabra'=>'ablegado'),
array('letra'=>'a', 'palabra'=>'ablentador'),
array('letra'=>'a', 'palabra'=>'ablentar'),
array('letra'=>'a', 'palabra'=>'ablucion'),
array('letra'=>'a', 'palabra'=>'ablusado'),
array('letra'=>'a', 'palabra'=>'abnegacion'),
array('letra'=>'a', 'palabra'=>'abnegado'),
array('letra'=>'a', 'palabra'=>'abnegar'),
array('letra'=>'a', 'palabra'=>'abobado'),
array('letra'=>'a', 'palabra'=>'abobamiento'),
array('letra'=>'a', 'palabra'=>'abobar'),
array('letra'=>'a', 'palabra'=>'abobra'),
array('letra'=>'a', 'palabra'=>'abocadear'),
array('letra'=>'a', 'palabra'=>'abocado'),
array('letra'=>'a', 'palabra'=>'abocamiento'),
array('letra'=>'a', 'palabra'=>'abocanar'),
array('letra'=>'a', 'palabra'=>'abocar'),
array('letra'=>'a', 'palabra'=>'abocardado'),
array('letra'=>'a', 'palabra'=>'abocardar'),
array('letra'=>'a', 'palabra'=>'abocardo'),
array('letra'=>'a', 'palabra'=>'abocelado'),
array('letra'=>'a', 'palabra'=>'abocetado'),
array('letra'=>'a', 'palabra'=>'abocetamiento'),
array('letra'=>'a', 'palabra'=>'abocetar'),
array('letra'=>'a', 'palabra'=>'abochornado'),
array('letra'=>'a', 'palabra'=>'abochornar'),
array('letra'=>'a', 'palabra'=>'abocinado'),
array('letra'=>'a', 'palabra'=>'abocinamiento'),
array('letra'=>'a', 'palabra'=>'abocinar'),
array('letra'=>'a', 'palabra'=>'abofado'),
array('letra'=>'a', 'palabra'=>'abofarse'),
array('letra'=>'a', 'palabra'=>'abofeteador'),
array('letra'=>'a', 'palabra'=>'abofetear'),
array('letra'=>'a', 'palabra'=>'abogacia'),
array('letra'=>'a', 'palabra'=>'abogaderas'),
array('letra'=>'a', 'palabra'=>'abogadesco'),
array('letra'=>'a', 'palabra'=>'abogadil'),
array('letra'=>'a', 'palabra'=>'abogadismo'),
array('letra'=>'a', 'palabra'=>'abogado'),
array('letra'=>'a', 'palabra'=>'abogador'),
array('letra'=>'a', 'palabra'=>'abogamiento'),
array('letra'=>'a', 'palabra'=>'abogar'),
array('letra'=>'a', 'palabra'=>'abohetado'),
array('letra'=>'a', 'palabra'=>'abolaga'),
array('letra'=>'a', 'palabra'=>'abolengo'),
array('letra'=>'a', 'palabra'=>'abolicion'),
array('letra'=>'a', 'palabra'=>'abolicionismo'),
array('letra'=>'a', 'palabra'=>'abolicionista'),
array('letra'=>'a', 'palabra'=>'abolir'),
array('letra'=>'a', 'palabra'=>'abollado'),
array('letra'=>'a', 'palabra'=>'abolladura'),
array('letra'=>'a', 'palabra'=>'abollar'),
array('letra'=>'a', 'palabra'=>'abollon'),
array('letra'=>'a', 'palabra'=>'abollonar'),
array('letra'=>'a', 'palabra'=>'abolorio'),
array('letra'=>'a', 'palabra'=>'abolsado'),
array('letra'=>'a', 'palabra'=>'abolsarse'),
array('letra'=>'a', 'palabra'=>'abomaso'),
array('letra'=>'a', 'palabra'=>'abombado'),
array('letra'=>'a', 'palabra'=>'abombamiento'),
array('letra'=>'a', 'palabra'=>'abombar'),
array('letra'=>'a', 'palabra'=>'abominable'),
array('letra'=>'a', 'palabra'=>'abominacion'),
array('letra'=>'a', 'palabra'=>'abominar'),
array('letra'=>'a', 'palabra'=>'abonable'),
array('letra'=>'a', 'palabra'=>'abonado'),
array('letra'=>'a', 'palabra'=>'abonador'),
array('letra'=>'a', 'palabra'=>'abonanza'),
array('letra'=>'a', 'palabra'=>'abonanzar'),
array('letra'=>'a', 'palabra'=>'abonar'),
array('letra'=>'a', 'palabra'=>'abonare'),
array('letra'=>'a', 'palabra'=>'abondado'),
array('letra'=>'a', 'palabra'=>'abondamiento'),
array('letra'=>'a', 'palabra'=>'abondar'),
array('letra'=>'a', 'palabra'=>'abondo'),
array('letra'=>'a', 'palabra'=>'abondoso'),
array('letra'=>'a', 'palabra'=>'abonero'),
array('letra'=>'a', 'palabra'=>'abono'),
array('letra'=>'a', 'palabra'=>'aboquillado'),
array('letra'=>'a', 'palabra'=>'aboquillar'),
array('letra'=>'a', 'palabra'=>'aboral'),
array('letra'=>'a', 'palabra'=>'abordable'),
array('letra'=>'a', 'palabra'=>'abordador'),
array('letra'=>'a', 'palabra'=>'abordaje'),
array('letra'=>'a', 'palabra'=>'abordar'),
array('letra'=>'a', 'palabra'=>'abordo'),
array('letra'=>'a', 'palabra'=>'abordonar'),
array('letra'=>'a', 'palabra'=>'aborigen'),
array('letra'=>'a', 'palabra'=>'aborlonado'),
array('letra'=>'a', 'palabra'=>'aborrachado'),
array('letra'=>'a', 'palabra'=>'aborrajarse'),
array('letra'=>'a', 'palabra'=>'aborrascarse'),
array('letra'=>'a', 'palabra'=>'aborrecedor'),
array('letra'=>'a', 'palabra'=>'aborrecer'),
array('letra'=>'a', 'palabra'=>'aborrecible'),
array('letra'=>'a', 'palabra'=>'aborrecimiento'),
array('letra'=>'a', 'palabra'=>'aborregado'),
array('letra'=>'a', 'palabra'=>'aborregarse'),
array('letra'=>'a', 'palabra'=>'aborrible'),
array('letra'=>'a', 'palabra'=>'aborrir'),
array('letra'=>'a', 'palabra'=>'aborronar'),
array('letra'=>'a', 'palabra'=>'aborso'),
array('letra'=>'a', 'palabra'=>'abortadura'),
array('letra'=>'a', 'palabra'=>'abortamiento'),
array('letra'=>'a', 'palabra'=>'abortar'),
array('letra'=>'a', 'palabra'=>'abortista'),
array('letra'=>'a', 'palabra'=>'abortivo'),
array('letra'=>'a', 'palabra'=>'aborto'),
array('letra'=>'a', 'palabra'=>'aborton'),
array('letra'=>'a', 'palabra'=>'aborujar'),
array('letra'=>'a', 'palabra'=>'abotagamiento'),
array('letra'=>'a', 'palabra'=>'abotagarse'),
array('letra'=>'a', 'palabra'=>'abotargarse'),
array('letra'=>'a', 'palabra'=>'abotinado'),
array('letra'=>'a', 'palabra'=>'abotonador'),
array('letra'=>'a', 'palabra'=>'abotonadura'),
array('letra'=>'a', 'palabra'=>'abotonar'),
array('letra'=>'a', 'palabra'=>'abovedado'),
array('letra'=>'a', 'palabra'=>'abovedar'),
array('letra'=>'a', 'palabra'=>'aboyado'),
array('letra'=>'a', 'palabra'=>'aboyar'),
array('letra'=>'a', 'palabra'=>'abozalar'),
array('letra'=>'a', 'palabra'=>'abozo'),
array('letra'=>'a', 'palabra'=>'abra'),
array('letra'=>'a', 'palabra'=>'abracadabra'),
array('letra'=>'a', 'palabra'=>'abracadabrante'),
array('letra'=>'a', 'palabra'=>'abracar'),
array('letra'=>'a', 'palabra'=>'abracijarse'),
array('letra'=>'a', 'palabra'=>'abracijo'),
array('letra'=>'a', 'palabra'=>'abraham'),
array('letra'=>'a', 'palabra'=>'abrasadamente'),
array('letra'=>'a', 'palabra'=>'abrasador'),
array('letra'=>'a', 'palabra'=>'abrasamiento'),
array('letra'=>'a', 'palabra'=>'abrasar'),
array('letra'=>'a', 'palabra'=>'abrasilado'),
array('letra'=>'a', 'palabra'=>'abrasion'),
array('letra'=>'a', 'palabra'=>'abrasivo'),
array('letra'=>'a', 'palabra'=>'abravar'),
array('letra'=>'a', 'palabra'=>'abravecer'),
array('letra'=>'a', 'palabra'=>'abraxas'),
array('letra'=>'a', 'palabra'=>'abrazada'),
array('letra'=>'a', 'palabra'=>'abrazadera'),
array('letra'=>'a', 'palabra'=>'abrazador'),
array('letra'=>'a', 'palabra'=>'abrazamiento'),
array('letra'=>'a', 'palabra'=>'abrazar'),
array('letra'=>'a', 'palabra'=>'abrazo'),
array('letra'=>'a', 'palabra'=>'abreboca'),
array('letra'=>'a', 'palabra'=>'abrebotellas'),
array('letra'=>'a', 'palabra'=>'abrecartas'),
array('letra'=>'a', 'palabra'=>'abrecoches'),
array('letra'=>'a', 'palabra'=>'abregancias'),
array('letra'=>'a', 'palabra'=>'abrego'),
array('letra'=>'a', 'palabra'=>'abrelatas'),
array('letra'=>'a', 'palabra'=>'abrenunciar'),
array('letra'=>'a', 'palabra'=>'abrenuncio'),
array('letra'=>'a', 'palabra'=>'abreojos'),
array('letra'=>'a', 'palabra'=>'abrepuño'),
array('letra'=>'a', 'palabra'=>'abretonar'),
array('letra'=>'a', 'palabra'=>'abrevadero'),
array('letra'=>'a', 'palabra'=>'abrevador'),
array('letra'=>'a', 'palabra'=>'abrevar'),
array('letra'=>'a', 'palabra'=>'abreviacion'),
array('letra'=>'a', 'palabra'=>'abreviadamente'),
array('letra'=>'a', 'palabra'=>'abreviado'),
array('letra'=>'a', 'palabra'=>'abreviador'),
array('letra'=>'a', 'palabra'=>'abreviaduria'),
array('letra'=>'a', 'palabra'=>'abreviamiento'),
array('letra'=>'a', 'palabra'=>'abreviar'),
array('letra'=>'a', 'palabra'=>'abreviatura'),
array('letra'=>'a', 'palabra'=>'abreviaturia'),
array('letra'=>'a', 'palabra'=>'abrezar'),
array('letra'=>'a', 'palabra'=>'abriboca'),
array('letra'=>'a', 'palabra'=>'abribonado'),
array('letra'=>'a', 'palabra'=>'abribonarse'),
array('letra'=>'a', 'palabra'=>'abridero'),
array('letra'=>'a', 'palabra'=>'abridor'),
array('letra'=>'a', 'palabra'=>'abrigada'),
array('letra'=>'a', 'palabra'=>'abrigadero'),
array('letra'=>'a', 'palabra'=>'abrigado'),
array('letra'=>'a', 'palabra'=>'abrigador'),
array('letra'=>'a', 'palabra'=>'abrigadura'),
array('letra'=>'a', 'palabra'=>'abrigamiento'),
array('letra'=>'a', 'palabra'=>'abrigaño'),
array('letra'=>'a', 'palabra'=>'abrigar'),
array('letra'=>'a', 'palabra'=>'abrigo'),
array('letra'=>'a', 'palabra'=>'abrigo'),
array('letra'=>'a', 'palabra'=>'abril'),
array('letra'=>'a', 'palabra'=>'abrileño'),
array('letra'=>'a', 'palabra'=>'abrillantador'),
array('letra'=>'a', 'palabra'=>'abrillantar'),
array('letra'=>'a', 'palabra'=>'abrimiento'),
array('letra'=>'a', 'palabra'=>'abriolar'),
array('letra'=>'a', 'palabra'=>'abrir'),
array('letra'=>'a', 'palabra'=>'abrochador'),
array('letra'=>'a', 'palabra'=>'abrochadura'),
array('letra'=>'a', 'palabra'=>'abrochamiento'),
array('letra'=>'a', 'palabra'=>'abrochar'),
array('letra'=>'a', 'palabra'=>'abrogacion'),
array('letra'=>'a', 'palabra'=>'abrogar'),
array('letra'=>'a', 'palabra'=>'abrojal'),
array('letra'=>'a', 'palabra'=>'abrojillo'),
array('letra'=>'a', 'palabra'=>'abrojin'),
array('letra'=>'a', 'palabra'=>'abrojo'),
array('letra'=>'a', 'palabra'=>'abroma'),
array('letra'=>'a', 'palabra'=>'abromado'),
array('letra'=>'a', 'palabra'=>'abromar'),
array('letra'=>'a', 'palabra'=>'abroncar'),
array('letra'=>'a', 'palabra'=>'abroquelado'),
array('letra'=>'a', 'palabra'=>'abroquelar'),
array('letra'=>'a', 'palabra'=>'abrotano'),
array('letra'=>'a', 'palabra'=>'abrotoñar'),
array('letra'=>'a', 'palabra'=>'abrumador'),
array('letra'=>'a', 'palabra'=>'abrumar'),
array('letra'=>'a', 'palabra'=>'abrumarse'),
array('letra'=>'a', 'palabra'=>'abrunal'),
array('letra'=>'a', 'palabra'=>'abruno'),
array('letra'=>'a', 'palabra'=>'abruñal'),
array('letra'=>'a', 'palabra'=>'abruño'),
array('letra'=>'a', 'palabra'=>'abrupcion'),
array('letra'=>'a', 'palabra'=>'abrupto'),
array('letra'=>'a', 'palabra'=>'abrutado'),
array('letra'=>'a', 'palabra'=>'abruzarse'),
array('letra'=>'a', 'palabra'=>'abruzo'),
array('letra'=>'a', 'palabra'=>'absceso'),
array('letra'=>'a', 'palabra'=>'abscisa'),
array('letra'=>'a', 'palabra'=>'abscision'),
array('letra'=>'a', 'palabra'=>'absconder'),
array('letra'=>'a', 'palabra'=>'absencia'),
array('letra'=>'a', 'palabra'=>'absenta'),
array('letra'=>'a', 'palabra'=>'absentarse'),
array('letra'=>'a', 'palabra'=>'absente'),
array('letra'=>'a', 'palabra'=>'absentismo'),
array('letra'=>'a', 'palabra'=>'absentista'),
array('letra'=>'a', 'palabra'=>'absida'),
array('letra'=>'a', 'palabra'=>'absidal'),
array('letra'=>'a', 'palabra'=>'abside'),
array('letra'=>'a', 'palabra'=>'absidiolo'),
array('letra'=>'a', 'palabra'=>'absintio'),
array('letra'=>'a', 'palabra'=>'absit'),
array('letra'=>'a', 'palabra'=>'absolucion'),
array('letra'=>'a', 'palabra'=>'absoluta'),
array('letra'=>'a', 'palabra'=>'absolutamente'),
array('letra'=>'a', 'palabra'=>'absolutidad'),
array('letra'=>'a', 'palabra'=>'absolutismo'),
array('letra'=>'a', 'palabra'=>'absolutista'),
array('letra'=>'a', 'palabra'=>'absoluto'),
array('letra'=>'a', 'palabra'=>'absolutorio'),
array('letra'=>'a', 'palabra'=>'absolvederas'),
array('letra'=>'a', 'palabra'=>'absolvedor'),
array('letra'=>'a', 'palabra'=>'absolver'),
array('letra'=>'a', 'palabra'=>'absorbencia'),
array('letra'=>'a', 'palabra'=>'absorbente'),
array('letra'=>'a', 'palabra'=>'absorber'),
array('letra'=>'a', 'palabra'=>'absorbible'),
array('letra'=>'a', 'palabra'=>'absorbimiento'),
array('letra'=>'a', 'palabra'=>'absorciometro'),
array('letra'=>'a', 'palabra'=>'absorcion'),
array('letra'=>'a', 'palabra'=>'absortar'),
array('letra'=>'a', 'palabra'=>'absorto'),
array('letra'=>'a', 'palabra'=>'abstemio'),
array('letra'=>'a', 'palabra'=>'abstencion'),
array('letra'=>'a', 'palabra'=>'abstencionismo'),
array('letra'=>'a', 'palabra'=>'abstencionista'),
array('letra'=>'a', 'palabra'=>'abstener'),
array('letra'=>'a', 'palabra'=>'abstergente'),
array('letra'=>'a', 'palabra'=>'absterger'),
array('letra'=>'a', 'palabra'=>'abstersion'),
array('letra'=>'a', 'palabra'=>'abstersivo'),
array('letra'=>'a', 'palabra'=>'abstinencia'),
array('letra'=>'a', 'palabra'=>'abstinente'),
array('letra'=>'a', 'palabra'=>'abstraccion'),
array('letra'=>'a', 'palabra'=>'abstractivo'),
array('letra'=>'a', 'palabra'=>'abstracto'),
array('letra'=>'a', 'palabra'=>'abstraer'),
array('letra'=>'a', 'palabra'=>'abstraido'),
array('letra'=>'a', 'palabra'=>'abstruso'),
array('letra'=>'a', 'palabra'=>'absuelto'),
array('letra'=>'a', 'palabra'=>'absurdidad'),
array('letra'=>'a', 'palabra'=>'absurdo'),
array('letra'=>'a', 'palabra'=>'abubilla'),
array('letra'=>'a', 'palabra'=>'abubo'),
array('letra'=>'a', 'palabra'=>'abuchear'),
array('letra'=>'a', 'palabra'=>'abucheo'),
array('letra'=>'a', 'palabra'=>'abuela'),
array('letra'=>'a', 'palabra'=>'abuelastro'),
array('letra'=>'a', 'palabra'=>'abuelo'),
array('letra'=>'a', 'palabra'=>'abuhado'),
array('letra'=>'a', 'palabra'=>'abuhamiento'),
array('letra'=>'a', 'palabra'=>'abuhardillado'),
array('letra'=>'a', 'palabra'=>'abujardar'),
array('letra'=>'a', 'palabra'=>'abuje'),
array('letra'=>'a', 'palabra'=>'abulaga'),
array('letra'=>'a', 'palabra'=>'abulagar'),
array('letra'=>'a', 'palabra'=>'abulense'),
array('letra'=>'a', 'palabra'=>'abulia'),
array('letra'=>'a', 'palabra'=>'abulico'),
array('letra'=>'a', 'palabra'=>'abullonar'),
array('letra'=>'a', 'palabra'=>'abulon'),
array('letra'=>'a', 'palabra'=>'abulonar'),
array('letra'=>'a', 'palabra'=>'abultado'),
array('letra'=>'a', 'palabra'=>'abultamiento'),
array('letra'=>'a', 'palabra'=>'abultar'),
array('letra'=>'a', 'palabra'=>'abundado'),
array('letra'=>'a', 'palabra'=>'abundamiento'),
array('letra'=>'a', 'palabra'=>'abundancia'),
array('letra'=>'a', 'palabra'=>'abundancial'),
array('letra'=>'a', 'palabra'=>'abundante'),
array('letra'=>'a', 'palabra'=>'abundantemente'),
array('letra'=>'a', 'palabra'=>'abundar'),
array('letra'=>'a', 'palabra'=>'abundo'),
array('letra'=>'a', 'palabra'=>'abundoso'),
array('letra'=>'a', 'palabra'=>'abuñolado'),
array('letra'=>'a', 'palabra'=>'abuñolar'),
array('letra'=>'a', 'palabra'=>'abuñuelado'),
array('letra'=>'a', 'palabra'=>'abuñuelar'),
array('letra'=>'a', 'palabra'=>'abur'),
array('letra'=>'a', 'palabra'=>'aburar'),
array('letra'=>'a', 'palabra'=>'aburelado'),
array('letra'=>'a', 'palabra'=>'aburguesamiento'),
array('letra'=>'a', 'palabra'=>'aburguesarse'),
array('letra'=>'a', 'palabra'=>'aburrado'),
array('letra'=>'a', 'palabra'=>'aburrarse'),
array('letra'=>'a', 'palabra'=>'aburricion'),
array('letra'=>'a', 'palabra'=>'aburridamente'),
array('letra'=>'a', 'palabra'=>'aburrido'),
array('letra'=>'a', 'palabra'=>'aburridor'),
array('letra'=>'a', 'palabra'=>'aburrimiento'),
array('letra'=>'a', 'palabra'=>'aburrir'),
array('letra'=>'a', 'palabra'=>'aburujar'),
array('letra'=>'a', 'palabra'=>'abusado'),
array('letra'=>'a', 'palabra'=>'abusador'),
array('letra'=>'a', 'palabra'=>'abusar'),
array('letra'=>'a', 'palabra'=>'abusion'),
array('letra'=>'a', 'palabra'=>'abusionero'),
array('letra'=>'a', 'palabra'=>'abusivo'),
array('letra'=>'a', 'palabra'=>'abuso'),
array('letra'=>'a', 'palabra'=>'abuson'),
array('letra'=>'a', 'palabra'=>'abuzarse'),
array('letra'=>'a', 'palabra'=>'abyeccion'),
array('letra'=>'a', 'palabra'=>'abyecto'),
array('letra'=>'a', 'palabra'=>'aca'),
array('letra'=>'a', 'palabra'=>'aca'),
array('letra'=>'a', 'palabra'=>'acabable'),
array('letra'=>'a', 'palabra'=>'acabada'),
array('letra'=>'a', 'palabra'=>'acabadamente'),
array('letra'=>'a', 'palabra'=>'acabado'),
array('letra'=>'a', 'palabra'=>'acabador'),
array('letra'=>'a', 'palabra'=>'acabalar'),
array('letra'=>'a', 'palabra'=>'acaballadero'),
array('letra'=>'a', 'palabra'=>'acaballado'),
array('letra'=>'a', 'palabra'=>'acaballar'),
array('letra'=>'a', 'palabra'=>'acaballerado'),
array('letra'=>'a', 'palabra'=>'acaballerar'),
array('letra'=>'a', 'palabra'=>'acaballonar'),
array('letra'=>'a', 'palabra'=>'acabamiento'),
array('letra'=>'a', 'palabra'=>'acabañar'),
array('letra'=>'a', 'palabra'=>'acabar'),
array('letra'=>'a', 'palabra'=>'acabe'),
array('letra'=>'a', 'palabra'=>'acabellado'),
array('letra'=>'a', 'palabra'=>'acabestrillar'),
array('letra'=>'a', 'palabra'=>'acabijo'),
array('letra'=>'a', 'palabra'=>'acabildar'),
array('letra'=>'a', 'palabra'=>'acabo'),
array('letra'=>'a', 'palabra'=>'acabose'),
array('letra'=>'a', 'palabra'=>'acabronado'),
array('letra'=>'a', 'palabra'=>'acacharse'),
array('letra'=>'a', 'palabra'=>'acachetar'),
array('letra'=>'a', 'palabra'=>'acachetear'),
array('letra'=>'a', 'palabra'=>'acachorrar'),
array('letra'=>'a', 'palabra'=>'acacia'),
array('letra'=>'a', 'palabra'=>'acaciano'),
array('letra'=>'a', 'palabra'=>'academia'),
array('letra'=>'a', 'palabra'=>'academicamente'),
array('letra'=>'a', 'palabra'=>'academicismo'),
array('letra'=>'a', 'palabra'=>'academicista'),
array('letra'=>'a', 'palabra'=>'academico'),
array('letra'=>'a', 'palabra'=>'academio'),
array('letra'=>'a', 'palabra'=>'academista'),
array('letra'=>'a', 'palabra'=>'academizar'),
array('letra'=>'a', 'palabra'=>'acadio'),
array('letra'=>'a', 'palabra'=>'acaecedero'),
array('letra'=>'a', 'palabra'=>'acaecer'),
array('letra'=>'a', 'palabra'=>'acaecimiento'),
array('letra'=>'a', 'palabra'=>'acafresna'),
array('letra'=>'a', 'palabra'=>'acaguasarse'),
array('letra'=>'a', 'palabra'=>'acahual'),
array('letra'=>'a', 'palabra'=>'acairelar'),
array('letra'=>'a', 'palabra'=>'acal'),
array('letra'=>'a', 'palabra'=>'acalabrotar'),
array('letra'=>'a', 'palabra'=>'acalambrar'),
array('letra'=>'a', 'palabra'=>'acaldar'),
array('letra'=>'a', 'palabra'=>'acalefo'),
array('letra'=>'a', 'palabra'=>'acalenturarse'),
array('letra'=>'a', 'palabra'=>'acalia'),
array('letra'=>'a', 'palabra'=>'acallador'),
array('letra'=>'a', 'palabra'=>'acallantar'),
array('letra'=>'a', 'palabra'=>'acallar'),
array('letra'=>'a', 'palabra'=>'acalmar'),
array('letra'=>'a', 'palabra'=>'acaloñar'),
array('letra'=>'a', 'palabra'=>'acaloradamente'),
array('letra'=>'a', 'palabra'=>'acalorado'),
array('letra'=>'a', 'palabra'=>'acaloramiento'),
array('letra'=>'a', 'palabra'=>'acalorar'),
array('letra'=>'a', 'palabra'=>'acalorico'),
array('letra'=>'a', 'palabra'=>'acaloro'),
array('letra'=>'a', 'palabra'=>'acalugar'),
array('letra'=>'a', 'palabra'=>'acalumniador'),
array('letra'=>'a', 'palabra'=>'acalumniar'),
array('letra'=>'a', 'palabra'=>'acamado'),
array('letra'=>'a', 'palabra'=>'acamar'),
array('letra'=>'a', 'palabra'=>'acamaya'),
array('letra'=>'a', 'palabra'=>'acambrayado'),
array('letra'=>'a', 'palabra'=>'acamellado'),
array('letra'=>'a', 'palabra'=>'acamellonar'),
array('letra'=>'a', 'palabra'=>'acampada'),
array('letra'=>'a', 'palabra'=>'acampamento'),
array('letra'=>'a', 'palabra'=>'acampanado'),
array('letra'=>'a', 'palabra'=>'acampanar'),
array('letra'=>'a', 'palabra'=>'acampar'),
array('letra'=>'a', 'palabra'=>'acampo'),
array('letra'=>'a', 'palabra'=>'acamuzado'),
array('letra'=>'a', 'palabra'=>'acana'),
array('letra'=>'a', 'palabra'=>'acanalado'),
array('letra'=>'a', 'palabra'=>'acanalador'),
array('letra'=>'a', 'palabra'=>'acanaladura'),
array('letra'=>'a', 'palabra'=>'acanalar'),
array('letra'=>'a', 'palabra'=>'acanallado'),
array('letra'=>'a', 'palabra'=>'acanallar'),
array('letra'=>'a', 'palabra'=>'acandilado'),
array('letra'=>'a', 'palabra'=>'acanelado'),
array('letra'=>'a', 'palabra'=>'acanelonar'),
array('letra'=>'a', 'palabra'=>'acanillado'),
array('letra'=>'a', 'palabra'=>'acanilladura'),
array('letra'=>'a', 'palabra'=>'acantaceo'),
array('letra'=>'a', 'palabra'=>'acantalear'),
array('letra'=>'a', 'palabra'=>'acantarar'),
array('letra'=>'a', 'palabra'=>'acantear'),
array('letra'=>'a', 'palabra'=>'acantilado'),
array('letra'=>'a', 'palabra'=>'acantilar'),
array('letra'=>'a', 'palabra'=>'acantinflado'),
array('letra'=>'a', 'palabra'=>'acantio'),
array('letra'=>'a', 'palabra'=>'acanto'),
array('letra'=>'a', 'palabra'=>'acantocefalo'),
array('letra'=>'a', 'palabra'=>'acantonamiento'),
array('letra'=>'a', 'palabra'=>'acantonar'),
array('letra'=>'a', 'palabra'=>'acantopterigio'),
array('letra'=>'a', 'palabra'=>'acañaverear'),
array('letra'=>'a', 'palabra'=>'acañonear'),
array('letra'=>'a', 'palabra'=>'acañutado'),
array('letra'=>'a', 'palabra'=>'acaparador'),
array('letra'=>'a', 'palabra'=>'acaparamiento'),
array('letra'=>'a', 'palabra'=>'acaparar'),
array('letra'=>'a', 'palabra'=>'acaparrarse'),
array('letra'=>'a', 'palabra'=>'acaparrosado'),
array('letra'=>'a', 'palabra'=>'acapillar'),
array('letra'=>'a', 'palabra'=>'acapite'),
array('letra'=>'a', 'palabra'=>'acapizarse'),
array('letra'=>'a', 'palabra'=>'acaponado'),
array('letra'=>'a', 'palabra'=>'acapullarse'),
array('letra'=>'a', 'palabra'=>'acapulqueño'),
array('letra'=>'a', 'palabra'=>'acaracolado'),
array('letra'=>'a', 'palabra'=>'acarambanado'),
array('letra'=>'a', 'palabra'=>'acaramelar'),
array('letra'=>'a', 'palabra'=>'acarar'),
array('letra'=>'a', 'palabra'=>'acardenalar'),
array('letra'=>'a', 'palabra'=>'acareamiento'),
array('letra'=>'a', 'palabra'=>'acarear'),
array('letra'=>'a', 'palabra'=>'acariciador'),
array('letra'=>'a', 'palabra'=>'acariciar'),
array('letra'=>'a', 'palabra'=>'acarido'),
array('letra'=>'a', 'palabra'=>'acarminado'),
array('letra'=>'a', 'palabra'=>'acarnerado'),
array('letra'=>'a', 'palabra'=>'acaro'),
array('letra'=>'a', 'palabra'=>'acaronar'),
array('letra'=>'a', 'palabra'=>'acarralado'),
array('letra'=>'a', 'palabra'=>'acarraladura'),
array('letra'=>'a', 'palabra'=>'acarralar'),
array('letra'=>'a', 'palabra'=>'acarrarse'),
array('letra'=>'a', 'palabra'=>'acarrascado'),
array('letra'=>'a', 'palabra'=>'acarrazarse'),
array('letra'=>'a', 'palabra'=>'acarreadizo'),
array('letra'=>'a', 'palabra'=>'acarreador'),
array('letra'=>'a', 'palabra'=>'acarreamiento'),
array('letra'=>'a', 'palabra'=>'acarrear'),
array('letra'=>'a', 'palabra'=>'acarreo'),
array('letra'=>'a', 'palabra'=>'acarretar'),
array('letra'=>'a', 'palabra'=>'acarreto'),
array('letra'=>'a', 'palabra'=>'acartonarse'),
array('letra'=>'a', 'palabra'=>'acasamatado'),
array('letra'=>'a', 'palabra'=>'acasarado'),
array('letra'=>'a', 'palabra'=>'acaserarse'),
array('letra'=>'a', 'palabra'=>'acaso'),
array('letra'=>'a', 'palabra'=>'acastañado'),
array('letra'=>'a', 'palabra'=>'acastillado'),
array('letra'=>'a', 'palabra'=>'acastorado'),
array('letra'=>'a', 'palabra'=>'acatable'),
array('letra'=>'a', 'palabra'=>'acatadamente'),
array('letra'=>'a', 'palabra'=>'acatadura'),
array('letra'=>'a', 'palabra'=>'acatalectico'),
array('letra'=>'a', 'palabra'=>'acatalecto'),
array('letra'=>'a', 'palabra'=>'acatamiento'),
array('letra'=>'a', 'palabra'=>'acatanca'),
array('letra'=>'a', 'palabra'=>'acatar'),
array('letra'=>'a', 'palabra'=>'acatarrar'),
array('letra'=>'a', 'palabra'=>'acates'),
array('letra'=>'a', 'palabra'=>'acato'),
array('letra'=>'a', 'palabra'=>'acatolico'),
array('letra'=>'a', 'palabra'=>'acaudalado'),
array('letra'=>'a', 'palabra'=>'acaudalador'),
array('letra'=>'a', 'palabra'=>'acaudalar'),
array('letra'=>'a', 'palabra'=>'acaudillador'),
array('letra'=>'a', 'palabra'=>'acaudillamiento'),
array('letra'=>'a', 'palabra'=>'acaudillar'),
array('letra'=>'a', 'palabra'=>'acaule'),
array('letra'=>'a', 'palabra'=>'acautelarse'),
array('letra'=>'a', 'palabra'=>'acceder'),
array('letra'=>'a', 'palabra'=>'accesibilidad'),
array('letra'=>'a', 'palabra'=>'accesible'),
array('letra'=>'a', 'palabra'=>'accesion'),
array('letra'=>'a', 'palabra'=>'accesional'),
array('letra'=>'a', 'palabra'=>'accesit'),
array('letra'=>'a', 'palabra'=>'acceso'),
array('letra'=>'a', 'palabra'=>'accesoria'),
array('letra'=>'a', 'palabra'=>'accesoriamente'),
array('letra'=>'a', 'palabra'=>'accesorio'),
array('letra'=>'a', 'palabra'=>'accidentabilidad'),
array('letra'=>'a', 'palabra'=>'accidentadamente'),
array('letra'=>'a', 'palabra'=>'accidentado'),
array('letra'=>'a', 'palabra'=>'accidental'),
array('letra'=>'a', 'palabra'=>'accidentalidad'),
array('letra'=>'a', 'palabra'=>'accidentalmente'),
array('letra'=>'a', 'palabra'=>'accidentar'),
array('letra'=>'a', 'palabra'=>'accidentariamente'),
array('letra'=>'a', 'palabra'=>'accidentario'),
array('letra'=>'a', 'palabra'=>'accidente'),
array('letra'=>'a', 'palabra'=>'accion'),
array('letra'=>'a', 'palabra'=>'accionado'),
array('letra'=>'a', 'palabra'=>'accionamiento'),
array('letra'=>'a', 'palabra'=>'accionar'),
array('letra'=>'a', 'palabra'=>'accionariado'),
array('letra'=>'a', 'palabra'=>'accionarial'),
array('letra'=>'a', 'palabra'=>'accionario'),
array('letra'=>'a', 'palabra'=>'accionista'),
array('letra'=>'a', 'palabra'=>'accitano'),
array('letra'=>'a', 'palabra'=>'acebadamiento'),
array('letra'=>'a', 'palabra'=>'acebadar'),
array('letra'=>'a', 'palabra'=>'acebal'),
array('letra'=>'a', 'palabra'=>'acebeda'),
array('letra'=>'a', 'palabra'=>'acebedo'),
array('letra'=>'a', 'palabra'=>'acebibe'),
array('letra'=>'a', 'palabra'=>'acebo'),
array('letra'=>'a', 'palabra'=>'acebollado'),
array('letra'=>'a', 'palabra'=>'acebolladura'),
array('letra'=>'a', 'palabra'=>'acebrado'),
array('letra'=>'a', 'palabra'=>'acebuchal'),
array('letra'=>'a', 'palabra'=>'acebuche'),
array('letra'=>'a', 'palabra'=>'acebucheno'),
array('letra'=>'a', 'palabra'=>'acebuchina'),
array('letra'=>'a', 'palabra'=>'acechadera'),
array('letra'=>'a', 'palabra'=>'acechadero'),
array('letra'=>'a', 'palabra'=>'acechador'),
array('letra'=>'a', 'palabra'=>'acechamiento'),
array('letra'=>'a', 'palabra'=>'acechanza'),
array('letra'=>'a', 'palabra'=>'acechar'),
array('letra'=>'a', 'palabra'=>'aceche'),
array('letra'=>'a', 'palabra'=>'acecho'),
array('letra'=>'a', 'palabra'=>'acechon'),
array('letra'=>'a', 'palabra'=>'acecido'),
array('letra'=>'a', 'palabra'=>'acecinar'),
array('letra'=>'a', 'palabra'=>'acedamente'),
array('letra'=>'a', 'palabra'=>'acedar'),
array('letra'=>'a', 'palabra'=>'acedera'),
array('letra'=>'a', 'palabra'=>'acederaque'),
array('letra'=>'a', 'palabra'=>'acederilla'),
array('letra'=>'a', 'palabra'=>'acederon'),
array('letra'=>'a', 'palabra'=>'acedia'),
array('letra'=>'a', 'palabra'=>'acedia'),
array('letra'=>'a', 'palabra'=>'acedo'),
array('letra'=>'a', 'palabra'=>'acedura'),
array('letra'=>'a', 'palabra'=>'acefalia'),
array('letra'=>'a', 'palabra'=>'acefalia'),
array('letra'=>'a', 'palabra'=>'acefalismo'),
array('letra'=>'a', 'palabra'=>'acefalo'),
array('letra'=>'a', 'palabra'=>'aceifa'),
array('letra'=>'a', 'palabra'=>'aceitada'),
array('letra'=>'a', 'palabra'=>'aceitar'),
array('letra'=>'a', 'palabra'=>'aceitazo'),
array('letra'=>'a', 'palabra'=>'aceite'),
array('letra'=>'a', 'palabra'=>'aceitera'),
array('letra'=>'a', 'palabra'=>'aceiteria'),
array('letra'=>'a', 'palabra'=>'aceitero'),
array('letra'=>'a', 'palabra'=>'aceiton'),
array('letra'=>'a', 'palabra'=>'aceitoso'),
array('letra'=>'a', 'palabra'=>'aceituna'),
array('letra'=>'a', 'palabra'=>'aceitunado'),
array('letra'=>'a', 'palabra'=>'aceitunero'),
array('letra'=>'a', 'palabra'=>'aceituni'),
array('letra'=>'a', 'palabra'=>'aceitunil'),
array('letra'=>'a', 'palabra'=>'aceitunillo'),
array('letra'=>'a', 'palabra'=>'aceituno'),
array('letra'=>'a', 'palabra'=>'acejero'),
array('letra'=>'a', 'palabra'=>'acelajado'),
array('letra'=>'a', 'palabra'=>'aceleracion'),
array('letra'=>'a', 'palabra'=>'acelerada'),
array('letra'=>'a', 'palabra'=>'aceleradamente'),
array('letra'=>'a', 'palabra'=>'acelerado'),
array('letra'=>'a', 'palabra'=>'acelerador'),
array('letra'=>'a', 'palabra'=>'aceleramiento'),
array('letra'=>'a', 'palabra'=>'acelerar'),
array('letra'=>'a', 'palabra'=>'aceleratriz'),
array('letra'=>'a', 'palabra'=>'acelerometro'),
array('letra'=>'a', 'palabra'=>'aceleron'),
array('letra'=>'a', 'palabra'=>'acelga'),
array('letra'=>'a', 'palabra'=>'acemila'),
array('letra'=>'a', 'palabra'=>'acemilado'),
array('letra'=>'a', 'palabra'=>'acemilar'),
array('letra'=>'a', 'palabra'=>'acemileria'),
array('letra'=>'a', 'palabra'=>'acemilero'),
array('letra'=>'a', 'palabra'=>'acemita'),
array('letra'=>'a', 'palabra'=>'acemite'),
array('letra'=>'a', 'palabra'=>'acender'),
array('letra'=>'a', 'palabra'=>'acendrado'),
array('letra'=>'a', 'palabra'=>'acendramiento'),
array('letra'=>'a', 'palabra'=>'acendrar'),
array('letra'=>'a', 'palabra'=>'acenefa'),
array('letra'=>'a', 'palabra'=>'acenoria'),
array('letra'=>'a', 'palabra'=>'acensar'),
array('letra'=>'a', 'palabra'=>'acensuador'),
array('letra'=>'a', 'palabra'=>'acensuar'),
array('letra'=>'a', 'palabra'=>'acento'),
array('letra'=>'a', 'palabra'=>'acentuacion'),
array('letra'=>'a', 'palabra'=>'acentuadamente'),
array('letra'=>'a', 'palabra'=>'acentual'),
array('letra'=>'a', 'palabra'=>'acentuar'),
array('letra'=>'a', 'palabra'=>'aceña'),
array('letra'=>'a', 'palabra'=>'aceñero'),
array('letra'=>'a', 'palabra'=>'acepar'),
array('letra'=>'a', 'palabra'=>'acepcion'),
array('letra'=>'a', 'palabra'=>'acepilladura'),
array('letra'=>'a', 'palabra'=>'acepillar'),
array('letra'=>'a', 'palabra'=>'aceptabilidad'),
array('letra'=>'a', 'palabra'=>'aceptable'),
array('letra'=>'a', 'palabra'=>'aceptacion'),
array('letra'=>'a', 'palabra'=>'aceptadamente'),
array('letra'=>'a', 'palabra'=>'aceptador'),
array('letra'=>'a', 'palabra'=>'aceptar'),
array('letra'=>'a', 'palabra'=>'acepto'),
array('letra'=>'a', 'palabra'=>'aceptor'),
array('letra'=>'a', 'palabra'=>'acequia'),
array('letra'=>'a', 'palabra'=>'acequiaje'),
array('letra'=>'a', 'palabra'=>'acequiar'),
array('letra'=>'a', 'palabra'=>'acequiero'),
array('letra'=>'a', 'palabra'=>'acera'),
array('letra'=>'a', 'palabra'=>'aceraceo'),
array('letra'=>'a', 'palabra'=>'aceracion'),
array('letra'=>'a', 'palabra'=>'acerado'),
array('letra'=>'a', 'palabra'=>'acerar'),
array('letra'=>'a', 'palabra'=>'acerbamente'),
array('letra'=>'a', 'palabra'=>'acerbidad'),
array('letra'=>'a', 'palabra'=>'acerbo'),
array('letra'=>'a', 'palabra'=>'acerca'),
array('letra'=>'a', 'palabra'=>'acercador'),
array('letra'=>'a', 'palabra'=>'acercamiento'),
array('letra'=>'a', 'palabra'=>'acercanza'),
array('letra'=>'a', 'palabra'=>'acercar'),
array('letra'=>'a', 'palabra'=>'acere'),
array('letra'=>'a', 'palabra'=>'acereria'),
array('letra'=>'a', 'palabra'=>'aceria'),
array('letra'=>'a', 'palabra'=>'acerico'),
array('letra'=>'a', 'palabra'=>'acerillo'),
array('letra'=>'a', 'palabra'=>'acerineo'),
array('letra'=>'a', 'palabra'=>'acerino'),
array('letra'=>'a', 'palabra'=>'acerista'),
array('letra'=>'a', 'palabra'=>'acernadar'),
array('letra'=>'a', 'palabra'=>'acero'),
array('letra'=>'a', 'palabra'=>'acerola'),
array('letra'=>'a', 'palabra'=>'acerolo'),
array('letra'=>'a', 'palabra'=>'acerrimo'),
array('letra'=>'a', 'palabra'=>'acerrojar'),
array('letra'=>'a', 'palabra'=>'acertado'),
array('letra'=>'a', 'palabra'=>'acertador'),
array('letra'=>'a', 'palabra'=>'acertajo'),
array('letra'=>'a', 'palabra'=>'acertajon'),
array('letra'=>'a', 'palabra'=>'acertamiento'),
array('letra'=>'a', 'palabra'=>'acertante'),
array('letra'=>'a', 'palabra'=>'acertar'),
array('letra'=>'a', 'palabra'=>'acertero'),
array('letra'=>'a', 'palabra'=>'acertijo'),
array('letra'=>'a', 'palabra'=>'aceruelo'),
array('letra'=>'a', 'palabra'=>'acervar'),
array('letra'=>'a', 'palabra'=>'acervo'),
array('letra'=>'a', 'palabra'=>'acescencia'),
array('letra'=>'a', 'palabra'=>'acescente'),
array('letra'=>'a', 'palabra'=>'acetabulo'),
array('letra'=>'a', 'palabra'=>'acetal'),
array('letra'=>'a', 'palabra'=>'acetaldehido'),
array('letra'=>'a', 'palabra'=>'acetar'),
array('letra'=>'a', 'palabra'=>'acetato'),
array('letra'=>'a', 'palabra'=>'acetico'),
array('letra'=>'a', 'palabra'=>'acetificacion'),
array('letra'=>'a', 'palabra'=>'acetificador'),
array('letra'=>'a', 'palabra'=>'acetificar'),
array('letra'=>'a', 'palabra'=>'acetileno'),
array('letra'=>'a', 'palabra'=>'acetilo'),
array('letra'=>'a', 'palabra'=>'acetimetria'),
array('letra'=>'a', 'palabra'=>'acetimetro'),
array('letra'=>'a', 'palabra'=>'acetin'),
array('letra'=>'a', 'palabra'=>'acetite'),
array('letra'=>'a', 'palabra'=>'aceto'),
array('letra'=>'a', 'palabra'=>'acetona'),
array('letra'=>'a', 'palabra'=>'acetosa'),
array('letra'=>'a', 'palabra'=>'acetosidad'),
array('letra'=>'a', 'palabra'=>'acetosilla'),
array('letra'=>'a', 'palabra'=>'acetoso'),
array('letra'=>'a', 'palabra'=>'acetre'),
array('letra'=>'a', 'palabra'=>'acetreria'),
array('letra'=>'a', 'palabra'=>'acetrero'),
array('letra'=>'a', 'palabra'=>'acetrinar'),
array('letra'=>'a', 'palabra'=>'acevilar'),
array('letra'=>'a', 'palabra'=>'acezante'),
array('letra'=>'a', 'palabra'=>'acezar'),
array('letra'=>'a', 'palabra'=>'acezo'),
array('letra'=>'a', 'palabra'=>'acezoso'),
array('letra'=>'a', 'palabra'=>'achabacanamiento'),
array('letra'=>'a', 'palabra'=>'achabacanar'),
array('letra'=>'a', 'palabra'=>'achacable'),
array('letra'=>'a', 'palabra'=>'achacar'),
array('letra'=>'a', 'palabra'=>'achachairu'),
array('letra'=>'a', 'palabra'=>'achachay'),
array('letra'=>'a', 'palabra'=>'achacoso'),
array('letra'=>'a', 'palabra'=>'achaflanar'),
array('letra'=>'a', 'palabra'=>'achajuanado'),
array('letra'=>'a', 'palabra'=>'achajuanarse'),
array('letra'=>'a', 'palabra'=>'achalay'),
array('letra'=>'a', 'palabra'=>'achambergado'),
array('letra'=>'a', 'palabra'=>'achampanado'),
array('letra'=>'a', 'palabra'=>'achampañado'),
array('letra'=>'a', 'palabra'=>'achancar'),
array('letra'=>'a', 'palabra'=>'achantar'),
array('letra'=>'a', 'palabra'=>'achaparrado'),
array('letra'=>'a', 'palabra'=>'achaparrarse'),
array('letra'=>'a', 'palabra'=>'achaplinarse'),
array('letra'=>'a', 'palabra'=>'achaque'),
array('letra'=>'a', 'palabra'=>'achaquero'),
array('letra'=>'a', 'palabra'=>'achaquiento'),
array('letra'=>'a', 'palabra'=>'achara'),
array('letra'=>'a', 'palabra'=>'achara'),
array('letra'=>'a', 'palabra'=>'acharar'),
array('letra'=>'a', 'palabra'=>'achares'),
array('letra'=>'a', 'palabra'=>'acharolado'),
array('letra'=>'a', 'palabra'=>'acharolar'),
array('letra'=>'a', 'palabra'=>'achatamiento'),
array('letra'=>'a', 'palabra'=>'achatar'),
array('letra'=>'a', 'palabra'=>'achicado'),
array('letra'=>'a', 'palabra'=>'achicador'),
array('letra'=>'a', 'palabra'=>'achicadura'),
array('letra'=>'a', 'palabra'=>'achicamiento'),
array('letra'=>'a', 'palabra'=>'achicar'),
array('letra'=>'a', 'palabra'=>'achicharradero'),
array('letra'=>'a', 'palabra'=>'achicharramiento'),
array('letra'=>'a', 'palabra'=>'achicharrar'),
array('letra'=>'a', 'palabra'=>'achicharronar'),
array('letra'=>'a', 'palabra'=>'achichincle'),
array('letra'=>'a', 'palabra'=>'achichinque'),
array('letra'=>'a', 'palabra'=>'achicoria'),
array('letra'=>'a', 'palabra'=>'achiguarse'),
array('letra'=>'a', 'palabra'=>'achin'),
array('letra'=>'a', 'palabra'=>'achinado'),
array('letra'=>'a', 'palabra'=>'achinar'),
array('letra'=>'a', 'palabra'=>'achinelado'),
array('letra'=>'a', 'palabra'=>'achineria'),
array('letra'=>'a', 'palabra'=>'achinero'),
array('letra'=>'a', 'palabra'=>'achiotal'),
array('letra'=>'a', 'palabra'=>'achiote'),
array('letra'=>'a', 'palabra'=>'achiotero'),
array('letra'=>'a', 'palabra'=>'achiotillo'),
array('letra'=>'a', 'palabra'=>'achique'),
array('letra'=>'a', 'palabra'=>'achique'),
array('letra'=>'a', 'palabra'=>'achiquillado'),
array('letra'=>'a', 'palabra'=>'achiquitar'),
array('letra'=>'a', 'palabra'=>'achira'),
array('letra'=>'a', 'palabra'=>'achis'),
array('letra'=>'a', 'palabra'=>'achispar'),
array('letra'=>'a', 'palabra'=>'achitabla'),
array('letra'=>'a', 'palabra'=>'achocadura'),
array('letra'=>'a', 'palabra'=>'achocar'),
array('letra'=>'a', 'palabra'=>'achocharse'),
array('letra'=>'a', 'palabra'=>'achocolatado'),
array('letra'=>'a', 'palabra'=>'achogcha'),
array('letra'=>'a', 'palabra'=>'achojcha'),
array('letra'=>'a', 'palabra'=>'acholado'),
array('letra'=>'a', 'palabra'=>'acholar'),
array('letra'=>'a', 'palabra'=>'acholole'),
array('letra'=>'a', 'palabra'=>'achololera'),
array('letra'=>'a', 'palabra'=>'achoque'),
array('letra'=>'a', 'palabra'=>'achote'),
array('letra'=>'a', 'palabra'=>'achubascarse'),
array('letra'=>'a', 'palabra'=>'achuchado'),
array('letra'=>'a', 'palabra'=>'achuchar'),
array('letra'=>'a', 'palabra'=>'achucharrar'),
array('letra'=>'a', 'palabra'=>'achuchon'),
array('letra'=>'a', 'palabra'=>'achucuyar'),
array('letra'=>'a', 'palabra'=>'achuela'),
array('letra'=>'a', 'palabra'=>'achulado'),
array('letra'=>'a', 'palabra'=>'achulaparse'),
array('letra'=>'a', 'palabra'=>'achularse'),
array('letra'=>'a', 'palabra'=>'achuma'),
array('letra'=>'a', 'palabra'=>'achunchar'),
array('letra'=>'a', 'palabra'=>'achuntar'),
array('letra'=>'a', 'palabra'=>'achupalla'),
array('letra'=>'a', 'palabra'=>'achura'),
array('letra'=>'a', 'palabra'=>'achurar'),
array('letra'=>'a', 'palabra'=>'aciago'),
array('letra'=>'a', 'palabra'=>'acial'),
array('letra'=>'a', 'palabra'=>'aciano'),
array('letra'=>'a', 'palabra'=>'acianos'),
array('letra'=>'a', 'palabra'=>'aciar'),
array('letra'=>'a', 'palabra'=>'acibar'),
array('letra'=>'a', 'palabra'=>'acibarar'),
array('letra'=>'a', 'palabra'=>'acibarrar'),
array('letra'=>'a', 'palabra'=>'aciberar'),
array('letra'=>'a', 'palabra'=>'acicalado'),
array('letra'=>'a', 'palabra'=>'acicalador'),
array('letra'=>'a', 'palabra'=>'acicaladura'),
array('letra'=>'a', 'palabra'=>'acicalamiento'),
array('letra'=>'a', 'palabra'=>'acicalar'),
array('letra'=>'a', 'palabra'=>'acicate'),
array('letra'=>'a', 'palabra'=>'acicatear'),
array('letra'=>'a', 'palabra'=>'aciche'),
array('letra'=>'a', 'palabra'=>'acicular'),
array('letra'=>'a', 'palabra'=>'acidalio'),
array('letra'=>'a', 'palabra'=>'acidaque'),
array('letra'=>'a', 'palabra'=>'acidez'),
array('letra'=>'a', 'palabra'=>'acidia'),
array('letra'=>'a', 'palabra'=>'acidificar'),
array('letra'=>'a', 'palabra'=>'acidimetria'),
array('letra'=>'a', 'palabra'=>'acidimetro'),
array('letra'=>'a', 'palabra'=>'acidioso'),
array('letra'=>'a', 'palabra'=>'acido'),
array('letra'=>'a', 'palabra'=>'acidorresistente'),
array('letra'=>'a', 'palabra'=>'acidosis'),
array('letra'=>'a', 'palabra'=>'acidular'),
array('letra'=>'a', 'palabra'=>'acidulo'),
array('letra'=>'a', 'palabra'=>'aciemar'),
array('letra'=>'a', 'palabra'=>'acientifico'),
array('letra'=>'a', 'palabra'=>'acierto'),
array('letra'=>'a', 'palabra'=>'acigos'),
array('letra'=>'a', 'palabra'=>'aciguatado'),
array('letra'=>'a', 'palabra'=>'aciguatar'),
array('letra'=>'a', 'palabra'=>'aciguatarse'),
array('letra'=>'a', 'palabra'=>'acijado'),
array('letra'=>'a', 'palabra'=>'acije'),
array('letra'=>'a', 'palabra'=>'acijoso'),
array('letra'=>'a', 'palabra'=>'acilo'),
array('letra'=>'a', 'palabra'=>'acimboga'),
array('letra'=>'a', 'palabra'=>'acimentarse'),
array('letra'=>'a', 'palabra'=>'acimo'),
array('letra'=>'a', 'palabra'=>'acimut'),
array('letra'=>'a', 'palabra'=>'acimutal'),
array('letra'=>'a', 'palabra'=>'acinesia'),
array('letra'=>'a', 'palabra'=>'acinturar'),
array('letra'=>'a', 'palabra'=>'acion'),
array('letra'=>'a', 'palabra'=>'acionera'),
array('letra'=>'a', 'palabra'=>'acionero'),
array('letra'=>'a', 'palabra'=>'acipado'),
array('letra'=>'a', 'palabra'=>'acipres'),
array('letra'=>'a', 'palabra'=>'acirate'),
array('letra'=>'a', 'palabra'=>'aciron'),
array('letra'=>'a', 'palabra'=>'acitara'),
array('letra'=>'a', 'palabra'=>'acitron'),
array('letra'=>'a', 'palabra'=>'acivilar'),
array('letra'=>'a', 'palabra'=>'aclamacion'),
array('letra'=>'a', 'palabra'=>'aclamador'),
array('letra'=>'a', 'palabra'=>'aclamar'),
array('letra'=>'a', 'palabra'=>'aclamideo'),
array('letra'=>'a', 'palabra'=>'aclaracion'),
array('letra'=>'a', 'palabra'=>'aclarado'),
array('letra'=>'a', 'palabra'=>'aclarador'),
array('letra'=>'a', 'palabra'=>'aclarar'),
array('letra'=>'a', 'palabra'=>'aclaratorio'),
array('letra'=>'a', 'palabra'=>'aclarecer'),
array('letra'=>'a', 'palabra'=>'aclareo'),
array('letra'=>'a', 'palabra'=>'aclavelado'),
array('letra'=>'a', 'palabra'=>'acle'),
array('letra'=>'a', 'palabra'=>'acleido'),
array('letra'=>'a', 'palabra'=>'aclimatable'),
array('letra'=>'a', 'palabra'=>'aclimatacion'),
array('letra'=>'a', 'palabra'=>'aclimatar'),
array('letra'=>'a', 'palabra'=>'aclla'),
array('letra'=>'a', 'palabra'=>'aclocar'),
array('letra'=>'a', 'palabra'=>'aclorhidria'),
array('letra'=>'a', 'palabra'=>'aclorhidrico'),
array('letra'=>'a', 'palabra'=>'acme'),
array('letra'=>'a', 'palabra'=>'acne'),
array('letra'=>'a', 'palabra'=>'acne'),
array('letra'=>'a', 'palabra'=>'acobardamiento'),
array('letra'=>'a', 'palabra'=>'acobardar'),
array('letra'=>'a', 'palabra'=>'acobijar'),
array('letra'=>'a', 'palabra'=>'acobijo'),
array('letra'=>'a', 'palabra'=>'acobrado'),
array('letra'=>'a', 'palabra'=>'acocarse'),
array('letra'=>'a', 'palabra'=>'acoceador'),
array('letra'=>'a', 'palabra'=>'acoceamiento'),
array('letra'=>'a', 'palabra'=>'acocear'),
array('letra'=>'a', 'palabra'=>'acochambrar'),
array('letra'=>'a', 'palabra'=>'acocharse'),
array('letra'=>'a', 'palabra'=>'acochinar'),
array('letra'=>'a', 'palabra'=>'acocil'),
array('letra'=>'a', 'palabra'=>'acoclarse'),
array('letra'=>'a', 'palabra'=>'acocotar'),
array('letra'=>'a', 'palabra'=>'acocote'),
array('letra'=>'a', 'palabra'=>'acodado'),
array('letra'=>'a', 'palabra'=>'acodadura'),
array('letra'=>'a', 'palabra'=>'acodalamiento'),
array('letra'=>'a', 'palabra'=>'acodalar'),
array('letra'=>'a', 'palabra'=>'acodar'),
array('letra'=>'a', 'palabra'=>'acoderamiento'),
array('letra'=>'a', 'palabra'=>'acoderar'),
array('letra'=>'a', 'palabra'=>'acodiciar'),
array('letra'=>'a', 'palabra'=>'acodillado'),
array('letra'=>'a', 'palabra'=>'acodillar'),
array('letra'=>'a', 'palabra'=>'acodo'),
array('letra'=>'a', 'palabra'=>'acogedizo'),
array('letra'=>'a', 'palabra'=>'acogedor'),
array('letra'=>'a', 'palabra'=>'acoger'),
array('letra'=>'a', 'palabra'=>'acogeta'),
array('letra'=>'a', 'palabra'=>'acogido'),
array('letra'=>'a', 'palabra'=>'acogimiento'),
array('letra'=>'a', 'palabra'=>'acogollar'),
array('letra'=>'a', 'palabra'=>'acogombradura'),
array('letra'=>'a', 'palabra'=>'acogombrar'),
array('letra'=>'a', 'palabra'=>'acogotar'),
array('letra'=>'a', 'palabra'=>'acogullado'),
array('letra'=>'a', 'palabra'=>'acohombrar'),
array('letra'=>'a', 'palabra'=>'acoitar'),
array('letra'=>'a', 'palabra'=>'acojinamiento'),
array('letra'=>'a', 'palabra'=>'acojinar'),
array('letra'=>'a', 'palabra'=>'acojonar'),
array('letra'=>'a', 'palabra'=>'acolada'),
array('letra'=>'a', 'palabra'=>'acolar'),
array('letra'=>'a', 'palabra'=>'acolchado'),
array('letra'=>'a', 'palabra'=>'acolchar'),
array('letra'=>'a', 'palabra'=>'acolchonar'),
array('letra'=>'a', 'palabra'=>'acolgar'),
array('letra'=>'a', 'palabra'=>'acolitado'),
array('letra'=>'a', 'palabra'=>'acolitar'),
array('letra'=>'a', 'palabra'=>'acolito'),
array('letra'=>'a', 'palabra'=>'acollador'),
array('letra'=>'a', 'palabra'=>'acollar'),
array('letra'=>'a', 'palabra'=>'acollarado'),
array('letra'=>'a', 'palabra'=>'acollaramiento'),
array('letra'=>'a', 'palabra'=>'acollarar'),
array('letra'=>'a', 'palabra'=>'acollonar'),
array('letra'=>'a', 'palabra'=>'acolmillado'),
array('letra'=>'a', 'palabra'=>'acombar'),
array('letra'=>'a', 'palabra'=>'acomedido'),
array('letra'=>'a', 'palabra'=>'acomedirse'),
array('letra'=>'a', 'palabra'=>'acomendar'),
array('letra'=>'a', 'palabra'=>'acometedor'),
array('letra'=>'a', 'palabra'=>'acometer'),
array('letra'=>'a', 'palabra'=>'acometida'),
array('letra'=>'a', 'palabra'=>'acometimiento'),
array('letra'=>'a', 'palabra'=>'acometividad'),
array('letra'=>'a', 'palabra'=>'acomodable'),
array('letra'=>'a', 'palabra'=>'acomodacion'),
array('letra'=>'a', 'palabra'=>'acomodadamente'),
array('letra'=>'a', 'palabra'=>'acomodadizo'),
array('letra'=>'a', 'palabra'=>'acomodado'),
array('letra'=>'a', 'palabra'=>'acomodador'),
array('letra'=>'a', 'palabra'=>'acomodamiento'),
array('letra'=>'a', 'palabra'=>'acomodar'),
array('letra'=>'a', 'palabra'=>'acomodaticio'),
array('letra'=>'a', 'palabra'=>'acomodo'),
array('letra'=>'a', 'palabra'=>'acompañado'),
array('letra'=>'a', 'palabra'=>'acompañador'),
array('letra'=>'a', 'palabra'=>'acompañamiento'),
array('letra'=>'a', 'palabra'=>'acompañanta'),
array('letra'=>'a', 'palabra'=>'acompañante'),
array('letra'=>'a', 'palabra'=>'acompañar'),
array('letra'=>'a', 'palabra'=>'acompasado'),
array('letra'=>'a', 'palabra'=>'acompasar'),
array('letra'=>'a', 'palabra'=>'acomplejado'),
array('letra'=>'a', 'palabra'=>'acomplejamiento'),
array('letra'=>'a', 'palabra'=>'acomplejar'),
array('letra'=>'a', 'palabra'=>'acomplexionado'),
array('letra'=>'a', 'palabra'=>'acomunalar'),
array('letra'=>'a', 'palabra'=>'acomunar'),
array('letra'=>'a', 'palabra'=>'aconcagüino'),
array('letra'=>'a', 'palabra'=>'aconchabarse'),
array('letra'=>'a', 'palabra'=>'aconchadillo'),
array('letra'=>'a', 'palabra'=>'aconchar'),
array('letra'=>'a', 'palabra'=>'aconcharse'),
array('letra'=>'a', 'palabra'=>'acondicionado'),
array('letra'=>'a', 'palabra'=>'acondicionador'),
array('letra'=>'a', 'palabra'=>'acondicionamiento'),
array('letra'=>'a', 'palabra'=>'acondicionar'),
array('letra'=>'a', 'palabra'=>'acondroplasia'),
array('letra'=>'a', 'palabra'=>'acondroplasico'),
array('letra'=>'a', 'palabra'=>'aconduchar'),
array('letra'=>'a', 'palabra'=>'aconfesional'),
array('letra'=>'a', 'palabra'=>'acongojadamente'),
array('letra'=>'a', 'palabra'=>'acongojador'),
array('letra'=>'a', 'palabra'=>'acongojar'),
array('letra'=>'a', 'palabra'=>'aconhortar'),
array('letra'=>'a', 'palabra'=>'aconitina'),
array('letra'=>'a', 'palabra'=>'aconito'),
array('letra'=>'a', 'palabra'=>'aconsejable'),
array('letra'=>'a', 'palabra'=>'aconsejado'),
array('letra'=>'a', 'palabra'=>'aconsejador'),
array('letra'=>'a', 'palabra'=>'aconsejar'),
array('letra'=>'a', 'palabra'=>'aconsonantar'),
array('letra'=>'a', 'palabra'=>'acontar'),
array('letra'=>'a', 'palabra'=>'acontecedero'),
array('letra'=>'a', 'palabra'=>'acontecer'),
array('letra'=>'a', 'palabra'=>'acontecido'),
array('letra'=>'a', 'palabra'=>'acontecimiento'),
array('letra'=>'a', 'palabra'=>'acontiado'),
array('letra'=>'a', 'palabra'=>'acopado'),
array('letra'=>'a', 'palabra'=>'acopar'),
array('letra'=>'a', 'palabra'=>'acopetado'),
array('letra'=>'a', 'palabra'=>'acopiador'),
array('letra'=>'a', 'palabra'=>'acopiamiento'),
array('letra'=>'a', 'palabra'=>'acopiar'),
array('letra'=>'a', 'palabra'=>'acopio'),
array('letra'=>'a', 'palabra'=>'acoplado'),
array('letra'=>'a', 'palabra'=>'acoplador'),
array('letra'=>'a', 'palabra'=>'acopladura'),
array('letra'=>'a', 'palabra'=>'acoplamiento'),
array('letra'=>'a', 'palabra'=>'acoplar'),
array('letra'=>'a', 'palabra'=>'acople'),
array('letra'=>'a', 'palabra'=>'acoquinamiento'),
array('letra'=>'a', 'palabra'=>'acoquinar'),
array('letra'=>'a', 'palabra'=>'acorar'),
array('letra'=>'a', 'palabra'=>'acorazada'),
array('letra'=>'a', 'palabra'=>'acorazado'),
array('letra'=>'a', 'palabra'=>'acorazamiento'),
array('letra'=>'a', 'palabra'=>'acorazar'),
array('letra'=>'a', 'palabra'=>'acorazonado'),
array('letra'=>'a', 'palabra'=>'acorchado'),
array('letra'=>'a', 'palabra'=>'acorchamiento'),
array('letra'=>'a', 'palabra'=>'acorcharse'),
array('letra'=>'a', 'palabra'=>'acordacion'),
array('letra'=>'a', 'palabra'=>'acordada'),
array('letra'=>'a', 'palabra'=>'acordadamente'),
array('letra'=>'a', 'palabra'=>'acordado'),
array('letra'=>'a', 'palabra'=>'acordamiento'),
array('letra'=>'a', 'palabra'=>'acordante'),
array('letra'=>'a', 'palabra'=>'acordanza'),
array('letra'=>'a', 'palabra'=>'acordar'),
array('letra'=>'a', 'palabra'=>'acorde'),
array('letra'=>'a', 'palabra'=>'acordelar'),
array('letra'=>'a', 'palabra'=>'acordemente'),
array('letra'=>'a', 'palabra'=>'acordeon'),
array('letra'=>'a', 'palabra'=>'acordeonista'),
array('letra'=>'a', 'palabra'=>'acordonado'),
array('letra'=>'a', 'palabra'=>'acordonamiento'),
array('letra'=>'a', 'palabra'=>'acordonar'),
array('letra'=>'a', 'palabra'=>'acores'),
array('letra'=>'a', 'palabra'=>'acornado'),
array('letra'=>'a', 'palabra'=>'acornar'),
array('letra'=>'a', 'palabra'=>'acorneador'),
array('letra'=>'a', 'palabra'=>'acornear'),
array('letra'=>'a', 'palabra'=>'acoro'),
array('letra'=>'a', 'palabra'=>'acorralamiento'),
array('letra'=>'a', 'palabra'=>'acorralar'),
array('letra'=>'a', 'palabra'=>'acorredor'),
array('letra'=>'a', 'palabra'=>'acorrer'),
array('letra'=>'a', 'palabra'=>'acorrimiento'),
array('letra'=>'a', 'palabra'=>'acorro'),
array('letra'=>'a', 'palabra'=>'acorrucarse'),
array('letra'=>'a', 'palabra'=>'acortamiento'),
array('letra'=>'a', 'palabra'=>'acortar'),
array('letra'=>'a', 'palabra'=>'acortejarse'),
array('letra'=>'a', 'palabra'=>'acorullar'),
array('letra'=>'a', 'palabra'=>'acorvar'),
array('letra'=>'a', 'palabra'=>'acorzar'),
array('letra'=>'a', 'palabra'=>'acosador'),
array('letra'=>'a', 'palabra'=>'acosamiento'),
array('letra'=>'a', 'palabra'=>'acosar'),
array('letra'=>'a', 'palabra'=>'acose'),
array('letra'=>'a', 'palabra'=>'acosijar'),
array('letra'=>'a', 'palabra'=>'acosmismo'),
array('letra'=>'a', 'palabra'=>'acoso'),
array('letra'=>'a', 'palabra'=>'acostado'),
array('letra'=>'a', 'palabra'=>'acostamiento'),
array('letra'=>'a', 'palabra'=>'acostar'),
array('letra'=>'a', 'palabra'=>'acostumbrar'),
array('letra'=>'a', 'palabra'=>'acotacion'),
array('letra'=>'a', 'palabra'=>'acotada'),
array('letra'=>'a', 'palabra'=>'acotamiento'),
array('letra'=>'a', 'palabra'=>'acotar'),
array('letra'=>'a', 'palabra'=>'acotejar'),
array('letra'=>'a', 'palabra'=>'acotejo'),
array('letra'=>'a', 'palabra'=>'acotiledon'),
array('letra'=>'a', 'palabra'=>'acotiledoneo'),
array('letra'=>'a', 'palabra'=>'acotillo'),
array('letra'=>'a', 'palabra'=>'acotolar'),
array('letra'=>'a', 'palabra'=>'acoyundar'),
array('letra'=>'a', 'palabra'=>'acoyuntar'),
array('letra'=>'a', 'palabra'=>'acoyuntero'),
array('letra'=>'a', 'palabra'=>'acracia'),
array('letra'=>'a', 'palabra'=>'acrata'),
array('letra'=>'a', 'palabra'=>'acratico'),
array('letra'=>'a', 'palabra'=>'acre'),
array('letra'=>'a', 'palabra'=>'acrebite'),
array('letra'=>'a', 'palabra'=>'acrecencia'),
array('letra'=>'a', 'palabra'=>'acrecentador'),
array('letra'=>'a', 'palabra'=>'acrecentamiento'),
array('letra'=>'a', 'palabra'=>'acrecentar'),
array('letra'=>'a', 'palabra'=>'acrecer'),
array('letra'=>'a', 'palabra'=>'acrecimiento'),
array('letra'=>'a', 'palabra'=>'acreditacion'),
array('letra'=>'a', 'palabra'=>'acreditado'),
array('letra'=>'a', 'palabra'=>'acreditar'),
array('letra'=>'a', 'palabra'=>'acreditativo'),
array('letra'=>'a', 'palabra'=>'acreedor'),
array('letra'=>'a', 'palabra'=>'acreencia'),
array('letra'=>'a', 'palabra'=>'acreer'),
array('letra'=>'a', 'palabra'=>'acremente'),
array('letra'=>'a', 'palabra'=>'acrescente'),
array('letra'=>'a', 'palabra'=>'acrianzar'),
array('letra'=>'a', 'palabra'=>'acribador'),
array('letra'=>'a', 'palabra'=>'acribadura'),
array('letra'=>'a', 'palabra'=>'acribar'),
array('letra'=>'a', 'palabra'=>'acribillar'),
array('letra'=>'a', 'palabra'=>'acridido'),
array('letra'=>'a', 'palabra'=>'acrilato'),
array('letra'=>'a', 'palabra'=>'acrilico'),
array('letra'=>'a', 'palabra'=>'acriminacion'),
array('letra'=>'a', 'palabra'=>'acriminador'),
array('letra'=>'a', 'palabra'=>'acriminar'),
array('letra'=>'a', 'palabra'=>'acrimonia'),
array('letra'=>'a', 'palabra'=>'acriollado'),
array('letra'=>'a', 'palabra'=>'acriollarse'),
array('letra'=>'a', 'palabra'=>'acrisoladamente'),
array('letra'=>'a', 'palabra'=>'acrisolado'),
array('letra'=>'a', 'palabra'=>'acrisolador'),
array('letra'=>'a', 'palabra'=>'acrisolar'),
array('letra'=>'a', 'palabra'=>'acristalado'),
array('letra'=>'a', 'palabra'=>'acristalamiento'),
array('letra'=>'a', 'palabra'=>'acristalar'),
array('letra'=>'a', 'palabra'=>'acristianado'),
array('letra'=>'a', 'palabra'=>'acristianar'),
array('letra'=>'a', 'palabra'=>'acritud'),
array('letra'=>'a', 'palabra'=>'acroamatico'),
array('letra'=>'a', 'palabra'=>'acrobacia'),
array('letra'=>'a', 'palabra'=>'acrobata'),
array('letra'=>'a', 'palabra'=>'acrobatico'),
array('letra'=>'a', 'palabra'=>'acrobatismo'),
array('letra'=>'a', 'palabra'=>'acroe'),
array('letra'=>'a', 'palabra'=>'acrofobia'),
array('letra'=>'a', 'palabra'=>'acroleina'),
array('letra'=>'a', 'palabra'=>'acromado'),
array('letra'=>'a', 'palabra'=>'acromatico'),
array('letra'=>'a', 'palabra'=>'acromatismo'),
array('letra'=>'a', 'palabra'=>'acromatizar'),
array('letra'=>'a', 'palabra'=>'acromatopsia'),
array('letra'=>'a', 'palabra'=>'acromegalia'),
array('letra'=>'a', 'palabra'=>'acromegalico'),
array('letra'=>'a', 'palabra'=>'acromial'),
array('letra'=>'a', 'palabra'=>'acromiano'),
array('letra'=>'a', 'palabra'=>'acromio'),
array('letra'=>'a', 'palabra'=>'acromion'),
array('letra'=>'a', 'palabra'=>'acronico'),
array('letra'=>'a', 'palabra'=>'acronimo'),
array('letra'=>'a', 'palabra'=>'acrono'),
array('letra'=>'a', 'palabra'=>'acropolis'),
array('letra'=>'a', 'palabra'=>'acrostico'),
array('letra'=>'a', 'palabra'=>'acrostolio'),
array('letra'=>'a', 'palabra'=>'acrotera'),
array('letra'=>'a', 'palabra'=>'acrotera'),
array('letra'=>'a', 'palabra'=>'acroteria'),
array('letra'=>'a', 'palabra'=>'acroterio'),
array('letra'=>'a', 'palabra'=>'acroy'),
array('letra'=>'a', 'palabra'=>'acta'),
array('letra'=>'a', 'palabra'=>'actea'),
array('letra'=>'a', 'palabra'=>'actinia'),
array('letra'=>'a', 'palabra'=>'actinico'),
array('letra'=>'a', 'palabra'=>'actinido'),
array('letra'=>'a', 'palabra'=>'actinio'),
array('letra'=>'a', 'palabra'=>'actinismo'),
array('letra'=>'a', 'palabra'=>'actinografo'),
array('letra'=>'a', 'palabra'=>'actinometria'),
array('letra'=>'a', 'palabra'=>'actinometrico'),
array('letra'=>'a', 'palabra'=>'actinometro'),
array('letra'=>'a', 'palabra'=>'actinomices'),
array('letra'=>'a', 'palabra'=>'actinomicosis'),
array('letra'=>'a', 'palabra'=>'actinomorfo'),
array('letra'=>'a', 'palabra'=>'actinota'),
array('letra'=>'a', 'palabra'=>'actitud'),
array('letra'=>'a', 'palabra'=>'activacion'),
array('letra'=>'a', 'palabra'=>'activador'),
array('letra'=>'a', 'palabra'=>'activamente'),
array('letra'=>'a', 'palabra'=>'activar'),
array('letra'=>'a', 'palabra'=>'actividad'),
array('letra'=>'a', 'palabra'=>'activismo'),
array('letra'=>'a', 'palabra'=>'activista'),
array('letra'=>'a', 'palabra'=>'activo'),
array('letra'=>'a', 'palabra'=>'acto'),
array('letra'=>'a', 'palabra'=>'actor'),
array('letra'=>'a', 'palabra'=>'actora'),
array('letra'=>'a', 'palabra'=>'actriz'),
array('letra'=>'a', 'palabra'=>'actuacion'),
array('letra'=>'a', 'palabra'=>'actuado'),
array('letra'=>'a', 'palabra'=>'actual'),
array('letra'=>'a', 'palabra'=>'actualidad'),
array('letra'=>'a', 'palabra'=>'actualizacion'),
array('letra'=>'a', 'palabra'=>'actualizador'),
array('letra'=>'a', 'palabra'=>'actualizar'),
array('letra'=>'a', 'palabra'=>'actualmente'),
array('letra'=>'a', 'palabra'=>'actuante'),
array('letra'=>'a', 'palabra'=>'actuar'),
array('letra'=>'a', 'palabra'=>'actuaria'),
array('letra'=>'a', 'palabra'=>'actuarial'),
array('letra'=>'a', 'palabra'=>'actuario'),
array('letra'=>'a', 'palabra'=>'actuosidad'),
array('letra'=>'a', 'palabra'=>'actuoso'),
array('letra'=>'a', 'palabra'=>'acuache'),
array('letra'=>'a', 'palabra'=>'acuadrillar'),
array('letra'=>'a', 'palabra'=>'acuantiar'),
array('letra'=>'a', 'palabra'=>'acuarela'),
array('letra'=>'a', 'palabra'=>'acuarelista'),
array('letra'=>'a', 'palabra'=>'acuarelistico'),
array('letra'=>'a', 'palabra'=>'acuario'),
array('letra'=>'a', 'palabra'=>'acuartar'),
array('letra'=>'a', 'palabra'=>'acuartelado'),
array('letra'=>'a', 'palabra'=>'acuartelamiento'),
array('letra'=>'a', 'palabra'=>'acuartelar'),
array('letra'=>'a', 'palabra'=>'acuartillar'),
array('letra'=>'a', 'palabra'=>'acuatico'),
array('letra'=>'a', 'palabra'=>'acuatil'),
array('letra'=>'a', 'palabra'=>'acuatizaje'),
array('letra'=>'a', 'palabra'=>'acuatizar'),
array('letra'=>'a', 'palabra'=>'acubado'),
array('letra'=>'a', 'palabra'=>'acubilar'),
array('letra'=>'a', 'palabra'=>'acucharado'),
array('letra'=>'a', 'palabra'=>'acuchilladizo'),
array('letra'=>'a', 'palabra'=>'acuchillado'),
array('letra'=>'a', 'palabra'=>'acuchillador'),
array('letra'=>'a', 'palabra'=>'acuchillar'),
array('letra'=>'a', 'palabra'=>'acucia'),
array('letra'=>'a', 'palabra'=>'acuciadamente'),
array('letra'=>'a', 'palabra'=>'acuciador'),
array('letra'=>'a', 'palabra'=>'acuciamiento'),
array('letra'=>'a', 'palabra'=>'acuciante'),
array('letra'=>'a', 'palabra'=>'acuciar'),
array('letra'=>'a', 'palabra'=>'acuciosamente'),
array('letra'=>'a', 'palabra'=>'acuciosidad'),
array('letra'=>'a', 'palabra'=>'acucioso'),
array('letra'=>'a', 'palabra'=>'acuclillarse'),
array('letra'=>'a', 'palabra'=>'acudiciar'),
array('letra'=>'a', 'palabra'=>'acudiente'),
array('letra'=>'a', 'palabra'=>'acudimiento'),
array('letra'=>'a', 'palabra'=>'acudir'),
array('letra'=>'a', 'palabra'=>'acueducto'),
array('letra'=>'a', 'palabra'=>'acueo'),
array('letra'=>'a', 'palabra'=>'acuerdo'),
array('letra'=>'a', 'palabra'=>'acuerpar'),
array('letra'=>'a', 'palabra'=>'acuesto'),
array('letra'=>'a', 'palabra'=>'acuicola'),
array('letra'=>'a', 'palabra'=>'acuicultura'),
array('letra'=>'a', 'palabra'=>'acuidad'),
array('letra'=>'a', 'palabra'=>'acuifero'),
array('letra'=>'a', 'palabra'=>'acuitadamente'),
array('letra'=>'a', 'palabra'=>'acuitamiento'),
array('letra'=>'a', 'palabra'=>'acuitar'),
array('letra'=>'a', 'palabra'=>'acula'),
array('letra'=>'a', 'palabra'=>'aculado'),
array('letra'=>'a', 'palabra'=>'acular'),
array('letra'=>'a', 'palabra'=>'aculatar'),
array('letra'=>'a', 'palabra'=>'aculebrinado'),
array('letra'=>'a', 'palabra'=>'aculeo'),
array('letra'=>'a', 'palabra'=>'aculla'),
array('letra'=>'a', 'palabra'=>'acullicar'),
array('letra'=>'a', 'palabra'=>'acullico'),
array('letra'=>'a', 'palabra'=>'aculturacion'),
array('letra'=>'a', 'palabra'=>'acumen'),
array('letra'=>'a', 'palabra'=>'acuminado'),
array('letra'=>'a', 'palabra'=>'acuminoso'),
array('letra'=>'a', 'palabra'=>'acumulable'),
array('letra'=>'a', 'palabra'=>'acumulacion'),
array('letra'=>'a', 'palabra'=>'acumulador'),
array('letra'=>'a', 'palabra'=>'acumulamiento'),
array('letra'=>'a', 'palabra'=>'acumular'),
array('letra'=>'a', 'palabra'=>'acumulativo'),
array('letra'=>'a', 'palabra'=>'acunar'),
array('letra'=>'a', 'palabra'=>'acundangarse'),
array('letra'=>'a', 'palabra'=>'acuntir'),
array('letra'=>'a', 'palabra'=>'acuñacion'),
array('letra'=>'a', 'palabra'=>'acuñador'),
array('letra'=>'a', 'palabra'=>'acuñar'),
array('letra'=>'a', 'palabra'=>'acuosidad'),
array('letra'=>'a', 'palabra'=>'acuoso'),
array('letra'=>'a', 'palabra'=>'acupuntor'),
array('letra'=>'a', 'palabra'=>'acupuntura'),
array('letra'=>'a', 'palabra'=>'acuradamente'),
array('letra'=>'a', 'palabra'=>'acurado'),
array('letra'=>'a', 'palabra'=>'acurdarse'),
array('letra'=>'a', 'palabra'=>'acure'),
array('letra'=>'a', 'palabra'=>'acurrucarse'),
array('letra'=>'a', 'palabra'=>'acurrullar'),
array('letra'=>'a', 'palabra'=>'acusable'),
array('letra'=>'a', 'palabra'=>'acusacion'),
array('letra'=>'a', 'palabra'=>'acusado'),
array('letra'=>'a', 'palabra'=>'acusador'),
array('letra'=>'a', 'palabra'=>'acusar'),
array('letra'=>'a', 'palabra'=>'acusativo'),
array('letra'=>'a', 'palabra'=>'acusatorio'),
array('letra'=>'a', 'palabra'=>'acuse'),
array('letra'=>'a', 'palabra'=>'acuseta'),
array('letra'=>'a', 'palabra'=>'acusetas'),
array('letra'=>'a', 'palabra'=>'acusete'),
array('letra'=>'a', 'palabra'=>'acusica'),
array('letra'=>'a', 'palabra'=>'acusique'),
array('letra'=>'a', 'palabra'=>'acuson'),
array('letra'=>'a', 'palabra'=>'acustico'),
array('letra'=>'a', 'palabra'=>'acutangulo'),
array('letra'=>'a', 'palabra'=>'acuti'),
array('letra'=>'a', 'palabra'=>'acuto'),
array('letra'=>'a', 'palabra'=>'ad'),
array('letra'=>'a', 'palabra'=>'adacilla'),
array('letra'=>'a', 'palabra'=>'adafina'),
array('letra'=>'a', 'palabra'=>'adagial'),
array('letra'=>'a', 'palabra'=>'adagio'),
array('letra'=>'a', 'palabra'=>'adaguar'),
array('letra'=>'a', 'palabra'=>'adahala'),
array('letra'=>'a', 'palabra'=>'adala'),
array('letra'=>'a', 'palabra'=>'adalid'),
array('letra'=>'a', 'palabra'=>'adamadamente'),
array('letra'=>'a', 'palabra'=>'adamado'),
array('letra'=>'a', 'palabra'=>'adamadura'),
array('letra'=>'a', 'palabra'=>'adamamiento'),
array('letra'=>'a', 'palabra'=>'adamante'),
array('letra'=>'a', 'palabra'=>'adamantino'),
array('letra'=>'a', 'palabra'=>'adamar'),
array('letra'=>'a', 'palabra'=>'adamarse'),
array('letra'=>'a', 'palabra'=>'adamascado'),
array('letra'=>'a', 'palabra'=>'adamascar'),
array('letra'=>'a', 'palabra'=>'adamico'),
array('letra'=>'a', 'palabra'=>'adamismo'),
array('letra'=>'a', 'palabra'=>'adamita'),
array('letra'=>'a', 'palabra'=>'adan'),
array('letra'=>'a', 'palabra'=>'adanico'),
array('letra'=>'a', 'palabra'=>'adanida'),
array('letra'=>'a', 'palabra'=>'adanismo'),
array('letra'=>'a', 'palabra'=>'adaptabilidad'),
array('letra'=>'a', 'palabra'=>'adaptable'),
array('letra'=>'a', 'palabra'=>'adaptacion'),
array('letra'=>'a', 'palabra'=>'adaptadamente'),
array('letra'=>'a', 'palabra'=>'adaptador'),
array('letra'=>'a', 'palabra'=>'adaptar'),
array('letra'=>'a', 'palabra'=>'adaraga'),
array('letra'=>'a', 'palabra'=>'adaraja'),
array('letra'=>'a', 'palabra'=>'adarame'),
array('letra'=>'a', 'palabra'=>'adarce'),
array('letra'=>'a', 'palabra'=>'adardear'),
array('letra'=>'a', 'palabra'=>'adarga'),
array('letra'=>'a', 'palabra'=>'adargama'),
array('letra'=>'a', 'palabra'=>'adargar'),
array('letra'=>'a', 'palabra'=>'adarguero'),
array('letra'=>'a', 'palabra'=>'adarme'),
array('letra'=>'a', 'palabra'=>'adarvar'),
array('letra'=>'a', 'palabra'=>'adarve'),
array('letra'=>'a', 'palabra'=>'adaza'),
array('letra'=>'a', 'palabra'=>'adecenamiento'),
array('letra'=>'a', 'palabra'=>'adecenar'),
array('letra'=>'a', 'palabra'=>'adecentar'),
array('letra'=>'a', 'palabra'=>'adecuacion'),
array('letra'=>'a', 'palabra'=>'adecuado'),
array('letra'=>'a', 'palabra'=>'adecuar'),
array('letra'=>'a', 'palabra'=>'adefera'),
array('letra'=>'a', 'palabra'=>'adefesio'),
array('letra'=>'a', 'palabra'=>'adefina'),
array('letra'=>'a', 'palabra'=>'adefuera'),
array('letra'=>'a', 'palabra'=>'adehala'),
array('letra'=>'a', 'palabra'=>'adehesamiento'),
array('letra'=>'a', 'palabra'=>'adehesar'),
array('letra'=>'a', 'palabra'=>'adelantadamente'),
array('letra'=>'a', 'palabra'=>'adelantado'),
array('letra'=>'a', 'palabra'=>'adelantador'),
array('letra'=>'a', 'palabra'=>'adelantamiento'),
array('letra'=>'a', 'palabra'=>'adelantar'),
array('letra'=>'a', 'palabra'=>'adelante'),
array('letra'=>'a', 'palabra'=>'adelanto'),
array('letra'=>'a', 'palabra'=>'adelfa'),
array('letra'=>'a', 'palabra'=>'adelfal'),
array('letra'=>'a', 'palabra'=>'adelfico'),
array('letra'=>'a', 'palabra'=>'adelfilla'),
array('letra'=>'a', 'palabra'=>'adelgazador'),
array('letra'=>'a', 'palabra'=>'adelgazamiento'),
array('letra'=>'a', 'palabra'=>'adelgazante'),
array('letra'=>'a', 'palabra'=>'adelgazar'),
array('letra'=>'a', 'palabra'=>'adeliñar'),
array('letra'=>'a', 'palabra'=>'adeliño'),
array('letra'=>'a', 'palabra'=>'adema'),
array('letra'=>'a', 'palabra'=>'ademador'),
array('letra'=>'a', 'palabra'=>'ademan'),
array('letra'=>'a', 'palabra'=>'ademar'),
array('letra'=>'a', 'palabra'=>'ademas'),
array('letra'=>'a', 'palabra'=>'ademe'),
array('letra'=>'a', 'palabra'=>'adempribio'),
array('letra'=>'a', 'palabra'=>'ademprio'),
array('letra'=>'a', 'palabra'=>'ademprio'),
array('letra'=>'a', 'palabra'=>'adenda'),
array('letra'=>'a', 'palabra'=>'adenia'),
array('letra'=>'a', 'palabra'=>'adenitis'),
array('letra'=>'a', 'palabra'=>'adenoideo'),
array('letra'=>'a', 'palabra'=>'adenoides'),
array('letra'=>'a', 'palabra'=>'adenologia'),
array('letra'=>'a', 'palabra'=>'adenoma'),
array('letra'=>'a', 'palabra'=>'adenopatia'),
array('letra'=>'a', 'palabra'=>'adenoso'),
array('letra'=>'a', 'palabra'=>'adensar'),
array('letra'=>'a', 'palabra'=>'adentellar'),
array('letra'=>'a', 'palabra'=>'adentrarse'),
array('letra'=>'a', 'palabra'=>'adentro'),
array('letra'=>'a', 'palabra'=>'adepto'),
array('letra'=>'a', 'palabra'=>'aderezado'),
array('letra'=>'a', 'palabra'=>'aderezamiento'),
array('letra'=>'a', 'palabra'=>'aderezar'),
array('letra'=>'a', 'palabra'=>'aderezo'),
array('letra'=>'a', 'palabra'=>'aderra'),
array('letra'=>'a', 'palabra'=>'aderredor'),
array('letra'=>'a', 'palabra'=>'adestrado'),
array('letra'=>'a', 'palabra'=>'adestrador'),
array('letra'=>'a', 'palabra'=>'adestramiento'),
array('letra'=>'a', 'palabra'=>'adestrar'),
array('letra'=>'a', 'palabra'=>'adestria'),
array('letra'=>'a', 'palabra'=>'adeudar'),
array('letra'=>'a', 'palabra'=>'adeudo'),
array('letra'=>'a', 'palabra'=>'adherecer'),
array('letra'=>'a', 'palabra'=>'adherencia'),
array('letra'=>'a', 'palabra'=>'adherente'),
array('letra'=>'a', 'palabra'=>'adherir'),
array('letra'=>'a', 'palabra'=>'adhesion'),
array('letra'=>'a', 'palabra'=>'adhesividad'),
array('letra'=>'a', 'palabra'=>'adhesivo'),
array('letra'=>'a', 'palabra'=>'adhortar'),
array('letra'=>'a', 'palabra'=>'adiabatico'),
array('letra'=>'a', 'palabra'=>'adiado'),
array('letra'=>'a', 'palabra'=>'adiafa'),
array('letra'=>'a', 'palabra'=>'adiaforesis'),
array('letra'=>'a', 'palabra'=>'adiamantado'),
array('letra'=>'a', 'palabra'=>'adiamiento'),
array('letra'=>'a', 'palabra'=>'adiano'),
array('letra'=>'a', 'palabra'=>'adiar'),
array('letra'=>'a', 'palabra'=>'adiccion'),
array('letra'=>'a', 'palabra'=>'adicion'),
array('letra'=>'a', 'palabra'=>'adicionador'),
array('letra'=>'a', 'palabra'=>'adicional'),
array('letra'=>'a', 'palabra'=>'adicionar'),
array('letra'=>'a', 'palabra'=>'adictivo'),
array('letra'=>'a', 'palabra'=>'adicto'),
array('letra'=>'a', 'palabra'=>'adieso'),
array('letra'=>'a', 'palabra'=>'adiestrado'),
array('letra'=>'a', 'palabra'=>'adiestrador'),
array('letra'=>'a', 'palabra'=>'adiestramiento'),
array('letra'=>'a', 'palabra'=>'adiestrar'),
array('letra'=>'a', 'palabra'=>'adietar'),
array('letra'=>'a', 'palabra'=>'adinamia'),
array('letra'=>'a', 'palabra'=>'adinamico'),
array('letra'=>'a', 'palabra'=>'adinerado'),
array('letra'=>'a', 'palabra'=>'adintelado'),
array('letra'=>'a', 'palabra'=>'adios'),
array('letra'=>'a', 'palabra'=>'adipocira'),
array('letra'=>'a', 'palabra'=>'adiposidad'),
array('letra'=>'a', 'palabra'=>'adiposis'),
array('letra'=>'a', 'palabra'=>'adiposo'),
array('letra'=>'a', 'palabra'=>'adipsia'),
array('letra'=>'a', 'palabra'=>'adir'),
array('letra'=>'a', 'palabra'=>'aditamento'),
array('letra'=>'a', 'palabra'=>'aditicio'),
array('letra'=>'a', 'palabra'=>'aditivo'),
array('letra'=>'a', 'palabra'=>'adiva'),
array('letra'=>'a', 'palabra'=>'adivas'),
array('letra'=>'a', 'palabra'=>'adive'),
array('letra'=>'a', 'palabra'=>'adivinacion'),
array('letra'=>'a', 'palabra'=>'adivinador'),
array('letra'=>'a', 'palabra'=>'adivinaja'),
array('letra'=>'a', 'palabra'=>'adivinamiento'),
array('letra'=>'a', 'palabra'=>'adivinanza'),
array('letra'=>'a', 'palabra'=>'adivinar'),
array('letra'=>'a', 'palabra'=>'adivinatorio'),
array('letra'=>'a', 'palabra'=>'adivino'),
array('letra'=>'a', 'palabra'=>'adjetivacion'),
array('letra'=>'a', 'palabra'=>'adjetival'),
array('letra'=>'a', 'palabra'=>'adjetivar'),
array('letra'=>'a', 'palabra'=>'adjetivo'),
array('letra'=>'a', 'palabra'=>'adjudicacion'),
array('letra'=>'a', 'palabra'=>'adjudicador'),
array('letra'=>'a', 'palabra'=>'adjudicar'),
array('letra'=>'a', 'palabra'=>'adjudicatario'),
array('letra'=>'a', 'palabra'=>'adjuncion'),
array('letra'=>'a', 'palabra'=>'adjunta'),
array('letra'=>'a', 'palabra'=>'adjuntar'),
array('letra'=>'a', 'palabra'=>'adjuntia'),
array('letra'=>'a', 'palabra'=>'adjunto'),
array('letra'=>'a', 'palabra'=>'adjurable'),
array('letra'=>'a', 'palabra'=>'adjuracion'),
array('letra'=>'a', 'palabra'=>'adjurado'),
array('letra'=>'a', 'palabra'=>'adjurador'),
array('letra'=>'a', 'palabra'=>'adjurar'),
array('letra'=>'a', 'palabra'=>'adjutor'),
array('letra'=>'a', 'palabra'=>'adjutorio'),
array('letra'=>'a', 'palabra'=>'adlatere'),
array('letra'=>'a', 'palabra'=>'adminicular'),
array('letra'=>'a', 'palabra'=>'adminiculo'),
array('letra'=>'a', 'palabra'=>'administracion'),
array('letra'=>'a', 'palabra'=>'administrado'),
array('letra'=>'a', 'palabra'=>'administrador'),
array('letra'=>'a', 'palabra'=>'administrar'),
array('letra'=>'a', 'palabra'=>'administrativamente'),
array('letra'=>'a', 'palabra'=>'administrativista'),
array('letra'=>'a', 'palabra'=>'administrativo'),
array('letra'=>'a', 'palabra'=>'administratorio'),
array('letra'=>'a', 'palabra'=>'admirable'),
array('letra'=>'a', 'palabra'=>'admiracion'),
array('letra'=>'a', 'palabra'=>'admirador'),
array('letra'=>'a', 'palabra'=>'admirar'),
array('letra'=>'a', 'palabra'=>'admirativo'),
array('letra'=>'a', 'palabra'=>'admisibilidad'),
array('letra'=>'a', 'palabra'=>'admisible'),
array('letra'=>'a', 'palabra'=>'admision'),
array('letra'=>'a', 'palabra'=>'admitancia'),
array('letra'=>'a', 'palabra'=>'admitencia'),
array('letra'=>'a', 'palabra'=>'admitir'),
array('letra'=>'a', 'palabra'=>'admixtion'),
array('letra'=>'a', 'palabra'=>'admonicion'),
array('letra'=>'a', 'palabra'=>'admonitor'),
array('letra'=>'a', 'palabra'=>'admonitorio'),
array('letra'=>'a', 'palabra'=>'adnado'),
array('letra'=>'a', 'palabra'=>'adnato'),
array('letra'=>'a', 'palabra'=>'ado'),
array('letra'=>'a', 'palabra'=>'adoba'),
array('letra'=>'a', 'palabra'=>'adobado'),
array('letra'=>'a', 'palabra'=>'adobador'),
array('letra'=>'a', 'palabra'=>'adobar'),
array('letra'=>'a', 'palabra'=>'adobasillas'),
array('letra'=>'a', 'palabra'=>'adobe'),
array('letra'=>'a', 'palabra'=>'adobera'),
array('letra'=>'a', 'palabra'=>'adoberia'),
array('letra'=>'a', 'palabra'=>'adobio'),
array('letra'=>'a', 'palabra'=>'adobo'),
array('letra'=>'a', 'palabra'=>'adocenado'),
array('letra'=>'a', 'palabra'=>'adocenar'),
array('letra'=>'a', 'palabra'=>'adocilar'),
array('letra'=>'a', 'palabra'=>'adoctrinador'),
array('letra'=>'a', 'palabra'=>'adoctrinamiento'),
array('letra'=>'a', 'palabra'=>'adoctrinar'),
array('letra'=>'a', 'palabra'=>'adolecer'),
array('letra'=>'a', 'palabra'=>'adoleciente'),
array('letra'=>'a', 'palabra'=>'adolescencia'),
array('letra'=>'a', 'palabra'=>'adolescente'),
array('letra'=>'a', 'palabra'=>'adolorado'),
array('letra'=>'a', 'palabra'=>'adolorar'),
array('letra'=>'a', 'palabra'=>'adolorido'),
array('letra'=>'a', 'palabra'=>'adonado'),
array('letra'=>'a', 'palabra'=>'adonai'),
array('letra'=>'a', 'palabra'=>'adonarse'),
array('letra'=>'a', 'palabra'=>'adonay'),
array('letra'=>'a', 'palabra'=>'adonde'),
array('letra'=>'a', 'palabra'=>'adondequiera'),
array('letra'=>'a', 'palabra'=>'adonecer'),
array('letra'=>'a', 'palabra'=>'adonico'),
array('letra'=>'a', 'palabra'=>'adonio'),
array('letra'=>'a', 'palabra'=>'adonis'),
array('letra'=>'a', 'palabra'=>'adonizarse'),
array('letra'=>'a', 'palabra'=>'adopcion'),
array('letra'=>'a', 'palabra'=>'adopcionismo'),
array('letra'=>'a', 'palabra'=>'adopcionista'),
array('letra'=>'a', 'palabra'=>'adoptable'),
array('letra'=>'a', 'palabra'=>'adoptacion'),
array('letra'=>'a', 'palabra'=>'adoptador'),
array('letra'=>'a', 'palabra'=>'adoptante'),
array('letra'=>'a', 'palabra'=>'adoptar'),
array('letra'=>'a', 'palabra'=>'adoptivo'),
array('letra'=>'a', 'palabra'=>'adoquier'),
array('letra'=>'a', 'palabra'=>'adoquiera'),
array('letra'=>'a', 'palabra'=>'adoquin'),
array('letra'=>'a', 'palabra'=>'adoquinado'),
array('letra'=>'a', 'palabra'=>'adoquinador'),
array('letra'=>'a', 'palabra'=>'adoquinar'),
array('letra'=>'a', 'palabra'=>'ador'),
array('letra'=>'a', 'palabra'=>'adorable'),
array('letra'=>'a', 'palabra'=>'adoracion'),
array('letra'=>'a', 'palabra'=>'adorador'),
array('letra'=>'a', 'palabra'=>'adorar'),
array('letra'=>'a', 'palabra'=>'adoratorio'),
array('letra'=>'a', 'palabra'=>'adoratriz'),
array('letra'=>'a', 'palabra'=>'adormecedor'),
array('letra'=>'a', 'palabra'=>'adormecer'),
array('letra'=>'a', 'palabra'=>'adormecimiento'),
array('letra'=>'a', 'palabra'=>'adormentar'),
array('letra'=>'a', 'palabra'=>'adormidera'),
array('letra'=>'a', 'palabra'=>'adormilarse'),
array('letra'=>'a', 'palabra'=>'adormimiento'),
array('letra'=>'a', 'palabra'=>'adormir'),
array('letra'=>'a', 'palabra'=>'adormitarse'),
array('letra'=>'a', 'palabra'=>'adornador'),
array('letra'=>'a', 'palabra'=>'adornamiento'),
array('letra'=>'a', 'palabra'=>'adornar'),
array('letra'=>'a', 'palabra'=>'adornista'),
array('letra'=>'a', 'palabra'=>'adorno'),
array('letra'=>'a', 'palabra'=>'adoro'),
array('letra'=>'a', 'palabra'=>'adosado'),
array('letra'=>'a', 'palabra'=>'adosar'),
array('letra'=>'a', 'palabra'=>'adotrinar'),
array('letra'=>'a', 'palabra'=>'adovelado'),
array('letra'=>'a', 'palabra'=>'adquirente'),
array('letra'=>'a', 'palabra'=>'adquirible'),
array('letra'=>'a', 'palabra'=>'adquiridor'),
array('letra'=>'a', 'palabra'=>'adquiriente'),
array('letra'=>'a', 'palabra'=>'adquirir'),
array('letra'=>'a', 'palabra'=>'adquisicion'),
array('letra'=>'a', 'palabra'=>'adquisidor'),
array('letra'=>'a', 'palabra'=>'adquisitivo'),
array('letra'=>'a', 'palabra'=>'adra'),
array('letra'=>'a', 'palabra'=>'adrado'),
array('letra'=>'a', 'palabra'=>'adragante'),
array('letra'=>'a', 'palabra'=>'adraganto'),
array('letra'=>'a', 'palabra'=>'adral'),
array('letra'=>'a', 'palabra'=>'adrar'),
array('letra'=>'a', 'palabra'=>'adrede'),
array('letra'=>'a', 'palabra'=>'adredemente'),
array('letra'=>'a', 'palabra'=>'adrenal'),
array('letra'=>'a', 'palabra'=>'adrenalina'),
array('letra'=>'a', 'palabra'=>'adrenergico'),
array('letra'=>'a', 'palabra'=>'adrezar'),
array('letra'=>'a', 'palabra'=>'adrezo'),
array('letra'=>'a', 'palabra'=>'adrian'),
array('letra'=>'a', 'palabra'=>'adriatico'),
array('letra'=>'a', 'palabra'=>'adrizamiento'),
array('letra'=>'a', 'palabra'=>'adrizar'),
array('letra'=>'a', 'palabra'=>'adrolla'),
array('letra'=>'a', 'palabra'=>'adrollero'),
array('letra'=>'a', 'palabra'=>'adscribir'),
array('letra'=>'a', 'palabra'=>'adscripcion'),
array('letra'=>'a', 'palabra'=>'adscripto'),
array('letra'=>'a', 'palabra'=>'adscrito'),
array('letra'=>'a', 'palabra'=>'adsorbente'),
array('letra'=>'a', 'palabra'=>'adsorber'),
array('letra'=>'a', 'palabra'=>'adsorcion'),
array('letra'=>'a', 'palabra'=>'adstrato'),
array('letra'=>'a', 'palabra'=>'adstriccion'),
array('letra'=>'a', 'palabra'=>'adstringente'),
array('letra'=>'a', 'palabra'=>'adstringir'),
array('letra'=>'a', 'palabra'=>'aduana'),
array('letra'=>'a', 'palabra'=>'aduanal'),
array('letra'=>'a', 'palabra'=>'aduanar'),
array('letra'=>'a', 'palabra'=>'aduanero'),
array('letra'=>'a', 'palabra'=>'aduar'),
array('letra'=>'a', 'palabra'=>'aducar'),
array('letra'=>'a', 'palabra'=>'aduccion'),
array('letra'=>'a', 'palabra'=>'aducir'),
array('letra'=>'a', 'palabra'=>'aductor'),
array('letra'=>'a', 'palabra'=>'aduendado'),
array('letra'=>'a', 'palabra'=>'adueñarse'),
array('letra'=>'a', 'palabra'=>'adufe'),
array('letra'=>'a', 'palabra'=>'adufero'),
array('letra'=>'a', 'palabra'=>'adufre'),
array('letra'=>'a', 'palabra'=>'aduja'),
array('letra'=>'a', 'palabra'=>'adujar'),
array('letra'=>'a', 'palabra'=>'adul'),
array('letra'=>'a', 'palabra'=>'adula'),
array('letra'=>'a', 'palabra'=>'adulacion'),
array('letra'=>'a', 'palabra'=>'adulador'),
array('letra'=>'a', 'palabra'=>'adular'),
array('letra'=>'a', 'palabra'=>'adularia'),
array('letra'=>'a', 'palabra'=>'adulatorio'),
array('letra'=>'a', 'palabra'=>'adulciguar'),
array('letra'=>'a', 'palabra'=>'adulcir'),
array('letra'=>'a', 'palabra'=>'adulete'),
array('letra'=>'a', 'palabra'=>'adulon'),
array('letra'=>'a', 'palabra'=>'aduloneria'),
array('letra'=>'a', 'palabra'=>'adulteracion'),
array('letra'=>'a', 'palabra'=>'adulterador'),
array('letra'=>'a', 'palabra'=>'adulterar'),
array('letra'=>'a', 'palabra'=>'adulterino'),
array('letra'=>'a', 'palabra'=>'adulterio'),
array('letra'=>'a', 'palabra'=>'adultero'),
array('letra'=>'a', 'palabra'=>'adultez'),
array('letra'=>'a', 'palabra'=>'adulto'),
array('letra'=>'a', 'palabra'=>'adulzar'),
array('letra'=>'a', 'palabra'=>'adulzorar'),
array('letra'=>'a', 'palabra'=>'adumbracion'),
array('letra'=>'a', 'palabra'=>'adumbrar'),
array('letra'=>'a', 'palabra'=>'adunacion'),
array('letra'=>'a', 'palabra'=>'adunar'),
array('letra'=>'a', 'palabra'=>'adunco'),
array('letra'=>'a', 'palabra'=>'adunia'),
array('letra'=>'a', 'palabra'=>'adurir'),
array('letra'=>'a', 'palabra'=>'aduro'),
array('letra'=>'a', 'palabra'=>'adustez'),
array('letra'=>'a', 'palabra'=>'adustible'),
array('letra'=>'a', 'palabra'=>'adustion'),
array('letra'=>'a', 'palabra'=>'adustivo'),
array('letra'=>'a', 'palabra'=>'adusto'),
array('letra'=>'a', 'palabra'=>'adutaque'),
array('letra'=>'a', 'palabra'=>'adveccion'),
array('letra'=>'a', 'palabra'=>'advenedizo'),
array('letra'=>'a', 'palabra'=>'advenidero'),
array('letra'=>'a', 'palabra'=>'advenimiento'),
array('letra'=>'a', 'palabra'=>'advenir'),
array('letra'=>'a', 'palabra'=>'adventicio'),
array('letra'=>'a', 'palabra'=>'adventismo'),
array('letra'=>'a', 'palabra'=>'adventista'),
array('letra'=>'a', 'palabra'=>'adveracion'),
array('letra'=>'a', 'palabra'=>'adverado'),
array('letra'=>'a', 'palabra'=>'adverar'),
array('letra'=>'a', 'palabra'=>'adverbial'),
array('letra'=>'a', 'palabra'=>'adverbializar'),
array('letra'=>'a', 'palabra'=>'adverbio'),
array('letra'=>'a', 'palabra'=>'adversador'),
array('letra'=>'a', 'palabra'=>'adversar'),
array('letra'=>'a', 'palabra'=>'adversario'),
array('letra'=>'a', 'palabra'=>'adversativo'),
array('letra'=>'a', 'palabra'=>'adversidad'),
array('letra'=>'a', 'palabra'=>'adversion'),
array('letra'=>'a', 'palabra'=>'adverso'),
array('letra'=>'a', 'palabra'=>'advertencia'),
array('letra'=>'a', 'palabra'=>'advertidamente'),
array('letra'=>'a', 'palabra'=>'advertido'),
array('letra'=>'a', 'palabra'=>'advertimiento'),
array('letra'=>'a', 'palabra'=>'advertir'),
array('letra'=>'a', 'palabra'=>'adviento'),
array('letra'=>'a', 'palabra'=>'advocacion'),
array('letra'=>'a', 'palabra'=>'advocar'),
array('letra'=>'a', 'palabra'=>'advocatorio'),
array('letra'=>'a', 'palabra'=>'adyacencia'),
array('letra'=>'a', 'palabra'=>'adyacente'),
array('letra'=>'a', 'palabra'=>'adyuvante'),
array('letra'=>'a', 'palabra'=>'aeda'),
array('letra'=>'a', 'palabra'=>'aedo'),
array('letra'=>'a', 'palabra'=>'aeracion'),
array('letra'=>'a', 'palabra'=>'aereo'),
array('letra'=>'a', 'palabra'=>'aerifero'),
array('letra'=>'a', 'palabra'=>'aeriforme'),
array('letra'=>'a', 'palabra'=>'aerobic'),
array('letra'=>'a', 'palabra'=>'aerobic'),
array('letra'=>'a', 'palabra'=>'aerobico'),
array('letra'=>'a', 'palabra'=>'aerobio'),
array('letra'=>'a', 'palabra'=>'aerobiosis'),
array('letra'=>'a', 'palabra'=>'aerobus'),
array('letra'=>'a', 'palabra'=>'aeroclub'),
array('letra'=>'a', 'palabra'=>'aerocriptografia'),
array('letra'=>'a', 'palabra'=>'aerocriptografico'),
array('letra'=>'a', 'palabra'=>'aerodeslizador'),
array('letra'=>'a', 'palabra'=>'aerodinamico'),
array('letra'=>'a', 'palabra'=>'aerodromo'),
array('letra'=>'a', 'palabra'=>'aeroespacial'),
array('letra'=>'a', 'palabra'=>'aerofagia'),
array('letra'=>'a', 'palabra'=>'aerofaro'),
array('letra'=>'a', 'palabra'=>'aerofobia'),
array('letra'=>'a', 'palabra'=>'aerofobo'),
array('letra'=>'a', 'palabra'=>'aerofotografia'),
array('letra'=>'a', 'palabra'=>'aerografo'),
array('letra'=>'a', 'palabra'=>'aerograma'),
array('letra'=>'a', 'palabra'=>'aerolinea'),
array('letra'=>'a', 'palabra'=>'aerolitico'),
array('letra'=>'a', 'palabra'=>'aerolito'),
array('letra'=>'a', 'palabra'=>'aeromancia'),
array('letra'=>'a', 'palabra'=>'aeromancia'),
array('letra'=>'a', 'palabra'=>'aeromantico'),
array('letra'=>'a', 'palabra'=>'aerometro'),
array('letra'=>'a', 'palabra'=>'aeromodelismo'),
array('letra'=>'a', 'palabra'=>'aeromodelista'),
array('letra'=>'a', 'palabra'=>'aeromodelo'),
array('letra'=>'a', 'palabra'=>'aeromotor'),
array('letra'=>'a', 'palabra'=>'aeromovil'),
array('letra'=>'a', 'palabra'=>'aeromoza'),
array('letra'=>'a', 'palabra'=>'aeronato'),
array('letra'=>'a', 'palabra'=>'aeronauta'),
array('letra'=>'a', 'palabra'=>'aeronautico'),
array('letra'=>'a', 'palabra'=>'aeronaval'),
array('letra'=>'a', 'palabra'=>'aeronave'),
array('letra'=>'a', 'palabra'=>'aeronavegacion'),
array('letra'=>'a', 'palabra'=>'aeroparque'),
array('letra'=>'a', 'palabra'=>'aeroplano'),
array('letra'=>'a', 'palabra'=>'aeroportuario'),
array('letra'=>'a', 'palabra'=>'aeropostal'),
array('letra'=>'a', 'palabra'=>'aeropuerto'),
array('letra'=>'a', 'palabra'=>'aerosol'),
array('letra'=>'a', 'palabra'=>'aerostacion'),
array('letra'=>'a', 'palabra'=>'aerostatica'),
array('letra'=>'a', 'palabra'=>'aerostatico'),
array('letra'=>'a', 'palabra'=>'aerostato'),
array('letra'=>'a', 'palabra'=>'aerostato'),
array('letra'=>'a', 'palabra'=>'aerostero'),
array('letra'=>'a', 'palabra'=>'aerotaxi'),
array('letra'=>'a', 'palabra'=>'aerotecnia'),
array('letra'=>'a', 'palabra'=>'aerotecnico'),
array('letra'=>'a', 'palabra'=>'aeroterapia'),
array('letra'=>'a', 'palabra'=>'aeroterrestre'),
array('letra'=>'a', 'palabra'=>'aerotransportar'),
array('letra'=>'a', 'palabra'=>'aerotren'),
array('letra'=>'a', 'palabra'=>'aerovia'),
array('letra'=>'a', 'palabra'=>'aeta'),
array('letra'=>'a', 'palabra'=>'afabilidad'),
array('letra'=>'a', 'palabra'=>'afable'),
array('letra'=>'a', 'palabra'=>'afablemente'),
array('letra'=>'a', 'palabra'=>'afabulacion'),
array('letra'=>'a', 'palabra'=>'afaca'),
array('letra'=>'a', 'palabra'=>'afaccionado'),
array('letra'=>'a', 'palabra'=>'afacer'),
array('letra'=>'a', 'palabra'=>'afacimiento'),
array('letra'=>'a', 'palabra'=>'afalagar'),
array('letra'=>'a', 'palabra'=>'afamado'),
array('letra'=>'a', 'palabra'=>'afamar'),
array('letra'=>'a', 'palabra'=>'afan'),
array('letra'=>'a', 'palabra'=>'afanado'),
array('letra'=>'a', 'palabra'=>'afanador'),
array('letra'=>'a', 'palabra'=>'afanar'),
array('letra'=>'a', 'palabra'=>'afaniptero'),
array('letra'=>'a', 'palabra'=>'afanita'),
array('letra'=>'a', 'palabra'=>'afanoso'),
array('letra'=>'a', 'palabra'=>'afarallonado'),
array('letra'=>'a', 'palabra'=>'afarolado'),
array('letra'=>'a', 'palabra'=>'afascalar'),
array('letra'=>'a', 'palabra'=>'afasia'),
array('letra'=>'a', 'palabra'=>'afasico'),
array('letra'=>'a', 'palabra'=>'afatar'),
array('letra'=>'a', 'palabra'=>'afate'),
array('letra'=>'a', 'palabra'=>'afeador'),
array('letra'=>'a', 'palabra'=>'afeamiento'),
array('letra'=>'a', 'palabra'=>'afear'),
array('letra'=>'a', 'palabra'=>'afeblecerse'),
array('letra'=>'a', 'palabra'=>'afeccion'),
array('letra'=>'a', 'palabra'=>'afeccionar'),
array('letra'=>'a', 'palabra'=>'afecho'),
array('letra'=>'a', 'palabra'=>'afectable'),
array('letra'=>'a', 'palabra'=>'afectacion'),
array('letra'=>'a', 'palabra'=>'afectado'),
array('letra'=>'a', 'palabra'=>'afectador'),
array('letra'=>'a', 'palabra'=>'afectar'),
array('letra'=>'a', 'palabra'=>'afectividad'),
array('letra'=>'a', 'palabra'=>'afectivo'),
array('letra'=>'a', 'palabra'=>'afecto'),
array('letra'=>'a', 'palabra'=>'afectuosidad'),
array('letra'=>'a', 'palabra'=>'afectuoso'),
array('letra'=>'a', 'palabra'=>'afeitada'),
array('letra'=>'a', 'palabra'=>'afeitadamente'),
array('letra'=>'a', 'palabra'=>'afeitadera'),
array('letra'=>'a', 'palabra'=>'afeitado'),
array('letra'=>'a', 'palabra'=>'afeitador'),
array('letra'=>'a', 'palabra'=>'afeitamiento'),
array('letra'=>'a', 'palabra'=>'afeitar'),
array('letra'=>'a', 'palabra'=>'afeite'),
array('letra'=>'a', 'palabra'=>'afelio'),
array('letra'=>'a', 'palabra'=>'afelpado'),
array('letra'=>'a', 'palabra'=>'afelpar'),
array('letra'=>'a', 'palabra'=>'afeminacion'),
array('letra'=>'a', 'palabra'=>'afeminadamente'),
array('letra'=>'a', 'palabra'=>'afeminado'),
array('letra'=>'a', 'palabra'=>'afeminamiento'),
array('letra'=>'a', 'palabra'=>'afeminar'),
array('letra'=>'a', 'palabra'=>'afer'),
array('letra'=>'a', 'palabra'=>'aferencia'),
array('letra'=>'a', 'palabra'=>'aferente'),
array('letra'=>'a', 'palabra'=>'aferesis'),
array('letra'=>'a', 'palabra'=>'aferidor'),
array('letra'=>'a', 'palabra'=>'aferir'),
array('letra'=>'a', 'palabra'=>'aferradamente'),
array('letra'=>'a', 'palabra'=>'aferrado'),
array('letra'=>'a', 'palabra'=>'aferrador'),
array('letra'=>'a', 'palabra'=>'aferramiento'),
array('letra'=>'a', 'palabra'=>'aferrar'),
array('letra'=>'a', 'palabra'=>'aferruzado'),
array('letra'=>'a', 'palabra'=>'afervorar'),
array('letra'=>'a', 'palabra'=>'afervorizar'),
array('letra'=>'a', 'palabra'=>'afestonado'),
array('letra'=>'a', 'palabra'=>'affaire'),
array('letra'=>'a', 'palabra'=>'affidavit'),
array('letra'=>'a', 'palabra'=>'afgano'),
array('letra'=>'a', 'palabra'=>'afianzador'),
array('letra'=>'a', 'palabra'=>'afianzamiento'),
array('letra'=>'a', 'palabra'=>'afianzar'),
array('letra'=>'a', 'palabra'=>'afiar'),
array('letra'=>'a', 'palabra'=>'afiblar'),
array('letra'=>'a', 'palabra'=>'afiche'),
array('letra'=>'a', 'palabra'=>'aficion'),
array('letra'=>'a', 'palabra'=>'aficionado'),
array('letra'=>'a', 'palabra'=>'aficionador'),
array('letra'=>'a', 'palabra'=>'aficionar'),
array('letra'=>'a', 'palabra'=>'afiebrarse'),
array('letra'=>'a', 'palabra'=>'afielar'),
array('letra'=>'a', 'palabra'=>'afijacion'),
array('letra'=>'a', 'palabra'=>'afijado'),
array('letra'=>'a', 'palabra'=>'afijamiento'),
array('letra'=>'a', 'palabra'=>'afijar'),
array('letra'=>'a', 'palabra'=>'afijo'),
array('letra'=>'a', 'palabra'=>'afiladera'),
array('letra'=>'a', 'palabra'=>'afilado'),
array('letra'=>'a', 'palabra'=>'afilador'),
array('letra'=>'a', 'palabra'=>'afiladura'),
array('letra'=>'a', 'palabra'=>'afilalapices'),
array('letra'=>'a', 'palabra'=>'afilamiento'),
array('letra'=>'a', 'palabra'=>'afilar'),
array('letra'=>'a', 'palabra'=>'afiliacion'),
array('letra'=>'a', 'palabra'=>'afiliado'),
array('letra'=>'a', 'palabra'=>'afiliar'),
array('letra'=>'a', 'palabra'=>'afiligranado'),
array('letra'=>'a', 'palabra'=>'afiligranar'),
array('letra'=>'a', 'palabra'=>'afilo'),
array('letra'=>'a', 'palabra'=>'afilo'),
array('letra'=>'a', 'palabra'=>'afilon'),
array('letra'=>'a', 'palabra'=>'afilorar'),
array('letra'=>'a', 'palabra'=>'afilosofado'),
array('letra'=>'a', 'palabra'=>'afin'),
array('letra'=>'a', 'palabra'=>'afinacion'),
array('letra'=>'a', 'palabra'=>'afinadamente'),
array('letra'=>'a', 'palabra'=>'afinador'),
array('letra'=>'a', 'palabra'=>'afinadura'),
array('letra'=>'a', 'palabra'=>'afinamiento'),
array('letra'=>'a', 'palabra'=>'afinar'),
array('letra'=>'a', 'palabra'=>'afincadamente'),
array('letra'=>'a', 'palabra'=>'afincado'),
array('letra'=>'a', 'palabra'=>'afincamiento'),
array('letra'=>'a', 'palabra'=>'afincar'),
array('letra'=>'a', 'palabra'=>'afinidad'),
array('letra'=>'a', 'palabra'=>'afino'),
array('letra'=>'a', 'palabra'=>'afinojar'),
array('letra'=>'a', 'palabra'=>'afirmacion'),
array('letra'=>'a', 'palabra'=>'afirmadamente'),
array('letra'=>'a', 'palabra'=>'afirmado'),
array('letra'=>'a', 'palabra'=>'afirmador'),
array('letra'=>'a', 'palabra'=>'afirmamiento'),
array('letra'=>'a', 'palabra'=>'afirmar'),
array('letra'=>'a', 'palabra'=>'afirmativo'),
array('letra'=>'a', 'palabra'=>'afirolar'),
array('letra'=>'a', 'palabra'=>'afistolar'),
array('letra'=>'a', 'palabra'=>'afistular'),
array('letra'=>'a', 'palabra'=>'afiuciar'),
array('letra'=>'a', 'palabra'=>'aflacar'),
array('letra'=>'a', 'palabra'=>'aflamar'),
array('letra'=>'a', 'palabra'=>'aflamencado'),
array('letra'=>'a', 'palabra'=>'aflaquecerse'),
array('letra'=>'a', 'palabra'=>'aflatarse'),
array('letra'=>'a', 'palabra'=>'aflato'),
array('letra'=>'a', 'palabra'=>'aflautado'),
array('letra'=>'a', 'palabra'=>'aflautar'),
array('letra'=>'a', 'palabra'=>'aflechado'),
array('letra'=>'a', 'palabra'=>'aflechate'),
array('letra'=>'a', 'palabra'=>'afletar'),
array('letra'=>'a', 'palabra'=>'afliccion'),
array('letra'=>'a', 'palabra'=>'aflictivo'),
array('letra'=>'a', 'palabra'=>'aflicto'),
array('letra'=>'a', 'palabra'=>'afligible'),
array('letra'=>'a', 'palabra'=>'afligidamente'),
array('letra'=>'a', 'palabra'=>'afligimiento'),
array('letra'=>'a', 'palabra'=>'afligir'),
array('letra'=>'a', 'palabra'=>'aflojamiento'),
array('letra'=>'a', 'palabra'=>'aflojar'),
array('letra'=>'a', 'palabra'=>'aflorado'),
array('letra'=>'a', 'palabra'=>'afloramiento'),
array('letra'=>'a', 'palabra'=>'aflorar'),
array('letra'=>'a', 'palabra'=>'afluencia'),
array('letra'=>'a', 'palabra'=>'afluente'),
array('letra'=>'a', 'palabra'=>'afluentemente'),
array('letra'=>'a', 'palabra'=>'afluir'),
array('letra'=>'a', 'palabra'=>'aflujo'),
array('letra'=>'a', 'palabra'=>'afofarse'),
array('letra'=>'a', 'palabra'=>'afogar'),
array('letra'=>'a', 'palabra'=>'afogarar'),
array('letra'=>'a', 'palabra'=>'afogonadura'),
array('letra'=>'a', 'palabra'=>'afollado'),
array('letra'=>'a', 'palabra'=>'afollar'),
array('letra'=>'a', 'palabra'=>'afondar'),
array('letra'=>'a', 'palabra'=>'afonia'),
array('letra'=>'a', 'palabra'=>'afonico'),
array('letra'=>'a', 'palabra'=>'afono'),
array('letra'=>'a', 'palabra'=>'aforado'),
array('letra'=>'a', 'palabra'=>'aforador'),
array('letra'=>'a', 'palabra'=>'aforamiento'),
array('letra'=>'a', 'palabra'=>'aforar'),
array('letra'=>'a', 'palabra'=>'aforcar'),
array('letra'=>'a', 'palabra'=>'aforisma'),
array('letra'=>'a', 'palabra'=>'aforismo'),
array('letra'=>'a', 'palabra'=>'aforistico'),
array('letra'=>'a', 'palabra'=>'aforo'),
array('letra'=>'a', 'palabra'=>'aforrado'),
array('letra'=>'a', 'palabra'=>'aforrador'),
array('letra'=>'a', 'palabra'=>'aforradura'),
array('letra'=>'a', 'palabra'=>'aforramiento'),
array('letra'=>'a', 'palabra'=>'aforrar'),
array('letra'=>'a', 'palabra'=>'aforrecho'),
array('letra'=>'a', 'palabra'=>'aforro'),
array('letra'=>'a', 'palabra'=>'afortalar'),
array('letra'=>'a', 'palabra'=>'afortunadamente'),
array('letra'=>'a', 'palabra'=>'afortunado'),
array('letra'=>'a', 'palabra'=>'afortunar'),
array('letra'=>'a', 'palabra'=>'afosarse'),
array('letra'=>'a', 'palabra'=>'afoscarse'),
array('letra'=>'a', 'palabra'=>'afotico'),
array('letra'=>'a', 'palabra'=>'afrailado'),
array('letra'=>'a', 'palabra'=>'afrailamiento'),
array('letra'=>'a', 'palabra'=>'afrailar'),
array('letra'=>'a', 'palabra'=>'afrancar'),
array('letra'=>'a', 'palabra'=>'afrancesado'),
array('letra'=>'a', 'palabra'=>'afrancesamiento'),
array('letra'=>'a', 'palabra'=>'afrancesar'),
array('letra'=>'a', 'palabra'=>'afranjado'),
array('letra'=>'a', 'palabra'=>'afrecharse'),
array('letra'=>'a', 'palabra'=>'afrechero'),
array('letra'=>'a', 'palabra'=>'afrecho'),
array('letra'=>'a', 'palabra'=>'afrenillar'),
array('letra'=>'a', 'palabra'=>'afrenta'),
array('letra'=>'a', 'palabra'=>'afrentador'),
array('letra'=>'a', 'palabra'=>'afrentar'),
array('letra'=>'a', 'palabra'=>'afrentoso'),
array('letra'=>'a', 'palabra'=>'afreñir'),
array('letra'=>'a', 'palabra'=>'afresado'),
array('letra'=>'a', 'palabra'=>'afretar'),
array('letra'=>'a', 'palabra'=>'africado'),
array('letra'=>'a', 'palabra'=>'africana'),
array('letra'=>'a', 'palabra'=>'africanidad'),
array('letra'=>'a', 'palabra'=>'africanismo'),
array('letra'=>'a', 'palabra'=>'africanista'),
array('letra'=>'a', 'palabra'=>'africanizar'),
array('letra'=>'a', 'palabra'=>'africano'),
array('letra'=>'a', 'palabra'=>'africo'),
array('letra'=>'a', 'palabra'=>'afrijolar'),
array('letra'=>'a', 'palabra'=>'afrikaans'),
array('letra'=>'a', 'palabra'=>'afrikaner'),
array('letra'=>'a', 'palabra'=>'afrisonado'),
array('letra'=>'a', 'palabra'=>'afro'),
array('letra'=>'a', 'palabra'=>'afroamericano'),
array('letra'=>'a', 'palabra'=>'afroantillano'),
array('letra'=>'a', 'palabra'=>'afroasiatico'),
array('letra'=>'a', 'palabra'=>'afrocubano'),
array('letra'=>'a', 'palabra'=>'afrodisiaco'),
array('letra'=>'a', 'palabra'=>'afrodisiaco'),
array('letra'=>'a', 'palabra'=>'afrodita'),
array('letra'=>'a', 'palabra'=>'afronegrismo'),
array('letra'=>'a', 'palabra'=>'afronegro'),
array('letra'=>'a', 'palabra'=>'afronitro'),
array('letra'=>'a', 'palabra'=>'afrontacion'),
array('letra'=>'a', 'palabra'=>'afrontado'),
array('letra'=>'a', 'palabra'=>'afrontamiento'),
array('letra'=>'a', 'palabra'=>'afrontar'),
array('letra'=>'a', 'palabra'=>'afruenta'),
array('letra'=>'a', 'palabra'=>'afrutado'),
array('letra'=>'a', 'palabra'=>'afta'),
array('letra'=>'a', 'palabra'=>'aftoso'),
array('letra'=>'a', 'palabra'=>'afuciado'),
array('letra'=>'a', 'palabra'=>'afuciar'),
array('letra'=>'a', 'palabra'=>'afuera'),
array('letra'=>'a', 'palabra'=>'afuereño'),
array('letra'=>'a', 'palabra'=>'afuerino'),
array('letra'=>'a', 'palabra'=>'afuero'),
array('letra'=>'a', 'palabra'=>'afufa'),
array('letra'=>'a', 'palabra'=>'afufar'),
array('letra'=>'a', 'palabra'=>'afufon'),
array('letra'=>'a', 'palabra'=>'afumado'),
array('letra'=>'a', 'palabra'=>'afumar'),
array('letra'=>'a', 'palabra'=>'afusion'),
array('letra'=>'a', 'palabra'=>'afuste'),
array('letra'=>'a', 'palabra'=>'aga'),
array('letra'=>'a', 'palabra'=>'agabachar'),
array('letra'=>'a', 'palabra'=>'agace'),
array('letra'=>'a', 'palabra'=>'agace'),
array('letra'=>'a', 'palabra'=>'agachada'),
array('letra'=>'a', 'palabra'=>'agachadera'),
array('letra'=>'a', 'palabra'=>'agachadita'),
array('letra'=>'a', 'palabra'=>'agachadiza'),
array('letra'=>'a', 'palabra'=>'agachaparse'),
array('letra'=>'a', 'palabra'=>'agachar'),
array('letra'=>'a', 'palabra'=>'agache'),
array('letra'=>'a', 'palabra'=>'agachona'),
array('letra'=>'a', 'palabra'=>'agadon'),
array('letra'=>'a', 'palabra'=>'agalactia'),
array('letra'=>'a', 'palabra'=>'agalbanado'),
array('letra'=>'a', 'palabra'=>'agalerar'),
array('letra'=>'a', 'palabra'=>'agalla'),
array('letra'=>'a', 'palabra'=>'agallado'),
array('letra'=>'a', 'palabra'=>'agalladura'),
array('letra'=>'a', 'palabra'=>'agallara'),
array('letra'=>'a', 'palabra'=>'agallegado'),
array('letra'=>'a', 'palabra'=>'agallo'),
array('letra'=>'a', 'palabra'=>'agallon'),
array('letra'=>'a', 'palabra'=>'agallonado'),
array('letra'=>'a', 'palabra'=>'agalludo'),
array('letra'=>'a', 'palabra'=>'agaloco'),
array('letra'=>'a', 'palabra'=>'agami'),
array('letra'=>'a', 'palabra'=>'agamitar'),
array('letra'=>'a', 'palabra'=>'agamuzado'),
array('letra'=>'a', 'palabra'=>'aganar'),
array('letra'=>'a', 'palabra'=>'agangrenarse'),
array('letra'=>'a', 'palabra'=>'aganipeo'),
array('letra'=>'a', 'palabra'=>'agañotar'),
array('letra'=>'a', 'palabra'=>'agapanto'),
array('letra'=>'a', 'palabra'=>'agape'),
array('letra'=>'a', 'palabra'=>'agarabatado'),
array('letra'=>'a', 'palabra'=>'agarbado'),
array('letra'=>'a', 'palabra'=>'agarbanzado'),
array('letra'=>'a', 'palabra'=>'agarbanzar'),
array('letra'=>'a', 'palabra'=>'agarbarse'),
array('letra'=>'a', 'palabra'=>'agarbillar'),
array('letra'=>'a', 'palabra'=>'agardamarse'),
array('letra'=>'a', 'palabra'=>'agareno'),
array('letra'=>'a', 'palabra'=>'agaricaceo'),
array('letra'=>'a', 'palabra'=>'agarico'),
array('letra'=>'a', 'palabra'=>'agarrada'),
array('letra'=>'a', 'palabra'=>'agarradera'),
array('letra'=>'a', 'palabra'=>'agarradero'),
array('letra'=>'a', 'palabra'=>'agarrado'),
array('letra'=>'a', 'palabra'=>'agarrador'),
array('letra'=>'a', 'palabra'=>'agarrafador'),
array('letra'=>'a', 'palabra'=>'agarrafar'),
array('letra'=>'a', 'palabra'=>'agarrante'),
array('letra'=>'a', 'palabra'=>'agarrar'),
array('letra'=>'a', 'palabra'=>'agarre'),
array('letra'=>'a', 'palabra'=>'agarro'),
array('letra'=>'a', 'palabra'=>'agarrochador'),
array('letra'=>'a', 'palabra'=>'agarrochar'),
array('letra'=>'a', 'palabra'=>'agarrochear'),
array('letra'=>'a', 'palabra'=>'agarron'),
array('letra'=>'a', 'palabra'=>'agarrotado'),
array('letra'=>'a', 'palabra'=>'agarrotamiento'),
array('letra'=>'a', 'palabra'=>'agarrotar'),
array('letra'=>'a', 'palabra'=>'agarrotear'),
array('letra'=>'a', 'palabra'=>'agasajable'),
array('letra'=>'a', 'palabra'=>'agasajado'),
array('letra'=>'a', 'palabra'=>'agasajador'),
array('letra'=>'a', 'palabra'=>'agasajar'),
array('letra'=>'a', 'palabra'=>'agasajo'),
array('letra'=>'a', 'palabra'=>'agata'),
array('letra'=>'a', 'palabra'=>'agateador'),
array('letra'=>'a', 'palabra'=>'agatino'),
array('letra'=>'a', 'palabra'=>'agatizarse'),
array('letra'=>'a', 'palabra'=>'agauchado'),
array('letra'=>'a', 'palabra'=>'agavanza'),
array('letra'=>'a', 'palabra'=>'agavanzo'),
array('letra'=>'a', 'palabra'=>'agave'),
array('letra'=>'a', 'palabra'=>'agavillador'),
array('letra'=>'a', 'palabra'=>'agavillar'),
array('letra'=>'a', 'palabra'=>'agazapar'),
array('letra'=>'a', 'palabra'=>'agencia'),
array('letra'=>'a', 'palabra'=>'agenciar'),
array('letra'=>'a', 'palabra'=>'agenciero'),
array('letra'=>'a', 'palabra'=>'agencioso'),
array('letra'=>'a', 'palabra'=>'agenda'),
array('letra'=>'a', 'palabra'=>'agenesia'),
array('letra'=>'a', 'palabra'=>'agente'),
array('letra'=>'a', 'palabra'=>'agerasia'),
array('letra'=>'a', 'palabra'=>'agerato'),
array('letra'=>'a', 'palabra'=>'agermanarse'),
array('letra'=>'a', 'palabra'=>'agestado'),
array('letra'=>'a', 'palabra'=>'agestarse'),
array('letra'=>'a', 'palabra'=>'agestion'),
array('letra'=>'a', 'palabra'=>'agibilibus'),
array('letra'=>'a', 'palabra'=>'agible'),
array('letra'=>'a', 'palabra'=>'agigantado'),
array('letra'=>'a', 'palabra'=>'agigantar'),
array('letra'=>'a', 'palabra'=>'agigotar'),
array('letra'=>'a', 'palabra'=>'agil'),
array('letra'=>'a', 'palabra'=>'agilibus'),
array('letra'=>'a', 'palabra'=>'agilidad'),
array('letra'=>'a', 'palabra'=>'agilitar'),
array('letra'=>'a', 'palabra'=>'agilizacion'),
array('letra'=>'a', 'palabra'=>'agilizar'),
array('letra'=>'a', 'palabra'=>'agio'),
array('letra'=>'a', 'palabra'=>'agiotador'),
array('letra'=>'a', 'palabra'=>'agiotaje'),
array('letra'=>'a', 'palabra'=>'agiotista'),
array('letra'=>'a', 'palabra'=>'agitable'),
array('letra'=>'a', 'palabra'=>'agitacion'),
array('letra'=>'a', 'palabra'=>'agitador'),
array('letra'=>'a', 'palabra'=>'agitanado'),
array('letra'=>'a', 'palabra'=>'agitanar'),
array('letra'=>'a', 'palabra'=>'agitante'),
array('letra'=>'a', 'palabra'=>'agitar'),
array('letra'=>'a', 'palabra'=>'aglomeracion'),
array('letra'=>'a', 'palabra'=>'aglomerado'),
array('letra'=>'a', 'palabra'=>'aglomerante'),
array('letra'=>'a', 'palabra'=>'aglomerar'),
array('letra'=>'a', 'palabra'=>'aglutinacion'),
array('letra'=>'a', 'palabra'=>'aglutinante'),
array('letra'=>'a', 'palabra'=>'aglutinar'),
array('letra'=>'a', 'palabra'=>'aglutinina'),
array('letra'=>'a', 'palabra'=>'agnacion'),
array('letra'=>'a', 'palabra'=>'agnado'),
array('letra'=>'a', 'palabra'=>'agnaticio'),
array('letra'=>'a', 'palabra'=>'agnicion'),
array('letra'=>'a', 'palabra'=>'agnocasto'),
array('letra'=>'a', 'palabra'=>'agnombre'),
array('letra'=>'a', 'palabra'=>'agnomento'),
array('letra'=>'a', 'palabra'=>'agnominacion'),
array('letra'=>'a', 'palabra'=>'agnosia'),
array('letra'=>'a', 'palabra'=>'agnosico'),
array('letra'=>'a', 'palabra'=>'agnosticismo'),
array('letra'=>'a', 'palabra'=>'agnostico'),
array('letra'=>'a', 'palabra'=>'agnus'),
array('letra'=>'a', 'palabra'=>'agnusdei'),
array('letra'=>'a', 'palabra'=>'agobiado'),
array('letra'=>'a', 'palabra'=>'agobiador'),
array('letra'=>'a', 'palabra'=>'agobiante'),
array('letra'=>'a', 'palabra'=>'agobiar'),
array('letra'=>'a', 'palabra'=>'agobio'),
array('letra'=>'a', 'palabra'=>'agogia'),
array('letra'=>'a', 'palabra'=>'agolar'),
array('letra'=>'a', 'palabra'=>'agolletar'),
array('letra'=>'a', 'palabra'=>'agolpamiento'),
array('letra'=>'a', 'palabra'=>'agolpar'),
array('letra'=>'a', 'palabra'=>'agonal'),
array('letra'=>'a', 'palabra'=>'agonia'),
array('letra'=>'a', 'palabra'=>'agonico'),
array('letra'=>'a', 'palabra'=>'agonioso'),
array('letra'=>'a', 'palabra'=>'agonista'),
array('letra'=>'a', 'palabra'=>'agonistica'),
array('letra'=>'a', 'palabra'=>'agonistico'),
array('letra'=>'a', 'palabra'=>'agonizante'),
array('letra'=>'a', 'palabra'=>'agonizar'),
array('letra'=>'a', 'palabra'=>'agora'),
array('letra'=>'a', 'palabra'=>'agora'),
array('letra'=>'a', 'palabra'=>'agorador'),
array('letra'=>'a', 'palabra'=>'agorafobia'),
array('letra'=>'a', 'palabra'=>'agorar'),
array('letra'=>'a', 'palabra'=>'agoreria'),
array('letra'=>'a', 'palabra'=>'agorero'),
array('letra'=>'a', 'palabra'=>'agorgojarse'),
array('letra'=>'a', 'palabra'=>'agosta'),
array('letra'=>'a', 'palabra'=>'agostadero'),
array('letra'=>'a', 'palabra'=>'agostado'),
array('letra'=>'a', 'palabra'=>'agostador'),
array('letra'=>'a', 'palabra'=>'agostamiento'),
array('letra'=>'a', 'palabra'=>'agostar'),
array('letra'=>'a', 'palabra'=>'agosteño'),
array('letra'=>'a', 'palabra'=>'agostero'),
array('letra'=>'a', 'palabra'=>'agostia'),
array('letra'=>'a', 'palabra'=>'agostizo'),
array('letra'=>'a', 'palabra'=>'agosto'),
array('letra'=>'a', 'palabra'=>'agotable'),
array('letra'=>'a', 'palabra'=>'agotador'),
array('letra'=>'a', 'palabra'=>'agotamiento'),
array('letra'=>'a', 'palabra'=>'agotar'),
array('letra'=>'a', 'palabra'=>'agote'),
array('letra'=>'a', 'palabra'=>'agovia'),
array('letra'=>'a', 'palabra'=>'agozcado'),
array('letra'=>'a', 'palabra'=>'agracejina'),
array('letra'=>'a', 'palabra'=>'agracejo'),
array('letra'=>'a', 'palabra'=>'agraceño'),
array('letra'=>'a', 'palabra'=>'agracero'),
array('letra'=>'a', 'palabra'=>'agraciadamente'),
array('letra'=>'a', 'palabra'=>'agraciado'),
array('letra'=>'a', 'palabra'=>'agraciar'),
array('letra'=>'a', 'palabra'=>'agracillo'),
array('letra'=>'a', 'palabra'=>'agradable'),
array('letra'=>'a', 'palabra'=>'agradablemente'),
array('letra'=>'a', 'palabra'=>'agradador'),
array('letra'=>'a', 'palabra'=>'agradamiento'),
array('letra'=>'a', 'palabra'=>'agradar'),
array('letra'=>'a', 'palabra'=>'agradecer'),
array('letra'=>'a', 'palabra'=>'agradecido'),
array('letra'=>'a', 'palabra'=>'agradecimiento'),
array('letra'=>'a', 'palabra'=>'agrado'),
array('letra'=>'a', 'palabra'=>'agrafia'),
array('letra'=>'a', 'palabra'=>'agrafia'),
array('letra'=>'a', 'palabra'=>'agrafo'),
array('letra'=>'a', 'palabra'=>'agramadera'),
array('letra'=>'a', 'palabra'=>'agramado'),
array('letra'=>'a', 'palabra'=>'agramador'),
array('letra'=>'a', 'palabra'=>'agramante'),
array('letra'=>'a', 'palabra'=>'agramar'),
array('letra'=>'a', 'palabra'=>'agramatical'),
array('letra'=>'a', 'palabra'=>'agramaticalidad'),
array('letra'=>'a', 'palabra'=>'agramente'),
array('letra'=>'a', 'palabra'=>'agramilar'),
array('letra'=>'a', 'palabra'=>'agramiza'),
array('letra'=>'a', 'palabra'=>'agramontes'),
array('letra'=>'a', 'palabra'=>'agrandado'),
array('letra'=>'a', 'palabra'=>'agrandamiento'),
array('letra'=>'a', 'palabra'=>'agrandar'),
array('letra'=>'a', 'palabra'=>'agranujado'),
array('letra'=>'a', 'palabra'=>'agrario'),
array('letra'=>'a', 'palabra'=>'agrarismo'),
array('letra'=>'a', 'palabra'=>'agrarista'),
array('letra'=>'a', 'palabra'=>'agras'),
array('letra'=>'a', 'palabra'=>'agravacion'),
array('letra'=>'a', 'palabra'=>'agravador'),
array('letra'=>'a', 'palabra'=>'agravamiento'),
array('letra'=>'a', 'palabra'=>'agravante'),
array('letra'=>'a', 'palabra'=>'agravantemente'),
array('letra'=>'a', 'palabra'=>'agravar'),
array('letra'=>'a', 'palabra'=>'agravatorio'),
array('letra'=>'a', 'palabra'=>'agraviadamente'),
array('letra'=>'a', 'palabra'=>'agraviado'),
array('letra'=>'a', 'palabra'=>'agraviador'),
array('letra'=>'a', 'palabra'=>'agraviamiento'),
array('letra'=>'a', 'palabra'=>'agraviar'),
array('letra'=>'a', 'palabra'=>'agravio'),
array('letra'=>'a', 'palabra'=>'agravioso'),
array('letra'=>'a', 'palabra'=>'agraz'),
array('letra'=>'a', 'palabra'=>'agrazada'),
array('letra'=>'a', 'palabra'=>'agrazar'),
array('letra'=>'a', 'palabra'=>'agrazon'),
array('letra'=>'a', 'palabra'=>'agre'),
array('letra'=>'a', 'palabra'=>'agrear'),
array('letra'=>'a', 'palabra'=>'agrecillo'),
array('letra'=>'a', 'palabra'=>'agredido'),
array('letra'=>'a', 'palabra'=>'agredir'),
array('letra'=>'a', 'palabra'=>'agregacion'),
array('letra'=>'a', 'palabra'=>'agregado'),
array('letra'=>'a', 'palabra'=>'agregaduria'),
array('letra'=>'a', 'palabra'=>'agregar'),
array('letra'=>'a', 'palabra'=>'agregativo'),
array('letra'=>'a', 'palabra'=>'agreman'),
array('letra'=>'a', 'palabra'=>'agremiacion'),
array('letra'=>'a', 'palabra'=>'agremiar'),
array('letra'=>'a', 'palabra'=>'agresion'),
array('letra'=>'a', 'palabra'=>'agresivamente'),
array('letra'=>'a', 'palabra'=>'agresividad'),
array('letra'=>'a', 'palabra'=>'agresivo'),
array('letra'=>'a', 'palabra'=>'agresor'),
array('letra'=>'a', 'palabra'=>'agreste'),
array('letra'=>'a', 'palabra'=>'agreta'),
array('letra'=>'a', 'palabra'=>'agreza'),
array('letra'=>'a', 'palabra'=>'agriado'),
array('letra'=>'a', 'palabra'=>'agriamente'),
array('letra'=>'a', 'palabra'=>'agriar'),
array('letra'=>'a', 'palabra'=>'agriaz'),
array('letra'=>'a', 'palabra'=>'agricola'),
array('letra'=>'a', 'palabra'=>'agricultor'),
array('letra'=>'a', 'palabra'=>'agricultura'),
array('letra'=>'a', 'palabra'=>'agridulce'),
array('letra'=>'a', 'palabra'=>'agriera'),
array('letra'=>'a', 'palabra'=>'agrietamiento'),
array('letra'=>'a', 'palabra'=>'agrietar'),
array('letra'=>'a', 'palabra'=>'agrifada'),
array('letra'=>'a', 'palabra'=>'agrifolio'),
array('letra'=>'a', 'palabra'=>'agrilla'),
array('letra'=>'a', 'palabra'=>'agrillarse'),
array('letra'=>'a', 'palabra'=>'agrimensor'),
array('letra'=>'a', 'palabra'=>'agrimensura'),
array('letra'=>'a', 'palabra'=>'agrimonia'),
array('letra'=>'a', 'palabra'=>'agringado'),
array('letra'=>'a', 'palabra'=>'agringarse'),
array('letra'=>'a', 'palabra'=>'agrio'),
array('letra'=>'a', 'palabra'=>'agrion'),
array('letra'=>'a', 'palabra'=>'agriotipo'),
array('letra'=>'a', 'palabra'=>'agripalma'),
array('letra'=>'a', 'palabra'=>'agrisado'),
array('letra'=>'a', 'palabra'=>'agrisar'),
array('letra'=>'a', 'palabra'=>'agrisetado'),
array('letra'=>'a', 'palabra'=>'agro'),
array('letra'=>'a', 'palabra'=>'agroalimentacion'),
array('letra'=>'a', 'palabra'=>'agroalimentario'),
array('letra'=>'a', 'palabra'=>'agroforestal'),
array('letra'=>'a', 'palabra'=>'agroindustria'),
array('letra'=>'a', 'palabra'=>'agroindustrial'),
array('letra'=>'a', 'palabra'=>'agrologia'),
array('letra'=>'a', 'palabra'=>'agrologico'),
array('letra'=>'a', 'palabra'=>'agronomia'),
array('letra'=>'a', 'palabra'=>'agronomico'),
array('letra'=>'a', 'palabra'=>'agronomo'),
array('letra'=>'a', 'palabra'=>'agropecuario'),
array('letra'=>'a', 'palabra'=>'agroquimica'),
array('letra'=>'a', 'palabra'=>'agror'),
array('letra'=>'a', 'palabra'=>'agrumar'),
array('letra'=>'a', 'palabra'=>'agrupable'),
array('letra'=>'a', 'palabra'=>'agrupacion'),
array('letra'=>'a', 'palabra'=>'agrupador'),
array('letra'=>'a', 'palabra'=>'agrupamiento'),
array('letra'=>'a', 'palabra'=>'agrupar'),
array('letra'=>'a', 'palabra'=>'agrura'),
array('letra'=>'a', 'palabra'=>'agua'),
array('letra'=>'a', 'palabra'=>'aguacal'),
array('letra'=>'a', 'palabra'=>'aguacatal'),
array('letra'=>'a', 'palabra'=>'aguacate'),
array('letra'=>'a', 'palabra'=>'aguacatero'),
array('letra'=>'a', 'palabra'=>'aguacatillo'),
array('letra'=>'a', 'palabra'=>'aguacero'),
array('letra'=>'a', 'palabra'=>'aguacha'),
array('letra'=>'a', 'palabra'=>'aguachacha'),
array('letra'=>'a', 'palabra'=>'aguachar'),
array('letra'=>'a', 'palabra'=>'aguachas'),
array('letra'=>'a', 'palabra'=>'aguachento'),
array('letra'=>'a', 'palabra'=>'aguachinar'),
array('letra'=>'a', 'palabra'=>'aguachirle'),
array('letra'=>'a', 'palabra'=>'aguacibera'),
array('letra'=>'a', 'palabra'=>'aguacil'),
array('letra'=>'a', 'palabra'=>'aguada'),
array('letra'=>'a', 'palabra'=>'aguadar'),
array('letra'=>'a', 'palabra'=>'aguadero'),
array('letra'=>'a', 'palabra'=>'aguadija'),
array('letra'=>'a', 'palabra'=>'aguado'),
array('letra'=>'a', 'palabra'=>'aguador'),
array('letra'=>'a', 'palabra'=>'aguaducho'),
array('letra'=>'a', 'palabra'=>'aguadulce'),
array('letra'=>'a', 'palabra'=>'aguadura'),
array('letra'=>'a', 'palabra'=>'aguafiestas'),
array('letra'=>'a', 'palabra'=>'aguafuerte'),
array('letra'=>'a', 'palabra'=>'aguafuertista'),
array('letra'=>'a', 'palabra'=>'aguagoma'),
array('letra'=>'a', 'palabra'=>'aguai'),
array('letra'=>'a', 'palabra'=>'aguaitacaiman'),
array('letra'=>'a', 'palabra'=>'aguaitador'),
array('letra'=>'a', 'palabra'=>'aguaitamiento'),
array('letra'=>'a', 'palabra'=>'aguaitar'),
array('letra'=>'a', 'palabra'=>'aguaite'),
array('letra'=>'a', 'palabra'=>'aguajaque'),
array('letra'=>'a', 'palabra'=>'aguaje'),
array('letra'=>'a', 'palabra'=>'aguajero'),
array('letra'=>'a', 'palabra'=>'aguaji'),
array('letra'=>'a', 'palabra'=>'agualoja'),
array('letra'=>'a', 'palabra'=>'agualotal'),
array('letra'=>'a', 'palabra'=>'aguamala'),
array('letra'=>'a', 'palabra'=>'aguamanil'),
array('letra'=>'a', 'palabra'=>'aguamanos'),
array('letra'=>'a', 'palabra'=>'aguamar'),
array('letra'=>'a', 'palabra'=>'aguamarina'),
array('letra'=>'a', 'palabra'=>'aguamelado'),
array('letra'=>'a', 'palabra'=>'aguamiel'),
array('letra'=>'a', 'palabra'=>'aguanal'),
array('letra'=>'a', 'palabra'=>'aguanieve'),
array('letra'=>'a', 'palabra'=>'aguanieves'),
array('letra'=>'a', 'palabra'=>'aguanosidad'),
array('letra'=>'a', 'palabra'=>'aguanoso'),
array('letra'=>'a', 'palabra'=>'aguantable'),
array('letra'=>'a', 'palabra'=>'aguantaderas'),
array('letra'=>'a', 'palabra'=>'aguantador'),
array('letra'=>'a', 'palabra'=>'aguantar'),
array('letra'=>'a', 'palabra'=>'aguante'),
array('letra'=>'a', 'palabra'=>'aguanton'),
array('letra'=>'a', 'palabra'=>'aguañon'),
array('letra'=>'a', 'palabra'=>'aguape'),
array('letra'=>'a', 'palabra'=>'aguapey'),
array('letra'=>'a', 'palabra'=>'aguapie'),
array('letra'=>'a', 'palabra'=>'aguar'),
array('letra'=>'a', 'palabra'=>'aguara'),
array('letra'=>'a', 'palabra'=>'aguaraiba'),
array('letra'=>'a', 'palabra'=>'aguaraparse'),
array('letra'=>'a', 'palabra'=>'aguardada'),
array('letra'=>'a', 'palabra'=>'aguardadero'),
array('letra'=>'a', 'palabra'=>'aguardador'),
array('letra'=>'a', 'palabra'=>'aguardamiento'),
array('letra'=>'a', 'palabra'=>'aguardar'),
array('letra'=>'a', 'palabra'=>'aguardenteria'),
array('letra'=>'a', 'palabra'=>'aguardentero'),
array('letra'=>'a', 'palabra'=>'aguardentoso'),
array('letra'=>'a', 'palabra'=>'aguardiente'),
array('letra'=>'a', 'palabra'=>'aguardillado'),
array('letra'=>'a', 'palabra'=>'aguardo'),
array('letra'=>'a', 'palabra'=>'aguaribay'),
array('letra'=>'a', 'palabra'=>'aguarico'),
array('letra'=>'a', 'palabra'=>'aguarrada'),
array('letra'=>'a', 'palabra'=>'aguarras'),
array('letra'=>'a', 'palabra'=>'aguasal'),
array('letra'=>'a', 'palabra'=>'aguascalentense'),
array('letra'=>'a', 'palabra'=>'aguasol'),
array('letra'=>'a', 'palabra'=>'aguate'),
array('letra'=>'a', 'palabra'=>'aguatero'),
array('letra'=>'a', 'palabra'=>'aguatinta'),
array('letra'=>'a', 'palabra'=>'aguatocha'),
array('letra'=>'a', 'palabra'=>'aguatocho'),
array('letra'=>'a', 'palabra'=>'aguaturma'),
array('letra'=>'a', 'palabra'=>'aguaucle'),
array('letra'=>'a', 'palabra'=>'aguaverde'),
array('letra'=>'a', 'palabra'=>'aguaviento'),
array('letra'=>'a', 'palabra'=>'aguavientos'),
array('letra'=>'a', 'palabra'=>'aguavilla'),
array('letra'=>'a', 'palabra'=>'aguay'),
array('letra'=>'a', 'palabra'=>'aguayo'),
array('letra'=>'a', 'palabra'=>'aguaza'),
array('letra'=>'a', 'palabra'=>'aguazal'),
array('letra'=>'a', 'palabra'=>'aguazar'),
array('letra'=>'a', 'palabra'=>'aguazo'),
array('letra'=>'a', 'palabra'=>'aguazoso'),
array('letra'=>'a', 'palabra'=>'aguazul'),
array('letra'=>'a', 'palabra'=>'aguazur'),
array('letra'=>'a', 'palabra'=>'agucia'),
array('letra'=>'a', 'palabra'=>'aguciar'),
array('letra'=>'a', 'palabra'=>'agucioso'),
array('letra'=>'a', 'palabra'=>'agudamente'),
array('letra'=>'a', 'palabra'=>'agudez'),
array('letra'=>'a', 'palabra'=>'agudeza'),
array('letra'=>'a', 'palabra'=>'agudizacion'),
array('letra'=>'a', 'palabra'=>'agudizar'),
array('letra'=>'a', 'palabra'=>'agudo'),
array('letra'=>'a', 'palabra'=>'aguedita'),
array('letra'=>'a', 'palabra'=>'agüela'),
array('letra'=>'a', 'palabra'=>'agüera'),
array('letra'=>'a', 'palabra'=>'agüerar'),
array('letra'=>'a', 'palabra'=>'agüero'),
array('letra'=>'a', 'palabra'=>'aguerrido'),
array('letra'=>'a', 'palabra'=>'aguija'),
array('letra'=>'a', 'palabra'=>'aguijada'),
array('letra'=>'a', 'palabra'=>'aguijadera'),
array('letra'=>'a', 'palabra'=>'aguijador'),
array('letra'=>'a', 'palabra'=>'aguijadura'),
array('letra'=>'a', 'palabra'=>'aguijar'),
array('letra'=>'a', 'palabra'=>'aguijon'),
array('letra'=>'a', 'palabra'=>'aguijonada'),
array('letra'=>'a', 'palabra'=>'aguijonamiento'),
array('letra'=>'a', 'palabra'=>'aguijonar'),
array('letra'=>'a', 'palabra'=>'aguijonazo'),
array('letra'=>'a', 'palabra'=>'aguijoneador'),
array('letra'=>'a', 'palabra'=>'aguijonear'),
array('letra'=>'a', 'palabra'=>'aguila'),
array('letra'=>'a', 'palabra'=>'aguilando'),
array('letra'=>'a', 'palabra'=>'aguileña'),
array('letra'=>'a', 'palabra'=>'aguileño'),
array('letra'=>'a', 'palabra'=>'aguililla'),
array('letra'=>'a', 'palabra'=>'aguilon'),
array('letra'=>'a', 'palabra'=>'aguilonia'),
array('letra'=>'a', 'palabra'=>'aguilucho'),
array('letra'=>'a', 'palabra'=>'aguin'),
array('letra'=>'a', 'palabra'=>'aguinaldo'),
array('letra'=>'a', 'palabra'=>'agüio'),
array('letra'=>'a', 'palabra'=>'aguisado'),
array('letra'=>'a', 'palabra'=>'aguisamiento'),
array('letra'=>'a', 'palabra'=>'aguisar'),
array('letra'=>'a', 'palabra'=>'agüista'),
array('letra'=>'a', 'palabra'=>'agüita'),
array('letra'=>'a', 'palabra'=>'aguizgar'),
array('letra'=>'a', 'palabra'=>'agüizote'),
array('letra'=>'a', 'palabra'=>'aguja'),
array('letra'=>'a', 'palabra'=>'agujadera'),
array('letra'=>'a', 'palabra'=>'agujal'),
array('letra'=>'a', 'palabra'=>'agujar'),
array('letra'=>'a', 'palabra'=>'agujazo'),
array('letra'=>'a', 'palabra'=>'agujerar'),
array('letra'=>'a', 'palabra'=>'agujerear'),
array('letra'=>'a', 'palabra'=>'agujero'),
array('letra'=>'a', 'palabra'=>'agujeta'),
array('letra'=>'a', 'palabra'=>'agujeteria'),
array('letra'=>'a', 'palabra'=>'agujetero'),
array('letra'=>'a', 'palabra'=>'agujon'),
array('letra'=>'a', 'palabra'=>'agujuela'),
array('letra'=>'a', 'palabra'=>'aguosidad'),
array('letra'=>'a', 'palabra'=>'aguoso'),
array('letra'=>'a', 'palabra'=>'agur'),
array('letra'=>'a', 'palabra'=>'agusanamiento'),
array('letra'=>'a', 'palabra'=>'agusanarse'),
array('letra'=>'a', 'palabra'=>'agustin'),
array('letra'=>'a', 'palabra'=>'agustinianismo'),
array('letra'=>'a', 'palabra'=>'agustiniano'),
array('letra'=>'a', 'palabra'=>'agustino'),
array('letra'=>'a', 'palabra'=>'aguti'),
array('letra'=>'a', 'palabra'=>'aguzadero'),
array('letra'=>'a', 'palabra'=>'aguzado'),
array('letra'=>'a', 'palabra'=>'aguzador'),
array('letra'=>'a', 'palabra'=>'aguzadura'),
array('letra'=>'a', 'palabra'=>'aguzamiento'),
array('letra'=>'a', 'palabra'=>'aguzanieves'),
array('letra'=>'a', 'palabra'=>'aguzar'),
array('letra'=>'a', 'palabra'=>'aguzonazo'),
array('letra'=>'a', 'palabra'=>'ah'),
array('letra'=>'a', 'palabra'=>'ahacado'),
array('letra'=>'a', 'palabra'=>'ahajar'),
array('letra'=>'a', 'palabra'=>'ahe'),
array('letra'=>'a', 'palabra'=>'ahebrado'),
array('letra'=>'a', 'palabra'=>'ahechadero'),
array('letra'=>'a', 'palabra'=>'ahechador'),
array('letra'=>'a', 'palabra'=>'ahechadura'),
array('letra'=>'a', 'palabra'=>'ahechar'),
array('letra'=>'a', 'palabra'=>'ahecho'),
array('letra'=>'a', 'palabra'=>'ahelear'),
array('letra'=>'a', 'palabra'=>'ahelgado'),
array('letra'=>'a', 'palabra'=>'ahembrado'),
array('letra'=>'a', 'palabra'=>'aherir'),
array('letra'=>'a', 'palabra'=>'ahermanar'),
array('letra'=>'a', 'palabra'=>'aherrojamiento'),
array('letra'=>'a', 'palabra'=>'aherrojar'),
array('letra'=>'a', 'palabra'=>'aherrumbrar'),
array('letra'=>'a', 'palabra'=>'aherventar'),
array('letra'=>'a', 'palabra'=>'ahervoradamente'),
array('letra'=>'a', 'palabra'=>'ahervorarse'),
array('letra'=>'a', 'palabra'=>'ahetrar'),
array('letra'=>'a', 'palabra'=>'ahi'),
array('letra'=>'a', 'palabra'=>'ahidalgado'),
array('letra'=>'a', 'palabra'=>'ahidalgar'),
array('letra'=>'a', 'palabra'=>'ahigadado'),
array('letra'=>'a', 'palabra'=>'ahijadera'),
array('letra'=>'a', 'palabra'=>'ahijadero'),
array('letra'=>'a', 'palabra'=>'ahijado'),
array('letra'=>'a', 'palabra'=>'ahijador'),
array('letra'=>'a', 'palabra'=>'ahijamiento'),
array('letra'=>'a', 'palabra'=>'ahijar'),
array('letra'=>'a', 'palabra'=>'ahijuna'),
array('letra'=>'a', 'palabra'=>'ahilado'),
array('letra'=>'a', 'palabra'=>'ahilamiento'),
array('letra'=>'a', 'palabra'=>'ahilar'),
array('letra'=>'a', 'palabra'=>'ahilo'),
array('letra'=>'a', 'palabra'=>'ahina'),
array('letra'=>'a', 'palabra'=>'ahincadamente'),
array('letra'=>'a', 'palabra'=>'ahincado'),
array('letra'=>'a', 'palabra'=>'ahincamiento'),
array('letra'=>'a', 'palabra'=>'ahincanza'),
array('letra'=>'a', 'palabra'=>'ahincar'),
array('letra'=>'a', 'palabra'=>'ahinco'),
array('letra'=>'a', 'palabra'=>'ahinojar'),
array('letra'=>'a', 'palabra'=>'ahirmar'),
array('letra'=>'a', 'palabra'=>'ahitamiento'),
array('letra'=>'a', 'palabra'=>'ahitar'),
array('letra'=>'a', 'palabra'=>'ahitera'),
array('letra'=>'a', 'palabra'=>'ahito'),
array('letra'=>'a', 'palabra'=>'aho'),
array('letra'=>'a', 'palabra'=>'ahobachonado'),
array('letra'=>'a', 'palabra'=>'ahocicar'),
array('letra'=>'a', 'palabra'=>'ahocinarse'),
array('letra'=>'a', 'palabra'=>'ahogadero'),
array('letra'=>'a', 'palabra'=>'ahogadilla'),
array('letra'=>'a', 'palabra'=>'ahogadizo'),
array('letra'=>'a', 'palabra'=>'ahogado'),
array('letra'=>'a', 'palabra'=>'ahogador'),
array('letra'=>'a', 'palabra'=>'ahogamiento'),
array('letra'=>'a', 'palabra'=>'ahogar'),
array('letra'=>'a', 'palabra'=>'ahogaviejas'),
array('letra'=>'a', 'palabra'=>'ahogo'),
array('letra'=>'a', 'palabra'=>'ahoguio'),
array('letra'=>'a', 'palabra'=>'ahombrado'),
array('letra'=>'a', 'palabra'=>'ahondamiento'),
array('letra'=>'a', 'palabra'=>'ahondar'),
array('letra'=>'a', 'palabra'=>'ahonde'),
array('letra'=>'a', 'palabra'=>'ahora'),
array('letra'=>'a', 'palabra'=>'ahorcable'),
array('letra'=>'a', 'palabra'=>'ahorcadizo'),
array('letra'=>'a', 'palabra'=>'ahorcado'),
array('letra'=>'a', 'palabra'=>'ahorcadora'),
array('letra'=>'a', 'palabra'=>'ahorcadura'),
array('letra'=>'a', 'palabra'=>'ahorcajarse'),
array('letra'=>'a', 'palabra'=>'ahorcamiento'),
array('letra'=>'a', 'palabra'=>'ahorcaperros'),
array('letra'=>'a', 'palabra'=>'ahorcar'),
array('letra'=>'a', 'palabra'=>'ahorita'),
array('letra'=>'a', 'palabra'=>'ahoritita'),
array('letra'=>'a', 'palabra'=>'ahormar'),
array('letra'=>'a', 'palabra'=>'ahornagamiento'),
array('letra'=>'a', 'palabra'=>'ahornagarse'),
array('letra'=>'a', 'palabra'=>'ahornar'),
array('letra'=>'a', 'palabra'=>'ahorquillado'),
array('letra'=>'a', 'palabra'=>'ahorquillar'),
array('letra'=>'a', 'palabra'=>'ahorradamente'),
array('letra'=>'a', 'palabra'=>'ahorrado'),
array('letra'=>'a', 'palabra'=>'ahorrador'),
array('letra'=>'a', 'palabra'=>'ahorramiento'),
array('letra'=>'a', 'palabra'=>'ahorrar'),
array('letra'=>'a', 'palabra'=>'ahorrativo'),
array('letra'=>'a', 'palabra'=>'ahorria'),
array('letra'=>'a', 'palabra'=>'ahorrista'),
array('letra'=>'a', 'palabra'=>'ahorro'),
array('letra'=>'a', 'palabra'=>'ahotado'),
array('letra'=>'a', 'palabra'=>'ahotar'),
array('letra'=>'a', 'palabra'=>'ahotas'),
array('letra'=>'a', 'palabra'=>'ahoyadura'),
array('letra'=>'a', 'palabra'=>'ahoyar'),
array('letra'=>'a', 'palabra'=>'ahuachapaneco'),
array('letra'=>'a', 'palabra'=>'ahuate'),
array('letra'=>'a', 'palabra'=>'ahuchador'),
array('letra'=>'a', 'palabra'=>'ahuchar'),
array('letra'=>'a', 'palabra'=>'ahuchear'),
array('letra'=>'a', 'palabra'=>'ahucheo'),
array('letra'=>'a', 'palabra'=>'ahuciar'),
array('letra'=>'a', 'palabra'=>'ahuecado'),
array('letra'=>'a', 'palabra'=>'ahuecador'),
array('letra'=>'a', 'palabra'=>'ahuecamiento'),
array('letra'=>'a', 'palabra'=>'ahuecar'),
array('letra'=>'a', 'palabra'=>'ahuehue'),
array('letra'=>'a', 'palabra'=>'ahuehuete'),
array('letra'=>'a', 'palabra'=>'ahuesado'),
array('letra'=>'a', 'palabra'=>'ahuesarse'),
array('letra'=>'a', 'palabra'=>'ahuevado'),
array('letra'=>'a', 'palabra'=>'ahuevar'),
array('letra'=>'a', 'palabra'=>'ahuevazon'),
array('letra'=>'a', 'palabra'=>'ahuizote'),
array('letra'=>'a', 'palabra'=>'ahulado'),
array('letra'=>'a', 'palabra'=>'ahumado'),
array('letra'=>'a', 'palabra'=>'ahumar'),
array('letra'=>'a', 'palabra'=>'ahurragado'),
array('letra'=>'a', 'palabra'=>'ahusado'),
array('letra'=>'a', 'palabra'=>'ahusar'),
array('letra'=>'a', 'palabra'=>'ahuyentador'),
array('letra'=>'a', 'palabra'=>'ahuyentar'),
array('letra'=>'a', 'palabra'=>'aiguaste'),
array('letra'=>'a', 'palabra'=>'aijada'),
array('letra'=>'a', 'palabra'=>'ailanto'),
array('letra'=>'a', 'palabra'=>'aillo'),
array('letra'=>'a', 'palabra'=>'aimara'),
array('letra'=>'a', 'palabra'=>'aimara'),
array('letra'=>'a', 'palabra'=>'aina'),
array('letra'=>'a', 'palabra'=>'ainas'),
array('letra'=>'a', 'palabra'=>'aindamais'),
array('letra'=>'a', 'palabra'=>'aindiado'),
array('letra'=>'a', 'palabra'=>'aindiarse'),
array('letra'=>'a', 'palabra'=>'aiquileño'),
array('letra'=>'a', 'palabra'=>'airada'),
array('letra'=>'a', 'palabra'=>'airadamente'),
array('letra'=>'a', 'palabra'=>'airamiento'),
array('letra'=>'a', 'palabra'=>'airampo'),
array('letra'=>'a', 'palabra'=>'airar'),
array('letra'=>'a', 'palabra'=>'airbag'),
array('letra'=>'a', 'palabra'=>'aire'),
array('letra'=>'a', 'palabra'=>'aireacion'),
array('letra'=>'a', 'palabra'=>'airear'),
array('letra'=>'a', 'palabra'=>'aireo'),
array('letra'=>'a', 'palabra'=>'airon'),
array('letra'=>'a', 'palabra'=>'airosamente'),
array('letra'=>'a', 'palabra'=>'airosidad'),
array('letra'=>'a', 'palabra'=>'airoso'),
array('letra'=>'a', 'palabra'=>'aisa'),
array('letra'=>'a', 'palabra'=>'aisenino'),
array('letra'=>'a', 'palabra'=>'aislable'),
array('letra'=>'a', 'palabra'=>'aislacionismo'),
array('letra'=>'a', 'palabra'=>'aislacionista'),
array('letra'=>'a', 'palabra'=>'aisladamente'),
array('letra'=>'a', 'palabra'=>'aislado'),
array('letra'=>'a', 'palabra'=>'aislador'),
array('letra'=>'a', 'palabra'=>'aislamiento'),
array('letra'=>'a', 'palabra'=>'aislante'),
array('letra'=>'a', 'palabra'=>'aislar'),
array('letra'=>'a', 'palabra'=>'aite'),
array('letra'=>'a', 'palabra'=>'aitinal'),
array('letra'=>'a', 'palabra'=>'aizcolari'),
array('letra'=>'a', 'palabra'=>'aizoaceo'),
array('letra'=>'a', 'palabra'=>'aj'),
array('letra'=>'a', 'palabra'=>'aja'),
array('letra'=>'a', 'palabra'=>'aja'),
array('letra'=>'a', 'palabra'=>'ajabeba'),
array('letra'=>'a', 'palabra'=>'ajada'),
array('letra'=>'a', 'palabra'=>'ajado'),
array('letra'=>'a', 'palabra'=>'ajadura'),
array('letra'=>'a', 'palabra'=>'ajaja'),
array('letra'=>'a', 'palabra'=>'ajajay'),
array('letra'=>'a', 'palabra'=>'ajambado'),
array('letra'=>'a', 'palabra'=>'ajamiento'),
array('letra'=>'a', 'palabra'=>'ajamonarse'),
array('letra'=>'a', 'palabra'=>'ajango'),
array('letra'=>'a', 'palabra'=>'ajaqueca'),
array('letra'=>'a', 'palabra'=>'ajaquecarse'),
array('letra'=>'a', 'palabra'=>'ajaquefa'),
array('letra'=>'a', 'palabra'=>'ajar'),
array('letra'=>'a', 'palabra'=>'ajaraca'),
array('letra'=>'a', 'palabra'=>'ajaracado'),
array('letra'=>'a', 'palabra'=>'ajarafe'),
array('letra'=>'a', 'palabra'=>'ajardinamiento'),
array('letra'=>'a', 'palabra'=>'ajardinar'),
array('letra'=>'a', 'palabra'=>'ajaspajas'),
array('letra'=>'a', 'palabra'=>'aje'),
array('letra'=>'a', 'palabra'=>'ajea'),
array('letra'=>'a', 'palabra'=>'ajear'),
array('letra'=>'a', 'palabra'=>'ajebe'),
array('letra'=>'a', 'palabra'=>'ajedrea'),
array('letra'=>'a', 'palabra'=>'ajedrecista'),
array('letra'=>'a', 'palabra'=>'ajedrecistico'),
array('letra'=>'a', 'palabra'=>'ajedrez'),
array('letra'=>'a', 'palabra'=>'ajedrezado'),
array('letra'=>'a', 'palabra'=>'ajenabe'),
array('letra'=>'a', 'palabra'=>'ajenable'),
array('letra'=>'a', 'palabra'=>'ajenabo'),
array('letra'=>'a', 'palabra'=>'ajenacion'),
array('letra'=>'a', 'palabra'=>'ajenador'),
array('letra'=>'a', 'palabra'=>'ajenamiento'),
array('letra'=>'a', 'palabra'=>'ajenar'),
array('letra'=>'a', 'palabra'=>'ajengibre'),
array('letra'=>'a', 'palabra'=>'ajenidad'),
array('letra'=>'a', 'palabra'=>'ajenjo'),
array('letra'=>'a', 'palabra'=>'ajeno'),
array('letra'=>'a', 'palabra'=>'ajenuz'),
array('letra'=>'a', 'palabra'=>'ajeo'),
array('letra'=>'a', 'palabra'=>'ajerezado'),
array('letra'=>'a', 'palabra'=>'ajero'),
array('letra'=>'a', 'palabra'=>'ajete'),
array('letra'=>'a', 'palabra'=>'ajetrear'),
array('letra'=>'a', 'palabra'=>'ajetreo'),
array('letra'=>'a', 'palabra'=>'aji'),
array('letra'=>'a', 'palabra'=>'ajiaceite'),
array('letra'=>'a', 'palabra'=>'ajiaco'),
array('letra'=>'a', 'palabra'=>'ajicero'),
array('letra'=>'a', 'palabra'=>'ajicola'),
array('letra'=>'a', 'palabra'=>'ajicomino'),
array('letra'=>'a', 'palabra'=>'ajicuervo'),
array('letra'=>'a', 'palabra'=>'ajilimoje'),
array('letra'=>'a', 'palabra'=>'ajilimojili'),
array('letra'=>'a', 'palabra'=>'ajillo'),
array('letra'=>'a', 'palabra'=>'ajimez'),
array('letra'=>'a', 'palabra'=>'ajimezado'),
array('letra'=>'a', 'palabra'=>'ajipa'),
array('letra'=>'a', 'palabra'=>'ajipuerro'),
array('letra'=>'a', 'palabra'=>'ajironar'),
array('letra'=>'a', 'palabra'=>'ajizal'),
array('letra'=>'a', 'palabra'=>'ajo'),
array('letra'=>'a', 'palabra'=>'ajo'),
array('letra'=>'a', 'palabra'=>'ajoaceite'),
array('letra'=>'a', 'palabra'=>'ajoarriero'),
array('letra'=>'a', 'palabra'=>'ajobar'),
array('letra'=>'a', 'palabra'=>'ajobero'),
array('letra'=>'a', 'palabra'=>'ajobilla'),
array('letra'=>'a', 'palabra'=>'ajobo'),
array('letra'=>'a', 'palabra'=>'ajochar'),
array('letra'=>'a', 'palabra'=>'ajofaina'),
array('letra'=>'a', 'palabra'=>'ajolin'),
array('letra'=>'a', 'palabra'=>'ajolio'),
array('letra'=>'a', 'palabra'=>'ajolote'),
array('letra'=>'a', 'palabra'=>'ajomate'),
array('letra'=>'a', 'palabra'=>'ajonje'),
array('letra'=>'a', 'palabra'=>'ajonjera'),
array('letra'=>'a', 'palabra'=>'ajonjero'),
array('letra'=>'a', 'palabra'=>'ajonjo'),
array('letra'=>'a', 'palabra'=>'ajonjoli'),
array('letra'=>'a', 'palabra'=>'ajonuez'),
array('letra'=>'a', 'palabra'=>'ajoqueso'),
array('letra'=>'a', 'palabra'=>'ajorar'),
array('letra'=>'a', 'palabra'=>'ajorca'),
array('letra'=>'a', 'palabra'=>'ajornalar'),
array('letra'=>'a', 'palabra'=>'ajorrar'),
array('letra'=>'a', 'palabra'=>'ajorro'),
array('letra'=>'a', 'palabra'=>'ajotar'),
array('letra'=>'a', 'palabra'=>'ajote'),
array('letra'=>'a', 'palabra'=>'ajotrino'),
array('letra'=>'a', 'palabra'=>'ajuagas'),
array('letra'=>'a', 'palabra'=>'ajuanetado'),
array('letra'=>'a', 'palabra'=>'ajuar'),
array('letra'=>'a', 'palabra'=>'ajuarar'),
array('letra'=>'a', 'palabra'=>'ajudiado'),
array('letra'=>'a', 'palabra'=>'ajuglarado'),
array('letra'=>'a', 'palabra'=>'ajuglarar'),
array('letra'=>'a', 'palabra'=>'ajuiciado'),
array('letra'=>'a', 'palabra'=>'ajuiciar'),
array('letra'=>'a', 'palabra'=>'ajuno'),
array('letra'=>'a', 'palabra'=>'ajuntamiento'),
array('letra'=>'a', 'palabra'=>'ajuntar'),
array('letra'=>'a', 'palabra'=>'ajustable'),
array('letra'=>'a', 'palabra'=>'ajustada'),
array('letra'=>'a', 'palabra'=>'ajustadamente'),
array('letra'=>'a', 'palabra'=>'ajustado'),
array('letra'=>'a', 'palabra'=>'ajustador'),
array('letra'=>'a', 'palabra'=>'ajustamiento'),
array('letra'=>'a', 'palabra'=>'ajustar'),
array('letra'=>'a', 'palabra'=>'ajuste'),
array('letra'=>'a', 'palabra'=>'ajustero'),
array('letra'=>'a', 'palabra'=>'ajusticiado'),
array('letra'=>'a', 'palabra'=>'ajusticiamiento'),
array('letra'=>'a', 'palabra'=>'ajusticiar'),
array('letra'=>'a', 'palabra'=>'ajuston'),
array('letra'=>'a', 'palabra'=>'al'),
array('letra'=>'a', 'palabra'=>'al'),
array('letra'=>'a', 'palabra'=>'ala'),
array('letra'=>'a', 'palabra'=>'ala'),
array('letra'=>'a', 'palabra'=>'alabable'),
array('letra'=>'a', 'palabra'=>'alabado'),
array('letra'=>'a', 'palabra'=>'alabador'),
array('letra'=>'a', 'palabra'=>'alabamiento'),
array('letra'=>'a', 'palabra'=>'alabancero'),
array('letra'=>'a', 'palabra'=>'alabancia'),
array('letra'=>'a', 'palabra'=>'alabancioso'),
array('letra'=>'a', 'palabra'=>'alabandina'),
array('letra'=>'a', 'palabra'=>'alabanza'),
array('letra'=>'a', 'palabra'=>'alabar'),
array('letra'=>'a', 'palabra'=>'alabarda'),
array('letra'=>'a', 'palabra'=>'alabardado'),
array('letra'=>'a', 'palabra'=>'alabardazo'),
array('letra'=>'a', 'palabra'=>'alabardero'),
array('letra'=>'a', 'palabra'=>'alabastrado'),
array('letra'=>'a', 'palabra'=>'alabastrino'),
array('letra'=>'a', 'palabra'=>'alabastrita'),
array('letra'=>'a', 'palabra'=>'alabastrites'),
array('letra'=>'a', 'palabra'=>'alabastro'),
array('letra'=>'a', 'palabra'=>'alabe'),
array('letra'=>'a', 'palabra'=>'alabeado'),
array('letra'=>'a', 'palabra'=>'alabear'),
array('letra'=>'a', 'palabra'=>'alabeo'),
array('letra'=>'a', 'palabra'=>'alabiado'),
array('letra'=>'a', 'palabra'=>'alabradorado'),
array('letra'=>'a', 'palabra'=>'alacate'),
array('letra'=>'a', 'palabra'=>'alacayo'),
array('letra'=>'a', 'palabra'=>'alacayuela'),
array('letra'=>'a', 'palabra'=>'alacena'),
array('letra'=>'a', 'palabra'=>'alacet'),
array('letra'=>'a', 'palabra'=>'alacha'),
array('letra'=>'a', 'palabra'=>'alache'),
array('letra'=>'a', 'palabra'=>'alaciarse'),
array('letra'=>'a', 'palabra'=>'alaco'),
array('letra'=>'a', 'palabra'=>'alacran'),
array('letra'=>'a', 'palabra'=>'alacranado'),
array('letra'=>'a', 'palabra'=>'alacrancillo'),
array('letra'=>'a', 'palabra'=>'alacranera'),
array('letra'=>'a', 'palabra'=>'alacranero'),
array('letra'=>'a', 'palabra'=>'alacre'),
array('letra'=>'a', 'palabra'=>'alacridad'),
array('letra'=>'a', 'palabra'=>'alada'),
array('letra'=>'a', 'palabra'=>'aladar'),
array('letra'=>'a', 'palabra'=>'aladierna'),
array('letra'=>'a', 'palabra'=>'aladierno'),
array('letra'=>'a', 'palabra'=>'alado'),
array('letra'=>'a', 'palabra'=>'aladrada'),
array('letra'=>'a', 'palabra'=>'aladrar'),
array('letra'=>'a', 'palabra'=>'aladrero'),
array('letra'=>'a', 'palabra'=>'aladro'),
array('letra'=>'a', 'palabra'=>'aladroque'),
array('letra'=>'a', 'palabra'=>'alafa'),
array('letra'=>'a', 'palabra'=>'alafia'),
array('letra'=>'a', 'palabra'=>'alaga'),
array('letra'=>'a', 'palabra'=>'alagadizo'),
array('letra'=>'a', 'palabra'=>'alagar'),
array('letra'=>'a', 'palabra'=>'alagartado'),
array('letra'=>'a', 'palabra'=>'alagartarse'),
array('letra'=>'a', 'palabra'=>'alaguna'),
array('letra'=>'a', 'palabra'=>'alahilca'),
array('letra'=>'a', 'palabra'=>'alajor'),
array('letra'=>'a', 'palabra'=>'alaju'),
array('letra'=>'a', 'palabra'=>'alajuelense'),
array('letra'=>'a', 'palabra'=>'alala'),
array('letra'=>'a', 'palabra'=>'alala'),
array('letra'=>'a', 'palabra'=>'alalau'),
array('letra'=>'a', 'palabra'=>'alalia'),
array('letra'=>'a', 'palabra'=>'alalimon'),
array('letra'=>'a', 'palabra'=>'alalo'),
array('letra'=>'a', 'palabra'=>'alama'),
array('letra'=>'a', 'palabra'=>'alamar'),
array('letra'=>'a', 'palabra'=>'alambar'),
array('letra'=>'a', 'palabra'=>'alambicado'),
array('letra'=>'a', 'palabra'=>'alambicamiento'),
array('letra'=>'a', 'palabra'=>'alambicar'),
array('letra'=>'a', 'palabra'=>'alambique'),
array('letra'=>'a', 'palabra'=>'alambiquero'),
array('letra'=>'a', 'palabra'=>'alambor'),
array('letra'=>'a', 'palabra'=>'alamborado'),
array('letra'=>'a', 'palabra'=>'alambrada'),
array('letra'=>'a', 'palabra'=>'alambrado'),
array('letra'=>'a', 'palabra'=>'alambrar'),
array('letra'=>'a', 'palabra'=>'alambre'),
array('letra'=>'a', 'palabra'=>'alambrear'),
array('letra'=>'a', 'palabra'=>'alambrera'),
array('letra'=>'a', 'palabra'=>'alambrilla'),
array('letra'=>'a', 'palabra'=>'alambrista'),
array('letra'=>'a', 'palabra'=>'alameda'),
array('letra'=>'a', 'palabra'=>'alamin'),
array('letra'=>'a', 'palabra'=>'alamina'),
array('letra'=>'a', 'palabra'=>'alaminazgo'),
array('letra'=>'a', 'palabra'=>'alamirre'),
array('letra'=>'a', 'palabra'=>'alamo'),
array('letra'=>'a', 'palabra'=>'alampar'),
array('letra'=>'a', 'palabra'=>'alamud'),
array('letra'=>'a', 'palabra'=>'alan'),
array('letra'=>'a', 'palabra'=>'alanceador'),
array('letra'=>'a', 'palabra'=>'alancear'),
array('letra'=>'a', 'palabra'=>'alandrearse'),
array('letra'=>'a', 'palabra'=>'alangiaceo'),
array('letra'=>'a', 'palabra'=>'alangieo'),
array('letra'=>'a', 'palabra'=>'alano'),
array('letra'=>'a', 'palabra'=>'alantoideo'),
array('letra'=>'a', 'palabra'=>'alantoides'),
array('letra'=>'a', 'palabra'=>'alantoina'),
array('letra'=>'a', 'palabra'=>'alanzar'),
array('letra'=>'a', 'palabra'=>'alaqueca'),
array('letra'=>'a', 'palabra'=>'alaqueque'),
array('letra'=>'a', 'palabra'=>'alar'),
array('letra'=>'a', 'palabra'=>'alarabe'),
array('letra'=>'a', 'palabra'=>'alarbe'),
array('letra'=>'a', 'palabra'=>'alarconiano'),
array('letra'=>'a', 'palabra'=>'alarde'),
array('letra'=>'a', 'palabra'=>'alardear'),
array('letra'=>'a', 'palabra'=>'alardoso'),
array('letra'=>'a', 'palabra'=>'alargadamente'),
array('letra'=>'a', 'palabra'=>'alargadera'),
array('letra'=>'a', 'palabra'=>'alargador'),
array('letra'=>'a', 'palabra'=>'alargama'),
array('letra'=>'a', 'palabra'=>'alargamiento'),
array('letra'=>'a', 'palabra'=>'alargar'),
array('letra'=>'a', 'palabra'=>'alargas'),
array('letra'=>'a', 'palabra'=>'alarguez'),
array('letra'=>'a', 'palabra'=>'alaria'),
array('letra'=>'a', 'palabra'=>'alarida'),
array('letra'=>'a', 'palabra'=>'alaridar'),
array('letra'=>'a', 'palabra'=>'alarido'),
array('letra'=>'a', 'palabra'=>'alarifazgo'),
array('letra'=>'a', 'palabra'=>'alarife'),
array('letra'=>'a', 'palabra'=>'alarije'),
array('letra'=>'a', 'palabra'=>'alarma'),
array('letra'=>'a', 'palabra'=>'alarmador'),
array('letra'=>'a', 'palabra'=>'alarmante'),
array('letra'=>'a', 'palabra'=>'alarmar'),
array('letra'=>'a', 'palabra'=>'alarmega'),
array('letra'=>'a', 'palabra'=>'alarmismo'),
array('letra'=>'a', 'palabra'=>'alarmista'),
array('letra'=>'a', 'palabra'=>'alaroz'),
array('letra'=>'a', 'palabra'=>'alaroza'),
array('letra'=>'a', 'palabra'=>'alasita'),
array('letra'=>'a', 'palabra'=>'alaste'),
array('letra'=>'a', 'palabra'=>'alastrar'),
array('letra'=>'a', 'palabra'=>'alatar'),
array('letra'=>'a', 'palabra'=>'alaterno'),
array('letra'=>'a', 'palabra'=>'alates'),
array('letra'=>'a', 'palabra'=>'alatinadamente'),
array('letra'=>'a', 'palabra'=>'alatinado'),
array('letra'=>'a', 'palabra'=>'alaton'),
array('letra'=>'a', 'palabra'=>'alatonero'),
array('letra'=>'a', 'palabra'=>'alatron'),
array('letra'=>'a', 'palabra'=>'alauda'),
array('letra'=>'a', 'palabra'=>'alaude'),
array('letra'=>'a', 'palabra'=>'alaui'),
array('letra'=>'a', 'palabra'=>'alauita'),
array('letra'=>'a', 'palabra'=>'alavanco'),
array('letra'=>'a', 'palabra'=>'alavense'),
array('letra'=>'a', 'palabra'=>'alaves'),
array('letra'=>'a', 'palabra'=>'alazan'),
array('letra'=>'a', 'palabra'=>'alazano'),
array('letra'=>'a', 'palabra'=>'alazo'),
array('letra'=>'a', 'palabra'=>'alazor'),
array('letra'=>'a', 'palabra'=>'alba'),
array('letra'=>'a', 'palabra'=>'albaca'),
array('letra'=>'a', 'palabra'=>'albacara'),
array('letra'=>'a', 'palabra'=>'albacara'),
array('letra'=>'a', 'palabra'=>'albacea'),
array('letra'=>'a', 'palabra'=>'albaceato'),
array('letra'=>'a', 'palabra'=>'albaceazgo'),
array('letra'=>'a', 'palabra'=>'albacetense'),
array('letra'=>'a', 'palabra'=>'albaceteño'),
array('letra'=>'a', 'palabra'=>'albacora'),
array('letra'=>'a', 'palabra'=>'albacoron'),
array('letra'=>'a', 'palabra'=>'albada'),
array('letra'=>'a', 'palabra'=>'albadena'),
array('letra'=>'a', 'palabra'=>'albahaca'),
array('letra'=>'a', 'palabra'=>'albahaquero'),
array('letra'=>'a', 'palabra'=>'albahaquilla'),
array('letra'=>'a', 'palabra'=>'albahio'),
array('letra'=>'a', 'palabra'=>'albaida'),
array('letra'=>'a', 'palabra'=>'albala'),
array('letra'=>'a', 'palabra'=>'albalaero'),
array('letra'=>'a', 'palabra'=>'albanado'),
array('letra'=>'a', 'palabra'=>'albanar'),
array('letra'=>'a', 'palabra'=>'albanecar'),
array('letra'=>'a', 'palabra'=>'albanega'),
array('letra'=>'a', 'palabra'=>'albanes'),
array('letra'=>'a', 'palabra'=>'albano'),
array('letra'=>'a', 'palabra'=>'albañal'),
array('letra'=>'a', 'palabra'=>'albañalero'),
array('letra'=>'a', 'palabra'=>'albañar'),
array('letra'=>'a', 'palabra'=>'albañear'),
array('letra'=>'a', 'palabra'=>'albañeria'),
array('letra'=>'a', 'palabra'=>'albañi'),
array('letra'=>'a', 'palabra'=>'albañil'),
array('letra'=>'a', 'palabra'=>'albañila'),
array('letra'=>'a', 'palabra'=>'albañilear'),
array('letra'=>'a', 'palabra'=>'albañileria'),
array('letra'=>'a', 'palabra'=>'albañir'),
array('letra'=>'a', 'palabra'=>'albaquia'),
array('letra'=>'a', 'palabra'=>'albar'),
array('letra'=>'a', 'palabra'=>'albaran'),
array('letra'=>'a', 'palabra'=>'albarazado'),
array('letra'=>'a', 'palabra'=>'albarazo'),
array('letra'=>'a', 'palabra'=>'albarca'),
array('letra'=>'a', 'palabra'=>'albarcoque'),
array('letra'=>'a', 'palabra'=>'albarcoquero'),
array('letra'=>'a', 'palabra'=>'albarda'),
array('letra'=>'a', 'palabra'=>'albardado'),
array('letra'=>'a', 'palabra'=>'albardan'),
array('letra'=>'a', 'palabra'=>'albardaneria'),
array('letra'=>'a', 'palabra'=>'albardania'),
array('letra'=>'a', 'palabra'=>'albardar'),
array('letra'=>'a', 'palabra'=>'albardear'),
array('letra'=>'a', 'palabra'=>'albardela'),
array('letra'=>'a', 'palabra'=>'albardera'),
array('letra'=>'a', 'palabra'=>'albarderia'),
array('letra'=>'a', 'palabra'=>'albardero'),
array('letra'=>'a', 'palabra'=>'albardilla'),
array('letra'=>'a', 'palabra'=>'albardin'),
array('letra'=>'a', 'palabra'=>'albardinar'),
array('letra'=>'a', 'palabra'=>'albardon'),
array('letra'=>'a', 'palabra'=>'albardoneria'),
array('letra'=>'a', 'palabra'=>'albardonero'),
array('letra'=>'a', 'palabra'=>'albarejo'),
array('letra'=>'a', 'palabra'=>'albarelo'),
array('letra'=>'a', 'palabra'=>'albareque'),
array('letra'=>'a', 'palabra'=>'albaricoque'),
array('letra'=>'a', 'palabra'=>'albaricoquero'),
array('letra'=>'a', 'palabra'=>'albarigo'),
array('letra'=>'a', 'palabra'=>'albarillo'),
array('letra'=>'a', 'palabra'=>'albarino'),
array('letra'=>'a', 'palabra'=>'albariño'),
array('letra'=>'a', 'palabra'=>'albarizo'),
array('letra'=>'a', 'palabra'=>'albarrada'),
array('letra'=>'a', 'palabra'=>'albarran'),
array('letra'=>'a', 'palabra'=>'albarrana'),
array('letra'=>'a', 'palabra'=>'albarraneo'),
array('letra'=>'a', 'palabra'=>'albarrania'),
array('letra'=>'a', 'palabra'=>'albarraniego'),
array('letra'=>'a', 'palabra'=>'albarranilla'),
array('letra'=>'a', 'palabra'=>'albarraz'),
array('letra'=>'a', 'palabra'=>'albarrazado'),
array('letra'=>'a', 'palabra'=>'albarsa'),
array('letra'=>'a', 'palabra'=>'albatoza'),
array('letra'=>'a', 'palabra'=>'albatros'),
array('letra'=>'a', 'palabra'=>'albayaldado'),
array('letra'=>'a', 'palabra'=>'albayalde'),
array('letra'=>'a', 'palabra'=>'albayano'),
array('letra'=>'a', 'palabra'=>'albazano'),
array('letra'=>'a', 'palabra'=>'albazo'),
array('letra'=>'a', 'palabra'=>'albear'),
array('letra'=>'a', 'palabra'=>'albedo'),
array('letra'=>'a', 'palabra'=>'albedriador'),
array('letra'=>'a', 'palabra'=>'albedriar'),
array('letra'=>'a', 'palabra'=>'albedrio'),
array('letra'=>'a', 'palabra'=>'albeitar'),
array('letra'=>'a', 'palabra'=>'albeiteria'),
array('letra'=>'a', 'palabra'=>'albeldadero'),
array('letra'=>'a', 'palabra'=>'albeldar'),
array('letra'=>'a', 'palabra'=>'albeldense'),
array('letra'=>'a', 'palabra'=>'albellanino'),
array('letra'=>'a', 'palabra'=>'albellon'),
array('letra'=>'a', 'palabra'=>'albenda'),
array('letra'=>'a', 'palabra'=>'albendera'),
array('letra'=>'a', 'palabra'=>'albengala'),
array('letra'=>'a', 'palabra'=>'albentola'),
array('letra'=>'a', 'palabra'=>'alberca'),
array('letra'=>'a', 'palabra'=>'alberchiga'),
array('letra'=>'a', 'palabra'=>'alberchigal'),
array('letra'=>'a', 'palabra'=>'alberchigo'),
array('letra'=>'a', 'palabra'=>'alberchiguero'),
array('letra'=>'a', 'palabra'=>'albercoque'),
array('letra'=>'a', 'palabra'=>'albercoquero'),
array('letra'=>'a', 'palabra'=>'albergada'),
array('letra'=>'a', 'palabra'=>'albergador'),
array('letra'=>'a', 'palabra'=>'albergadura'),
array('letra'=>'a', 'palabra'=>'albergar'),
array('letra'=>'a', 'palabra'=>'alberge'),
array('letra'=>'a', 'palabra'=>'albergero'),
array('letra'=>'a', 'palabra'=>'albergo'),
array('letra'=>'a', 'palabra'=>'albergue'),
array('letra'=>'a', 'palabra'=>'albergueria'),
array('letra'=>'a', 'palabra'=>'alberguero'),
array('letra'=>'a', 'palabra'=>'albericoque'),
array('letra'=>'a', 'palabra'=>'albero'),
array('letra'=>'a', 'palabra'=>'alberque'),
array('letra'=>'a', 'palabra'=>'alberquero'),
array('letra'=>'a', 'palabra'=>'albicante'),
array('letra'=>'a', 'palabra'=>'albigense'),
array('letra'=>'a', 'palabra'=>'albihar'),
array('letra'=>'a', 'palabra'=>'albilla'),
array('letra'=>'a', 'palabra'=>'albillo'),
array('letra'=>'a', 'palabra'=>'albin'),
array('letra'=>'a', 'palabra'=>'albina'),
array('letra'=>'a', 'palabra'=>'albinismo'),
array('letra'=>'a', 'palabra'=>'albino'),
array('letra'=>'a', 'palabra'=>'albita'),
array('letra'=>'a', 'palabra'=>'albitana'),
array('letra'=>'a', 'palabra'=>'albo'),
array('letra'=>'a', 'palabra'=>'alboaire'),
array('letra'=>'a', 'palabra'=>'albogon'),
array('letra'=>'a', 'palabra'=>'albogue'),
array('letra'=>'a', 'palabra'=>'alboguear'),
array('letra'=>'a', 'palabra'=>'alboguero'),
array('letra'=>'a', 'palabra'=>'alboheza'),
array('letra'=>'a', 'palabra'=>'albohol'),
array('letra'=>'a', 'palabra'=>'albollon'),
array('letra'=>'a', 'palabra'=>'albondiga'),
array('letra'=>'a', 'palabra'=>'albondiguilla'),
array('letra'=>'a', 'palabra'=>'alboqueron'),
array('letra'=>'a', 'palabra'=>'albor'),
array('letra'=>'a', 'palabra'=>'alborada'),
array('letra'=>'a', 'palabra'=>'alborbola'),
array('letra'=>'a', 'palabra'=>'alboreada'),
array('letra'=>'a', 'palabra'=>'alborear'),
array('letra'=>'a', 'palabra'=>'alborecer'),
array('letra'=>'a', 'palabra'=>'alboreo'),
array('letra'=>'a', 'palabra'=>'alborga'),
array('letra'=>'a', 'palabra'=>'albornia'),
array('letra'=>'a', 'palabra'=>'alborno'),
array('letra'=>'a', 'palabra'=>'albornoz'),
array('letra'=>'a', 'palabra'=>'alborocera'),
array('letra'=>'a', 'palabra'=>'alboronia'),
array('letra'=>'a', 'palabra'=>'alboroque'),
array('letra'=>'a', 'palabra'=>'alborotadizo'),
array('letra'=>'a', 'palabra'=>'alborotado'),
array('letra'=>'a', 'palabra'=>'alborotador'),
array('letra'=>'a', 'palabra'=>'alborotapueblos'),
array('letra'=>'a', 'palabra'=>'alborotar'),
array('letra'=>'a', 'palabra'=>'alborote'),
array('letra'=>'a', 'palabra'=>'alborotero'),
array('letra'=>'a', 'palabra'=>'alborotista'),
array('letra'=>'a', 'palabra'=>'alboroto'),
array('letra'=>'a', 'palabra'=>'alborotoso'),
array('letra'=>'a', 'palabra'=>'alborozadamente'),
array('letra'=>'a', 'palabra'=>'alborozador'),
array('letra'=>'a', 'palabra'=>'alborozamiento'),
array('letra'=>'a', 'palabra'=>'alborozar'),
array('letra'=>'a', 'palabra'=>'alborozo'),
array('letra'=>'a', 'palabra'=>'alborto'),
array('letra'=>'a', 'palabra'=>'alborzo'),
array('letra'=>'a', 'palabra'=>'albotin'),
array('letra'=>'a', 'palabra'=>'albricia'),
array('letra'=>'a', 'palabra'=>'albriciar'),
array('letra'=>'a', 'palabra'=>'albricias'),
array('letra'=>'a', 'palabra'=>'albudeca'),
array('letra'=>'a', 'palabra'=>'albuerbola'),
array('letra'=>'a', 'palabra'=>'albufera'),
array('letra'=>'a', 'palabra'=>'albugineo'),
array('letra'=>'a', 'palabra'=>'albugo'),
array('letra'=>'a', 'palabra'=>'albuhera'),
array('letra'=>'a', 'palabra'=>'album'),
array('letra'=>'a', 'palabra'=>'albumen'),
array('letra'=>'a', 'palabra'=>'albumina'),
array('letra'=>'a', 'palabra'=>'albuminado'),
array('letra'=>'a', 'palabra'=>'albuminar'),
array('letra'=>'a', 'palabra'=>'albuminoide'),
array('letra'=>'a', 'palabra'=>'albuminoideo'),
array('letra'=>'a', 'palabra'=>'albuminometro'),
array('letra'=>'a', 'palabra'=>'albuminoso'),
array('letra'=>'a', 'palabra'=>'albuminuria'),
array('letra'=>'a', 'palabra'=>'albur'),
array('letra'=>'a', 'palabra'=>'albura'),
array('letra'=>'a', 'palabra'=>'alburear'),
array('letra'=>'a', 'palabra'=>'alburente'),
array('letra'=>'a', 'palabra'=>'alburero'),
array('letra'=>'a', 'palabra'=>'alburno'),
array('letra'=>'a', 'palabra'=>'alca'),
array('letra'=>'a', 'palabra'=>'alcabala'),
array('letra'=>'a', 'palabra'=>'alcabalatorio'),
array('letra'=>'a', 'palabra'=>'alcabalero'),
array('letra'=>'a', 'palabra'=>'alcabor'),
array('letra'=>'a', 'palabra'=>'alcabota'),
array('letra'=>'a', 'palabra'=>'alcabtea'),
array('letra'=>'a', 'palabra'=>'alcabuz'),
array('letra'=>'a', 'palabra'=>'alcacel'),
array('letra'=>'a', 'palabra'=>'alcaceña'),
array('letra'=>'a', 'palabra'=>'alcacer'),
array('letra'=>'a', 'palabra'=>'alcachofa'),
array('letra'=>'a', 'palabra'=>'alcachofado'),
array('letra'=>'a', 'palabra'=>'alcachofal'),
array('letra'=>'a', 'palabra'=>'alcachofar'),
array('letra'=>'a', 'palabra'=>'alcachofero'),
array('letra'=>'a', 'palabra'=>'alcaci'),
array('letra'=>'a', 'palabra'=>'alcacil'),
array('letra'=>'a', 'palabra'=>'alcaduz'),
array('letra'=>'a', 'palabra'=>'alcaeceria'),
array('letra'=>'a', 'palabra'=>'alcafar'),
array('letra'=>'a', 'palabra'=>'alcahaz'),
array('letra'=>'a', 'palabra'=>'alcahazada'),
array('letra'=>'a', 'palabra'=>'alcahazar'),
array('letra'=>'a', 'palabra'=>'alcahotar'),
array('letra'=>'a', 'palabra'=>'alcahoteria'),
array('letra'=>'a', 'palabra'=>'alcahueta'),
array('letra'=>'a', 'palabra'=>'alcahuetar'),
array('letra'=>'a', 'palabra'=>'alcahuetazgo'),
array('letra'=>'a', 'palabra'=>'alcahuete'),
array('letra'=>'a', 'palabra'=>'alcahuetear'),
array('letra'=>'a', 'palabra'=>'alcahueteria'),
array('letra'=>'a', 'palabra'=>'alcaiceria'),
array('letra'=>'a', 'palabra'=>'alcaico'),
array('letra'=>'a', 'palabra'=>'alcaide'),
array('letra'=>'a', 'palabra'=>'alcaidesa'),
array('letra'=>'a', 'palabra'=>'alcaidia'),
array('letra'=>'a', 'palabra'=>'alcaidiado'),
array('letra'=>'a', 'palabra'=>'alcairia'),
array('letra'=>'a', 'palabra'=>'alcala'),
array('letra'=>'a', 'palabra'=>'alcaladino'),
array('letra'=>'a', 'palabra'=>'alcalaeño'),
array('letra'=>'a', 'palabra'=>'alcalaino'),
array('letra'=>'a', 'palabra'=>'alcalareño'),
array('letra'=>'a', 'palabra'=>'alcaldada'),
array('letra'=>'a', 'palabra'=>'alcalde'),
array('letra'=>'a', 'palabra'=>'alcaldesa'),
array('letra'=>'a', 'palabra'=>'alcaldia'),
array('letra'=>'a', 'palabra'=>'alcalescencia'),
array('letra'=>'a', 'palabra'=>'alcali'),
array('letra'=>'a', 'palabra'=>'alcalifa'),
array('letra'=>'a', 'palabra'=>'alcalifaje'),
array('letra'=>'a', 'palabra'=>'alcalimetro'),
array('letra'=>'a', 'palabra'=>'alcalinidad'),
array('letra'=>'a', 'palabra'=>'alcalinizacion'),
array('letra'=>'a', 'palabra'=>'alcalinizar'),
array('letra'=>'a', 'palabra'=>'alcalino'),
array('letra'=>'a', 'palabra'=>'alcalizacion'),
array('letra'=>'a', 'palabra'=>'alcalizar'),
array('letra'=>'a', 'palabra'=>'alcaller'),
array('letra'=>'a', 'palabra'=>'alcalleria'),
array('letra'=>'a', 'palabra'=>'alcaloide'),
array('letra'=>'a', 'palabra'=>'alcaloideo'),
array('letra'=>'a', 'palabra'=>'alcalometria'),
array('letra'=>'a', 'palabra'=>'alcalosis'),
array('letra'=>'a', 'palabra'=>'alcamar'),
array('letra'=>'a', 'palabra'=>'alcamiz'),
array('letra'=>'a', 'palabra'=>'alcamonias'),
array('letra'=>'a', 'palabra'=>'alcana'),
array('letra'=>'a', 'palabra'=>'alcana'),
array('letra'=>'a', 'palabra'=>'alcance'),
array('letra'=>'a', 'palabra'=>'alcancia'),
array('letra'=>'a', 'palabra'=>'alcanciazo'),
array('letra'=>'a', 'palabra'=>'alcandara'),
array('letra'=>'a', 'palabra'=>'alcandia'),
array('letra'=>'a', 'palabra'=>'alcandial'),
array('letra'=>'a', 'palabra'=>'alcandora'),
array('letra'=>'a', 'palabra'=>'alcandora'),
array('letra'=>'a', 'palabra'=>'alcaneria'),
array('letra'=>'a', 'palabra'=>'alcanfor'),
array('letra'=>'a', 'palabra'=>'alcanforada'),
array('letra'=>'a', 'palabra'=>'alcanforar'),
array('letra'=>'a', 'palabra'=>'alcanforero'),
array('letra'=>'a', 'palabra'=>'alcantara'),
array('letra'=>'a', 'palabra'=>'alcantarilla'),
array('letra'=>'a', 'palabra'=>'alcantarillado'),
array('letra'=>'a', 'palabra'=>'alcantarillar'),
array('letra'=>'a', 'palabra'=>'alcantarillero'),
array('letra'=>'a', 'palabra'=>'alcantarino'),
array('letra'=>'a', 'palabra'=>'alcanzable'),
array('letra'=>'a', 'palabra'=>'alcanzadizo'),
array('letra'=>'a', 'palabra'=>'alcanzado'),
array('letra'=>'a', 'palabra'=>'alcanzador'),
array('letra'=>'a', 'palabra'=>'alcanzadura'),
array('letra'=>'a', 'palabra'=>'alcanzamiento'),
array('letra'=>'a', 'palabra'=>'alcanzar'),
array('letra'=>'a', 'palabra'=>'alcanzativo'),
array('letra'=>'a', 'palabra'=>'alcañizano'),
array('letra'=>'a', 'palabra'=>'alcaparra'),
array('letra'=>'a', 'palabra'=>'alcaparrado'),
array('letra'=>'a', 'palabra'=>'alcaparral'),
array('letra'=>'a', 'palabra'=>'alcaparrera'),
array('letra'=>'a', 'palabra'=>'alcaparro'),
array('letra'=>'a', 'palabra'=>'alcaparron'),
array('letra'=>'a', 'palabra'=>'alcaparrosa'),
array('letra'=>'a', 'palabra'=>'alcaptonuria'),
array('letra'=>'a', 'palabra'=>'alcapurria'),
array('letra'=>'a', 'palabra'=>'alcaraceño'),
array('letra'=>'a', 'palabra'=>'alcaravan'),
array('letra'=>'a', 'palabra'=>'alcaravanero'),
array('letra'=>'a', 'palabra'=>'alcaravea'),
array('letra'=>'a', 'palabra'=>'alcarceña'),
array('letra'=>'a', 'palabra'=>'alcarceñal'),
array('letra'=>'a', 'palabra'=>'alcarchofa'),
array('letra'=>'a', 'palabra'=>'alcarchofado'),
array('letra'=>'a', 'palabra'=>'alcarchofar'),
array('letra'=>'a', 'palabra'=>'alcarcil'),
array('letra'=>'a', 'palabra'=>'alcaria'),
array('letra'=>'a', 'palabra'=>'alcarracero'),
array('letra'=>'a', 'palabra'=>'alcarraza'),
array('letra'=>'a', 'palabra'=>'alcarreño'),
array('letra'=>'a', 'palabra'=>'alcarreto'),
array('letra'=>'a', 'palabra'=>'alcarria'),
array('letra'=>'a', 'palabra'=>'alcartaz'),
array('letra'=>'a', 'palabra'=>'alcatara'),
array('letra'=>'a', 'palabra'=>'alcatenes'),
array('letra'=>'a', 'palabra'=>'alcatifa'),
array('letra'=>'a', 'palabra'=>'alcatifar'),
array('letra'=>'a', 'palabra'=>'alcatraz'),
array('letra'=>'a', 'palabra'=>'alcauci'),
array('letra'=>'a', 'palabra'=>'alcaucil'),
array('letra'=>'a', 'palabra'=>'alcaudon'),
array('letra'=>'a', 'palabra'=>'alcavela'),
array('letra'=>'a', 'palabra'=>'alcavera'),
array('letra'=>'a', 'palabra'=>'alcayata'),
array('letra'=>'a', 'palabra'=>'alcayatar'),
array('letra'=>'a', 'palabra'=>'alcazaba'),
array('letra'=>'a', 'palabra'=>'alcazar'),
array('letra'=>'a', 'palabra'=>'alcazareño'),
array('letra'=>'a', 'palabra'=>'alcazuz'),
array('letra'=>'a', 'palabra'=>'alce'),
array('letra'=>'a', 'palabra'=>'alcea'),
array('letra'=>'a', 'palabra'=>'alcedo'),
array('letra'=>'a', 'palabra'=>'alcedon'),
array('letra'=>'a', 'palabra'=>'alcino'),
array('letra'=>'a', 'palabra'=>'alcion'),
array('letra'=>'a', 'palabra'=>'alcionio'),
array('letra'=>'a', 'palabra'=>'alcionito'),
array('letra'=>'a', 'palabra'=>'alcireño'),
array('letra'=>'a', 'palabra'=>'alcista'),
array('letra'=>'a', 'palabra'=>'alcoba'),
array('letra'=>'a', 'palabra'=>'alcobilla'),
array('letra'=>'a', 'palabra'=>'alcocarra'),
array('letra'=>'a', 'palabra'=>'alcofol'),
array('letra'=>'a', 'palabra'=>'alcohela'),
array('letra'=>'a', 'palabra'=>'alcohol'),
array('letra'=>'a', 'palabra'=>'alcoholado'),
array('letra'=>'a', 'palabra'=>'alcoholador'),
array('letra'=>'a', 'palabra'=>'alcoholar'),
array('letra'=>'a', 'palabra'=>'alcoholato'),
array('letra'=>'a', 'palabra'=>'alcoholaturo'),
array('letra'=>'a', 'palabra'=>'alcoholemia'),
array('letra'=>'a', 'palabra'=>'alcoholero'),
array('letra'=>'a', 'palabra'=>'alcoholico'),
array('letra'=>'a', 'palabra'=>'alcoholimetria'),
array('letra'=>'a', 'palabra'=>'alcoholimetro'),
array('letra'=>'a', 'palabra'=>'alcoholisis'),
array('letra'=>'a', 'palabra'=>'alcoholismo'),
array('letra'=>'a', 'palabra'=>'alcoholizacion'),
array('letra'=>'a', 'palabra'=>'alcoholizado'),
array('letra'=>'a', 'palabra'=>'alcoholizar'),
array('letra'=>'a', 'palabra'=>'alcohometria'),
array('letra'=>'a', 'palabra'=>'alcohometro'),
array('letra'=>'a', 'palabra'=>'alcojolado'),
array('letra'=>'a', 'palabra'=>'alcolla'),
array('letra'=>'a', 'palabra'=>'alcomenias'),
array('letra'=>'a', 'palabra'=>'alconcilla'),
array('letra'=>'a', 'palabra'=>'alcor'),
array('letra'=>'a', 'palabra'=>'alcoran'),
array('letra'=>'a', 'palabra'=>'alcoranico'),
array('letra'=>'a', 'palabra'=>'alcoranista'),
array('letra'=>'a', 'palabra'=>'alcorce'),
array('letra'=>'a', 'palabra'=>'alcorci'),
array('letra'=>'a', 'palabra'=>'alcornocal'),
array('letra'=>'a', 'palabra'=>'alcornoque'),
array('letra'=>'a', 'palabra'=>'alcornoqueño'),
array('letra'=>'a', 'palabra'=>'alcorque'),
array('letra'=>'a', 'palabra'=>'alcorza'),
array('letra'=>'a', 'palabra'=>'alcorzado'),
array('letra'=>'a', 'palabra'=>'alcorzar'),
array('letra'=>'a', 'palabra'=>'alcotan'),
array('letra'=>'a', 'palabra'=>'alcotana'),
array('letra'=>'a', 'palabra'=>'alcoyano'),
array('letra'=>'a', 'palabra'=>'alcrebite'),
array('letra'=>'a', 'palabra'=>'alcribis'),
array('letra'=>'a', 'palabra'=>'alcribite'),
array('letra'=>'a', 'palabra'=>'alcubilla'),
array('letra'=>'a', 'palabra'=>'alcucero'),
array('letra'=>'a', 'palabra'=>'alcuña'),
array('letra'=>'a', 'palabra'=>'alcuño'),
array('letra'=>'a', 'palabra'=>'alcurnia'),
array('letra'=>'a', 'palabra'=>'alcuza'),
array('letra'=>'a', 'palabra'=>'alcuzada'),
array('letra'=>'a', 'palabra'=>'alcuzcucero'),
array('letra'=>'a', 'palabra'=>'alcuzcuz'),
array('letra'=>'a', 'palabra'=>'alcuzcuzu'),
array('letra'=>'a', 'palabra'=>'aldaba'),
array('letra'=>'a', 'palabra'=>'aldabada'),
array('letra'=>'a', 'palabra'=>'aldabazo'),
array('letra'=>'a', 'palabra'=>'aldabear'),
array('letra'=>'a', 'palabra'=>'aldabeo'),
array('letra'=>'a', 'palabra'=>'aldabia'),
array('letra'=>'a', 'palabra'=>'aldabilla'),
array('letra'=>'a', 'palabra'=>'aldabon'),
array('letra'=>'a', 'palabra'=>'aldabonazo'),
array('letra'=>'a', 'palabra'=>'aldea'),
array('letra'=>'a', 'palabra'=>'aldeanamente'),
array('letra'=>'a', 'palabra'=>'aldeaniego'),
array('letra'=>'a', 'palabra'=>'aldeanismo'),
array('letra'=>'a', 'palabra'=>'aldeano'),
array('letra'=>'a', 'palabra'=>'aldehidico'),
array('letra'=>'a', 'palabra'=>'aldehido'),
array('letra'=>'a', 'palabra'=>'aldeon'),
array('letra'=>'a', 'palabra'=>'aldeorrio'),
array('letra'=>'a', 'palabra'=>'aldeorro'),
array('letra'=>'a', 'palabra'=>'alderredor'),
array('letra'=>'a', 'palabra'=>'aldino'),
array('letra'=>'a', 'palabra'=>'aldiza'),
array('letra'=>'a', 'palabra'=>'aldohexosa'),
array('letra'=>'a', 'palabra'=>'aldorta'),
array('letra'=>'a', 'palabra'=>'alducar'),
array('letra'=>'a', 'palabra'=>'ale'),
array('letra'=>'a', 'palabra'=>'alea'),
array('letra'=>'a', 'palabra'=>'aleacion'),
array('letra'=>'a', 'palabra'=>'alear'),
array('letra'=>'a', 'palabra'=>'aleatoriedad'),
array('letra'=>'a', 'palabra'=>'aleatorio'),
array('letra'=>'a', 'palabra'=>'alebrarse'),
array('letra'=>'a', 'palabra'=>'alebrastarse'),
array('letra'=>'a', 'palabra'=>'alebrestado'),
array('letra'=>'a', 'palabra'=>'alebrestarse'),
array('letra'=>'a', 'palabra'=>'alebronarse'),
array('letra'=>'a', 'palabra'=>'aleccionador'),
array('letra'=>'a', 'palabra'=>'aleccionamiento'),
array('letra'=>'a', 'palabra'=>'aleccionar'),
array('letra'=>'a', 'palabra'=>'alece'),
array('letra'=>'a', 'palabra'=>'aleche'),
array('letra'=>'a', 'palabra'=>'alechigar'),
array('letra'=>'a', 'palabra'=>'alechugado'),
array('letra'=>'a', 'palabra'=>'alechugar'),
array('letra'=>'a', 'palabra'=>'alecrin'),
array('letra'=>'a', 'palabra'=>'alectomancia'),
array('letra'=>'a', 'palabra'=>'alectomancia'),
array('letra'=>'a', 'palabra'=>'alectoria'),
array('letra'=>'a', 'palabra'=>'aleda'),
array('letra'=>'a', 'palabra'=>'aledaño'),
array('letra'=>'a', 'palabra'=>'alef'),
array('letra'=>'a', 'palabra'=>'alefangina'),
array('letra'=>'a', 'palabra'=>'alefato'),
array('letra'=>'a', 'palabra'=>'alefriz'),
array('letra'=>'a', 'palabra'=>'alegacion'),
array('letra'=>'a', 'palabra'=>'alegador'),
array('letra'=>'a', 'palabra'=>'alegamar'),
array('letra'=>'a', 'palabra'=>'aleganarse'),
array('letra'=>'a', 'palabra'=>'alegar'),
array('letra'=>'a', 'palabra'=>'alegato'),
array('letra'=>'a', 'palabra'=>'alegatorio'),
array('letra'=>'a', 'palabra'=>'alegoria'),
array('letra'=>'a', 'palabra'=>'alegorico'),
array('letra'=>'a', 'palabra'=>'alegorismo'),
array('letra'=>'a', 'palabra'=>'alegorizacion'),
array('letra'=>'a', 'palabra'=>'alegorizar'),
array('letra'=>'a', 'palabra'=>'alegra'),
array('letra'=>'a', 'palabra'=>'alegrador'),
array('letra'=>'a', 'palabra'=>'alegradura'),
array('letra'=>'a', 'palabra'=>'alegranza'),
array('letra'=>'a', 'palabra'=>'alegrar'),
array('letra'=>'a', 'palabra'=>'alegre'),
array('letra'=>'a', 'palabra'=>'alegremente'),
array('letra'=>'a', 'palabra'=>'alegreto'),
array('letra'=>'a', 'palabra'=>'alegria'),
array('letra'=>'a', 'palabra'=>'alegro'),
array('letra'=>'a', 'palabra'=>'alegron'),
array('letra'=>'a', 'palabra'=>'alegroso'),
array('letra'=>'a', 'palabra'=>'aleja'),
array('letra'=>'a', 'palabra'=>'alejado'),
array('letra'=>'a', 'palabra'=>'alejamiento'),
array('letra'=>'a', 'palabra'=>'alejandria'),
array('letra'=>'a', 'palabra'=>'alejandrinismo'),
array('letra'=>'a', 'palabra'=>'alejandrino'),
array('letra'=>'a', 'palabra'=>'alejandrita'),
array('letra'=>'a', 'palabra'=>'alejar'),
array('letra'=>'a', 'palabra'=>'alejija'),
array('letra'=>'a', 'palabra'=>'alejur'),
array('letra'=>'a', 'palabra'=>'alelado'),
array('letra'=>'a', 'palabra'=>'alelamiento'),
array('letra'=>'a', 'palabra'=>'alelar'),
array('letra'=>'a', 'palabra'=>'alelevi'),
array('letra'=>'a', 'palabra'=>'aleli'),
array('letra'=>'a', 'palabra'=>'alelo'),
array('letra'=>'a', 'palabra'=>'alelomorfico'),
array('letra'=>'a', 'palabra'=>'alelomorfo'),
array('letra'=>'a', 'palabra'=>'aleluya'),
array('letra'=>'a', 'palabra'=>'alema'),
array('letra'=>'a', 'palabra'=>'aleman'),
array('letra'=>'a', 'palabra'=>'alemanda'),
array('letra'=>'a', 'palabra'=>'alemanes'),
array('letra'=>'a', 'palabra'=>'alemanesco'),
array('letra'=>'a', 'palabra'=>'alemanico'),
array('letra'=>'a', 'palabra'=>'alemanisco'),
array('letra'=>'a', 'palabra'=>'alenguamiento'),
array('letra'=>'a', 'palabra'=>'alenguar'),
array('letra'=>'a', 'palabra'=>'alentada'),
array('letra'=>'a', 'palabra'=>'alentadamente'),
array('letra'=>'a', 'palabra'=>'alentado'),
array('letra'=>'a', 'palabra'=>'alentador'),
array('letra'=>'a', 'palabra'=>'alentar'),
array('letra'=>'a', 'palabra'=>'alentoso'),
array('letra'=>'a', 'palabra'=>'aleonado'),
array('letra'=>'a', 'palabra'=>'aleonar'),
array('letra'=>'a', 'palabra'=>'alepin'),
array('letra'=>'a', 'palabra'=>'alerce'),
array('letra'=>'a', 'palabra'=>'alergeno'),
array('letra'=>'a', 'palabra'=>'alergeno'),
array('letra'=>'a', 'palabra'=>'alergia'),
array('letra'=>'a', 'palabra'=>'alergico'),
array('letra'=>'a', 'palabra'=>'alergista'),
array('letra'=>'a', 'palabra'=>'alergologia'),
array('letra'=>'a', 'palabra'=>'alergologo'),
array('letra'=>'a', 'palabra'=>'alero'),
array('letra'=>'a', 'palabra'=>'aleron'),
array('letra'=>'a', 'palabra'=>'alerta'),
array('letra'=>'a', 'palabra'=>'alertado'),
array('letra'=>'a', 'palabra'=>'alertamente'),
array('letra'=>'a', 'palabra'=>'alertar'),
array('letra'=>'a', 'palabra'=>'alerto'),
array('letra'=>'a', 'palabra'=>'alerzal'),
array('letra'=>'a', 'palabra'=>'alesna'),
array('letra'=>'a', 'palabra'=>'alesnado'),
array('letra'=>'a', 'palabra'=>'aleta'),
array('letra'=>'a', 'palabra'=>'aletada'),
array('letra'=>'a', 'palabra'=>'aletargamiento'),
array('letra'=>'a', 'palabra'=>'aletargar'),
array('letra'=>'a', 'palabra'=>'aletazo'),
array('letra'=>'a', 'palabra'=>'aletear'),
array('letra'=>'a', 'palabra'=>'aleteo'),
array('letra'=>'a', 'palabra'=>'aleto'),
array('letra'=>'a', 'palabra'=>'aletria'),
array('letra'=>'a', 'palabra'=>'aleudar'),
array('letra'=>'a', 'palabra'=>'aleutiano'),
array('letra'=>'a', 'palabra'=>'alevantadizo'),
array('letra'=>'a', 'palabra'=>'alevantar'),
array('letra'=>'a', 'palabra'=>'aleve'),
array('letra'=>'a', 'palabra'=>'aleviar'),
array('letra'=>'a', 'palabra'=>'alevilla'),
array('letra'=>'a', 'palabra'=>'alevin'),
array('letra'=>'a', 'palabra'=>'alevosa'),
array('letra'=>'a', 'palabra'=>'alevosia'),
array('letra'=>'a', 'palabra'=>'alevoso'),
array('letra'=>'a', 'palabra'=>'alexia'),
array('letra'=>'a', 'palabra'=>'alexifarmaco'),
array('letra'=>'a', 'palabra'=>'aleya'),
array('letra'=>'a', 'palabra'=>'alezna'),
array('letra'=>'a', 'palabra'=>'aleznado'),
array('letra'=>'a', 'palabra'=>'aleznar'),
array('letra'=>'a', 'palabra'=>'alezo'),
array('letra'=>'a', 'palabra'=>'alfa'),
array('letra'=>'a', 'palabra'=>'alfaba'),
array('letra'=>'a', 'palabra'=>'alfabega'),
array('letra'=>'a', 'palabra'=>'alfabeticamente'),
array('letra'=>'a', 'palabra'=>'alfabetico'),
array('letra'=>'a', 'palabra'=>'alfabetizacion'),
array('letra'=>'a', 'palabra'=>'alfabetizado'),
array('letra'=>'a', 'palabra'=>'alfabetizar'),
array('letra'=>'a', 'palabra'=>'alfabeto'),
array('letra'=>'a', 'palabra'=>'alfadia'),
array('letra'=>'a', 'palabra'=>'alfaguara'),
array('letra'=>'a', 'palabra'=>'alfahar'),
array('letra'=>'a', 'palabra'=>'alfahareria'),
array('letra'=>'a', 'palabra'=>'alfaharero'),
array('letra'=>'a', 'palabra'=>'alfaida'),
array('letra'=>'a', 'palabra'=>'alfaja'),
array('letra'=>'a', 'palabra'=>'alfajeme'),
array('letra'=>'a', 'palabra'=>'alfajia'),
array('letra'=>'a', 'palabra'=>'alfajor'),
array('letra'=>'a', 'palabra'=>'alfalfa'),
array('letra'=>'a', 'palabra'=>'alfalfal'),
array('letra'=>'a', 'palabra'=>'alfalfar'),
array('letra'=>'a', 'palabra'=>'alfalfe'),
array('letra'=>'a', 'palabra'=>'alfalfez'),
array('letra'=>'a', 'palabra'=>'alfama'),
array('letra'=>'a', 'palabra'=>'alfamar'),
array('letra'=>'a', 'palabra'=>'alfamarada'),
array('letra'=>'a', 'palabra'=>'alfana'),
array('letra'=>'a', 'palabra'=>'alfandoque'),
array('letra'=>'a', 'palabra'=>'alfaneque'),
array('letra'=>'a', 'palabra'=>'alfanjado'),
array('letra'=>'a', 'palabra'=>'alfanjazo'),
array('letra'=>'a', 'palabra'=>'alfanje'),
array('letra'=>'a', 'palabra'=>'alfanumerico'),
array('letra'=>'a', 'palabra'=>'alfanumero'),
array('letra'=>'a', 'palabra'=>'alfaque'),
array('letra'=>'a', 'palabra'=>'alfaqueque'),
array('letra'=>'a', 'palabra'=>'alfaqui'),
array('letra'=>'a', 'palabra'=>'alfaquin'),
array('letra'=>'a', 'palabra'=>'alfar'),
array('letra'=>'a', 'palabra'=>'alfaraz'),
array('letra'=>'a', 'palabra'=>'alfarda'),
array('letra'=>'a', 'palabra'=>'alfardilla'),
array('letra'=>'a', 'palabra'=>'alfardon'),
array('letra'=>'a', 'palabra'=>'alfareme'),
array('letra'=>'a', 'palabra'=>'alfareria'),
array('letra'=>'a', 'palabra'=>'alfarero'),
array('letra'=>'a', 'palabra'=>'alfarje'),
array('letra'=>'a', 'palabra'=>'alfarjia'),
array('letra'=>'a', 'palabra'=>'alfarma'),
array('letra'=>'a', 'palabra'=>'alfarnate'),
array('letra'=>'a', 'palabra'=>'alfarrazador'),
array('letra'=>'a', 'palabra'=>'alfarrazar'),
array('letra'=>'a', 'palabra'=>'alfaya'),
array('letra'=>'a', 'palabra'=>'alfayate'),
array('letra'=>'a', 'palabra'=>'alfayateria'),
array('letra'=>'a', 'palabra'=>'alfazaque'),
array('letra'=>'a', 'palabra'=>'alfeiza'),
array('letra'=>'a', 'palabra'=>'alfeizar'),
array('letra'=>'a', 'palabra'=>'alfeizar'),
array('letra'=>'a', 'palabra'=>'alfendoz'),
array('letra'=>'a', 'palabra'=>'alfeñar'),
array('letra'=>'a', 'palabra'=>'alfeñicarse'),
array('letra'=>'a', 'palabra'=>'alfeñique'),
array('letra'=>'a', 'palabra'=>'alferazgo'),
array('letra'=>'a', 'palabra'=>'alferecia'),
array('letra'=>'a', 'palabra'=>'alferez'),
array('letra'=>'a', 'palabra'=>'alferraz'),
array('letra'=>'a', 'palabra'=>'alferza'),
array('letra'=>'a', 'palabra'=>'alficoz'),
array('letra'=>'a', 'palabra'=>'alfil'),
array('letra'=>'a', 'palabra'=>'alfilel'),
array('letra'=>'a', 'palabra'=>'alfiler'),
array('letra'=>'a', 'palabra'=>'alfilerazo'),
array('letra'=>'a', 'palabra'=>'alfilerera'),
array('letra'=>'a', 'palabra'=>'alfileresco'),
array('letra'=>'a', 'palabra'=>'alfilerillo'),
array('letra'=>'a', 'palabra'=>'alfiletero'),
array('letra'=>'a', 'palabra'=>'alfinge'),
array('letra'=>'a', 'palabra'=>'alfitete'),
array('letra'=>'a', 'palabra'=>'alfiz'),
array('letra'=>'a', 'palabra'=>'alfocigo'),
array('letra'=>'a', 'palabra'=>'alfoli'),
array('letra'=>'a', 'palabra'=>'alfoliero'),
array('letra'=>'a', 'palabra'=>'alfolinero'),
array('letra'=>'a', 'palabra'=>'alfombra'),
array('letra'=>'a', 'palabra'=>'alfombrado'),
array('letra'=>'a', 'palabra'=>'alfombrar'),
array('letra'=>'a', 'palabra'=>'alfombrero'),
array('letra'=>'a', 'palabra'=>'alfombrilla'),
array('letra'=>'a', 'palabra'=>'alfombrista'),
array('letra'=>'a', 'palabra'=>'alfoncigo'),
array('letra'=>'a', 'palabra'=>'alfondiga'),
array('letra'=>'a', 'palabra'=>'alfondoque'),
array('letra'=>'a', 'palabra'=>'alfonsario'),
array('letra'=>'a', 'palabra'=>'alfonsearse'),
array('letra'=>'a', 'palabra'=>'alfonsi'),
array('letra'=>'a', 'palabra'=>'alfonsigo'),
array('letra'=>'a', 'palabra'=>'alfonsino'),
array('letra'=>'a', 'palabra'=>'alfonsismo'),
array('letra'=>'a', 'palabra'=>'alforfon'),
array('letra'=>'a', 'palabra'=>'alforin'),
array('letra'=>'a', 'palabra'=>'alforja'),
array('letra'=>'a', 'palabra'=>'alforjero'),
array('letra'=>'a', 'palabra'=>'alforjon'),
array('letra'=>'a', 'palabra'=>'alforre'),
array('letra'=>'a', 'palabra'=>'alforrochar'),
array('letra'=>'a', 'palabra'=>'alforrocho'),
array('letra'=>'a', 'palabra'=>'alforza'),
array('letra'=>'a', 'palabra'=>'alforzar'),
array('letra'=>'a', 'palabra'=>'alfostiga'),
array('letra'=>'a', 'palabra'=>'alfoz'),
array('letra'=>'a', 'palabra'=>'alga'),
array('letra'=>'a', 'palabra'=>'algaba'),
array('letra'=>'a', 'palabra'=>'algabeño'),
array('letra'=>'a', 'palabra'=>'algadara'),
array('letra'=>'a', 'palabra'=>'algaida'),
array('letra'=>'a', 'palabra'=>'algaido'),
array('letra'=>'a', 'palabra'=>'algalia'),
array('letra'=>'a', 'palabra'=>'algaliar'),
array('letra'=>'a', 'palabra'=>'algaliero'),
array('letra'=>'a', 'palabra'=>'algar'),
array('letra'=>'a', 'palabra'=>'algara'),
array('letra'=>'a', 'palabra'=>'algarabia'),
array('letra'=>'a', 'palabra'=>'algarabiado'),
array('letra'=>'a', 'palabra'=>'algarabio'),
array('letra'=>'a', 'palabra'=>'algaracear'),
array('letra'=>'a', 'palabra'=>'algarada'),
array('letra'=>'a', 'palabra'=>'algarazo'),
array('letra'=>'a', 'palabra'=>'algareador'),
array('letra'=>'a', 'palabra'=>'algarear'),
array('letra'=>'a', 'palabra'=>'algarero'),
array('letra'=>'a', 'palabra'=>'algarivo'),
array('letra'=>'a', 'palabra'=>'algarrada'),
array('letra'=>'a', 'palabra'=>'algarroba'),
array('letra'=>'a', 'palabra'=>'algarrobal'),
array('letra'=>'a', 'palabra'=>'algarrobera'),
array('letra'=>'a', 'palabra'=>'algarrobero'),
array('letra'=>'a', 'palabra'=>'algarrobilla'),
array('letra'=>'a', 'palabra'=>'algarrobo'),
array('letra'=>'a', 'palabra'=>'algavaro'),
array('letra'=>'a', 'palabra'=>'algazara'),
array('letra'=>'a', 'palabra'=>'algazul'),
array('letra'=>'a', 'palabra'=>'algebra'),
array('letra'=>'a', 'palabra'=>'algebraico'),
array('letra'=>'a', 'palabra'=>'algebrico'),
array('letra'=>'a', 'palabra'=>'algebrista'),
array('letra'=>'a', 'palabra'=>'algecireño'),
array('letra'=>'a', 'palabra'=>'algente'),
array('letra'=>'a', 'palabra'=>'algia'),
array('letra'=>'a', 'palabra'=>'algidez'),
array('letra'=>'a', 'palabra'=>'algido'),
array('letra'=>'a', 'palabra'=>'algo'),
array('letra'=>'a', 'palabra'=>'algodon'),
array('letra'=>'a', 'palabra'=>'algodonal'),
array('letra'=>'a', 'palabra'=>'algodonar'),
array('letra'=>'a', 'palabra'=>'algodoncillo'),
array('letra'=>'a', 'palabra'=>'algodonero'),
array('letra'=>'a', 'palabra'=>'algodonoso'),
array('letra'=>'a', 'palabra'=>'algol'),
array('letra'=>'a', 'palabra'=>'algonquino'),
array('letra'=>'a', 'palabra'=>'algorfa'),
array('letra'=>'a', 'palabra'=>'algorin'),
array('letra'=>'a', 'palabra'=>'algoritmia'),
array('letra'=>'a', 'palabra'=>'algoritmico'),
array('letra'=>'a', 'palabra'=>'algoritmo'),
array('letra'=>'a', 'palabra'=>'algorto'),
array('letra'=>'a', 'palabra'=>'algorza'),
array('letra'=>'a', 'palabra'=>'algoso'),
array('letra'=>'a', 'palabra'=>'algotro'),
array('letra'=>'a', 'palabra'=>'alguacil'),
array('letra'=>'a', 'palabra'=>'alguacila'),
array('letra'=>'a', 'palabra'=>'alguaciladgo'),
array('letra'=>'a', 'palabra'=>'alguacilazgo'),
array('letra'=>'a', 'palabra'=>'alguacileria'),
array('letra'=>'a', 'palabra'=>'alguacilesco'),
array('letra'=>'a', 'palabra'=>'alguacilillo'),
array('letra'=>'a', 'palabra'=>'alguandre'),
array('letra'=>'a', 'palabra'=>'alguaquida'),
array('letra'=>'a', 'palabra'=>'alguaquidero'),
array('letra'=>'a', 'palabra'=>'alguarin'),
array('letra'=>'a', 'palabra'=>'alguarismo'),
array('letra'=>'a', 'palabra'=>'alguaza'),
array('letra'=>'a', 'palabra'=>'alguero'),
array('letra'=>'a', 'palabra'=>'alguese'),
array('letra'=>'a', 'palabra'=>'alguien'),
array('letra'=>'a', 'palabra'=>'alguinio'),
array('letra'=>'a', 'palabra'=>'algun'),
array('letra'=>'a', 'palabra'=>'algunamente'),
array('letra'=>'a', 'palabra'=>'algund'),
array('letra'=>'a', 'palabra'=>'alguno'),
array('letra'=>'a', 'palabra'=>'alhabega'),
array('letra'=>'a', 'palabra'=>'alhacena'),
array('letra'=>'a', 'palabra'=>'alhaite'),
array('letra'=>'a', 'palabra'=>'alhaja'),
array('letra'=>'a', 'palabra'=>'alhajar'),
array('letra'=>'a', 'palabra'=>'alhajera'),
array('letra'=>'a', 'palabra'=>'alhajero'),
array('letra'=>'a', 'palabra'=>'alhajita'),
array('letra'=>'a', 'palabra'=>'alhajito'),
array('letra'=>'a', 'palabra'=>'alhaju'),
array('letra'=>'a', 'palabra'=>'alhamar'),
array('letra'=>'a', 'palabra'=>'alhamega'),
array('letra'=>'a', 'palabra'=>'alhamel'),
array('letra'=>'a', 'palabra'=>'alhami'),
array('letra'=>'a', 'palabra'=>'alhandal'),
array('letra'=>'a', 'palabra'=>'alhania'),
array('letra'=>'a', 'palabra'=>'alhaquin'),
array('letra'=>'a', 'palabra'=>'alharaca'),
array('letra'=>'a', 'palabra'=>'alharaquero'),
array('letra'=>'a', 'palabra'=>'alharaquiento'),
array('letra'=>'a', 'palabra'=>'alhareme'),
array('letra'=>'a', 'palabra'=>'alhargama'),
array('letra'=>'a', 'palabra'=>'alharma'),
array('letra'=>'a', 'palabra'=>'alhavara'),
array('letra'=>'a', 'palabra'=>'alheli'),
array('letra'=>'a', 'palabra'=>'alheña'),
array('letra'=>'a', 'palabra'=>'alheñar'),
array('letra'=>'a', 'palabra'=>'alhidada'),
array('letra'=>'a', 'palabra'=>'alhocigo'),
array('letra'=>'a', 'palabra'=>'alholi'),
array('letra'=>'a', 'palabra'=>'alholia'),
array('letra'=>'a', 'palabra'=>'alholva'),
array('letra'=>'a', 'palabra'=>'alholvar'),
array('letra'=>'a', 'palabra'=>'alhombra'),
array('letra'=>'a', 'palabra'=>'alhombrar'),
array('letra'=>'a', 'palabra'=>'alhondiga'),
array('letra'=>'a', 'palabra'=>'alhondiguero'),
array('letra'=>'a', 'palabra'=>'alhori'),
array('letra'=>'a', 'palabra'=>'alhorin'),
array('letra'=>'a', 'palabra'=>'alhorra'),
array('letra'=>'a', 'palabra'=>'alhorre'),
array('letra'=>'a', 'palabra'=>'alhorria'),
array('letra'=>'a', 'palabra'=>'alhorro'),
array('letra'=>'a', 'palabra'=>'alhorza'),
array('letra'=>'a', 'palabra'=>'alhoz'),
array('letra'=>'a', 'palabra'=>'alhucema'),
array('letra'=>'a', 'palabra'=>'alhucemilla'),
array('letra'=>'a', 'palabra'=>'alhuceña'),
array('letra'=>'a', 'palabra'=>'alhumajo'),
array('letra'=>'a', 'palabra'=>'alhurreca'),
array('letra'=>'a', 'palabra'=>'ali'),
array('letra'=>'a', 'palabra'=>'aliabierto'),
array('letra'=>'a', 'palabra'=>'aliacan'),
array('letra'=>'a', 'palabra'=>'aliacanado'),
array('letra'=>'a', 'palabra'=>'aliaceo'),
array('letra'=>'a', 'palabra'=>'aliado'),
array('letra'=>'a', 'palabra'=>'aliadofilo'),
array('letra'=>'a', 'palabra'=>'aliaga'),
array('letra'=>'a', 'palabra'=>'aliagar'),
array('letra'=>'a', 'palabra'=>'aliancista'),
array('letra'=>'a', 'palabra'=>'alianza'),
array('letra'=>'a', 'palabra'=>'alianzarse'),
array('letra'=>'a', 'palabra'=>'aliar'),
array('letra'=>'a', 'palabra'=>'aliara'),
array('letra'=>'a', 'palabra'=>'aliaria'),
array('letra'=>'a', 'palabra'=>'alias'),
array('letra'=>'a', 'palabra'=>'aliblanca'),
array('letra'=>'a', 'palabra'=>'alible'),
array('letra'=>'a', 'palabra'=>'alica'),
array('letra'=>'a', 'palabra'=>'alicaido'),
array('letra'=>'a', 'palabra'=>'alicantara'),
array('letra'=>'a', 'palabra'=>'alicante'),
array('letra'=>'a', 'palabra'=>'alicantina'),
array('letra'=>'a', 'palabra'=>'alicantino'),
array('letra'=>'a', 'palabra'=>'alicanto'),
array('letra'=>'a', 'palabra'=>'alicatado'),
array('letra'=>'a', 'palabra'=>'alicatar'),
array('letra'=>'a', 'palabra'=>'alicate'),
array('letra'=>'a', 'palabra'=>'alicer'),
array('letra'=>'a', 'palabra'=>'aliciente'),
array('letra'=>'a', 'palabra'=>'alicionar'),
array('letra'=>'a', 'palabra'=>'alicortar'),
array('letra'=>'a', 'palabra'=>'alicorto'),
array('letra'=>'a', 'palabra'=>'alicrejo'),
array('letra'=>'a', 'palabra'=>'alicuanta'),
array('letra'=>'a', 'palabra'=>'alicuota'),
array('letra'=>'a', 'palabra'=>'alidada'),
array('letra'=>'a', 'palabra'=>'alidona'),
array('letra'=>'a', 'palabra'=>'alienable'),
array('letra'=>'a', 'palabra'=>'alienacion'),
array('letra'=>'a', 'palabra'=>'alienado'),
array('letra'=>'a', 'palabra'=>'alienante'),
array('letra'=>'a', 'palabra'=>'alienar'),
array('letra'=>'a', 'palabra'=>'aliende'),
array('letra'=>'a', 'palabra'=>'alienigena'),
array('letra'=>'a', 'palabra'=>'alienigeno'),
array('letra'=>'a', 'palabra'=>'alienismo'),
array('letra'=>'a', 'palabra'=>'alienista'),
array('letra'=>'a', 'palabra'=>'aliento'),
array('letra'=>'a', 'palabra'=>'alier'),
array('letra'=>'a', 'palabra'=>'alifa'),
array('letra'=>'a', 'palabra'=>'alifafe'),
array('letra'=>'a', 'palabra'=>'alifara'),
array('letra'=>'a', 'palabra'=>'alifatico'),
array('letra'=>'a', 'palabra'=>'alifato'),
array('letra'=>'a', 'palabra'=>'alifero'),
array('letra'=>'a', 'palabra'=>'aligacion'),
array('letra'=>'a', 'palabra'=>'aligamiento'),
array('letra'=>'a', 'palabra'=>'aligar'),
array('letra'=>'a', 'palabra'=>'aligator'),
array('letra'=>'a', 'palabra'=>'aligator'),
array('letra'=>'a', 'palabra'=>'aliger'),
array('letra'=>'a', 'palabra'=>'aligeramiento'),
array('letra'=>'a', 'palabra'=>'aligerar'),
array('letra'=>'a', 'palabra'=>'aligero'),
array('letra'=>'a', 'palabra'=>'aligonero'),
array('letra'=>'a', 'palabra'=>'aligote'),
array('letra'=>'a', 'palabra'=>'aligustre'),
array('letra'=>'a', 'palabra'=>'alijador'),
array('letra'=>'a', 'palabra'=>'alijar'),
array('letra'=>'a', 'palabra'=>'alijarar'),
array('letra'=>'a', 'palabra'=>'alijarero'),
array('letra'=>'a', 'palabra'=>'alijariego'),
array('letra'=>'a', 'palabra'=>'alijo'),
array('letra'=>'a', 'palabra'=>'alim'),
array('letra'=>'a', 'palabra'=>'alimania'),
array('letra'=>'a', 'palabra'=>'alimanisco'),
array('letra'=>'a', 'palabra'=>'alimaña'),
array('letra'=>'a', 'palabra'=>'alimañero'),
array('letra'=>'a', 'palabra'=>'alimara'),
array('letra'=>'a', 'palabra'=>'alimentacion'),
array('letra'=>'a', 'palabra'=>'alimentador'),
array('letra'=>'a', 'palabra'=>'alimental'),
array('letra'=>'a', 'palabra'=>'alimentar'),
array('letra'=>'a', 'palabra'=>'alimentario'),
array('letra'=>'a', 'palabra'=>'alimenticio'),
array('letra'=>'a', 'palabra'=>'alimentista'),
array('letra'=>'a', 'palabra'=>'alimento'),
array('letra'=>'a', 'palabra'=>'alimentoso'),
array('letra'=>'a', 'palabra'=>'alimo'),
array('letra'=>'a', 'palabra'=>'alimoche'),
array('letra'=>'a', 'palabra'=>'alimon'),
array('letra'=>'a', 'palabra'=>'alimonarse'),
array('letra'=>'a', 'palabra'=>'alimpiador'),
array('letra'=>'a', 'palabra'=>'alimpiamiento'),
array('letra'=>'a', 'palabra'=>'alimpiar'),
array('letra'=>'a', 'palabra'=>'alindado'),
array('letra'=>'a', 'palabra'=>'alindamiento'),
array('letra'=>'a', 'palabra'=>'alindar'),
array('letra'=>'a', 'palabra'=>'alinde'),
array('letra'=>'a', 'palabra'=>'alinderar'),
array('letra'=>'a', 'palabra'=>'alineacion'),
array('letra'=>'a', 'palabra'=>'alineado'),
array('letra'=>'a', 'palabra'=>'alineamiento'),
array('letra'=>'a', 'palabra'=>'alinear'),
array('letra'=>'a', 'palabra'=>'aliñado'),
array('letra'=>'a', 'palabra'=>'aliñador'),
array('letra'=>'a', 'palabra'=>'aliñamiento'),
array('letra'=>'a', 'palabra'=>'aliñar'),
array('letra'=>'a', 'palabra'=>'aliño'),
array('letra'=>'a', 'palabra'=>'aliñoso'),
array('letra'=>'a', 'palabra'=>'alioj'),
array('letra'=>'a', 'palabra'=>'alioli'),
array('letra'=>'a', 'palabra'=>'alionin'),
array('letra'=>'a', 'palabra'=>'alipata'),
array('letra'=>'a', 'palabra'=>'alipede'),
array('letra'=>'a', 'palabra'=>'alipedo'),
array('letra'=>'a', 'palabra'=>'alipegarse'),
array('letra'=>'a', 'palabra'=>'alipego'),
array('letra'=>'a', 'palabra'=>'aliquebrado'),
array('letra'=>'a', 'palabra'=>'aliquebrar'),
array('letra'=>'a', 'palabra'=>'aliron'),
array('letra'=>'a', 'palabra'=>'alirrojo'),
array('letra'=>'a', 'palabra'=>'alisador'),
array('letra'=>'a', 'palabra'=>'alisadura'),
array('letra'=>'a', 'palabra'=>'alisal'),
array('letra'=>'a', 'palabra'=>'alisar'),
array('letra'=>'a', 'palabra'=>'aliseda'),
array('letra'=>'a', 'palabra'=>'alisios'),
array('letra'=>'a', 'palabra'=>'alisma'),
array('letra'=>'a', 'palabra'=>'alismaceo'),
array('letra'=>'a', 'palabra'=>'alismataceo'),
array('letra'=>'a', 'palabra'=>'aliso'),
array('letra'=>'a', 'palabra'=>'alistado'),
array('letra'=>'a', 'palabra'=>'alistador'),
array('letra'=>'a', 'palabra'=>'alistamiento'),
array('letra'=>'a', 'palabra'=>'alistano'),
array('letra'=>'a', 'palabra'=>'alistar'),
array('letra'=>'a', 'palabra'=>'alitan'),
array('letra'=>'a', 'palabra'=>'aliteracion'),
array('letra'=>'a', 'palabra'=>'aliterado'),
array('letra'=>'a', 'palabra'=>'alitierno'),
array('letra'=>'a', 'palabra'=>'alitranco'),
array('letra'=>'a', 'palabra'=>'aliviadero'),
array('letra'=>'a', 'palabra'=>'aliviador'),
array('letra'=>'a', 'palabra'=>'aliviamiento'),
array('letra'=>'a', 'palabra'=>'alivianar'),
array('letra'=>'a', 'palabra'=>'aliviar'),
array('letra'=>'a', 'palabra'=>'alivio'),
array('letra'=>'a', 'palabra'=>'alivioso'),
array('letra'=>'a', 'palabra'=>'alizace'),
array('letra'=>'a', 'palabra'=>'alizar'),
array('letra'=>'a', 'palabra'=>'alizarina'),
array('letra'=>'a', 'palabra'=>'aljaba'),
array('letra'=>'a', 'palabra'=>'aljabibe'),
array('letra'=>'a', 'palabra'=>'aljafana'),
array('letra'=>'a', 'palabra'=>'aljama'),
array('letra'=>'a', 'palabra'=>'aljamel'),
array('letra'=>'a', 'palabra'=>'aljamia'),
array('letra'=>'a', 'palabra'=>'aljamiado'),
array('letra'=>'a', 'palabra'=>'aljarafe'),
array('letra'=>'a', 'palabra'=>'aljaraz'),
array('letra'=>'a', 'palabra'=>'aljarfa'),
array('letra'=>'a', 'palabra'=>'aljarfe'),
array('letra'=>'a', 'palabra'=>'aljebana'),
array('letra'=>'a', 'palabra'=>'aljeceria'),
array('letra'=>'a', 'palabra'=>'aljecero'),
array('letra'=>'a', 'palabra'=>'aljemifao'),
array('letra'=>'a', 'palabra'=>'aljerife'),
array('letra'=>'a', 'palabra'=>'aljerifero'),
array('letra'=>'a', 'palabra'=>'aljez'),
array('letra'=>'a', 'palabra'=>'aljezar'),
array('letra'=>'a', 'palabra'=>'aljezon'),
array('letra'=>'a', 'palabra'=>'aljibe'),
array('letra'=>'a', 'palabra'=>'aljibero'),
array('letra'=>'a', 'palabra'=>'aljofaina'),
array('letra'=>'a', 'palabra'=>'aljofar'),
array('letra'=>'a', 'palabra'=>'aljofarar'),
array('letra'=>'a', 'palabra'=>'aljofifa'),
array('letra'=>'a', 'palabra'=>'aljofifar'),
array('letra'=>'a', 'palabra'=>'aljonje'),
array('letra'=>'a', 'palabra'=>'aljonjera'),
array('letra'=>'a', 'palabra'=>'aljonjero'),
array('letra'=>'a', 'palabra'=>'aljonjoli'),
array('letra'=>'a', 'palabra'=>'aljor'),
array('letra'=>'a', 'palabra'=>'aljorca'),
array('letra'=>'a', 'palabra'=>'aljuba'),
array('letra'=>'a', 'palabra'=>'aljuma'),
array('letra'=>'a', 'palabra'=>'alkermes'),
array('letra'=>'a', 'palabra'=>'alla'),
array('letra'=>'a', 'palabra'=>'allanabarrancos'),
array('letra'=>'a', 'palabra'=>'allanador'),
array('letra'=>'a', 'palabra'=>'allanamiento'),
array('letra'=>'a', 'palabra'=>'allanar'),
array('letra'=>'a', 'palabra'=>'allariz'),
array('letra'=>'a', 'palabra'=>'allegadera'),
array('letra'=>'a', 'palabra'=>'allegadizo'),
array('letra'=>'a', 'palabra'=>'allegado'),
array('letra'=>'a', 'palabra'=>'allegador'),
array('letra'=>'a', 'palabra'=>'allegamiento'),
array('letra'=>'a', 'palabra'=>'alleganza'),
array('letra'=>'a', 'palabra'=>'allegar'),
array('letra'=>'a', 'palabra'=>'allen'),
array('letra'=>'a', 'palabra'=>'allende'),
array('letra'=>'a', 'palabra'=>'alli'),
array('letra'=>'a', 'palabra'=>'allora'),
array('letra'=>'a', 'palabra'=>'alloza'),
array('letra'=>'a', 'palabra'=>'allozar'),
array('letra'=>'a', 'palabra'=>'allozo'),
array('letra'=>'a', 'palabra'=>'allu'),
array('letra'=>'a', 'palabra'=>'alludel'),
array('letra'=>'a', 'palabra'=>'alma'),
array('letra'=>'a', 'palabra'=>'almacabra'),
array('letra'=>'a', 'palabra'=>'almacen'),
array('letra'=>'a', 'palabra'=>'almacenaje'),
array('letra'=>'a', 'palabra'=>'almacenamiento'),
array('letra'=>'a', 'palabra'=>'almacenar'),
array('letra'=>'a', 'palabra'=>'almacenero'),
array('letra'=>'a', 'palabra'=>'almacenista'),
array('letra'=>'a', 'palabra'=>'almaceno'),
array('letra'=>'a', 'palabra'=>'almaceria'),
array('letra'=>'a', 'palabra'=>'almaciga'),
array('letra'=>'a', 'palabra'=>'almacigado'),
array('letra'=>'a', 'palabra'=>'almacigar'),
array('letra'=>'a', 'palabra'=>'almacigo'),
array('letra'=>'a', 'palabra'=>'almaciguero'),
array('letra'=>'a', 'palabra'=>'almadana'),
array('letra'=>'a', 'palabra'=>'almadearse'),
array('letra'=>'a', 'palabra'=>'almaden'),
array('letra'=>'a', 'palabra'=>'almadena'),
array('letra'=>'a', 'palabra'=>'almadia'),
array('letra'=>'a', 'palabra'=>'almadiar'),
array('letra'=>'a', 'palabra'=>'almadiero'),
array('letra'=>'a', 'palabra'=>'almadina'),
array('letra'=>'a', 'palabra'=>'almadraba'),
array('letra'=>'a', 'palabra'=>'almadrabero'),
array('letra'=>'a', 'palabra'=>'almadraque'),
array('letra'=>'a', 'palabra'=>'almadreña'),
array('letra'=>'a', 'palabra'=>'almadreñero'),
array('letra'=>'a', 'palabra'=>'almagacen'),
array('letra'=>'a', 'palabra'=>'almagana'),
array('letra'=>'a', 'palabra'=>'almagra'),
array('letra'=>'a', 'palabra'=>'almagradura'),
array('letra'=>'a', 'palabra'=>'almagral'),
array('letra'=>'a', 'palabra'=>'almagrar'),
array('letra'=>'a', 'palabra'=>'almagre'),
array('letra'=>'a', 'palabra'=>'almagreño'),
array('letra'=>'a', 'palabra'=>'almagrero'),
array('letra'=>'a', 'palabra'=>'almahala'),
array('letra'=>'a', 'palabra'=>'almaizal'),
array('letra'=>'a', 'palabra'=>'almaizar'),
array('letra'=>'a', 'palabra'=>'almaizo'),
array('letra'=>'a', 'palabra'=>'almaja'),
array('letra'=>'a', 'palabra'=>'almajal'),
array('letra'=>'a', 'palabra'=>'almajaneque'),
array('letra'=>'a', 'palabra'=>'almajar'),
array('letra'=>'a', 'palabra'=>'almajara'),
array('letra'=>'a', 'palabra'=>'almaje'),
array('letra'=>'a', 'palabra'=>'almajo'),
array('letra'=>'a', 'palabra'=>'almalafa'),
array('letra'=>'a', 'palabra'=>'almanac'),
array('letra'=>'a', 'palabra'=>'almanaca'),
array('letra'=>'a', 'palabra'=>'almanaque'),
array('letra'=>'a', 'palabra'=>'almanaquero'),
array('letra'=>'a', 'palabra'=>'almancebe'),
array('letra'=>'a', 'palabra'=>'almandina'),
array('letra'=>'a', 'palabra'=>'almandino'),
array('letra'=>'a', 'palabra'=>'almanta'),
array('letra'=>'a', 'palabra'=>'almarada'),
array('letra'=>'a', 'palabra'=>'almarbatar'),
array('letra'=>'a', 'palabra'=>'almarbate'),
array('letra'=>'a', 'palabra'=>'almarcha'),
array('letra'=>'a', 'palabra'=>'almario'),
array('letra'=>'a', 'palabra'=>'almarjal'),
array('letra'=>'a', 'palabra'=>'almarjo'),
array('letra'=>'a', 'palabra'=>'almaro'),
array('letra'=>'a', 'palabra'=>'almarra'),
array('letra'=>'a', 'palabra'=>'almarraja'),
array('letra'=>'a', 'palabra'=>'almarraza'),
array('letra'=>'a', 'palabra'=>'almartaga'),
array('letra'=>'a', 'palabra'=>'almartigon'),
array('letra'=>'a', 'palabra'=>'almastiga'),
array('letra'=>'a', 'palabra'=>'almastigado'),
array('letra'=>'a', 'palabra'=>'almatica'),
array('letra'=>'a', 'palabra'=>'almatriche'),
array('letra'=>'a', 'palabra'=>'almatroque'),
array('letra'=>'a', 'palabra'=>'almazara'),
array('letra'=>'a', 'palabra'=>'almazarero'),
array('letra'=>'a', 'palabra'=>'almazarron'),
array('letra'=>'a', 'palabra'=>'almea'),
array('letra'=>'a', 'palabra'=>'almecina'),
array('letra'=>'a', 'palabra'=>'almecino'),
array('letra'=>'a', 'palabra'=>'almeja'),
array('letra'=>'a', 'palabra'=>'almejar'),
array('letra'=>'a', 'palabra'=>'almeji'),
array('letra'=>'a', 'palabra'=>'almejia'),
array('letra'=>'a', 'palabra'=>'almena'),
array('letra'=>'a', 'palabra'=>'almenado'),
array('letra'=>'a', 'palabra'=>'almenaje'),
array('letra'=>'a', 'palabra'=>'almenar'),
array('letra'=>'a', 'palabra'=>'almenara'),
array('letra'=>'a', 'palabra'=>'almendra'),
array('letra'=>'a', 'palabra'=>'almendrado'),
array('letra'=>'a', 'palabra'=>'almendral'),
array('letra'=>'a', 'palabra'=>'almendrar'),
array('letra'=>'a', 'palabra'=>'almendrate'),
array('letra'=>'a', 'palabra'=>'almendrera'),
array('letra'=>'a', 'palabra'=>'almendrero'),
array('letra'=>'a', 'palabra'=>'almendrilla'),
array('letra'=>'a', 'palabra'=>'almendro'),
array('letra'=>'a', 'palabra'=>'almendrolon'),
array('letra'=>'a', 'palabra'=>'almendron'),
array('letra'=>'a', 'palabra'=>'almendruco'),
array('letra'=>'a', 'palabra'=>'almenilla'),
array('letra'=>'a', 'palabra'=>'almeriense'),
array('letra'=>'a', 'palabra'=>'almete'),
array('letra'=>'a', 'palabra'=>'almez'),
array('letra'=>'a', 'palabra'=>'almeza'),
array('letra'=>'a', 'palabra'=>'almezo'),
array('letra'=>'a', 'palabra'=>'almiar'),
array('letra'=>'a', 'palabra'=>'almiarar'),
array('letra'=>'a', 'palabra'=>'almibar'),
array('letra'=>'a', 'palabra'=>'almibarado'),
array('letra'=>'a', 'palabra'=>'almibarar'),
array('letra'=>'a', 'palabra'=>'almicantarat'),
array('letra'=>'a', 'palabra'=>'almidon'),
array('letra'=>'a', 'palabra'=>'almidonado'),
array('letra'=>'a', 'palabra'=>'almidonar'),
array('letra'=>'a', 'palabra'=>'almidoneria'),
array('letra'=>'a', 'palabra'=>'almijar'),
array('letra'=>'a', 'palabra'=>'almijara'),
array('letra'=>'a', 'palabra'=>'almijarero'),
array('letra'=>'a', 'palabra'=>'almijarra'),
array('letra'=>'a', 'palabra'=>'almilla'),
array('letra'=>'a', 'palabra'=>'almimbar'),
array('letra'=>'a', 'palabra'=>'alminar'),
array('letra'=>'a', 'palabra'=>'almiqui'),
array('letra'=>'a', 'palabra'=>'almiranta'),
array('letra'=>'a', 'palabra'=>'almirantazgo'),
array('letra'=>'a', 'palabra'=>'almirante'),
array('letra'=>'a', 'palabra'=>'almirantesa'),
array('letra'=>'a', 'palabra'=>'almirantia'),
array('letra'=>'a', 'palabra'=>'almirez'),
array('letra'=>'a', 'palabra'=>'almiron'),
array('letra'=>'a', 'palabra'=>'almizate'),
array('letra'=>'a', 'palabra'=>'almizclado'),
array('letra'=>'a', 'palabra'=>'almizclar'),
array('letra'=>'a', 'palabra'=>'almizcle'),
array('letra'=>'a', 'palabra'=>'almizcleño'),
array('letra'=>'a', 'palabra'=>'almizclero'),
array('letra'=>'a', 'palabra'=>'almizque'),
array('letra'=>'a', 'palabra'=>'almizquera'),
array('letra'=>'a', 'palabra'=>'almo'),
array('letra'=>'a', 'palabra'=>'almocaden'),
array('letra'=>'a', 'palabra'=>'almocafre'),
array('letra'=>'a', 'palabra'=>'almocarabe'),
array('letra'=>'a', 'palabra'=>'almocarbe'),
array('letra'=>'a', 'palabra'=>'almocatracia'),
array('letra'=>'a', 'palabra'=>'almocela'),
array('letra'=>'a', 'palabra'=>'almocrebe'),
array('letra'=>'a', 'palabra'=>'almocri'),
array('letra'=>'a', 'palabra'=>'almodi'),
array('letra'=>'a', 'palabra'=>'almodon'),
array('letra'=>'a', 'palabra'=>'almodovareño'),
array('letra'=>'a', 'palabra'=>'almodrote'),
array('letra'=>'a', 'palabra'=>'almofalla'),
array('letra'=>'a', 'palabra'=>'almofar'),
array('letra'=>'a', 'palabra'=>'almofariz'),
array('letra'=>'a', 'palabra'=>'almofia'),
array('letra'=>'a', 'palabra'=>'almoflate'),
array('letra'=>'a', 'palabra'=>'almofrej'),
array('letra'=>'a', 'palabra'=>'almofrez'),
array('letra'=>'a', 'palabra'=>'almogama'),
array('letra'=>'a', 'palabra'=>'almogavar'),
array('letra'=>'a', 'palabra'=>'almogavarear'),
array('letra'=>'a', 'palabra'=>'almogavaria'),
array('letra'=>'a', 'palabra'=>'almogaveria'),
array('letra'=>'a', 'palabra'=>'almohada'),
array('letra'=>'a', 'palabra'=>'almohadado'),
array('letra'=>'a', 'palabra'=>'almohadazo'),
array('letra'=>'a', 'palabra'=>'almohade'),
array('letra'=>'a', 'palabra'=>'almohadilla'),
array('letra'=>'a', 'palabra'=>'almohadillado'),
array('letra'=>'a', 'palabra'=>'almohadillar'),
array('letra'=>'a', 'palabra'=>'almohadillazo'),
array('letra'=>'a', 'palabra'=>'almohadillero'),
array('letra'=>'a', 'palabra'=>'almohadon'),
array('letra'=>'a', 'palabra'=>'almoharrefa'),
array('letra'=>'a', 'palabra'=>'almohater'),
array('letra'=>'a', 'palabra'=>'almohatre'),
array('letra'=>'a', 'palabra'=>'almohaza'),
array('letra'=>'a', 'palabra'=>'almohazador'),
array('letra'=>'a', 'palabra'=>'almohazar'),
array('letra'=>'a', 'palabra'=>'almojabana'),
array('letra'=>'a', 'palabra'=>'almojama'),
array('letra'=>'a', 'palabra'=>'almojarifadgo'),
array('letra'=>'a', 'palabra'=>'almojarifalgo'),
array('letra'=>'a', 'palabra'=>'almojarifazgo'),
array('letra'=>'a', 'palabra'=>'almojarife'),
array('letra'=>'a', 'palabra'=>'almojater'),
array('letra'=>'a', 'palabra'=>'almojatre'),
array('letra'=>'a', 'palabra'=>'almojaya'),
array('letra'=>'a', 'palabra'=>'almojerifazgo'),
array('letra'=>'a', 'palabra'=>'almojerife'),
array('letra'=>'a', 'palabra'=>'almona'),
array('letra'=>'a', 'palabra'=>'almondiga'),
array('letra'=>'a', 'palabra'=>'almondiguilla'),
array('letra'=>'a', 'palabra'=>'almoneda'),
array('letra'=>'a', 'palabra'=>'almonedar'),
array('letra'=>'a', 'palabra'=>'almonedear'),
array('letra'=>'a', 'palabra'=>'almora'),
array('letra'=>'a', 'palabra'=>'almorabu'),
array('letra'=>'a', 'palabra'=>'almoraduj'),
array('letra'=>'a', 'palabra'=>'almoradux'),
array('letra'=>'a', 'palabra'=>'almoravide'),
array('letra'=>'a', 'palabra'=>'almorejo'),
array('letra'=>'a', 'palabra'=>'almori'),
array('letra'=>'a', 'palabra'=>'almoronia'),
array('letra'=>'a', 'palabra'=>'almorraja'),
array('letra'=>'a', 'palabra'=>'almorrana'),
array('letra'=>'a', 'palabra'=>'almorraniento'),
array('letra'=>'a', 'palabra'=>'almorrefa'),
array('letra'=>'a', 'palabra'=>'almorriña'),
array('letra'=>'a', 'palabra'=>'almorron'),
array('letra'=>'a', 'palabra'=>'almorta'),
array('letra'=>'a', 'palabra'=>'almorzada'),
array('letra'=>'a', 'palabra'=>'almorzado'),
array('letra'=>'a', 'palabra'=>'almorzar'),
array('letra'=>'a', 'palabra'=>'almosna'),
array('letra'=>'a', 'palabra'=>'almosnar'),
array('letra'=>'a', 'palabra'=>'almotacen'),
array('letra'=>'a', 'palabra'=>'almotacenadgo'),
array('letra'=>'a', 'palabra'=>'almotacenalgo'),
array('letra'=>'a', 'palabra'=>'almotacenazgo'),
array('letra'=>'a', 'palabra'=>'almotacenia'),
array('letra'=>'a', 'palabra'=>'almotalafe'),
array('letra'=>'a', 'palabra'=>'almotazaf'),
array('letra'=>'a', 'palabra'=>'almotazan'),
array('letra'=>'a', 'palabra'=>'almotazania'),
array('letra'=>'a', 'palabra'=>'almozada'),
array('letra'=>'a', 'palabra'=>'almozala'),
array('letra'=>'a', 'palabra'=>'almozalla'),
array('letra'=>'a', 'palabra'=>'almozarabe'),
array('letra'=>'a', 'palabra'=>'almud'),
array('letra'=>'a', 'palabra'=>'almudada'),
array('letra'=>'a', 'palabra'=>'almudejo'),
array('letra'=>'a', 'palabra'=>'almudero'),
array('letra'=>'a', 'palabra'=>'almudi'),
array('letra'=>'a', 'palabra'=>'almudin'),
array('letra'=>'a', 'palabra'=>'almuecin'),
array('letra'=>'a', 'palabra'=>'almuedano'),
array('letra'=>'a', 'palabra'=>'almueden'),
array('letra'=>'a', 'palabra'=>'almuerceria'),
array('letra'=>'a', 'palabra'=>'almuercero'),
array('letra'=>'a', 'palabra'=>'almuerdago'),
array('letra'=>'a', 'palabra'=>'almuerza'),
array('letra'=>'a', 'palabra'=>'almuerzo'),
array('letra'=>'a', 'palabra'=>'almueza'),
array('letra'=>'a', 'palabra'=>'almuezada'),
array('letra'=>'a', 'palabra'=>'almugavar'),
array('letra'=>'a', 'palabra'=>'almunia'),
array('letra'=>'a', 'palabra'=>'almutacen'),
array('letra'=>'a', 'palabra'=>'almutazaf'),
array('letra'=>'a', 'palabra'=>'almuzala'),
array('letra'=>'a', 'palabra'=>'almuzalla'),
array('letra'=>'a', 'palabra'=>'alna'),
array('letra'=>'a', 'palabra'=>'alnado'),
array('letra'=>'a', 'palabra'=>'alnafe'),
array('letra'=>'a', 'palabra'=>'alnedo'),
array('letra'=>'a', 'palabra'=>'alno'),
array('letra'=>'a', 'palabra'=>'aloaria'),
array('letra'=>'a', 'palabra'=>'alobadado'),
array('letra'=>'a', 'palabra'=>'alobado'),
array('letra'=>'a', 'palabra'=>'alobar'),
array('letra'=>'a', 'palabra'=>'alobreguecer'),
array('letra'=>'a', 'palabra'=>'alobroge'),
array('letra'=>'a', 'palabra'=>'alobrogico'),
array('letra'=>'a', 'palabra'=>'alobrogo'),
array('letra'=>'a', 'palabra'=>'alobunado'),
array('letra'=>'a', 'palabra'=>'alocadamente'),
array('letra'=>'a', 'palabra'=>'alocado'),
array('letra'=>'a', 'palabra'=>'alocar'),
array('letra'=>'a', 'palabra'=>'aloctono'),
array('letra'=>'a', 'palabra'=>'alocucion'),
array('letra'=>'a', 'palabra'=>'alodial'),
array('letra'=>'a', 'palabra'=>'alodio'),
array('letra'=>'a', 'palabra'=>'aloe'),
array('letra'=>'a', 'palabra'=>'aloe'),
array('letra'=>'a', 'palabra'=>'aloes'),
array('letra'=>'a', 'palabra'=>'aloes'),
array('letra'=>'a', 'palabra'=>'aloeta'),
array('letra'=>'a', 'palabra'=>'aloetico'),
array('letra'=>'a', 'palabra'=>'alofono'),
array('letra'=>'a', 'palabra'=>'alogador'),
array('letra'=>'a', 'palabra'=>'alogamiento'),
array('letra'=>'a', 'palabra'=>'alogar'),
array('letra'=>'a', 'palabra'=>'alogeno'),
array('letra'=>'a', 'palabra'=>'aloguer'),
array('letra'=>'a', 'palabra'=>'aloja'),
array('letra'=>'a', 'palabra'=>'alojado'),
array('letra'=>'a', 'palabra'=>'alojamiento'),
array('letra'=>'a', 'palabra'=>'alojar'),
array('letra'=>'a', 'palabra'=>'alojeria'),
array('letra'=>'a', 'palabra'=>'alojero'),
array('letra'=>'a', 'palabra'=>'alomado'),
array('letra'=>'a', 'palabra'=>'alomar'),
array('letra'=>'a', 'palabra'=>'alombar'),
array('letra'=>'a', 'palabra'=>'alombra'),
array('letra'=>'a', 'palabra'=>'alomorfo'),
array('letra'=>'a', 'palabra'=>'alon'),
array('letra'=>'a', 'palabra'=>'alondra'),
array('letra'=>'a', 'palabra'=>'alongado'),
array('letra'=>'a', 'palabra'=>'alongamiento'),
array('letra'=>'a', 'palabra'=>'alongar'),
array('letra'=>'a', 'palabra'=>'alonso'),
array('letra'=>'a', 'palabra'=>'alopata'),
array('letra'=>'a', 'palabra'=>'alopatia'),
array('letra'=>'a', 'palabra'=>'alopatico'),
array('letra'=>'a', 'palabra'=>'alopecia'),
array('letra'=>'a', 'palabra'=>'alopecico'),
array('letra'=>'a', 'palabra'=>'alopecuro'),
array('letra'=>'a', 'palabra'=>'alopiado'),
array('letra'=>'a', 'palabra'=>'alopicia'),
array('letra'=>'a', 'palabra'=>'aloque'),
array('letra'=>'a', 'palabra'=>'aloquecer'),
array('letra'=>'a', 'palabra'=>'aloquin'),
array('letra'=>'a', 'palabra'=>'alora'),
array('letra'=>'a', 'palabra'=>'alosa'),
array('letra'=>'a', 'palabra'=>'alosna'),
array('letra'=>'a', 'palabra'=>'alotar'),
array('letra'=>'a', 'palabra'=>'alotropia'),
array('letra'=>'a', 'palabra'=>'alotropico'),
array('letra'=>'a', 'palabra'=>'aloya'),
array('letra'=>'a', 'palabra'=>'alpaca'),
array('letra'=>'a', 'palabra'=>'alpamato'),
array('letra'=>'a', 'palabra'=>'alpañata'),
array('letra'=>'a', 'palabra'=>'alparcear'),
array('letra'=>'a', 'palabra'=>'alparceria'),
array('letra'=>'a', 'palabra'=>'alparcero'),
array('letra'=>'a', 'palabra'=>'alpargata'),
array('letra'=>'a', 'palabra'=>'alpargatado'),
array('letra'=>'a', 'palabra'=>'alpargatar'),
array('letra'=>'a', 'palabra'=>'alpargate'),
array('letra'=>'a', 'palabra'=>'alpargateria'),
array('letra'=>'a', 'palabra'=>'alpargatero'),
array('letra'=>'a', 'palabra'=>'alpargatilla'),
array('letra'=>'a', 'palabra'=>'alpartaz'),
array('letra'=>'a', 'palabra'=>'alpatana'),
array('letra'=>'a', 'palabra'=>'alpechin'),
array('letra'=>'a', 'palabra'=>'alpechinera'),
array('letra'=>'a', 'palabra'=>'alpende'),
array('letra'=>'a', 'palabra'=>'alpendre'),
array('letra'=>'a', 'palabra'=>'alpes'),
array('letra'=>'a', 'palabra'=>'alpestre'),
array('letra'=>'a', 'palabra'=>'alpicoz'),
array('letra'=>'a', 'palabra'=>'alpinismo'),
array('letra'=>'a', 'palabra'=>'alpinista'),
array('letra'=>'a', 'palabra'=>'alpino'),
array('letra'=>'a', 'palabra'=>'alpiste'),
array('letra'=>'a', 'palabra'=>'alpistela'),
array('letra'=>'a', 'palabra'=>'alpistera'),
array('letra'=>'a', 'palabra'=>'alpistero'),
array('letra'=>'a', 'palabra'=>'alpujarreño'),
array('letra'=>'a', 'palabra'=>'alquequenje'),
array('letra'=>'a', 'palabra'=>'alqueria'),
array('letra'=>'a', 'palabra'=>'alquermes'),
array('letra'=>'a', 'palabra'=>'alquerque'),
array('letra'=>'a', 'palabra'=>'alquez'),
array('letra'=>'a', 'palabra'=>'alquezar'),
array('letra'=>'a', 'palabra'=>'alquibla'),
array('letra'=>'a', 'palabra'=>'alquicel'),
array('letra'=>'a', 'palabra'=>'alquicer'),
array('letra'=>'a', 'palabra'=>'alquifol'),
array('letra'=>'a', 'palabra'=>'alquila'),
array('letra'=>'a', 'palabra'=>'alquilable'),
array('letra'=>'a', 'palabra'=>'alquiladizo'),
array('letra'=>'a', 'palabra'=>'alquilador'),
array('letra'=>'a', 'palabra'=>'alquilamiento'),
array('letra'=>'a', 'palabra'=>'alquilar'),
array('letra'=>'a', 'palabra'=>'alquilate'),
array('letra'=>'a', 'palabra'=>'alquile'),
array('letra'=>'a', 'palabra'=>'alquiler'),
array('letra'=>'a', 'palabra'=>'alquilon'),
array('letra'=>'a', 'palabra'=>'alquimia'),
array('letra'=>'a', 'palabra'=>'alquimico'),
array('letra'=>'a', 'palabra'=>'alquimila'),
array('letra'=>'a', 'palabra'=>'alquimista'),
array('letra'=>'a', 'palabra'=>'alquinal'),
array('letra'=>'a', 'palabra'=>'alquitara'),
array('letra'=>'a', 'palabra'=>'alquitarar'),
array('letra'=>'a', 'palabra'=>'alquitifa'),
array('letra'=>'a', 'palabra'=>'alquitira'),
array('letra'=>'a', 'palabra'=>'alquitrabe'),
array('letra'=>'a', 'palabra'=>'alquitran'),
array('letra'=>'a', 'palabra'=>'alquitranado'),
array('letra'=>'a', 'palabra'=>'alquitranar'),
array('letra'=>'a', 'palabra'=>'alrededor'),
array('letra'=>'a', 'palabra'=>'alrevesado'),
array('letra'=>'a', 'palabra'=>'alrota'),
array('letra'=>'a', 'palabra'=>'alsaciano'),
array('letra'=>'a', 'palabra'=>'alsine'),
array('letra'=>'a', 'palabra'=>'alta'),
array('letra'=>'a', 'palabra'=>'altabaca'),
array('letra'=>'a', 'palabra'=>'altabaque'),
array('letra'=>'a', 'palabra'=>'altabaquilla'),
array('letra'=>'a', 'palabra'=>'altabaquillo'),
array('letra'=>'a', 'palabra'=>'altaico'),
array('letra'=>'a', 'palabra'=>'altamandria'),
array('letra'=>'a', 'palabra'=>'altamente'),
array('letra'=>'a', 'palabra'=>'altamia'),
array('letra'=>'a', 'palabra'=>'altamisa'),
array('letra'=>'a', 'palabra'=>'altana'),
array('letra'=>'a', 'palabra'=>'altaneria'),
array('letra'=>'a', 'palabra'=>'altanero'),
array('letra'=>'a', 'palabra'=>'altanez'),
array('letra'=>'a', 'palabra'=>'altano'),
array('letra'=>'a', 'palabra'=>'altar'),
array('letra'=>'a', 'palabra'=>'altarero'),
array('letra'=>'a', 'palabra'=>'altaricon'),
array('letra'=>'a', 'palabra'=>'altarreina'),
array('letra'=>'a', 'palabra'=>'altavoz'),
array('letra'=>'a', 'palabra'=>'altea'),
array('letra'=>'a', 'palabra'=>'altear'),
array('letra'=>'a', 'palabra'=>'alterabilidad'),
array('letra'=>'a', 'palabra'=>'alterable'),
array('letra'=>'a', 'palabra'=>'alteracion'),
array('letra'=>'a', 'palabra'=>'alteradizo'),
array('letra'=>'a', 'palabra'=>'alterado'),
array('letra'=>'a', 'palabra'=>'alterador'),
array('letra'=>'a', 'palabra'=>'alterante'),
array('letra'=>'a', 'palabra'=>'alterar'),
array('letra'=>'a', 'palabra'=>'alterativo'),
array('letra'=>'a', 'palabra'=>'altercacion'),
array('letra'=>'a', 'palabra'=>'altercado'),
array('letra'=>'a', 'palabra'=>'altercador'),
array('letra'=>'a', 'palabra'=>'altercar'),
array('letra'=>'a', 'palabra'=>'alteridad'),
array('letra'=>'a', 'palabra'=>'alternacion'),
array('letra'=>'a', 'palabra'=>'alternadamente'),
array('letra'=>'a', 'palabra'=>'alternado'),
array('letra'=>'a', 'palabra'=>'alternador'),
array('letra'=>'a', 'palabra'=>'alternancia'),
array('letra'=>'a', 'palabra'=>'alternante'),
array('letra'=>'a', 'palabra'=>'alternar'),
array('letra'=>'a', 'palabra'=>'alternativa'),
array('letra'=>'a', 'palabra'=>'alternativamente'),
array('letra'=>'a', 'palabra'=>'alternativo'),
array('letra'=>'a', 'palabra'=>'alterne'),
array('letra'=>'a', 'palabra'=>'alterno'),
array('letra'=>'a', 'palabra'=>'altero'),
array('letra'=>'a', 'palabra'=>'alteroso'),
array('letra'=>'a', 'palabra'=>'alteza'),
array('letra'=>'a', 'palabra'=>'altibajo'),
array('letra'=>'a', 'palabra'=>'altillo'),
array('letra'=>'a', 'palabra'=>'altilocuencia'),
array('letra'=>'a', 'palabra'=>'altilocuente'),
array('letra'=>'a', 'palabra'=>'altilocuo'),
array('letra'=>'a', 'palabra'=>'altimetria'),
array('letra'=>'a', 'palabra'=>'altimetro'),
array('letra'=>'a', 'palabra'=>'altipampa'),
array('letra'=>'a', 'palabra'=>'altiplanicie'),
array('letra'=>'a', 'palabra'=>'altiplano'),
array('letra'=>'a', 'palabra'=>'altiricon'),
array('letra'=>'a', 'palabra'=>'altisimo'),
array('letra'=>'a', 'palabra'=>'altisonancia'),
array('letra'=>'a', 'palabra'=>'altisonante'),
array('letra'=>'a', 'palabra'=>'altisono'),
array('letra'=>'a', 'palabra'=>'altitonante'),
array('letra'=>'a', 'palabra'=>'altitud'),
array('letra'=>'a', 'palabra'=>'altivar'),
array('letra'=>'a', 'palabra'=>'altivecer'),
array('letra'=>'a', 'palabra'=>'altivez'),
array('letra'=>'a', 'palabra'=>'altiveza'),
array('letra'=>'a', 'palabra'=>'altividad'),
array('letra'=>'a', 'palabra'=>'altivo'),
array('letra'=>'a', 'palabra'=>'alto'),
array('letra'=>'a', 'palabra'=>'altocumulo'),
array('letra'=>'a', 'palabra'=>'altoparlante'),
array('letra'=>'a', 'palabra'=>'altor'),
array('letra'=>'a', 'palabra'=>'altorrelieve'),
array('letra'=>'a', 'palabra'=>'altozano'),
array('letra'=>'a', 'palabra'=>'altramucero'),
array('letra'=>'a', 'palabra'=>'altramuz'),
array('letra'=>'a', 'palabra'=>'altruismo'),
array('letra'=>'a', 'palabra'=>'altruista'),
array('letra'=>'a', 'palabra'=>'altura'),
array('letra'=>'a', 'palabra'=>'alua'),
array('letra'=>'a', 'palabra'=>'alubia'),
array('letra'=>'a', 'palabra'=>'alubiar'),
array('letra'=>'a', 'palabra'=>'aluchar'),
array('letra'=>'a', 'palabra'=>'aluche'),
array('letra'=>'a', 'palabra'=>'aluciar'),
array('letra'=>'a', 'palabra'=>'alucinacion'),
array('letra'=>'a', 'palabra'=>'alucinadamente'),
array('letra'=>'a', 'palabra'=>'alucinado'),
array('letra'=>'a', 'palabra'=>'alucinador'),
array('letra'=>'a', 'palabra'=>'alucinamiento'),
array('letra'=>'a', 'palabra'=>'alucinante'),
array('letra'=>'a', 'palabra'=>'alucinar'),
array('letra'=>'a', 'palabra'=>'alucinatorio'),
array('letra'=>'a', 'palabra'=>'alucine'),
array('letra'=>'a', 'palabra'=>'alucinogeno'),
array('letra'=>'a', 'palabra'=>'alucon'),
array('letra'=>'a', 'palabra'=>'alud'),
array('letra'=>'a', 'palabra'=>'aluda'),
array('letra'=>'a', 'palabra'=>'aludel'),
array('letra'=>'a', 'palabra'=>'aludido'),
array('letra'=>'a', 'palabra'=>'aludir'),
array('letra'=>'a', 'palabra'=>'aludo'),
array('letra'=>'a', 'palabra'=>'alueñarse'),
array('letra'=>'a', 'palabra'=>'alufrar'),
array('letra'=>'a', 'palabra'=>'alugar'),
array('letra'=>'a', 'palabra'=>'alula'),
array('letra'=>'a', 'palabra'=>'alumbrado'),
array('letra'=>'a', 'palabra'=>'alumbrador'),
array('letra'=>'a', 'palabra'=>'alumbramiento'),
array('letra'=>'a', 'palabra'=>'alumbrante'),
array('letra'=>'a', 'palabra'=>'alumbrar'),
array('letra'=>'a', 'palabra'=>'alumbre'),
array('letra'=>'a', 'palabra'=>'alumbrera'),
array('letra'=>'a', 'palabra'=>'alumbroso'),
array('letra'=>'a', 'palabra'=>'alumina'),
array('letra'=>'a', 'palabra'=>'aluminado'),
array('letra'=>'a', 'palabra'=>'aluminato'),
array('letra'=>'a', 'palabra'=>'aluminio'),
array('letra'=>'a', 'palabra'=>'aluminita'),
array('letra'=>'a', 'palabra'=>'aluminosis'),
array('letra'=>'a', 'palabra'=>'aluminoso'),
array('letra'=>'a', 'palabra'=>'aluminotermia'),
array('letra'=>'a', 'palabra'=>'alumnado'),
array('letra'=>'a', 'palabra'=>'alumno'),
array('letra'=>'a', 'palabra'=>'alunado'),
array('letra'=>'a', 'palabra'=>'alunamiento'),
array('letra'=>'a', 'palabra'=>'alunarado'),
array('letra'=>'a', 'palabra'=>'alunarse'),
array('letra'=>'a', 'palabra'=>'alunizaje'),
array('letra'=>'a', 'palabra'=>'alunizar'),
array('letra'=>'a', 'palabra'=>'alusion'),
array('letra'=>'a', 'palabra'=>'alusivo'),
array('letra'=>'a', 'palabra'=>'alustrar'),
array('letra'=>'a', 'palabra'=>'aluvial'),
array('letra'=>'a', 'palabra'=>'aluvion'),
array('letra'=>'a', 'palabra'=>'aluzar'),
array('letra'=>'a', 'palabra'=>'alvareque'),
array('letra'=>'a', 'palabra'=>'alveario'),
array('letra'=>'a', 'palabra'=>'alveo'),
array('letra'=>'a', 'palabra'=>'alveolar'),
array('letra'=>'a', 'palabra'=>'alveolo'),
array('letra'=>'a', 'palabra'=>'alveolo'),
array('letra'=>'a', 'palabra'=>'alverja'),
array('letra'=>'a', 'palabra'=>'alverjana'),
array('letra'=>'a', 'palabra'=>'alverjilla'),
array('letra'=>'a', 'palabra'=>'alverjon'),
array('letra'=>'a', 'palabra'=>'alvino'),
array('letra'=>'a', 'palabra'=>'alza'),
array('letra'=>'a', 'palabra'=>'alzacola'),
array('letra'=>'a', 'palabra'=>'alzacuello'),
array('letra'=>'a', 'palabra'=>'alzada'),
array('letra'=>'a', 'palabra'=>'alzadamente'),
array('letra'=>'a', 'palabra'=>'alzadera'),
array('letra'=>'a', 'palabra'=>'alzadero'),
array('letra'=>'a', 'palabra'=>'alzadizo'),
array('letra'=>'a', 'palabra'=>'alzado'),
array('letra'=>'a', 'palabra'=>'alzador'),
array('letra'=>'a', 'palabra'=>'alzadura'),
array('letra'=>'a', 'palabra'=>'alzafuelles'),
array('letra'=>'a', 'palabra'=>'alzamiento'),
array('letra'=>'a', 'palabra'=>'alzapaño'),
array('letra'=>'a', 'palabra'=>'alzapie'),
array('letra'=>'a', 'palabra'=>'alzapon'),
array('letra'=>'a', 'palabra'=>'alzaprima'),
array('letra'=>'a', 'palabra'=>'alzaprimar'),
array('letra'=>'a', 'palabra'=>'alzapuertas'),
array('letra'=>'a', 'palabra'=>'alzar'),
array('letra'=>'a', 'palabra'=>'alzo'),
array('letra'=>'a', 'palabra'=>'ama'),
array('letra'=>'a', 'palabra'=>'amabilidad'),
array('letra'=>'a', 'palabra'=>'amable'),
array('letra'=>'a', 'palabra'=>'amablemente'),
array('letra'=>'a', 'palabra'=>'amacayo'),
array('letra'=>'a', 'palabra'=>'amaceno'),
array('letra'=>'a', 'palabra'=>'amacharse'),
array('letra'=>'a', 'palabra'=>'amachetear'),
array('letra'=>'a', 'palabra'=>'amachinarse'),
array('letra'=>'a', 'palabra'=>'amacho'),
array('letra'=>'a', 'palabra'=>'amachorrarse'),
array('letra'=>'a', 'palabra'=>'amacigado'),
array('letra'=>'a', 'palabra'=>'amacion'),
array('letra'=>'a', 'palabra'=>'amacizar'),
array('letra'=>'a', 'palabra'=>'amacollar'),
array('letra'=>'a', 'palabra'=>'amadeo'),
array('letra'=>'a', 'palabra'=>'amado'),
array('letra'=>'a', 'palabra'=>'amador'),
array('letra'=>'a', 'palabra'=>'amadrigar'),
array('letra'=>'a', 'palabra'=>'amadrinamiento'),
array('letra'=>'a', 'palabra'=>'amadrinar'),
array('letra'=>'a', 'palabra'=>'amadroñado'),
array('letra'=>'a', 'palabra'=>'amaestradamente'),
array('letra'=>'a', 'palabra'=>'amaestrado'),
array('letra'=>'a', 'palabra'=>'amaestrador'),
array('letra'=>'a', 'palabra'=>'amaestradura'),
array('letra'=>'a', 'palabra'=>'amaestramiento'),
array('letra'=>'a', 'palabra'=>'amaestrar'),
array('letra'=>'a', 'palabra'=>'amagamiento'),
array('letra'=>'a', 'palabra'=>'amagar'),
array('letra'=>'a', 'palabra'=>'amagatorio'),
array('letra'=>'a', 'palabra'=>'amago'),
array('letra'=>'a', 'palabra'=>'amago'),
array('letra'=>'a', 'palabra'=>'amainador'),
array('letra'=>'a', 'palabra'=>'amainar'),
array('letra'=>'a', 'palabra'=>'amaine'),
array('letra'=>'a', 'palabra'=>'amaitinar'),
array('letra'=>'a', 'palabra'=>'amajadar'),
array('letra'=>'a', 'palabra'=>'amajanar'),
array('letra'=>'a', 'palabra'=>'amalar'),
array('letra'=>'a', 'palabra'=>'amalaya'),
array('letra'=>'a', 'palabra'=>'amalayar'),
array('letra'=>'a', 'palabra'=>'amalear'),
array('letra'=>'a', 'palabra'=>'amalecita'),
array('letra'=>'a', 'palabra'=>'amalequita'),
array('letra'=>'a', 'palabra'=>'amalfitano'),
array('letra'=>'a', 'palabra'=>'amalgama'),
array('letra'=>'a', 'palabra'=>'amalgamacion'),
array('letra'=>'a', 'palabra'=>'amalgamador'),
array('letra'=>'a', 'palabra'=>'amalgamamiento'),
array('letra'=>'a', 'palabra'=>'amalgamar'),
array('letra'=>'a', 'palabra'=>'amalladar'),
array('letra'=>'a', 'palabra'=>'amallarse'),
array('letra'=>'a', 'palabra'=>'amalo'),
array('letra'=>'a', 'palabra'=>'amamantador'),
array('letra'=>'a', 'palabra'=>'amamantamiento'),
array('letra'=>'a', 'palabra'=>'amamantar'),
array('letra'=>'a', 'palabra'=>'aman'),
array('letra'=>'a', 'palabra'=>'amanal'),
array('letra'=>'a', 'palabra'=>'amanar'),
array('letra'=>'a', 'palabra'=>'amancay'),
array('letra'=>'a', 'palabra'=>'amancaya'),
array('letra'=>'a', 'palabra'=>'amancayo'),
array('letra'=>'a', 'palabra'=>'amancebamiento'),
array('letra'=>'a', 'palabra'=>'amancebarse'),
array('letra'=>'a', 'palabra'=>'amancillar'),
array('letra'=>'a', 'palabra'=>'amanear'),
array('letra'=>'a', 'palabra'=>'amanecer'),
array('letra'=>'a', 'palabra'=>'amanerado'),
array('letra'=>'a', 'palabra'=>'amaneramiento'),
array('letra'=>'a', 'palabra'=>'amanerarse'),
array('letra'=>'a', 'palabra'=>'amanezca'),
array('letra'=>'a', 'palabra'=>'amangualar'),
array('letra'=>'a', 'palabra'=>'amaniatar'),
array('letra'=>'a', 'palabra'=>'amanojado'),
array('letra'=>'a', 'palabra'=>'amanojar'),
array('letra'=>'a', 'palabra'=>'amansado'),
array('letra'=>'a', 'palabra'=>'amansador'),
array('letra'=>'a', 'palabra'=>'amansamiento'),
array('letra'=>'a', 'palabra'=>'amansar'),
array('letra'=>'a', 'palabra'=>'amantar'),
array('letra'=>'a', 'palabra'=>'amante'),
array('letra'=>'a', 'palabra'=>'amantero'),
array('letra'=>'a', 'palabra'=>'amantillar'),
array('letra'=>'a', 'palabra'=>'amantillo'),
array('letra'=>'a', 'palabra'=>'amanuense'),
array('letra'=>'a', 'palabra'=>'amanzanamiento'),
array('letra'=>'a', 'palabra'=>'amanzanar'),
array('letra'=>'a', 'palabra'=>'amañar'),
array('letra'=>'a', 'palabra'=>'amaño'),
array('letra'=>'a', 'palabra'=>'amapola'),
array('letra'=>'a', 'palabra'=>'amapolar'),
array('letra'=>'a', 'palabra'=>'amar'),
array('letra'=>'a', 'palabra'=>'amaracino'),
array('letra'=>'a', 'palabra'=>'amaraco'),
array('letra'=>'a', 'palabra'=>'amaraje'),
array('letra'=>'a', 'palabra'=>'amarantaceo'),
array('letra'=>'a', 'palabra'=>'amarantina'),
array('letra'=>'a', 'palabra'=>'amaranto'),
array('letra'=>'a', 'palabra'=>'amarañar'),
array('letra'=>'a', 'palabra'=>'amarar'),
array('letra'=>'a', 'palabra'=>'amarcar'),
array('letra'=>'a', 'palabra'=>'amarcigado'),
array('letra'=>'a', 'palabra'=>'amarecer'),
array('letra'=>'a', 'palabra'=>'amargado'),
array('letra'=>'a', 'palabra'=>'amargaleja'),
array('letra'=>'a', 'palabra'=>'amargamente'),
array('letra'=>'a', 'palabra'=>'amargar'),
array('letra'=>'a', 'palabra'=>'amargazon'),
array('letra'=>'a', 'palabra'=>'amargo'),
array('letra'=>'a', 'palabra'=>'amargon'),
array('letra'=>'a', 'palabra'=>'amargor'),
array('letra'=>'a', 'palabra'=>'amargoso'),
array('letra'=>'a', 'palabra'=>'amarguera'),
array('letra'=>'a', 'palabra'=>'amarguero'),
array('letra'=>'a', 'palabra'=>'amarguillo'),
array('letra'=>'a', 'palabra'=>'amargura'),
array('letra'=>'a', 'palabra'=>'amaricado'),
array('letra'=>'a', 'palabra'=>'amariconado'),
array('letra'=>'a', 'palabra'=>'amariconar'),
array('letra'=>'a', 'palabra'=>'amarilidaceo'),
array('letra'=>'a', 'palabra'=>'amarilideo'),
array('letra'=>'a', 'palabra'=>'amarilis'),
array('letra'=>'a', 'palabra'=>'amarilla'),
array('letra'=>'a', 'palabra'=>'amarillear'),
array('letra'=>'a', 'palabra'=>'amarillecer'),
array('letra'=>'a', 'palabra'=>'amarillejo'),
array('letra'=>'a', 'palabra'=>'amarillento'),
array('letra'=>'a', 'palabra'=>'amarilleo'),
array('letra'=>'a', 'palabra'=>'amarillez'),
array('letra'=>'a', 'palabra'=>'amarillismo'),
array('letra'=>'a', 'palabra'=>'amarillista'),
array('letra'=>'a', 'palabra'=>'amarillo'),
array('letra'=>'a', 'palabra'=>'amarillor'),
array('letra'=>'a', 'palabra'=>'amarilloso'),
array('letra'=>'a', 'palabra'=>'amarillura'),
array('letra'=>'a', 'palabra'=>'amarinar'),
array('letra'=>'a', 'palabra'=>'amariposado'),
array('letra'=>'a', 'palabra'=>'amaritud'),
array('letra'=>'a', 'palabra'=>'amarizaje'),
array('letra'=>'a', 'palabra'=>'amarizar'),
array('letra'=>'a', 'palabra'=>'amarizarse'),
array('letra'=>'a', 'palabra'=>'amaro'),
array('letra'=>'a', 'palabra'=>'amaromar'),
array('letra'=>'a', 'palabra'=>'amarra'),
array('letra'=>'a', 'palabra'=>'amarraco'),
array('letra'=>'a', 'palabra'=>'amarradero'),
array('letra'=>'a', 'palabra'=>'amarradijo'),
array('letra'=>'a', 'palabra'=>'amarrado'),
array('letra'=>'a', 'palabra'=>'amarradura'),
array('letra'=>'a', 'palabra'=>'amarraje'),
array('letra'=>'a', 'palabra'=>'amarrar'),
array('letra'=>'a', 'palabra'=>'amarre'),
array('letra'=>'a', 'palabra'=>'amarreco'),
array('letra'=>'a', 'palabra'=>'amarrequear'),
array('letra'=>'a', 'palabra'=>'amarrete'),
array('letra'=>'a', 'palabra'=>'amarrido'),
array('letra'=>'a', 'palabra'=>'amarro'),
array('letra'=>'a', 'palabra'=>'amarroso'),
array('letra'=>'a', 'palabra'=>'amarteladamente'),
array('letra'=>'a', 'palabra'=>'amartelado'),
array('letra'=>'a', 'palabra'=>'amartelamiento'),
array('letra'=>'a', 'palabra'=>'amartelar'),
array('letra'=>'a', 'palabra'=>'amartillar'),
array('letra'=>'a', 'palabra'=>'amarulencia'),
array('letra'=>'a', 'palabra'=>'amasadera'),
array('letra'=>'a', 'palabra'=>'amasadero'),
array('letra'=>'a', 'palabra'=>'amasado'),
array('letra'=>'a', 'palabra'=>'amasador'),
array('letra'=>'a', 'palabra'=>'amasadura'),
array('letra'=>'a', 'palabra'=>'amasamiento'),
array('letra'=>'a', 'palabra'=>'amasanderia'),
array('letra'=>'a', 'palabra'=>'amasandero'),
array('letra'=>'a', 'palabra'=>'amasar'),
array('letra'=>'a', 'palabra'=>'amasiato'),
array('letra'=>'a', 'palabra'=>'amasijo'),
array('letra'=>'a', 'palabra'=>'amasio'),
array('letra'=>'a', 'palabra'=>'amatador'),
array('letra'=>'a', 'palabra'=>'amatar'),
array('letra'=>'a', 'palabra'=>'amate'),
array('letra'=>'a', 'palabra'=>'amatista'),
array('letra'=>'a', 'palabra'=>'amatiste'),
array('letra'=>'a', 'palabra'=>'amatividad'),
array('letra'=>'a', 'palabra'=>'amativo'),
array('letra'=>'a', 'palabra'=>'amatorio'),
array('letra'=>'a', 'palabra'=>'amaurosis'),
array('letra'=>'a', 'palabra'=>'amauta'),
array('letra'=>'a', 'palabra'=>'amayorazgar'),
array('letra'=>'a', 'palabra'=>'amayuela'),
array('letra'=>'a', 'palabra'=>'amazacotado'),
array('letra'=>'a', 'palabra'=>'amazona'),
array('letra'=>'a', 'palabra'=>'amazonas'),
array('letra'=>'a', 'palabra'=>'amazonense'),
array('letra'=>'a', 'palabra'=>'amazonico'),
array('letra'=>'a', 'palabra'=>'amazonio'),
array('letra'=>'a', 'palabra'=>'ambages'),
array('letra'=>'a', 'palabra'=>'ambagioso'),
array('letra'=>'a', 'palabra'=>'ambar'),
array('letra'=>'a', 'palabra'=>'ambarar'),
array('letra'=>'a', 'palabra'=>'ambarino'),
array('letra'=>'a', 'palabra'=>'ambateño'),
array('letra'=>'a', 'palabra'=>'amberino'),
array('letra'=>'a', 'palabra'=>'ambicion'),
array('letra'=>'a', 'palabra'=>'ambicionar'),
array('letra'=>'a', 'palabra'=>'ambicionear'),
array('letra'=>'a', 'palabra'=>'ambiciosamente'),
array('letra'=>'a', 'palabra'=>'ambicioso'),
array('letra'=>'a', 'palabra'=>'ambidextro'),
array('letra'=>'a', 'palabra'=>'ambidiestro'),
array('letra'=>'a', 'palabra'=>'ambientacion'),
array('letra'=>'a', 'palabra'=>'ambientador'),
array('letra'=>'a', 'palabra'=>'ambiental'),
array('letra'=>'a', 'palabra'=>'ambientalismo'),
array('letra'=>'a', 'palabra'=>'ambientar'),
array('letra'=>'a', 'palabra'=>'ambiente'),
array('letra'=>'a', 'palabra'=>'ambigu'),
array('letra'=>'a', 'palabra'=>'ambiguamente'),
array('letra'=>'a', 'palabra'=>'ambigüedad'),
array('letra'=>'a', 'palabra'=>'ambiguo'),
array('letra'=>'a', 'palabra'=>'ambito'),
array('letra'=>'a', 'palabra'=>'ambivalencia'),
array('letra'=>'a', 'palabra'=>'ambivalente'),
array('letra'=>'a', 'palabra'=>'amblador'),
array('letra'=>'a', 'palabra'=>'ambladura'),
array('letra'=>'a', 'palabra'=>'amblar'),
array('letra'=>'a', 'palabra'=>'ambleo'),
array('letra'=>'a', 'palabra'=>'ambligonio'),
array('letra'=>'a', 'palabra'=>'ambliope'),
array('letra'=>'a', 'palabra'=>'ambliopia'),
array('letra'=>'a', 'palabra'=>'ambo'),
array('letra'=>'a', 'palabra'=>'ambon'),
array('letra'=>'a', 'palabra'=>'ambos'),
array('letra'=>'a', 'palabra'=>'ambrolla'),
array('letra'=>'a', 'palabra'=>'ambrollar'),
array('letra'=>'a', 'palabra'=>'ambrosia'),
array('letra'=>'a', 'palabra'=>'ambrosia'),
array('letra'=>'a', 'palabra'=>'ambrosiano'),
array('letra'=>'a', 'palabra'=>'ambuesta'),
array('letra'=>'a', 'palabra'=>'ambueza'),
array('letra'=>'a', 'palabra'=>'ambulacion'),
array('letra'=>'a', 'palabra'=>'ambulacral'),
array('letra'=>'a', 'palabra'=>'ambulacro'),
array('letra'=>'a', 'palabra'=>'ambulancia'),
array('letra'=>'a', 'palabra'=>'ambulante'),
array('letra'=>'a', 'palabra'=>'ambular'),
array('letra'=>'a', 'palabra'=>'ambulativo'),
array('letra'=>'a', 'palabra'=>'ambulatorio'),
array('letra'=>'a', 'palabra'=>'ameba'),
array('letra'=>'a', 'palabra'=>'amebeo'),
array('letra'=>'a', 'palabra'=>'amebiasis'),
array('letra'=>'a', 'palabra'=>'amechar'),
array('letra'=>'a', 'palabra'=>'amedrantar'),
array('letra'=>'a', 'palabra'=>'amedrentador'),
array('letra'=>'a', 'palabra'=>'amedrentar'),
array('letra'=>'a', 'palabra'=>'amejoramiento'),
array('letra'=>'a', 'palabra'=>'amel'),
array('letra'=>'a', 'palabra'=>'amelar'),
array('letra'=>'a', 'palabra'=>'amelcochado'),
array('letra'=>'a', 'palabra'=>'amelcochar'),
array('letra'=>'a', 'palabra'=>'amelga'),
array('letra'=>'a', 'palabra'=>'amelgado'),
array('letra'=>'a', 'palabra'=>'amelgador'),
array('letra'=>'a', 'palabra'=>'amelgar'),
array('letra'=>'a', 'palabra'=>'amelia'),
array('letra'=>'a', 'palabra'=>'amellar'),
array('letra'=>'a', 'palabra'=>'amelo'),
array('letra'=>'a', 'palabra'=>'amelocotonado'),
array('letra'=>'a', 'palabra'=>'amelonado'),
array('letra'=>'a', 'palabra'=>'amembrillado'),
array('letra'=>'a', 'palabra'=>'amen'),
array('letra'=>'a', 'palabra'=>'amenaza'),
array('letra'=>'a', 'palabra'=>'amenazador'),
array('letra'=>'a', 'palabra'=>'amenazante'),
array('letra'=>'a', 'palabra'=>'amenazar'),
array('letra'=>'a', 'palabra'=>'amencia'),
array('letra'=>'a', 'palabra'=>'amenguadamente'),
array('letra'=>'a', 'palabra'=>'amenguadero'),
array('letra'=>'a', 'palabra'=>'amenguamiento'),
array('letra'=>'a', 'palabra'=>'amenguar'),
array('letra'=>'a', 'palabra'=>'amenidad'),
array('letra'=>'a', 'palabra'=>'amenizar'),
array('letra'=>'a', 'palabra'=>'ameno'),
array('letra'=>'a', 'palabra'=>'amenorar'),
array('letra'=>'a', 'palabra'=>'amenorgar'),
array('letra'=>'a', 'palabra'=>'amenorrea'),
array('letra'=>'a', 'palabra'=>'amentaceo'),
array('letra'=>'a', 'palabra'=>'amente'),
array('letra'=>'a', 'palabra'=>'amento'),
array('letra'=>'a', 'palabra'=>'ameos'),
array('letra'=>'a', 'palabra'=>'amerar'),
array('letra'=>'a', 'palabra'=>'amercearse'),
array('letra'=>'a', 'palabra'=>'amercendearse'),
array('letra'=>'a', 'palabra'=>'amerengado'),
array('letra'=>'a', 'palabra'=>'america'),
array('letra'=>'a', 'palabra'=>'americana'),
array('letra'=>'a', 'palabra'=>'americanada'),
array('letra'=>'a', 'palabra'=>'americanismo'),
array('letra'=>'a', 'palabra'=>'americanista'),
array('letra'=>'a', 'palabra'=>'americanizacion'),
array('letra'=>'a', 'palabra'=>'americanizar'),
array('letra'=>'a', 'palabra'=>'americano'),
array('letra'=>'a', 'palabra'=>'americio'),
array('letra'=>'a', 'palabra'=>'americo'),
array('letra'=>'a', 'palabra'=>'amerindio'),
array('letra'=>'a', 'palabra'=>'ameritado'),
array('letra'=>'a', 'palabra'=>'ameritar'),
array('letra'=>'a', 'palabra'=>'amerizaje'),
array('letra'=>'a', 'palabra'=>'amerizar'),
array('letra'=>'a', 'palabra'=>'amesnador'),
array('letra'=>'a', 'palabra'=>'amesnar'),
array('letra'=>'a', 'palabra'=>'amestizado'),
array('letra'=>'a', 'palabra'=>'amesurar'),
array('letra'=>'a', 'palabra'=>'ametalado'),
array('letra'=>'a', 'palabra'=>'ametalar'),
array('letra'=>'a', 'palabra'=>'ametista'),
array('letra'=>'a', 'palabra'=>'ametisto'),
array('letra'=>'a', 'palabra'=>'ametrallador'),
array('letra'=>'a', 'palabra'=>'ametrallamiento'),
array('letra'=>'a', 'palabra'=>'ametrallar'),
array('letra'=>'a', 'palabra'=>'ametria'),
array('letra'=>'a', 'palabra'=>'ametrico'),
array('letra'=>'a', 'palabra'=>'ametrope'),
array('letra'=>'a', 'palabra'=>'ametropia'),
array('letra'=>'a', 'palabra'=>'amezquindarse'),
array('letra'=>'a', 'palabra'=>'ami'),
array('letra'=>'a', 'palabra'=>'amia'),
array('letra'=>'a', 'palabra'=>'amianta'),
array('letra'=>'a', 'palabra'=>'amianto'),
array('letra'=>'a', 'palabra'=>'amiba'),
array('letra'=>'a', 'palabra'=>'amibo'),
array('letra'=>'a', 'palabra'=>'amicicia'),
array('letra'=>'a', 'palabra'=>'amicisimo'),
array('letra'=>'a', 'palabra'=>'amida'),
array('letra'=>'a', 'palabra'=>'amidos'),
array('letra'=>'a', 'palabra'=>'amiento'),
array('letra'=>'a', 'palabra'=>'amiesgado'),
array('letra'=>'a', 'palabra'=>'amiga'),
array('letra'=>'a', 'palabra'=>'amigabilidad'),
array('letra'=>'a', 'palabra'=>'amigable'),
array('letra'=>'a', 'palabra'=>'amigablemente'),
array('letra'=>'a', 'palabra'=>'amigacho'),
array('letra'=>'a', 'palabra'=>'amigajado'),
array('letra'=>'a', 'palabra'=>'amiganza'),
array('letra'=>'a', 'palabra'=>'amigar'),
array('letra'=>'a', 'palabra'=>'amigdala'),
array('letra'=>'a', 'palabra'=>'amigdalaceo'),
array('letra'=>'a', 'palabra'=>'amigdalina'),
array('letra'=>'a', 'palabra'=>'amigdalitis'),
array('letra'=>'a', 'palabra'=>'amigo'),
array('letra'=>'a', 'palabra'=>'amigote'),
array('letra'=>'a', 'palabra'=>'amiguero'),
array('letra'=>'a', 'palabra'=>'amiguete'),
array('letra'=>'a', 'palabra'=>'amiguismo'),
array('letra'=>'a', 'palabra'=>'amilaceo'),
array('letra'=>'a', 'palabra'=>'amilamia'),
array('letra'=>'a', 'palabra'=>'amilanamiento'),
array('letra'=>'a', 'palabra'=>'amilanar'),
array('letra'=>'a', 'palabra'=>'amilico'),
array('letra'=>'a', 'palabra'=>'amillaramiento'),
array('letra'=>'a', 'palabra'=>'amillarar'),
array('letra'=>'a', 'palabra'=>'amillonado'),
array('letra'=>'a', 'palabra'=>'amiloideo'),
array('letra'=>'a', 'palabra'=>'amilosis'),
array('letra'=>'a', 'palabra'=>'amimia'),
array('letra'=>'a', 'palabra'=>'amin'),
array('letra'=>'a', 'palabra'=>'amina'),
array('letra'=>'a', 'palabra'=>'aminar'),
array('letra'=>'a', 'palabra'=>'aminico'),
array('letra'=>'a', 'palabra'=>'amino'),
array('letra'=>'a', 'palabra'=>'aminoacido'),
array('letra'=>'a', 'palabra'=>'aminoracion'),
array('letra'=>'a', 'palabra'=>'aminorar'),
array('letra'=>'a', 'palabra'=>'amir'),
array('letra'=>'a', 'palabra'=>'amiri'),
array('letra'=>'a', 'palabra'=>'amision'),
array('letra'=>'a', 'palabra'=>'amistad'),
array('letra'=>'a', 'palabra'=>'amistanza'),
array('letra'=>'a', 'palabra'=>'amistar'),
array('letra'=>'a', 'palabra'=>'amistoso'),
array('letra'=>'a', 'palabra'=>'amito'),
array('letra'=>'a', 'palabra'=>'amitosis'),
array('letra'=>'a', 'palabra'=>'amitotico'),
array('letra'=>'a', 'palabra'=>'amnesia'),
array('letra'=>'a', 'palabra'=>'amnesico'),
array('letra'=>'a', 'palabra'=>'amnestia'),
array('letra'=>'a', 'palabra'=>'amnios'),
array('letra'=>'a', 'palabra'=>'amniota'),
array('letra'=>'a', 'palabra'=>'amniotico'),
array('letra'=>'a', 'palabra'=>'amnistia'),
array('letra'=>'a', 'palabra'=>'amnistiar'),
array('letra'=>'a', 'palabra'=>'amo'),
array('letra'=>'a', 'palabra'=>'amoblar'),
array('letra'=>'a', 'palabra'=>'amochar'),
array('letra'=>'a', 'palabra'=>'amochiguar'),
array('letra'=>'a', 'palabra'=>'amodita'),
array('letra'=>'a', 'palabra'=>'amodorrado'),
array('letra'=>'a', 'palabra'=>'amodorramiento'),
array('letra'=>'a', 'palabra'=>'amodorrarse'),
array('letra'=>'a', 'palabra'=>'amodorrecer'),
array('letra'=>'a', 'palabra'=>'amodorrido'),
array('letra'=>'a', 'palabra'=>'amogotado'),
array('letra'=>'a', 'palabra'=>'amohecer'),
array('letra'=>'a', 'palabra'=>'amohinamiento'),
array('letra'=>'a', 'palabra'=>'amohinar'),
array('letra'=>'a', 'palabra'=>'amohosarse'),
array('letra'=>'a', 'palabra'=>'amojamamiento'),
array('letra'=>'a', 'palabra'=>'amojamar'),
array('letra'=>'a', 'palabra'=>'amojelar'),
array('letra'=>'a', 'palabra'=>'amojonador'),
array('letra'=>'a', 'palabra'=>'amojonamiento'),
array('letra'=>'a', 'palabra'=>'amojonar'),
array('letra'=>'a', 'palabra'=>'amok'),
array('letra'=>'a', 'palabra'=>'amol'),
array('letra'=>'a', 'palabra'=>'amolada'),
array('letra'=>'a', 'palabra'=>'amoladera'),
array('letra'=>'a', 'palabra'=>'amolado'),
array('letra'=>'a', 'palabra'=>'amolador'),
array('letra'=>'a', 'palabra'=>'amoladura'),
array('letra'=>'a', 'palabra'=>'amolanchin'),
array('letra'=>'a', 'palabra'=>'amolar'),
array('letra'=>'a', 'palabra'=>'amoldable'),
array('letra'=>'a', 'palabra'=>'amoldador'),
array('letra'=>'a', 'palabra'=>'amoldamiento'),
array('letra'=>'a', 'palabra'=>'amoldar'),
array('letra'=>'a', 'palabra'=>'amole'),
array('letra'=>'a', 'palabra'=>'amollador'),
array('letra'=>'a', 'palabra'=>'amollar'),
array('letra'=>'a', 'palabra'=>'amollecer'),
array('letra'=>'a', 'palabra'=>'amollentadura'),
array('letra'=>'a', 'palabra'=>'amollentar'),
array('letra'=>'a', 'palabra'=>'amollentativo'),
array('letra'=>'a', 'palabra'=>'amolletado'),
array('letra'=>'a', 'palabra'=>'amomo'),
array('letra'=>'a', 'palabra'=>'amon'),
array('letra'=>'a', 'palabra'=>'amonal'),
array('letra'=>'a', 'palabra'=>'amonarse'),
array('letra'=>'a', 'palabra'=>'amondongado'),
array('letra'=>'a', 'palabra'=>'amonedacion'),
array('letra'=>'a', 'palabra'=>'amonedar'),
array('letra'=>'a', 'palabra'=>'amonestacion'),
array('letra'=>'a', 'palabra'=>'amonestador'),
array('letra'=>'a', 'palabra'=>'amonestamiento'),
array('letra'=>'a', 'palabra'=>'amonestar'),
array('letra'=>'a', 'palabra'=>'amoniacal'),
array('letra'=>'a', 'palabra'=>'amoniaco'),
array('letra'=>'a', 'palabra'=>'amoniaco'),
array('letra'=>'a', 'palabra'=>'amonico'),
array('letra'=>'a', 'palabra'=>'amonio'),
array('letra'=>'a', 'palabra'=>'amonita'),
array('letra'=>'a', 'palabra'=>'amonites'),
array('letra'=>'a', 'palabra'=>'amontadgar'),
array('letra'=>'a', 'palabra'=>'amontar'),
array('letra'=>'a', 'palabra'=>'amontazgar'),
array('letra'=>'a', 'palabra'=>'amontillado'),
array('letra'=>'a', 'palabra'=>'amontonadamente'),
array('letra'=>'a', 'palabra'=>'amontonador'),
array('letra'=>'a', 'palabra'=>'amontonamiento'),
array('letra'=>'a', 'palabra'=>'amontonar'),
array('letra'=>'a', 'palabra'=>'amor'),
array('letra'=>'a', 'palabra'=>'amoragar'),
array('letra'=>'a', 'palabra'=>'amoral'),
array('letra'=>'a', 'palabra'=>'amoralidad'),
array('letra'=>'a', 'palabra'=>'amoralismo'),
array('letra'=>'a', 'palabra'=>'amoratado'),
array('letra'=>'a', 'palabra'=>'amoratarse'),
array('letra'=>'a', 'palabra'=>'amorbar'),
array('letra'=>'a', 'palabra'=>'amorcar'),
array('letra'=>'a', 'palabra'=>'amorcillo'),
array('letra'=>'a', 'palabra'=>'amordazador'),
array('letra'=>'a', 'palabra'=>'amordazamiento'),
array('letra'=>'a', 'palabra'=>'amordazar'),
array('letra'=>'a', 'palabra'=>'amorecada'),
array('letra'=>'a', 'palabra'=>'amorecer'),
array('letra'=>'a', 'palabra'=>'amorfia'),
array('letra'=>'a', 'palabra'=>'amorfia'),
array('letra'=>'a', 'palabra'=>'amorfismo'),
array('letra'=>'a', 'palabra'=>'amorfo'),
array('letra'=>'a', 'palabra'=>'amorgonar'),
array('letra'=>'a', 'palabra'=>'amoricones'),
array('letra'=>'a', 'palabra'=>'amorillar'),
array('letra'=>'a', 'palabra'=>'amorio'),
array('letra'=>'a', 'palabra'=>'amoriscado'),
array('letra'=>'a', 'palabra'=>'amormado'),
array('letra'=>'a', 'palabra'=>'amormio'),
array('letra'=>'a', 'palabra'=>'amorocharse'),
array('letra'=>'a', 'palabra'=>'amorosamente'),
array('letra'=>'a', 'palabra'=>'amoroso'),
array('letra'=>'a', 'palabra'=>'amorrar'),
array('letra'=>'a', 'palabra'=>'amorreo'),
array('letra'=>'a', 'palabra'=>'amorriñar'),
array('letra'=>'a', 'palabra'=>'amorrionado'),
array('letra'=>'a', 'palabra'=>'amorronar'),
array('letra'=>'a', 'palabra'=>'amortajador'),
array('letra'=>'a', 'palabra'=>'amortajamiento'),
array('letra'=>'a', 'palabra'=>'amortajar'),
array('letra'=>'a', 'palabra'=>'amortecer'),
array('letra'=>'a', 'palabra'=>'amortecimiento'),
array('letra'=>'a', 'palabra'=>'amortiguacion'),
array('letra'=>'a', 'palabra'=>'amortiguador'),
array('letra'=>'a', 'palabra'=>'amortiguamiento'),
array('letra'=>'a', 'palabra'=>'amortiguar'),
array('letra'=>'a', 'palabra'=>'amortizable'),
array('letra'=>'a', 'palabra'=>'amortizacion'),
array('letra'=>'a', 'palabra'=>'amortizar'),
array('letra'=>'a', 'palabra'=>'amos'),
array('letra'=>'a', 'palabra'=>'amos'),
array('letra'=>'a', 'palabra'=>'amoscador'),
array('letra'=>'a', 'palabra'=>'amoscamiento'),
array('letra'=>'a', 'palabra'=>'amoscar'),
array('letra'=>'a', 'palabra'=>'amosquilarse'),
array('letra'=>'a', 'palabra'=>'amostachado'),
array('letra'=>'a', 'palabra'=>'amostazar'),
array('letra'=>'a', 'palabra'=>'amostramiento'),
array('letra'=>'a', 'palabra'=>'amostrar'),
array('letra'=>'a', 'palabra'=>'amotetarse'),
array('letra'=>'a', 'palabra'=>'amotinado'),
array('letra'=>'a', 'palabra'=>'amotinador'),
array('letra'=>'a', 'palabra'=>'amotinamiento'),
array('letra'=>'a', 'palabra'=>'amotinar'),
array('letra'=>'a', 'palabra'=>'amover'),
array('letra'=>'a', 'palabra'=>'amovible'),
array('letra'=>'a', 'palabra'=>'amovilidad'),
array('letra'=>'a', 'palabra'=>'ampalaba'),
array('letra'=>'a', 'palabra'=>'ampalagua'),
array('letra'=>'a', 'palabra'=>'amparador'),
array('letra'=>'a', 'palabra'=>'amparamiento'),
array('letra'=>'a', 'palabra'=>'amparar'),
array('letra'=>'a', 'palabra'=>'amparo'),
array('letra'=>'a', 'palabra'=>'ampelideo'),
array('letra'=>'a', 'palabra'=>'ampelita'),
array('letra'=>'a', 'palabra'=>'ampelografia'),
array('letra'=>'a', 'palabra'=>'ampelografico'),
array('letra'=>'a', 'palabra'=>'ampelografo'),
array('letra'=>'a', 'palabra'=>'amperaje'),
array('letra'=>'a', 'palabra'=>'ampere'),
array('letra'=>'a', 'palabra'=>'amperimetro'),
array('letra'=>'a', 'palabra'=>'amperio'),
array('letra'=>'a', 'palabra'=>'ampervuelta'),
array('letra'=>'a', 'palabra'=>'amplexicaulo'),
array('letra'=>'a', 'palabra'=>'amplexo'),
array('letra'=>'a', 'palabra'=>'ampliable'),
array('letra'=>'a', 'palabra'=>'ampliacion'),
array('letra'=>'a', 'palabra'=>'ampliador'),
array('letra'=>'a', 'palabra'=>'ampliar'),
array('letra'=>'a', 'palabra'=>'ampliativo'),
array('letra'=>'a', 'palabra'=>'ampliatorio'),
array('letra'=>'a', 'palabra'=>'amplificacion'),
array('letra'=>'a', 'palabra'=>'amplificador'),
array('letra'=>'a', 'palabra'=>'amplificar'),
array('letra'=>'a', 'palabra'=>'amplificativo'),
array('letra'=>'a', 'palabra'=>'amplio'),
array('letra'=>'a', 'palabra'=>'amplitud'),
array('letra'=>'a', 'palabra'=>'amplo'),
array('letra'=>'a', 'palabra'=>'ampo'),
array('letra'=>'a', 'palabra'=>'ampolla'),
array('letra'=>'a', 'palabra'=>'ampollar'),
array('letra'=>'a', 'palabra'=>'ampolleta'),
array('letra'=>'a', 'palabra'=>'ampon'),
array('letra'=>'a', 'palabra'=>'amprar'),
array('letra'=>'a', 'palabra'=>'ampulosidad'),
array('letra'=>'a', 'palabra'=>'ampuloso'),
array('letra'=>'a', 'palabra'=>'ampurdanes'),
array('letra'=>'a', 'palabra'=>'amputacion'),
array('letra'=>'a', 'palabra'=>'amputar'),
array('letra'=>'a', 'palabra'=>'amuchachado'),
array('letra'=>'a', 'palabra'=>'amuchar'),
array('letra'=>'a', 'palabra'=>'amuchiguar'),
array('letra'=>'a', 'palabra'=>'amueblar'),
array('letra'=>'a', 'palabra'=>'amuelar'),
array('letra'=>'a', 'palabra'=>'amuermar'),
array('letra'=>'a', 'palabra'=>'amufar'),
array('letra'=>'a', 'palabra'=>'amugamiento'),
array('letra'=>'a', 'palabra'=>'amugronador'),
array('letra'=>'a', 'palabra'=>'amugronamiento'),
array('letra'=>'a', 'palabra'=>'amugronar'),
array('letra'=>'a', 'palabra'=>'amujerado'),
array('letra'=>'a', 'palabra'=>'amujeramiento'),
array('letra'=>'a', 'palabra'=>'amular'),
array('letra'=>'a', 'palabra'=>'amulatado'),
array('letra'=>'a', 'palabra'=>'amuleto'),
array('letra'=>'a', 'palabra'=>'amunicionar'),
array('letra'=>'a', 'palabra'=>'amuñecado'),
array('letra'=>'a', 'palabra'=>'amuñuñar'),
array('letra'=>'a', 'palabra'=>'amura'),
array('letra'=>'a', 'palabra'=>'amurada'),
array('letra'=>'a', 'palabra'=>'amurallado'),
array('letra'=>'a', 'palabra'=>'amurallar'),
array('letra'=>'a', 'palabra'=>'amurar'),
array('letra'=>'a', 'palabra'=>'amurca'),
array('letra'=>'a', 'palabra'=>'amurcar'),
array('letra'=>'a', 'palabra'=>'amurco'),
array('letra'=>'a', 'palabra'=>'amurillar'),
array('letra'=>'a', 'palabra'=>'amurriñarse'),
array('letra'=>'a', 'palabra'=>'amusco'),
array('letra'=>'a', 'palabra'=>'amusgar'),
array('letra'=>'a', 'palabra'=>'amuso'),
array('letra'=>'a', 'palabra'=>'amustiar'),
array('letra'=>'a', 'palabra'=>'ana'),
array('letra'=>'a', 'palabra'=>'anabaptismo'),
array('letra'=>'a', 'palabra'=>'anabaptista'),
array('letra'=>'a', 'palabra'=>'anabatista'),
array('letra'=>'a', 'palabra'=>'anabi'),
array('letra'=>'a', 'palabra'=>'anabolena'),
array('letra'=>'a', 'palabra'=>'anabolico'),
array('letra'=>'a', 'palabra'=>'anabolismo'),
array('letra'=>'a', 'palabra'=>'anabolizante'),
array('letra'=>'a', 'palabra'=>'anacahuita'),
array('letra'=>'a', 'palabra'=>'anacalo'),
array('letra'=>'a', 'palabra'=>'anacanto'),
array('letra'=>'a', 'palabra'=>'anacarado'),
array('letra'=>'a', 'palabra'=>'anacardiaceo'),
array('letra'=>'a', 'palabra'=>'anacardino'),
array('letra'=>'a', 'palabra'=>'anacardo'),
array('letra'=>'a', 'palabra'=>'anaco'),
array('letra'=>'a', 'palabra'=>'anacoluto'),
array('letra'=>'a', 'palabra'=>'anaconda'),
array('letra'=>'a', 'palabra'=>'anacora'),
array('letra'=>'a', 'palabra'=>'anacoreta'),
array('letra'=>'a', 'palabra'=>'anacoretico'),
array('letra'=>'a', 'palabra'=>'anacorita'),
array('letra'=>'a', 'palabra'=>'anacreontico'),
array('letra'=>'a', 'palabra'=>'anacronico'),
array('letra'=>'a', 'palabra'=>'anacronismo'),
array('letra'=>'a', 'palabra'=>'anacrusa'),
array('letra'=>'a', 'palabra'=>'anade'),
array('letra'=>'a', 'palabra'=>'anadear'),
array('letra'=>'a', 'palabra'=>'anadina'),
array('letra'=>'a', 'palabra'=>'anadino'),
array('letra'=>'a', 'palabra'=>'anadiplosis'),
array('letra'=>'a', 'palabra'=>'anadon'),
array('letra'=>'a', 'palabra'=>'anadromo'),
array('letra'=>'a', 'palabra'=>'anaerobio'),
array('letra'=>'a', 'palabra'=>'anafaga'),
array('letra'=>'a', 'palabra'=>'anafalla'),
array('letra'=>'a', 'palabra'=>'anafaya'),
array('letra'=>'a', 'palabra'=>'anafe'),
array('letra'=>'a', 'palabra'=>'anafilactico'),
array('letra'=>'a', 'palabra'=>'anafilaxia'),
array('letra'=>'a', 'palabra'=>'anafilaxis'),
array('letra'=>'a', 'palabra'=>'anafora'),
array('letra'=>'a', 'palabra'=>'anaforico'),
array('letra'=>'a', 'palabra'=>'anafre'),
array('letra'=>'a', 'palabra'=>'anafrodisia'),
array('letra'=>'a', 'palabra'=>'anafrodisiaco'),
array('letra'=>'a', 'palabra'=>'anafrodisiaco'),
array('letra'=>'a', 'palabra'=>'anafrodita'),
array('letra'=>'a', 'palabra'=>'anaglifico'),
array('letra'=>'a', 'palabra'=>'anaglifo'),
array('letra'=>'a', 'palabra'=>'anagnorisis'),
array('letra'=>'a', 'palabra'=>'anagoge'),
array('letra'=>'a', 'palabra'=>'anagogia'),
array('letra'=>'a', 'palabra'=>'anagogico'),
array('letra'=>'a', 'palabra'=>'anagrama'),
array('letra'=>'a', 'palabra'=>'anagramatico'),
array('letra'=>'a', 'palabra'=>'anagramatista'),
array('letra'=>'a', 'palabra'=>'anagramista'),
array('letra'=>'a', 'palabra'=>'anaiboa'),
array('letra'=>'a', 'palabra'=>'anal'),
array('letra'=>'a', 'palabra'=>'analectas'),
array('letra'=>'a', 'palabra'=>'analeptico'),
array('letra'=>'a', 'palabra'=>'analfabetismo'),
array('letra'=>'a', 'palabra'=>'analfabeto'),
array('letra'=>'a', 'palabra'=>'analgesia'),
array('letra'=>'a', 'palabra'=>'analgesico'),
array('letra'=>'a', 'palabra'=>'analisis'),
array('letra'=>'a', 'palabra'=>'analista'),
array('letra'=>'a', 'palabra'=>'analistico'),
array('letra'=>'a', 'palabra'=>'analitica'),
array('letra'=>'a', 'palabra'=>'analiticamente'),
array('letra'=>'a', 'palabra'=>'analitico'),
array('letra'=>'a', 'palabra'=>'analizable'),
array('letra'=>'a', 'palabra'=>'analizador'),
array('letra'=>'a', 'palabra'=>'analizar'),
array('letra'=>'a', 'palabra'=>'analogamente'),
array('letra'=>'a', 'palabra'=>'analogia'),
array('letra'=>'a', 'palabra'=>'analogicamente'),
array('letra'=>'a', 'palabra'=>'analogico'),
array('letra'=>'a', 'palabra'=>'analogo'),
array('letra'=>'a', 'palabra'=>'anamita'),
array('letra'=>'a', 'palabra'=>'anamnesis'),
array('letra'=>'a', 'palabra'=>'anamniota'),
array('letra'=>'a', 'palabra'=>'anamniotico'),
array('letra'=>'a', 'palabra'=>'anamorfosis'),
array('letra'=>'a', 'palabra'=>'anamu'),
array('letra'=>'a', 'palabra'=>'anana'),
array('letra'=>'a', 'palabra'=>'ananas'),
array('letra'=>'a', 'palabra'=>'ananay'),
array('letra'=>'a', 'palabra'=>'anapelo'),
array('letra'=>'a', 'palabra'=>'anapestico'),
array('letra'=>'a', 'palabra'=>'anapesto'),
array('letra'=>'a', 'palabra'=>'anaptixis'),
array('letra'=>'a', 'palabra'=>'anaquel'),
array('letra'=>'a', 'palabra'=>'anaqueleria'),
array('letra'=>'a', 'palabra'=>'anaranjado'),
array('letra'=>'a', 'palabra'=>'anaranjear'),
array('letra'=>'a', 'palabra'=>'anarco'),
array('letra'=>'a', 'palabra'=>'anarcosindicalismo'),
array('letra'=>'a', 'palabra'=>'anarcosindicalista'),
array('letra'=>'a', 'palabra'=>'anarquia'),
array('letra'=>'a', 'palabra'=>'anarquico'),
array('letra'=>'a', 'palabra'=>'anarquismo'),
array('letra'=>'a', 'palabra'=>'anarquista'),
array('letra'=>'a', 'palabra'=>'anarquizante'),
array('letra'=>'a', 'palabra'=>'anarquizar'),
array('letra'=>'a', 'palabra'=>'anasarca'),
array('letra'=>'a', 'palabra'=>'anascote'),
array('letra'=>'a', 'palabra'=>'anastasia'),
array('letra'=>'a', 'palabra'=>'anastigmatico'),
array('letra'=>'a', 'palabra'=>'anastomizarse'),
array('letra'=>'a', 'palabra'=>'anastomosarse'),
array('letra'=>'a', 'palabra'=>'anastomosis'),
array('letra'=>'a', 'palabra'=>'anastrofe'),
array('letra'=>'a', 'palabra'=>'anata'),
array('letra'=>'a', 'palabra'=>'anatado'),
array('letra'=>'a', 'palabra'=>'anatema'),
array('letra'=>'a', 'palabra'=>'anatematismo'),
array('letra'=>'a', 'palabra'=>'anatematizador'),
array('letra'=>'a', 'palabra'=>'anatematizar'),
array('letra'=>'a', 'palabra'=>'anatemizar'),
array('letra'=>'a', 'palabra'=>'anatiforme'),
array('letra'=>'a', 'palabra'=>'anatista'),
array('letra'=>'a', 'palabra'=>'anatomia'),
array('letra'=>'a', 'palabra'=>'anatomicamente'),
array('letra'=>'a', 'palabra'=>'anatomico'),
array('letra'=>'a', 'palabra'=>'anatomista'),
array('letra'=>'a', 'palabra'=>'anatomizar'),
array('letra'=>'a', 'palabra'=>'anatomopatologico'),
array('letra'=>'a', 'palabra'=>'anatomopatologo'),
array('letra'=>'a', 'palabra'=>'anavia'),
array('letra'=>'a', 'palabra'=>'anay'),
array('letra'=>'a', 'palabra'=>'anca'),
array('letra'=>'a', 'palabra'=>'ancado'),
array('letra'=>'a', 'palabra'=>'ancashino'),
array('letra'=>'a', 'palabra'=>'ancestral'),
array('letra'=>'a', 'palabra'=>'ancestro'),
array('letra'=>'a', 'palabra'=>'ancha'),
array('letra'=>'a', 'palabra'=>'anchamente'),
array('letra'=>'a', 'palabra'=>'anchar'),
array('letra'=>'a', 'palabra'=>'ancharia'),
array('letra'=>'a', 'palabra'=>'ancheta'),
array('letra'=>'a', 'palabra'=>'ancheza'),
array('letra'=>'a', 'palabra'=>'anchicorto'),
array('letra'=>'a', 'palabra'=>'ancho'),
array('letra'=>'a', 'palabra'=>'anchoa'),
array('letra'=>'a', 'palabra'=>'anchoar'),
array('letra'=>'a', 'palabra'=>'anchor'),
array('letra'=>'a', 'palabra'=>'anchova'),
array('letra'=>'a', 'palabra'=>'anchoveta'),
array('letra'=>'a', 'palabra'=>'anchuelo'),
array('letra'=>'a', 'palabra'=>'anchura'),
array('letra'=>'a', 'palabra'=>'anchuron'),
array('letra'=>'a', 'palabra'=>'anchuroso'),
array('letra'=>'a', 'palabra'=>'ancianamente'),
array('letra'=>'a', 'palabra'=>'anciania'),
array('letra'=>'a', 'palabra'=>'ancianidad'),
array('letra'=>'a', 'palabra'=>'ancianismo'),
array('letra'=>'a', 'palabra'=>'anciano'),
array('letra'=>'a', 'palabra'=>'ancila'),
array('letra'=>'a', 'palabra'=>'ancilar'),
array('letra'=>'a', 'palabra'=>'ancilario'),
array('letra'=>'a', 'palabra'=>'ancla'),
array('letra'=>'a', 'palabra'=>'ancladero'),
array('letra'=>'a', 'palabra'=>'anclaje'),
array('letra'=>'a', 'palabra'=>'anclar'),
array('letra'=>'a', 'palabra'=>'anclear'),
array('letra'=>'a', 'palabra'=>'anclote'),
array('letra'=>'a', 'palabra'=>'ancon'),
array('letra'=>'a', 'palabra'=>'anconada'),
array('letra'=>'a', 'palabra'=>'anconitano'),
array('letra'=>'a', 'palabra'=>'ancora'),
array('letra'=>'a', 'palabra'=>'ancorada'),
array('letra'=>'a', 'palabra'=>'ancoraje'),
array('letra'=>'a', 'palabra'=>'ancorar'),
array('letra'=>'a', 'palabra'=>'ancorca'),
array('letra'=>'a', 'palabra'=>'ancorel'),
array('letra'=>'a', 'palabra'=>'ancoreria'),
array('letra'=>'a', 'palabra'=>'ancorero'),
array('letra'=>'a', 'palabra'=>'ancua'),
array('letra'=>'a', 'palabra'=>'ancuco'),
array('letra'=>'a', 'palabra'=>'ancudo'),
array('letra'=>'a', 'palabra'=>'ancusa'),
array('letra'=>'a', 'palabra'=>'ancuviña'),
array('letra'=>'a', 'palabra'=>'anda'),
array('letra'=>'a', 'palabra'=>'andabata'),
array('letra'=>'a', 'palabra'=>'andaboba'),
array('letra'=>'a', 'palabra'=>'andada'),
array('letra'=>'a', 'palabra'=>'andadero'),
array('letra'=>'a', 'palabra'=>'andado'),
array('letra'=>'a', 'palabra'=>'andador'),
array('letra'=>'a', 'palabra'=>'andadura'),
array('letra'=>'a', 'palabra'=>'andalia'),
array('letra'=>'a', 'palabra'=>'andalon'),
array('letra'=>'a', 'palabra'=>'andalotero'),
array('letra'=>'a', 'palabra'=>'andalucismo'),
array('letra'=>'a', 'palabra'=>'andalucista'),
array('letra'=>'a', 'palabra'=>'andalucita'),
array('letra'=>'a', 'palabra'=>'andalusi'),
array('letra'=>'a', 'palabra'=>'andaluz'),
array('letra'=>'a', 'palabra'=>'andaluzada'),
array('letra'=>'a', 'palabra'=>'andamiada'),
array('letra'=>'a', 'palabra'=>'andamiaje'),
array('letra'=>'a', 'palabra'=>'andamiento'),
array('letra'=>'a', 'palabra'=>'andamio'),
array('letra'=>'a', 'palabra'=>'andana'),
array('letra'=>'a', 'palabra'=>'andanada'),
array('letra'=>'a', 'palabra'=>'andancia'),
array('letra'=>'a', 'palabra'=>'andancio'),
array('letra'=>'a', 'palabra'=>'andaniño'),
array('letra'=>'a', 'palabra'=>'andante'),
array('letra'=>'a', 'palabra'=>'andantesco'),
array('letra'=>'a', 'palabra'=>'andantino'),
array('letra'=>'a', 'palabra'=>'andanza'),
array('letra'=>'a', 'palabra'=>'andar'),
array('letra'=>'a', 'palabra'=>'andaraje'),
array('letra'=>'a', 'palabra'=>'andarica'),
array('letra'=>'a', 'palabra'=>'andariego'),
array('letra'=>'a', 'palabra'=>'andarin'),
array('letra'=>'a', 'palabra'=>'andarina'),
array('letra'=>'a', 'palabra'=>'andarivel'),
array('letra'=>'a', 'palabra'=>'andarraya'),
array('letra'=>'a', 'palabra'=>'andarrios'),
array('letra'=>'a', 'palabra'=>'andas'),
array('letra'=>'a', 'palabra'=>'andavete'),
array('letra'=>'a', 'palabra'=>'andel'),
array('letra'=>'a', 'palabra'=>'anden'),
array('letra'=>'a', 'palabra'=>'andeneria'),
array('letra'=>'a', 'palabra'=>'andero'),
array('letra'=>'a', 'palabra'=>'andesina'),
array('letra'=>'a', 'palabra'=>'andesita'),
array('letra'=>'a', 'palabra'=>'andinismo'),
array('letra'=>'a', 'palabra'=>'andinista'),
array('letra'=>'a', 'palabra'=>'andino'),
array('letra'=>'a', 'palabra'=>'andito'),
array('letra'=>'a', 'palabra'=>'andoba'),
array('letra'=>'a', 'palabra'=>'andobal'),
array('letra'=>'a', 'palabra'=>'andola'),
array('letra'=>'a', 'palabra'=>'andolencia'),
array('letra'=>'a', 'palabra'=>'andolina'),
array('letra'=>'a', 'palabra'=>'andon'),
array('letra'=>'a', 'palabra'=>'andorga'),
array('letra'=>'a', 'palabra'=>'andorina'),
array('letra'=>'a', 'palabra'=>'andorra'),
array('letra'=>'a', 'palabra'=>'andorrano'),
array('letra'=>'a', 'palabra'=>'andorrear'),
array('letra'=>'a', 'palabra'=>'andorrero'),
array('letra'=>'a', 'palabra'=>'andosco'),
array('letra'=>'a', 'palabra'=>'andrado'),
array('letra'=>'a', 'palabra'=>'andrajero'),
array('letra'=>'a', 'palabra'=>'andrajo'),
array('letra'=>'a', 'palabra'=>'andrajosamente'),
array('letra'=>'a', 'palabra'=>'andrajoso'),
array('letra'=>'a', 'palabra'=>'andres'),
array('letra'=>'a', 'palabra'=>'andriana'),
array('letra'=>'a', 'palabra'=>'andrina'),
array('letra'=>'a', 'palabra'=>'andrino'),
array('letra'=>'a', 'palabra'=>'androceo'),
array('letra'=>'a', 'palabra'=>'androfobia'),
array('letra'=>'a', 'palabra'=>'androgenesis'),
array('letra'=>'a', 'palabra'=>'androgeno'),
array('letra'=>'a', 'palabra'=>'androgino'),
array('letra'=>'a', 'palabra'=>'androide'),
array('letra'=>'a', 'palabra'=>'andromina'),
array('letra'=>'a', 'palabra'=>'andropausia'),
array('letra'=>'a', 'palabra'=>'androsemo'),
array('letra'=>'a', 'palabra'=>'andujareño'),
array('letra'=>'a', 'palabra'=>'andulario'),
array('letra'=>'a', 'palabra'=>'andulencia'),
array('letra'=>'a', 'palabra'=>'andullo'),
array('letra'=>'a', 'palabra'=>'andurrial'),
array('letra'=>'a', 'palabra'=>'anea'),
array('letra'=>'a', 'palabra'=>'aneaje'),
array('letra'=>'a', 'palabra'=>'anear'),
array('letra'=>'a', 'palabra'=>'aneblar'),
array('letra'=>'a', 'palabra'=>'anecdota'),
array('letra'=>'a', 'palabra'=>'anecdotario'),
array('letra'=>'a', 'palabra'=>'anecdotico'),
array('letra'=>'a', 'palabra'=>'anecdotismo'),
array('letra'=>'a', 'palabra'=>'anecdotista'),
array('letra'=>'a', 'palabra'=>'aneciarse'),
array('letra'=>'a', 'palabra'=>'anegable'),
array('letra'=>'a', 'palabra'=>'anegacion'),
array('letra'=>'a', 'palabra'=>'anegadizo'),
array('letra'=>'a', 'palabra'=>'anegamiento'),
array('letra'=>'a', 'palabra'=>'anegar'),
array('letra'=>'a', 'palabra'=>'anegociado'),
array('letra'=>'a', 'palabra'=>'anejar'),
array('letra'=>'a', 'palabra'=>'anejir'),
array('letra'=>'a', 'palabra'=>'anejo'),
array('letra'=>'a', 'palabra'=>'aneldo'),
array('letra'=>'a', 'palabra'=>'anelido'),
array('letra'=>'a', 'palabra'=>'anemia'),
array('letra'=>'a', 'palabra'=>'anemico'),
array('letra'=>'a', 'palabra'=>'anemocordio'),
array('letra'=>'a', 'palabra'=>'anemofilo'),
array('letra'=>'a', 'palabra'=>'anemografia'),
array('letra'=>'a', 'palabra'=>'anemografico'),
array('letra'=>'a', 'palabra'=>'anemografo'),
array('letra'=>'a', 'palabra'=>'anemometria'),
array('letra'=>'a', 'palabra'=>'anemometrico'),
array('letra'=>'a', 'palabra'=>'anemometro'),
array('letra'=>'a', 'palabra'=>'anemona'),
array('letra'=>'a', 'palabra'=>'anemona'),
array('letra'=>'a', 'palabra'=>'anemone'),
array('letra'=>'a', 'palabra'=>'anemoscopio'),
array('letra'=>'a', 'palabra'=>'aneota'),
array('letra'=>'a', 'palabra'=>'aneota'),
array('letra'=>'a', 'palabra'=>'anepigrafico'),
array('letra'=>'a', 'palabra'=>'aneroide'),
array('letra'=>'a', 'palabra'=>'anestesia'),
array('letra'=>'a', 'palabra'=>'anestesiar'),
array('letra'=>'a', 'palabra'=>'anestesico'),
array('letra'=>'a', 'palabra'=>'anestesiologia'),
array('letra'=>'a', 'palabra'=>'anestesiologo'),
array('letra'=>'a', 'palabra'=>'anestesista'),
array('letra'=>'a', 'palabra'=>'aneto'),
array('letra'=>'a', 'palabra'=>'aneurisma'),
array('letra'=>'a', 'palabra'=>'anexar'),
array('letra'=>'a', 'palabra'=>'anexidad'),
array('letra'=>'a', 'palabra'=>'anexion'),
array('letra'=>'a', 'palabra'=>'anexionar'),
array('letra'=>'a', 'palabra'=>'anexionismo'),
array('letra'=>'a', 'palabra'=>'anexionista'),
array('letra'=>'a', 'palabra'=>'anexitis'),
array('letra'=>'a', 'palabra'=>'anexo'),
array('letra'=>'a', 'palabra'=>'anfesibena'),
array('letra'=>'a', 'palabra'=>'anfeta'),
array('letra'=>'a', 'palabra'=>'anfetamina'),
array('letra'=>'a', 'palabra'=>'anfibio'),
array('letra'=>'a', 'palabra'=>'anfibol'),
array('letra'=>'a', 'palabra'=>'anfibolita'),
array('letra'=>'a', 'palabra'=>'anfibologia'),
array('letra'=>'a', 'palabra'=>'anfibologico'),
array('letra'=>'a', 'palabra'=>'anfibraco'),
array('letra'=>'a', 'palabra'=>'anfiction'),
array('letra'=>'a', 'palabra'=>'anfictionado'),
array('letra'=>'a', 'palabra'=>'anfictionia'),
array('letra'=>'a', 'palabra'=>'anfictionico'),
array('letra'=>'a', 'palabra'=>'anfimacro'),
array('letra'=>'a', 'palabra'=>'anfineuro'),
array('letra'=>'a', 'palabra'=>'anfion'),
array('letra'=>'a', 'palabra'=>'anfipodo'),
array('letra'=>'a', 'palabra'=>'anfiprostilo'),
array('letra'=>'a', 'palabra'=>'anfisbena'),
array('letra'=>'a', 'palabra'=>'anfiscio'),
array('letra'=>'a', 'palabra'=>'anfisibena'),
array('letra'=>'a', 'palabra'=>'anfiteatro'),
array('letra'=>'a', 'palabra'=>'anfitrion'),
array('letra'=>'a', 'palabra'=>'anfora'),
array('letra'=>'a', 'palabra'=>'anfotero'),
array('letra'=>'a', 'palabra'=>'anfractuosidad'),
array('letra'=>'a', 'palabra'=>'anfractuoso'),
array('letra'=>'a', 'palabra'=>'anganillas'),
array('letra'=>'a', 'palabra'=>'angaria'),
array('letra'=>'a', 'palabra'=>'angarillada'),
array('letra'=>'a', 'palabra'=>'angarillar'),
array('letra'=>'a', 'palabra'=>'angaripola'),
array('letra'=>'a', 'palabra'=>'angaro'),
array('letra'=>'a', 'palabra'=>'angazo'),
array('letra'=>'a', 'palabra'=>'angel'),
array('letra'=>'a', 'palabra'=>'angela'),
array('letra'=>'a', 'palabra'=>'angelica'),
array('letra'=>'a', 'palabra'=>'angelical'),
array('letra'=>'a', 'palabra'=>'angelicalmente'),
array('letra'=>'a', 'palabra'=>'angelico'),
array('letra'=>'a', 'palabra'=>'angelico'),
array('letra'=>'a', 'palabra'=>'angelin'),
array('letra'=>'a', 'palabra'=>'angelino'),
array('letra'=>'a', 'palabra'=>'angelito'),
array('letra'=>'a', 'palabra'=>'angelizar'),
array('letra'=>'a', 'palabra'=>'angelologia'),
array('letra'=>'a', 'palabra'=>'angelon'),
array('letra'=>'a', 'palabra'=>'angelopolitano'),
array('letra'=>'a', 'palabra'=>'angelota'),
array('letra'=>'a', 'palabra'=>'angelote'),
array('letra'=>'a', 'palabra'=>'angelus'),
array('letra'=>'a', 'palabra'=>'angevino'),
array('letra'=>'a', 'palabra'=>'angina'),
array('letra'=>'a', 'palabra'=>'anginoso'),
array('letra'=>'a', 'palabra'=>'angiografia'),
array('letra'=>'a', 'palabra'=>'angiologia'),
array('letra'=>'a', 'palabra'=>'angiologo'),
array('letra'=>'a', 'palabra'=>'angioma'),
array('letra'=>'a', 'palabra'=>'angiospermo'),
array('letra'=>'a', 'palabra'=>'angitis'),
array('letra'=>'a', 'palabra'=>'anglesita'),
array('letra'=>'a', 'palabra'=>'anglicado'),
array('letra'=>'a', 'palabra'=>'anglicanismo'),
array('letra'=>'a', 'palabra'=>'anglicanizado'),
array('letra'=>'a', 'palabra'=>'anglicanizante'),
array('letra'=>'a', 'palabra'=>'anglicano'),
array('letra'=>'a', 'palabra'=>'anglicismo'),
array('letra'=>'a', 'palabra'=>'anglicista'),
array('letra'=>'a', 'palabra'=>'anglico'),
array('letra'=>'a', 'palabra'=>'angliparla'),
array('letra'=>'a', 'palabra'=>'anglista'),
array('letra'=>'a', 'palabra'=>'anglistico'),
array('letra'=>'a', 'palabra'=>'anglo'),
array('letra'=>'a', 'palabra'=>'angloamericanismo'),
array('letra'=>'a', 'palabra'=>'angloamericano'),
array('letra'=>'a', 'palabra'=>'anglocanadiense'),
array('letra'=>'a', 'palabra'=>'anglofilia'),
array('letra'=>'a', 'palabra'=>'anglofilo'),
array('letra'=>'a', 'palabra'=>'anglofobia'),
array('letra'=>'a', 'palabra'=>'anglofobo'),
array('letra'=>'a', 'palabra'=>'anglofono'),
array('letra'=>'a', 'palabra'=>'anglohablante'),
array('letra'=>'a', 'palabra'=>'angloindio'),
array('letra'=>'a', 'palabra'=>'anglomania'),
array('letra'=>'a', 'palabra'=>'anglomano'),
array('letra'=>'a', 'palabra'=>'anglonormando'),
array('letra'=>'a', 'palabra'=>'angloparlante'),
array('letra'=>'a', 'palabra'=>'anglosajon'),
array('letra'=>'a', 'palabra'=>'angoja'),
array('letra'=>'a', 'palabra'=>'angojoso'),
array('letra'=>'a', 'palabra'=>'angolan'),
array('letra'=>'a', 'palabra'=>'angoleño'),
array('letra'=>'a', 'palabra'=>'angolino'),
array('letra'=>'a', 'palabra'=>'angor'),
array('letra'=>'a', 'palabra'=>'angor'),
array('letra'=>'a', 'palabra'=>'angora'),
array('letra'=>'a', 'palabra'=>'angorina'),
array('letra'=>'a', 'palabra'=>'angorra'),
array('letra'=>'a', 'palabra'=>'angostamente'),
array('letra'=>'a', 'palabra'=>'angostamiento'),
array('letra'=>'a', 'palabra'=>'angostar'),
array('letra'=>'a', 'palabra'=>'angosto'),
array('letra'=>'a', 'palabra'=>'angostura'),
array('letra'=>'a', 'palabra'=>'angra'),
array('letra'=>'a', 'palabra'=>'angrelado'),
array('letra'=>'a', 'palabra'=>'angstrom'),
array('letra'=>'a', 'palabra'=>'angström'),
array('letra'=>'a', 'palabra'=>'angu'),
array('letra'=>'a', 'palabra'=>'anguarina'),
array('letra'=>'a', 'palabra'=>'angüejo'),
array('letra'=>'a', 'palabra'=>'anguera'),
array('letra'=>'a', 'palabra'=>'anguila'),
array('letra'=>'a', 'palabra'=>'anguilazo'),
array('letra'=>'a', 'palabra'=>'anguilero'),
array('letra'=>'a', 'palabra'=>'anguilla'),
array('letra'=>'a', 'palabra'=>'anguilo'),
array('letra'=>'a', 'palabra'=>'anguina'),
array('letra'=>'a', 'palabra'=>'angula'),
array('letra'=>'a', 'palabra'=>'angulado'),
array('letra'=>'a', 'palabra'=>'angular'),
array('letra'=>'a', 'palabra'=>'angularmente'),
array('letra'=>'a', 'palabra'=>'angulema'),
array('letra'=>'a', 'palabra'=>'angulo'),
array('letra'=>'a', 'palabra'=>'angulosidad'),
array('letra'=>'a', 'palabra'=>'anguloso'),
array('letra'=>'a', 'palabra'=>'anguria'),
array('letra'=>'a', 'palabra'=>'angurria'),
array('letra'=>'a', 'palabra'=>'angurriento'),
array('letra'=>'a', 'palabra'=>'angustia'),
array('letra'=>'a', 'palabra'=>'angustiado'),
array('letra'=>'a', 'palabra'=>'angustiador'),
array('letra'=>'a', 'palabra'=>'angustiar'),
array('letra'=>'a', 'palabra'=>'angustioso'),
array('letra'=>'a', 'palabra'=>'anhelacion'),
array('letra'=>'a', 'palabra'=>'anhelante'),
array('letra'=>'a', 'palabra'=>'anhelar'),
array('letra'=>'a', 'palabra'=>'anhelito'),
array('letra'=>'a', 'palabra'=>'anhelo'),
array('letra'=>'a', 'palabra'=>'anheloso'),
array('letra'=>'a', 'palabra'=>'anhidrido'),
array('letra'=>'a', 'palabra'=>'anhidrita'),
array('letra'=>'a', 'palabra'=>'anhidro'),
array('letra'=>'a', 'palabra'=>'anhidrosis'),
array('letra'=>'a', 'palabra'=>'aniaga'),
array('letra'=>'a', 'palabra'=>'anidacion'),
array('letra'=>'a', 'palabra'=>'anidamiento'),
array('letra'=>'a', 'palabra'=>'anidar'),
array('letra'=>'a', 'palabra'=>'anidiar'),
array('letra'=>'a', 'palabra'=>'anidio'),
array('letra'=>'a', 'palabra'=>'anieblar'),
array('letra'=>'a', 'palabra'=>'aniego'),
array('letra'=>'a', 'palabra'=>'aniejar'),
array('letra'=>'a', 'palabra'=>'aniejo'),
array('letra'=>'a', 'palabra'=>'anihilacion'),
array('letra'=>'a', 'palabra'=>'anihilamiento'),
array('letra'=>'a', 'palabra'=>'anihilar'),
array('letra'=>'a', 'palabra'=>'anilina'),
array('letra'=>'a', 'palabra'=>'anilla'),
array('letra'=>'a', 'palabra'=>'anillado'),
array('letra'=>'a', 'palabra'=>'anillamiento'),
array('letra'=>'a', 'palabra'=>'anillar'),
array('letra'=>'a', 'palabra'=>'anillo'),
array('letra'=>'a', 'palabra'=>'anima'),
array('letra'=>'a', 'palabra'=>'animacion'),
array('letra'=>'a', 'palabra'=>'animado'),
array('letra'=>'a', 'palabra'=>'animador'),
array('letra'=>'a', 'palabra'=>'animadversion'),
array('letra'=>'a', 'palabra'=>'animadvertencia'),
array('letra'=>'a', 'palabra'=>'animal'),
array('letra'=>'a', 'palabra'=>'animalada'),
array('letra'=>'a', 'palabra'=>'animalaje'),
array('letra'=>'a', 'palabra'=>'animalario'),
array('letra'=>'a', 'palabra'=>'animalculo'),
array('letra'=>'a', 'palabra'=>'animalero'),
array('letra'=>'a', 'palabra'=>'animalia'),
array('letra'=>'a', 'palabra'=>'animalias'),
array('letra'=>'a', 'palabra'=>'animalidad'),
array('letra'=>'a', 'palabra'=>'animalizacion'),
array('letra'=>'a', 'palabra'=>'animalizar'),
array('letra'=>'a', 'palabra'=>'animalucho'),
array('letra'=>'a', 'palabra'=>'animante'),
array('letra'=>'a', 'palabra'=>'animar'),
array('letra'=>'a', 'palabra'=>'anime'),
array('letra'=>'a', 'palabra'=>'animero'),
array('letra'=>'a', 'palabra'=>'animico'),
array('letra'=>'a', 'palabra'=>'animismo'),
array('letra'=>'a', 'palabra'=>'animista'),
array('letra'=>'a', 'palabra'=>'animizar'),
array('letra'=>'a', 'palabra'=>'animo'),
array('letra'=>'a', 'palabra'=>'animosamente'),
array('letra'=>'a', 'palabra'=>'animosidad'),
array('letra'=>'a', 'palabra'=>'animoso'),
array('letra'=>'a', 'palabra'=>'aniñadamente'),
array('letra'=>'a', 'palabra'=>'aniñado'),
array('letra'=>'a', 'palabra'=>'aniñamiento'),
array('letra'=>'a', 'palabra'=>'aniñarse'),
array('letra'=>'a', 'palabra'=>'anion'),
array('letra'=>'a', 'palabra'=>'anionico'),
array('letra'=>'a', 'palabra'=>'aniquilable'),
array('letra'=>'a', 'palabra'=>'aniquilacion'),
array('letra'=>'a', 'palabra'=>'aniquilador'),
array('letra'=>'a', 'palabra'=>'aniquilamiento'),
array('letra'=>'a', 'palabra'=>'aniquilar'),
array('letra'=>'a', 'palabra'=>'anis'),
array('letra'=>'a', 'palabra'=>'anisado'),
array('letra'=>'a', 'palabra'=>'anisal'),
array('letra'=>'a', 'palabra'=>'anisar'),
array('letra'=>'a', 'palabra'=>'anisete'),
array('letra'=>'a', 'palabra'=>'anisodonte'),
array('letra'=>'a', 'palabra'=>'anisofilo'),
array('letra'=>'a', 'palabra'=>'anisomero'),
array('letra'=>'a', 'palabra'=>'anisopetalo'),
array('letra'=>'a', 'palabra'=>'anisotropia'),
array('letra'=>'a', 'palabra'=>'anisotropo'),
array('letra'=>'a', 'palabra'=>'anito'),
array('letra'=>'a', 'palabra'=>'anivelar'),
array('letra'=>'a', 'palabra'=>'aniversario'),
array('letra'=>'a', 'palabra'=>'anjeo'),
array('letra'=>'a', 'palabra'=>'anjova'),
array('letra'=>'a', 'palabra'=>'annamita'),
array('letra'=>'a', 'palabra'=>'ano'),
array('letra'=>'a', 'palabra'=>'ano'),
array('letra'=>'a', 'palabra'=>'anoa'),
array('letra'=>'a', 'palabra'=>'anobio'),
array('letra'=>'a', 'palabra'=>'anoche'),
array('letra'=>'a', 'palabra'=>'anochecedor'),
array('letra'=>'a', 'palabra'=>'anochecer'),
array('letra'=>'a', 'palabra'=>'anochecida'),
array('letra'=>'a', 'palabra'=>'anochecido'),
array('letra'=>'a', 'palabra'=>'anodico'),
array('letra'=>'a', 'palabra'=>'anodinia'),
array('letra'=>'a', 'palabra'=>'anodino'),
array('letra'=>'a', 'palabra'=>'anodo'),
array('letra'=>'a', 'palabra'=>'anofeles'),
array('letra'=>'a', 'palabra'=>'anomalia'),
array('letra'=>'a', 'palabra'=>'anomalidad'),
array('letra'=>'a', 'palabra'=>'anomalistico'),
array('letra'=>'a', 'palabra'=>'anomalo'),
array('letra'=>'a', 'palabra'=>'anomia'),
array('letra'=>'a', 'palabra'=>'anomia'),
array('letra'=>'a', 'palabra'=>'anomuro'),
array('letra'=>'a', 'palabra'=>'anon'),
array('letra'=>'a', 'palabra'=>'anona'),
array('letra'=>'a', 'palabra'=>'anonaceo'),
array('letra'=>'a', 'palabra'=>'anonadacion'),
array('letra'=>'a', 'palabra'=>'anonadador'),
array('letra'=>'a', 'palabra'=>'anonadamiento'),
array('letra'=>'a', 'palabra'=>'anonadar'),
array('letra'=>'a', 'palabra'=>'anonimato'),
array('letra'=>'a', 'palabra'=>'anonimia'),
array('letra'=>'a', 'palabra'=>'anonimo'),
array('letra'=>'a', 'palabra'=>'anopluro'),
array('letra'=>'a', 'palabra'=>'anorak'),
array('letra'=>'a', 'palabra'=>'anorexia'),
array('letra'=>'a', 'palabra'=>'anorexico'),
array('letra'=>'a', 'palabra'=>'anoria'),
array('letra'=>'a', 'palabra'=>'anormal'),
array('letra'=>'a', 'palabra'=>'anormalidad'),
array('letra'=>'a', 'palabra'=>'anorza'),
array('letra'=>'a', 'palabra'=>'anosmia'),
array('letra'=>'a', 'palabra'=>'anotacion'),
array('letra'=>'a', 'palabra'=>'anotador'),
array('letra'=>'a', 'palabra'=>'anotar'),
array('letra'=>'a', 'palabra'=>'anoticiar'),
array('letra'=>'a', 'palabra'=>'anotomia'),
array('letra'=>'a', 'palabra'=>'anotomico'),
array('letra'=>'a', 'palabra'=>'anovelado'),
array('letra'=>'a', 'palabra'=>'anovulatorio'),
array('letra'=>'a', 'palabra'=>'anoxia'),
array('letra'=>'a', 'palabra'=>'anquear'),
array('letra'=>'a', 'palabra'=>'anquera'),
array('letra'=>'a', 'palabra'=>'anqueta'),
array('letra'=>'a', 'palabra'=>'anquialmendrado'),
array('letra'=>'a', 'palabra'=>'anquiboyuno'),
array('letra'=>'a', 'palabra'=>'anquiderribado'),
array('letra'=>'a', 'palabra'=>'anquilosamiento'),
array('letra'=>'a', 'palabra'=>'anquilosar'),
array('letra'=>'a', 'palabra'=>'anquilosis'),
array('letra'=>'a', 'palabra'=>'anquilostoma'),
array('letra'=>'a', 'palabra'=>'anquilostomiasis'),
array('letra'=>'a', 'palabra'=>'anquirredondo'),
array('letra'=>'a', 'palabra'=>'anquiseco'),
array('letra'=>'a', 'palabra'=>'ansa'),
array('letra'=>'a', 'palabra'=>'ansar'),
array('letra'=>'a', 'palabra'=>'ansareria'),
array('letra'=>'a', 'palabra'=>'ansarero'),
array('letra'=>'a', 'palabra'=>'ansarino'),
array('letra'=>'a', 'palabra'=>'ansaron'),
array('letra'=>'a', 'palabra'=>'anseatico'),
array('letra'=>'a', 'palabra'=>'anseriforme'),
array('letra'=>'a', 'palabra'=>'ansi'),
array('letra'=>'a', 'palabra'=>'ansia'),
array('letra'=>'a', 'palabra'=>'ansiar'),
array('letra'=>'a', 'palabra'=>'ansiedad'),
array('letra'=>'a', 'palabra'=>'ansimesmo'),
array('letra'=>'a', 'palabra'=>'ansimismo'),
array('letra'=>'a', 'palabra'=>'ansina'),
array('letra'=>'a', 'palabra'=>'ansiolitico'),
array('letra'=>'a', 'palabra'=>'ansion'),
array('letra'=>'a', 'palabra'=>'ansiosidad'),
array('letra'=>'a', 'palabra'=>'ansioso'),
array('letra'=>'a', 'palabra'=>'ansotano'),
array('letra'=>'a', 'palabra'=>'anta'),
array('letra'=>'a', 'palabra'=>'antagalla'),
array('letra'=>'a', 'palabra'=>'antagallar'),
array('letra'=>'a', 'palabra'=>'antagonico'),
array('letra'=>'a', 'palabra'=>'antagonismo'),
array('letra'=>'a', 'palabra'=>'antagonista'),
array('letra'=>'a', 'palabra'=>'antamilla'),
array('letra'=>'a', 'palabra'=>'antana'),
array('letra'=>'a', 'palabra'=>'antañada'),
array('letra'=>'a', 'palabra'=>'antañazo'),
array('letra'=>'a', 'palabra'=>'antaño'),
array('letra'=>'a', 'palabra'=>'antañon'),
array('letra'=>'a', 'palabra'=>'antarca'),
array('letra'=>'a', 'palabra'=>'antarquear'),
array('letra'=>'a', 'palabra'=>'antartico'),
array('letra'=>'a', 'palabra'=>'ante'),
array('letra'=>'a', 'palabra'=>'anteado'),
array('letra'=>'a', 'palabra'=>'antealtar'),
array('letra'=>'a', 'palabra'=>'anteanoche'),
array('letra'=>'a', 'palabra'=>'anteanteanoche'),
array('letra'=>'a', 'palabra'=>'anteanteayer'),
array('letra'=>'a', 'palabra'=>'anteantenoche'),
array('letra'=>'a', 'palabra'=>'anteantier'),
array('letra'=>'a', 'palabra'=>'anteayer'),
array('letra'=>'a', 'palabra'=>'antebrazo'),
array('letra'=>'a', 'palabra'=>'antecama'),
array('letra'=>'a', 'palabra'=>'antecamara'),
array('letra'=>'a', 'palabra'=>'antecapilla'),
array('letra'=>'a', 'palabra'=>'antecedencia'),
array('letra'=>'a', 'palabra'=>'antecedente'),
array('letra'=>'a', 'palabra'=>'anteceder'),
array('letra'=>'a', 'palabra'=>'antecesor'),
array('letra'=>'a', 'palabra'=>'anteclasico'),
array('letra'=>'a', 'palabra'=>'anteco'),
array('letra'=>'a', 'palabra'=>'antecocina'),
array('letra'=>'a', 'palabra'=>'antecoger'),
array('letra'=>'a', 'palabra'=>'antecoro'),
array('letra'=>'a', 'palabra'=>'antecristo'),
array('letra'=>'a', 'palabra'=>'antecuarto'),
array('letra'=>'a', 'palabra'=>'antedata'),
array('letra'=>'a', 'palabra'=>'antedatar'),
array('letra'=>'a', 'palabra'=>'antedespacho'),
array('letra'=>'a', 'palabra'=>'antedia'),
array('letra'=>'a', 'palabra'=>'antedicho'),
array('letra'=>'a', 'palabra'=>'antediluviano'),
array('letra'=>'a', 'palabra'=>'anteferir'),
array('letra'=>'a', 'palabra'=>'antefija'),
array('letra'=>'a', 'palabra'=>'antefirma'),
array('letra'=>'a', 'palabra'=>'antefoso'),
array('letra'=>'a', 'palabra'=>'anteguerra'),
array('letra'=>'a', 'palabra'=>'antehistorico'),
array('letra'=>'a', 'palabra'=>'anteiglesia'),
array('letra'=>'a', 'palabra'=>'anteislamico'),
array('letra'=>'a', 'palabra'=>'antejardin'),
array('letra'=>'a', 'palabra'=>'antejo'),
array('letra'=>'a', 'palabra'=>'antejuicio'),
array('letra'=>'a', 'palabra'=>'antelacion'),
array('letra'=>'a', 'palabra'=>'antelar'),
array('letra'=>'a', 'palabra'=>'antelina'),
array('letra'=>'a', 'palabra'=>'antelucano'),
array('letra'=>'a', 'palabra'=>'antemano'),
array('letra'=>'a', 'palabra'=>'antemeridiano'),
array('letra'=>'a', 'palabra'=>'antemural'),
array('letra'=>'a', 'palabra'=>'antemuralla'),
array('letra'=>'a', 'palabra'=>'antemuro'),
array('letra'=>'a', 'palabra'=>'antena'),
array('letra'=>'a', 'palabra'=>'antenacido'),
array('letra'=>'a', 'palabra'=>'antenado'),
array('letra'=>'a', 'palabra'=>'antenista'),
array('letra'=>'a', 'palabra'=>'antenoche'),
array('letra'=>'a', 'palabra'=>'antenombre'),
array('letra'=>'a', 'palabra'=>'antenotar'),
array('letra'=>'a', 'palabra'=>'antenupcial'),
array('letra'=>'a', 'palabra'=>'anteojera'),
array('letra'=>'a', 'palabra'=>'anteojero'),
array('letra'=>'a', 'palabra'=>'anteojo'),
array('letra'=>'a', 'palabra'=>'anteojudo'),
array('letra'=>'a', 'palabra'=>'anteon'),
array('letra'=>'a', 'palabra'=>'antepagar'),
array('letra'=>'a', 'palabra'=>'antepalco'),
array('letra'=>'a', 'palabra'=>'antepasado'),
array('letra'=>'a', 'palabra'=>'antepasar'),
array('letra'=>'a', 'palabra'=>'antepechado'),
array('letra'=>'a', 'palabra'=>'antepecho'),
array('letra'=>'a', 'palabra'=>'antepenultimo'),
array('letra'=>'a', 'palabra'=>'antepie'),
array('letra'=>'a', 'palabra'=>'anteponer'),
array('letra'=>'a', 'palabra'=>'anteporta'),
array('letra'=>'a', 'palabra'=>'anteportada'),
array('letra'=>'a', 'palabra'=>'anteporton'),
array('letra'=>'a', 'palabra'=>'anteposicion'),
array('letra'=>'a', 'palabra'=>'anteproyecto'),
array('letra'=>'a', 'palabra'=>'antepuerta'),
array('letra'=>'a', 'palabra'=>'antepuerto'),
array('letra'=>'a', 'palabra'=>'antepuesto'),
array('letra'=>'a', 'palabra'=>'antequerano'),
array('letra'=>'a', 'palabra'=>'antequino'),
array('letra'=>'a', 'palabra'=>'antera'),
array('letra'=>'a', 'palabra'=>'anterior'),
array('letra'=>'a', 'palabra'=>'anterioridad'),
array('letra'=>'a', 'palabra'=>'anteriormente'),
array('letra'=>'a', 'palabra'=>'antero'),
array('letra'=>'a', 'palabra'=>'anterrollo'),
array('letra'=>'a', 'palabra'=>'antes'),
array('letra'=>'a', 'palabra'=>'antesacristia'),
array('letra'=>'a', 'palabra'=>'antesala'),
array('letra'=>'a', 'palabra'=>'anteseña'),
array('letra'=>'a', 'palabra'=>'antetecho'),
array('letra'=>'a', 'palabra'=>'antetemplo'),
array('letra'=>'a', 'palabra'=>'antetitulo'),
array('letra'=>'a', 'palabra'=>'antevedimiento'),
array('letra'=>'a', 'palabra'=>'antevenir'),
array('letra'=>'a', 'palabra'=>'antever'),
array('letra'=>'a', 'palabra'=>'anteviso'),
array('letra'=>'a', 'palabra'=>'antevispera'),
array('letra'=>'a', 'palabra'=>'antevisto'),
array('letra'=>'a', 'palabra'=>'antevocalico'),
array('letra'=>'a', 'palabra'=>'antia'),
array('letra'=>'a', 'palabra'=>'antiabortista'),
array('letra'=>'a', 'palabra'=>'antiacademico'),
array('letra'=>'a', 'palabra'=>'antiacido'),
array('letra'=>'a', 'palabra'=>'antiadherente'),
array('letra'=>'a', 'palabra'=>'antiaereo'),
array('letra'=>'a', 'palabra'=>'antiafrodisiaco'),
array('letra'=>'a', 'palabra'=>'antiafrodisiaco'),
array('letra'=>'a', 'palabra'=>'antialcali'),
array('letra'=>'a', 'palabra'=>'antialcalino'),
array('letra'=>'a', 'palabra'=>'antialcoholico'),
array('letra'=>'a', 'palabra'=>'antialergico'),
array('letra'=>'a', 'palabra'=>'antiartistico'),
array('letra'=>'a', 'palabra'=>'antiartritico'),
array('letra'=>'a', 'palabra'=>'antiasmatico'),
array('letra'=>'a', 'palabra'=>'antiatomico'),
array('letra'=>'a', 'palabra'=>'antibalas'),
array('letra'=>'a', 'palabra'=>'antibaquio'),
array('letra'=>'a', 'palabra'=>'antibiograma'),
array('letra'=>'a', 'palabra'=>'antibiotico'),
array('letra'=>'a', 'palabra'=>'anticanceroso'),
array('letra'=>'a', 'palabra'=>'anticanonico'),
array('letra'=>'a', 'palabra'=>'anticariense'),
array('letra'=>'a', 'palabra'=>'anticarro'),
array('letra'=>'a', 'palabra'=>'anticatodo'),
array('letra'=>'a', 'palabra'=>'anticatolico'),
array('letra'=>'a', 'palabra'=>'anticiclon'),
array('letra'=>'a', 'palabra'=>'anticiclonico'),
array('letra'=>'a', 'palabra'=>'anticientifico'),
array('letra'=>'a', 'palabra'=>'anticipacion'),
array('letra'=>'a', 'palabra'=>'anticipada'),
array('letra'=>'a', 'palabra'=>'anticipadamente'),
array('letra'=>'a', 'palabra'=>'anticipado'),
array('letra'=>'a', 'palabra'=>'anticipador'),
array('letra'=>'a', 'palabra'=>'anticipamiento'),
array('letra'=>'a', 'palabra'=>'anticipante'),
array('letra'=>'a', 'palabra'=>'anticipar'),
array('letra'=>'a', 'palabra'=>'anticipativamente'),
array('letra'=>'a', 'palabra'=>'anticipo'),
array('letra'=>'a', 'palabra'=>'anticlerical'),
array('letra'=>'a', 'palabra'=>'anticlericalismo'),
array('letra'=>'a', 'palabra'=>'anticlimax'),
array('letra'=>'a', 'palabra'=>'anticlinal'),
array('letra'=>'a', 'palabra'=>'anticolegialista'),
array('letra'=>'a', 'palabra'=>'anticolonial'),
array('letra'=>'a', 'palabra'=>'anticolonialista'),
array('letra'=>'a', 'palabra'=>'anticomunismo'),
array('letra'=>'a', 'palabra'=>'anticomunista'),
array('letra'=>'a', 'palabra'=>'anticoncepcion'),
array('letra'=>'a', 'palabra'=>'anticoncepcional'),
array('letra'=>'a', 'palabra'=>'anticoncepcionismo'),
array('letra'=>'a', 'palabra'=>'anticonceptivo'),
array('letra'=>'a', 'palabra'=>'anticongelante'),
array('letra'=>'a', 'palabra'=>'anticonstitucional'),
array('letra'=>'a', 'palabra'=>'anticorrosivo'),
array('letra'=>'a', 'palabra'=>'anticorrupcion'),
array('letra'=>'a', 'palabra'=>'anticresis'),
array('letra'=>'a', 'palabra'=>'anticresista'),
array('letra'=>'a', 'palabra'=>'anticretico'),
array('letra'=>'a', 'palabra'=>'anticristiano'),
array('letra'=>'a', 'palabra'=>'anticristo'),
array('letra'=>'a', 'palabra'=>'anticritico'),
array('letra'=>'a', 'palabra'=>'anticuado'),
array('letra'=>'a', 'palabra'=>'anticuar'),
array('letra'=>'a', 'palabra'=>'anticuario'),
array('letra'=>'a', 'palabra'=>'anticucho'),
array('letra'=>'a', 'palabra'=>'anticuco'),
array('letra'=>'a', 'palabra'=>'anticuerpo'),
array('letra'=>'a', 'palabra'=>'antidactilo'),
array('letra'=>'a', 'palabra'=>'antidemocratico'),
array('letra'=>'a', 'palabra'=>'antideportivo'),
array('letra'=>'a', 'palabra'=>'antidepresivo'),
array('letra'=>'a', 'palabra'=>'antideslizante'),
array('letra'=>'a', 'palabra'=>'antidetonante'),
array('letra'=>'a', 'palabra'=>'antidifterico'),
array('letra'=>'a', 'palabra'=>'antidinastico'),
array('letra'=>'a', 'palabra'=>'antidisturbios'),
array('letra'=>'a', 'palabra'=>'antidotario'),
array('letra'=>'a', 'palabra'=>'antidoto'),
array('letra'=>'a', 'palabra'=>'antidroga'),
array('letra'=>'a', 'palabra'=>'antiemetico'),
array('letra'=>'a', 'palabra'=>'antier'),
array('letra'=>'a', 'palabra'=>'antiescorbutico'),
array('letra'=>'a', 'palabra'=>'antiespasmodico'),
array('letra'=>'a', 'palabra'=>'antiespumante'),
array('letra'=>'a', 'palabra'=>'antiestatico'),
array('letra'=>'a', 'palabra'=>'antiestetico'),
array('letra'=>'a', 'palabra'=>'antifascismo'),
array('letra'=>'a', 'palabra'=>'antifascista'),
array('letra'=>'a', 'palabra'=>'antifaz'),
array('letra'=>'a', 'palabra'=>'antifebril'),
array('letra'=>'a', 'palabra'=>'antifeminismo'),
array('letra'=>'a', 'palabra'=>'antifeminista'),
array('letra'=>'a', 'palabra'=>'antiflogistico'),
array('letra'=>'a', 'palabra'=>'antifona'),
array('letra'=>'a', 'palabra'=>'antifonal'),
array('letra'=>'a', 'palabra'=>'antifonario'),
array('letra'=>'a', 'palabra'=>'antifonero'),
array('letra'=>'a', 'palabra'=>'antifrasis'),
array('letra'=>'a', 'palabra'=>'antifriccion'),
array('letra'=>'a', 'palabra'=>'antigas'),
array('letra'=>'a', 'palabra'=>'antigenico'),
array('letra'=>'a', 'palabra'=>'antigeno'),
array('letra'=>'a', 'palabra'=>'antigramatical'),
array('letra'=>'a', 'palabra'=>'antigripal'),
array('letra'=>'a', 'palabra'=>'antigualla'),
array('letra'=>'a', 'palabra'=>'antiguamente'),
array('letra'=>'a', 'palabra'=>'antiguamiento'),
array('letra'=>'a', 'palabra'=>'antiguar'),
array('letra'=>'a', 'palabra'=>'antigubernamental'),
array('letra'=>'a', 'palabra'=>'antigüedad'),
array('letra'=>'a', 'palabra'=>'antigüeño'),
array('letra'=>'a', 'palabra'=>'antiguo'),
array('letra'=>'a', 'palabra'=>'antihelmintico'),
array('letra'=>'a', 'palabra'=>'antiheroe'),
array('letra'=>'a', 'palabra'=>'antihidropico'),
array('letra'=>'a', 'palabra'=>'antihigienico'),
array('letra'=>'a', 'palabra'=>'antihipertensivo'),
array('letra'=>'a', 'palabra'=>'antihistaminico'),
array('letra'=>'a', 'palabra'=>'antihisterico'),
array('letra'=>'a', 'palabra'=>'antiimperialismo'),
array('letra'=>'a', 'palabra'=>'antiimperialista'),
array('letra'=>'a', 'palabra'=>'antiinflamatorio'),
array('letra'=>'a', 'palabra'=>'antijuridico'),
array('letra'=>'a', 'palabra'=>'antiliberal'),
array('letra'=>'a', 'palabra'=>'antiliberalismo'),
array('letra'=>'a', 'palabra'=>'antillano'),
array('letra'=>'a', 'palabra'=>'antillas'),
array('letra'=>'a', 'palabra'=>'antilogaritmo'),
array('letra'=>'a', 'palabra'=>'antilogia'),
array('letra'=>'a', 'palabra'=>'antilogico'),
array('letra'=>'a', 'palabra'=>'antilope'),
array('letra'=>'a', 'palabra'=>'antimacasar'),
array('letra'=>'a', 'palabra'=>'antimafia'),
array('letra'=>'a', 'palabra'=>'antimagnetico'),
array('letra'=>'a', 'palabra'=>'antimateria'),
array('letra'=>'a', 'palabra'=>'antimeridiano'),
array('letra'=>'a', 'palabra'=>'antimilitarismo'),
array('letra'=>'a', 'palabra'=>'antimilitarista'),
array('letra'=>'a', 'palabra'=>'antimisil'),
array('letra'=>'a', 'palabra'=>'antimonial'),
array('letra'=>'a', 'palabra'=>'antimonico'),
array('letra'=>'a', 'palabra'=>'antimonio'),
array('letra'=>'a', 'palabra'=>'antimonioso'),
array('letra'=>'a', 'palabra'=>'antimonita'),
array('letra'=>'a', 'palabra'=>'antimoniuro'),
array('letra'=>'a', 'palabra'=>'antimoral'),
array('letra'=>'a', 'palabra'=>'antinatural'),
array('letra'=>'a', 'palabra'=>'antineoplasico'),
array('letra'=>'a', 'palabra'=>'antineutrino'),
array('letra'=>'a', 'palabra'=>'antineutron'),
array('letra'=>'a', 'palabra'=>'antiniebla'),
array('letra'=>'a', 'palabra'=>'antinomia'),
array('letra'=>'a', 'palabra'=>'antinomico'),
array('letra'=>'a', 'palabra'=>'antinuclear'),
array('letra'=>'a', 'palabra'=>'antioqueno'),
array('letra'=>'a', 'palabra'=>'antioqueño'),
array('letra'=>'a', 'palabra'=>'antioxidante'),
array('letra'=>'a', 'palabra'=>'antipaludico'),
array('letra'=>'a', 'palabra'=>'antipapa'),
array('letra'=>'a', 'palabra'=>'antipapado'),
array('letra'=>'a', 'palabra'=>'antipapista'),
array('letra'=>'a', 'palabra'=>'antipara'),
array('letra'=>'a', 'palabra'=>'antiparasitario'),
array('letra'=>'a', 'palabra'=>'antiparero'),
array('letra'=>'a', 'palabra'=>'antiparlamentario'),
array('letra'=>'a', 'palabra'=>'antiparras'),
array('letra'=>'a', 'palabra'=>'antiparticula'),
array('letra'=>'a', 'palabra'=>'antipatia'),
array('letra'=>'a', 'palabra'=>'antipatico'),
array('letra'=>'a', 'palabra'=>'antipatizar'),
array('letra'=>'a', 'palabra'=>'antipatriota'),
array('letra'=>'a', 'palabra'=>'antipatriotico'),
array('letra'=>'a', 'palabra'=>'antipedagogico'),
array('letra'=>'a', 'palabra'=>'antipendio'),
array('letra'=>'a', 'palabra'=>'antiperistaltico'),
array('letra'=>'a', 'palabra'=>'antiperistasis'),
array('letra'=>'a', 'palabra'=>'antiperistatico'),
array('letra'=>'a', 'palabra'=>'antipiretico'),
array('letra'=>'a', 'palabra'=>'antipirina'),
array('letra'=>'a', 'palabra'=>'antipoda'),
array('letra'=>'a', 'palabra'=>'antipodia'),
array('letra'=>'a', 'palabra'=>'antipodio'),
array('letra'=>'a', 'palabra'=>'antipoetico'),
array('letra'=>'a', 'palabra'=>'antipontificado'),
array('letra'=>'a', 'palabra'=>'antiproton'),
array('letra'=>'a', 'palabra'=>'antiputrido'),
array('letra'=>'a', 'palabra'=>'antiquisimo'),
array('letra'=>'a', 'palabra'=>'antiquismo'),
array('letra'=>'a', 'palabra'=>'antirrabico'),
array('letra'=>'a', 'palabra'=>'antirreglamentario'),
array('letra'=>'a', 'palabra'=>'antirreligioso'),
array('letra'=>'a', 'palabra'=>'antirreumatico'),
array('letra'=>'a', 'palabra'=>'antirrobo'),
array('letra'=>'a', 'palabra'=>'antiscio'),
array('letra'=>'a', 'palabra'=>'antisemita'),
array('letra'=>'a', 'palabra'=>'antisemitico'),
array('letra'=>'a', 'palabra'=>'antisemitismo'),
array('letra'=>'a', 'palabra'=>'antisepsia'),
array('letra'=>'a', 'palabra'=>'antiseptico'),
array('letra'=>'a', 'palabra'=>'antisifilitico'),
array('letra'=>'a', 'palabra'=>'antisocial'),
array('letra'=>'a', 'palabra'=>'antispasto'),
array('letra'=>'a', 'palabra'=>'antistrofa'),
array('letra'=>'a', 'palabra'=>'antisubmarino'),
array('letra'=>'a', 'palabra'=>'antisudoral'),
array('letra'=>'a', 'palabra'=>'antisuero'),
array('letra'=>'a', 'palabra'=>'antitabaco'),
array('letra'=>'a', 'palabra'=>'antitanque'),
array('letra'=>'a', 'palabra'=>'antitermico'),
array('letra'=>'a', 'palabra'=>'antiterrorista'),
array('letra'=>'a', 'palabra'=>'antitesis'),
array('letra'=>'a', 'palabra'=>'antitetanico'),
array('letra'=>'a', 'palabra'=>'antitetico'),
array('letra'=>'a', 'palabra'=>'antitoxico'),
array('letra'=>'a', 'palabra'=>'antitoxina'),
array('letra'=>'a', 'palabra'=>'antitrago'),
array('letra'=>'a', 'palabra'=>'antitrinitario'),
array('letra'=>'a', 'palabra'=>'antituberculoso'),
array('letra'=>'a', 'palabra'=>'antitusigeno'),
array('letra'=>'a', 'palabra'=>'antivariolico'),
array('letra'=>'a', 'palabra'=>'antivenereo'),
array('letra'=>'a', 'palabra'=>'antivirus'),
array('letra'=>'a', 'palabra'=>'antociana'),
array('letra'=>'a', 'palabra'=>'antocianina'),
array('letra'=>'a', 'palabra'=>'antofagastino'),
array('letra'=>'a', 'palabra'=>'antofago'),
array('letra'=>'a', 'palabra'=>'antofilo'),
array('letra'=>'a', 'palabra'=>'antofilo'),
array('letra'=>'a', 'palabra'=>'antojadizamente'),
array('letra'=>'a', 'palabra'=>'antojadizo'),
array('letra'=>'a', 'palabra'=>'antojado'),
array('letra'=>'a', 'palabra'=>'antojamiento'),
array('letra'=>'a', 'palabra'=>'antojana'),
array('letra'=>'a', 'palabra'=>'antojanza'),
array('letra'=>'a', 'palabra'=>'antojarse'),
array('letra'=>'a', 'palabra'=>'antojera'),
array('letra'=>'a', 'palabra'=>'antojitos'),
array('letra'=>'a', 'palabra'=>'antojo'),
array('letra'=>'a', 'palabra'=>'antologia'),
array('letra'=>'a', 'palabra'=>'antologico'),
array('letra'=>'a', 'palabra'=>'antologo'),
array('letra'=>'a', 'palabra'=>'anton'),
array('letra'=>'a', 'palabra'=>'antoniano'),
array('letra'=>'a', 'palabra'=>'antonimia'),
array('letra'=>'a', 'palabra'=>'antonimo'),
array('letra'=>'a', 'palabra'=>'antoniniano'),
array('letra'=>'a', 'palabra'=>'antonino'),
array('letra'=>'a', 'palabra'=>'antonomasia'),
array('letra'=>'a', 'palabra'=>'antonomasticamente'),
array('letra'=>'a', 'palabra'=>'antonomastico'),
array('letra'=>'a', 'palabra'=>'antorcha'),
array('letra'=>'a', 'palabra'=>'antorchar'),
array('letra'=>'a', 'palabra'=>'antorchero'),
array('letra'=>'a', 'palabra'=>'antosta'),
array('letra'=>'a', 'palabra'=>'antozoo'),
array('letra'=>'a', 'palabra'=>'antracita'),
array('letra'=>'a', 'palabra'=>'antracosis'),
array('letra'=>'a', 'palabra'=>'antrax'),
array('letra'=>'a', 'palabra'=>'antro'),
array('letra'=>'a', 'palabra'=>'antropocentrico'),
array('letra'=>'a', 'palabra'=>'antropocentrismo'),
array('letra'=>'a', 'palabra'=>'antropofagia'),
array('letra'=>'a', 'palabra'=>'antropofago'),
array('letra'=>'a', 'palabra'=>'antropografia'),
array('letra'=>'a', 'palabra'=>'antropografico'),
array('letra'=>'a', 'palabra'=>'antropoide'),
array('letra'=>'a', 'palabra'=>'antropoideo'),
array('letra'=>'a', 'palabra'=>'antropologia'),
array('letra'=>'a', 'palabra'=>'antropologico'),
array('letra'=>'a', 'palabra'=>'antropologo'),
array('letra'=>'a', 'palabra'=>'antropometra'),
array('letra'=>'a', 'palabra'=>'antropometria'),
array('letra'=>'a', 'palabra'=>'antropometrico'),
array('letra'=>'a', 'palabra'=>'antropomorfico'),
array('letra'=>'a', 'palabra'=>'antropomorfismo'),
array('letra'=>'a', 'palabra'=>'antropomorfita'),
array('letra'=>'a', 'palabra'=>'antropomorfo'),
array('letra'=>'a', 'palabra'=>'antroponimia'),
array('letra'=>'a', 'palabra'=>'antroponimico'),
array('letra'=>'a', 'palabra'=>'antroponimo'),
array('letra'=>'a', 'palabra'=>'antropopiteco'),
array('letra'=>'a', 'palabra'=>'antroposofia'),
array('letra'=>'a', 'palabra'=>'antroposofo'),
array('letra'=>'a', 'palabra'=>'antropozoico'),
array('letra'=>'a', 'palabra'=>'antruejada'),
array('letra'=>'a', 'palabra'=>'antruejar'),
array('letra'=>'a', 'palabra'=>'antruejo'),
array('letra'=>'a', 'palabra'=>'antruido'),
array('letra'=>'a', 'palabra'=>'antuerpiense'),
array('letra'=>'a', 'palabra'=>'antuviado'),
array('letra'=>'a', 'palabra'=>'antuviador'),
array('letra'=>'a', 'palabra'=>'antuviar'),
array('letra'=>'a', 'palabra'=>'antuvio'),
array('letra'=>'a', 'palabra'=>'antuvion'),
array('letra'=>'a', 'palabra'=>'antuzano'),
array('letra'=>'a', 'palabra'=>'anual'),
array('letra'=>'a', 'palabra'=>'anualidad'),
array('letra'=>'a', 'palabra'=>'anualmente'),
array('letra'=>'a', 'palabra'=>'anuario'),
array('letra'=>'a', 'palabra'=>'anubada'),
array('letra'=>'a', 'palabra'=>'anubada'),
array('letra'=>'a', 'palabra'=>'anubado'),
array('letra'=>'a', 'palabra'=>'anubarrado'),
array('letra'=>'a', 'palabra'=>'anublar'),
array('letra'=>'a', 'palabra'=>'anublo'),
array('letra'=>'a', 'palabra'=>'anudador'),
array('letra'=>'a', 'palabra'=>'anudadura'),
array('letra'=>'a', 'palabra'=>'anudamiento'),
array('letra'=>'a', 'palabra'=>'anudar'),
array('letra'=>'a', 'palabra'=>'anuencia'),
array('letra'=>'a', 'palabra'=>'anuente'),
array('letra'=>'a', 'palabra'=>'anulable'),
array('letra'=>'a', 'palabra'=>'anulacion'),
array('letra'=>'a', 'palabra'=>'anulador'),
array('letra'=>'a', 'palabra'=>'anular'),
array('letra'=>'a', 'palabra'=>'anulativo'),
array('letra'=>'a', 'palabra'=>'anulete'),
array('letra'=>'a', 'palabra'=>'anulo'),
array('letra'=>'a', 'palabra'=>'anuloso'),
array('letra'=>'a', 'palabra'=>'anumeracion'),
array('letra'=>'a', 'palabra'=>'anumerar'),
array('letra'=>'a', 'palabra'=>'anuncia'),
array('letra'=>'a', 'palabra'=>'anunciacion'),
array('letra'=>'a', 'palabra'=>'anunciador'),
array('letra'=>'a', 'palabra'=>'anunciamiento'),
array('letra'=>'a', 'palabra'=>'anunciante'),
array('letra'=>'a', 'palabra'=>'anunciar'),
array('letra'=>'a', 'palabra'=>'anuncio'),
array('letra'=>'a', 'palabra'=>'anuo'),
array('letra'=>'a', 'palabra'=>'anuria'),
array('letra'=>'a', 'palabra'=>'anuro'),
array('letra'=>'a', 'palabra'=>'anuteba'),
array('letra'=>'a', 'palabra'=>'anverso'),
array('letra'=>'a', 'palabra'=>'anzoateguiense'),
array('letra'=>'a', 'palabra'=>'anzoatiguense'),
array('letra'=>'a', 'palabra'=>'anzolar'),
array('letra'=>'a', 'palabra'=>'anzolero'),
array('letra'=>'a', 'palabra'=>'anzuelo'),
array('letra'=>'a', 'palabra'=>'aña'),
array('letra'=>'a', 'palabra'=>'añacal'),
array('letra'=>'a', 'palabra'=>'añacalero'),
array('letra'=>'a', 'palabra'=>'añacea'),
array('letra'=>'a', 'palabra'=>'añacear'),
array('letra'=>'a', 'palabra'=>'añada'),
array('letra'=>'a', 'palabra'=>'añadido'),
array('letra'=>'a', 'palabra'=>'añadidura'),
array('letra'=>'a', 'palabra'=>'añadimiento'),
array('letra'=>'a', 'palabra'=>'añadir'),
array('letra'=>'a', 'palabra'=>'añafea'),
array('letra'=>'a', 'palabra'=>'añafil'),
array('letra'=>'a', 'palabra'=>'añafilero'),
array('letra'=>'a', 'palabra'=>'añagaza'),
array('letra'=>'a', 'palabra'=>'añal'),
array('letra'=>'a', 'palabra'=>'añalejo'),
array('letra'=>'a', 'palabra'=>'añangotarse'),
array('letra'=>'a', 'palabra'=>'añañay'),
array('letra'=>'a', 'palabra'=>'añares'),
array('letra'=>'a', 'palabra'=>'añas'),
array('letra'=>'a', 'palabra'=>'añas'),
array('letra'=>'a', 'palabra'=>'añascar'),
array('letra'=>'a', 'palabra'=>'añazme'),
array('letra'=>'a', 'palabra'=>'añedir'),
array('letra'=>'a', 'palabra'=>'añejado'),
array('letra'=>'a', 'palabra'=>'añejamiento'),
array('letra'=>'a', 'palabra'=>'añejar'),
array('letra'=>'a', 'palabra'=>'añejez'),
array('letra'=>'a', 'palabra'=>'añejo'),
array('letra'=>'a', 'palabra'=>'añero'),
array('letra'=>'a', 'palabra'=>'añicos'),
array('letra'=>'a', 'palabra'=>'añidir'),
array('letra'=>'a', 'palabra'=>'añil'),
array('letra'=>'a', 'palabra'=>'añilar'),
array('letra'=>'a', 'palabra'=>'añileria'),
array('letra'=>'a', 'palabra'=>'añinero'),
array('letra'=>'a', 'palabra'=>'añino'),
array('letra'=>'a', 'palabra'=>'añir'),
array('letra'=>'a', 'palabra'=>'año'),
array('letra'=>'a', 'palabra'=>'añoja'),
array('letra'=>'a', 'palabra'=>'añojada'),
array('letra'=>'a', 'palabra'=>'añojal'),
array('letra'=>'a', 'palabra'=>'añojo'),
array('letra'=>'a', 'palabra'=>'añoranza'),
array('letra'=>'a', 'palabra'=>'añorar'),
array('letra'=>'a', 'palabra'=>'añoso'),
array('letra'=>'a', 'palabra'=>'añublar'),
array('letra'=>'a', 'palabra'=>'añublo'),
array('letra'=>'a', 'palabra'=>'añudador'),
array('letra'=>'a', 'palabra'=>'añudadura'),
array('letra'=>'a', 'palabra'=>'añudamiento'),
array('letra'=>'a', 'palabra'=>'añudar'),
array('letra'=>'a', 'palabra'=>'añusgarse'),
array('letra'=>'a', 'palabra'=>'aocar'),
array('letra'=>'a', 'palabra'=>'aojador'),
array('letra'=>'a', 'palabra'=>'aojadura'),
array('letra'=>'a', 'palabra'=>'aojamiento'),
array('letra'=>'a', 'palabra'=>'aojar'),
array('letra'=>'a', 'palabra'=>'aojo'),
array('letra'=>'a', 'palabra'=>'aonides'),
array('letra'=>'a', 'palabra'=>'aonio'),
array('letra'=>'a', 'palabra'=>'aoristo'),
array('letra'=>'a', 'palabra'=>'aorta'),
array('letra'=>'a', 'palabra'=>'aortico'),
array('letra'=>'a', 'palabra'=>'aortitis'),
array('letra'=>'a', 'palabra'=>'aovado'),
array('letra'=>'a', 'palabra'=>'aovar'),
array('letra'=>'a', 'palabra'=>'aovillarse'),
array('letra'=>'a', 'palabra'=>'apa'),
array('letra'=>'a', 'palabra'=>'apabilado'),
array('letra'=>'a', 'palabra'=>'apabilar'),
array('letra'=>'a', 'palabra'=>'apabullamiento'),
array('letra'=>'a', 'palabra'=>'apabullante'),
array('letra'=>'a', 'palabra'=>'apabullar'),
array('letra'=>'a', 'palabra'=>'apabullo'),
array('letra'=>'a', 'palabra'=>'apacentadero'),
array('letra'=>'a', 'palabra'=>'apacentador'),
array('letra'=>'a', 'palabra'=>'apacentamiento'),
array('letra'=>'a', 'palabra'=>'apacentar'),
array('letra'=>'a', 'palabra'=>'apacer'),
array('letra'=>'a', 'palabra'=>'apachar'),
array('letra'=>'a', 'palabra'=>'apache'),
array('letra'=>'a', 'palabra'=>'apacheta'),
array('letra'=>'a', 'palabra'=>'apachurrar'),
array('letra'=>'a', 'palabra'=>'apacibilidad'),
array('letra'=>'a', 'palabra'=>'apacible'),
array('letra'=>'a', 'palabra'=>'apaciblemente'),
array('letra'=>'a', 'palabra'=>'apaciguador'),
array('letra'=>'a', 'palabra'=>'apaciguamiento'),
array('letra'=>'a', 'palabra'=>'apaciguar'),
array('letra'=>'a', 'palabra'=>'apacorral'),
array('letra'=>'a', 'palabra'=>'apadrinador'),
array('letra'=>'a', 'palabra'=>'apadrinamiento'),
array('letra'=>'a', 'palabra'=>'apadrinar'),
array('letra'=>'a', 'palabra'=>'apagable'),
array('letra'=>'a', 'palabra'=>'apagadizo'),
array('letra'=>'a', 'palabra'=>'apagado'),
array('letra'=>'a', 'palabra'=>'apagador'),
array('letra'=>'a', 'palabra'=>'apagamiento'),
array('letra'=>'a', 'palabra'=>'apagapenol'),
array('letra'=>'a', 'palabra'=>'apagar'),
array('letra'=>'a', 'palabra'=>'apagavelas'),
array('letra'=>'a', 'palabra'=>'apagon'),
array('letra'=>'a', 'palabra'=>'apainelado'),
array('letra'=>'a', 'palabra'=>'apaisado'),
array('letra'=>'a', 'palabra'=>'apalabrar'),
array('letra'=>'a', 'palabra'=>'apalambrar'),
array('letra'=>'a', 'palabra'=>'apalancamiento'),
array('letra'=>'a', 'palabra'=>'apalancar'),
array('letra'=>'a', 'palabra'=>'apaleador'),
array('letra'=>'a', 'palabra'=>'apaleamiento'),
array('letra'=>'a', 'palabra'=>'apalear'),
array('letra'=>'a', 'palabra'=>'apaleo'),
array('letra'=>'a', 'palabra'=>'apalmada'),
array('letra'=>'a', 'palabra'=>'apalpar'),
array('letra'=>'a', 'palabra'=>'apanado'),
array('letra'=>'a', 'palabra'=>'apanalado'),
array('letra'=>'a', 'palabra'=>'apancle'),
array('letra'=>'a', 'palabra'=>'apancora'),
array('letra'=>'a', 'palabra'=>'apandar'),
array('letra'=>'a', 'palabra'=>'apandillar'),
array('letra'=>'a', 'palabra'=>'apangado'),
array('letra'=>'a', 'palabra'=>'apaniaguado'),
array('letra'=>'a', 'palabra'=>'apaniguado'),
array('letra'=>'a', 'palabra'=>'apaniguar'),
array('letra'=>'a', 'palabra'=>'apanojado'),
array('letra'=>'a', 'palabra'=>'apantallado'),
array('letra'=>'a', 'palabra'=>'apantallar'),
array('letra'=>'a', 'palabra'=>'apantanar'),
array('letra'=>'a', 'palabra'=>'apante'),
array('letra'=>'a', 'palabra'=>'apantle'),
array('letra'=>'a', 'palabra'=>'apantuflado'),
array('letra'=>'a', 'palabra'=>'apañado'),
array('letra'=>'a', 'palabra'=>'apañador'),
array('letra'=>'a', 'palabra'=>'apañadura'),
array('letra'=>'a', 'palabra'=>'apañamiento'),
array('letra'=>'a', 'palabra'=>'apañar'),
array('letra'=>'a', 'palabra'=>'apaño'),
array('letra'=>'a', 'palabra'=>'apañuscador'),
array('letra'=>'a', 'palabra'=>'apañuscar'),
array('letra'=>'a', 'palabra'=>'apapachar'),
array('letra'=>'a', 'palabra'=>'apapacho'),
array('letra'=>'a', 'palabra'=>'apapagayado'),
array('letra'=>'a', 'palabra'=>'aparador'),
array('letra'=>'a', 'palabra'=>'aparadorista'),
array('letra'=>'a', 'palabra'=>'aparadura'),
array('letra'=>'a', 'palabra'=>'aparamento'),
array('letra'=>'a', 'palabra'=>'aparar'),
array('letra'=>'a', 'palabra'=>'aparasolado'),
array('letra'=>'a', 'palabra'=>'aparatar'),
array('letra'=>'a', 'palabra'=>'aparatero'),
array('letra'=>'a', 'palabra'=>'aparato'),
array('letra'=>'a', 'palabra'=>'aparatosamente'),
array('letra'=>'a', 'palabra'=>'aparatosidad'),
array('letra'=>'a', 'palabra'=>'aparatoso'),
array('letra'=>'a', 'palabra'=>'aparcacoches'),
array('letra'=>'a', 'palabra'=>'aparcadero'),
array('letra'=>'a', 'palabra'=>'aparcamiento'),
array('letra'=>'a', 'palabra'=>'aparcar'),
array('letra'=>'a', 'palabra'=>'aparceria'),
array('letra'=>'a', 'palabra'=>'aparcero'),
array('letra'=>'a', 'palabra'=>'aparcionero'),
array('letra'=>'a', 'palabra'=>'apareamiento'),
array('letra'=>'a', 'palabra'=>'aparear'),
array('letra'=>'a', 'palabra'=>'aparecer'),
array('letra'=>'a', 'palabra'=>'aparecido'),
array('letra'=>'a', 'palabra'=>'aparecimiento'),
array('letra'=>'a', 'palabra'=>'aparejadamente'),
array('letra'=>'a', 'palabra'=>'aparejado'),
array('letra'=>'a', 'palabra'=>'aparejador'),
array('letra'=>'a', 'palabra'=>'aparejamiento'),
array('letra'=>'a', 'palabra'=>'aparejar'),
array('letra'=>'a', 'palabra'=>'aparejo'),
array('letra'=>'a', 'palabra'=>'aparencial'),
array('letra'=>'a', 'palabra'=>'aparentador'),
array('letra'=>'a', 'palabra'=>'aparentar'),
array('letra'=>'a', 'palabra'=>'aparente'),
array('letra'=>'a', 'palabra'=>'aparentemente'),
array('letra'=>'a', 'palabra'=>'aparicion'),
array('letra'=>'a', 'palabra'=>'apariencia'),
array('letra'=>'a', 'palabra'=>'aparir'),
array('letra'=>'a', 'palabra'=>'aparrado'),
array('letra'=>'a', 'palabra'=>'aparragarse'),
array('letra'=>'a', 'palabra'=>'aparrar'),
array('letra'=>'a', 'palabra'=>'aparroquiado'),
array('letra'=>'a', 'palabra'=>'aparroquiar'),
array('letra'=>'a', 'palabra'=>'apartacion'),
array('letra'=>'a', 'palabra'=>'apartadamente'),
array('letra'=>'a', 'palabra'=>'apartadero'),
array('letra'=>'a', 'palabra'=>'apartadijo'),
array('letra'=>'a', 'palabra'=>'apartadizo'),
array('letra'=>'a', 'palabra'=>'apartado'),
array('letra'=>'a', 'palabra'=>'apartador'),
array('letra'=>'a', 'palabra'=>'apartamento'),
array('letra'=>'a', 'palabra'=>'apartamiento'),
array('letra'=>'a', 'palabra'=>'apartar'),
array('letra'=>'a', 'palabra'=>'aparte'),
array('letra'=>'a', 'palabra'=>'apartheid'),
array('letra'=>'a', 'palabra'=>'apartidar'),
array('letra'=>'a', 'palabra'=>'apartijo'),
array('letra'=>'a', 'palabra'=>'apartotel'),
array('letra'=>'a', 'palabra'=>'aparvadera'),
array('letra'=>'a', 'palabra'=>'aparvadero'),
array('letra'=>'a', 'palabra'=>'aparvador'),
array('letra'=>'a', 'palabra'=>'aparvar'),
array('letra'=>'a', 'palabra'=>'apasanca'),
array('letra'=>'a', 'palabra'=>'apasionadamente'),
array('letra'=>'a', 'palabra'=>'apasionado'),
array('letra'=>'a', 'palabra'=>'apasionamiento'),
array('letra'=>'a', 'palabra'=>'apasionante'),
array('letra'=>'a', 'palabra'=>'apasionar'),
array('letra'=>'a', 'palabra'=>'apastar'),
array('letra'=>'a', 'palabra'=>'apaste'),
array('letra'=>'a', 'palabra'=>'apastle'),
array('letra'=>'a', 'palabra'=>'apastragarse'),
array('letra'=>'a', 'palabra'=>'apastrarse'),
array('letra'=>'a', 'palabra'=>'apasturar'),
array('letra'=>'a', 'palabra'=>'apatan'),
array('letra'=>'a', 'palabra'=>'apatanado'),
array('letra'=>'a', 'palabra'=>'apatia'),
array('letra'=>'a', 'palabra'=>'apatico'),
array('letra'=>'a', 'palabra'=>'apatrida'),
array('letra'=>'a', 'palabra'=>'apatrocinar'),
array('letra'=>'a', 'palabra'=>'apatusca'),
array('letra'=>'a', 'palabra'=>'apatusco'),
array('letra'=>'a', 'palabra'=>'apaularse'),
array('letra'=>'a', 'palabra'=>'apaulillarse'),
array('letra'=>'a', 'palabra'=>'apayasar'),
array('letra'=>'a', 'palabra'=>'apazguado'),
array('letra'=>'a', 'palabra'=>'apea'),
array('letra'=>'a', 'palabra'=>'apeadero'),
array('letra'=>'a', 'palabra'=>'apeador'),
array('letra'=>'a', 'palabra'=>'apealar'),
array('letra'=>'a', 'palabra'=>'apeamiento'),
array('letra'=>'a', 'palabra'=>'apear'),
array('letra'=>'a', 'palabra'=>'apechar'),
array('letra'=>'a', 'palabra'=>'apechugar'),
array('letra'=>'a', 'palabra'=>'apedazar'),
array('letra'=>'a', 'palabra'=>'apedernalado'),
array('letra'=>'a', 'palabra'=>'apedrar'),
array('letra'=>'a', 'palabra'=>'apedrea'),
array('letra'=>'a', 'palabra'=>'apedreadero'),
array('letra'=>'a', 'palabra'=>'apedreado'),
array('letra'=>'a', 'palabra'=>'apedreador'),
array('letra'=>'a', 'palabra'=>'apedreamiento'),
array('letra'=>'a', 'palabra'=>'apedrear'),
array('letra'=>'a', 'palabra'=>'apedreo'),
array('letra'=>'a', 'palabra'=>'apegadamente'),
array('letra'=>'a', 'palabra'=>'apegaderas'),
array('letra'=>'a', 'palabra'=>'apegadizo'),
array('letra'=>'a', 'palabra'=>'apegamiento'),
array('letra'=>'a', 'palabra'=>'apegar'),
array('letra'=>'a', 'palabra'=>'apego'),
array('letra'=>'a', 'palabra'=>'apegualar'),
array('letra'=>'a', 'palabra'=>'apelable'),
array('letra'=>'a', 'palabra'=>'apelacion'),
array('letra'=>'a', 'palabra'=>'apelado'),
array('letra'=>'a', 'palabra'=>'apelambrar'),
array('letra'=>'a', 'palabra'=>'apelante'),
array('letra'=>'a', 'palabra'=>'apelar'),
array('letra'=>'a', 'palabra'=>'apelativo'),
array('letra'=>'a', 'palabra'=>'apeldar'),
array('letra'=>'a', 'palabra'=>'apelde'),
array('letra'=>'a', 'palabra'=>'apelgararse'),
array('letra'=>'a', 'palabra'=>'apeligrar'),
array('letra'=>'a', 'palabra'=>'apellar'),
array('letra'=>'a', 'palabra'=>'apellidador'),
array('letra'=>'a', 'palabra'=>'apellidamiento'),
array('letra'=>'a', 'palabra'=>'apellidar'),
array('letra'=>'a', 'palabra'=>'apellidero'),
array('letra'=>'a', 'palabra'=>'apellido'),
array('letra'=>'a', 'palabra'=>'apelmazadamente'),
array('letra'=>'a', 'palabra'=>'apelmazado'),
array('letra'=>'a', 'palabra'=>'apelmazar'),
array('letra'=>'a', 'palabra'=>'apelotonar'),
array('letra'=>'a', 'palabra'=>'apena'),
array('letra'=>'a', 'palabra'=>'apenar'),
array('letra'=>'a', 'palabra'=>'apenas'),
array('letra'=>'a', 'palabra'=>'apencar'),
array('letra'=>'a', 'palabra'=>'apendejar'),
array('letra'=>'a', 'palabra'=>'apendencia'),
array('letra'=>'a', 'palabra'=>'apendice'),
array('letra'=>'a', 'palabra'=>'apendicitis'),
array('letra'=>'a', 'palabra'=>'apendicular'),
array('letra'=>'a', 'palabra'=>'apensionar'),
array('letra'=>'a', 'palabra'=>'apeñuscar'),
array('letra'=>'a', 'palabra'=>'apeo'),
array('letra'=>'a', 'palabra'=>'apeonar'),
array('letra'=>'a', 'palabra'=>'apepsia'),
array('letra'=>'a', 'palabra'=>'aperado'),
array('letra'=>'a', 'palabra'=>'aperador'),
array('letra'=>'a', 'palabra'=>'aperar'),
array('letra'=>'a', 'palabra'=>'apercancar'),
array('letra'=>'a', 'palabra'=>'apercebimiento'),
array('letra'=>'a', 'palabra'=>'apercebir'),
array('letra'=>'a', 'palabra'=>'apercepcion'),
array('letra'=>'a', 'palabra'=>'aperchar'),
array('letra'=>'a', 'palabra'=>'apercibimiento'),
array('letra'=>'a', 'palabra'=>'apercibir'),
array('letra'=>'a', 'palabra'=>'apercibo'),
array('letra'=>'a', 'palabra'=>'apercion'),
array('letra'=>'a', 'palabra'=>'apercollar'),
array('letra'=>'a', 'palabra'=>'aperdigar'),
array('letra'=>'a', 'palabra'=>'aperea'),
array('letra'=>'a', 'palabra'=>'apergaminado'),
array('letra'=>'a', 'palabra'=>'apergaminarse'),
array('letra'=>'a', 'palabra'=>'apergollar'),
array('letra'=>'a', 'palabra'=>'aperital'),
array('letra'=>'a', 'palabra'=>'aperitivo'),
array('letra'=>'a', 'palabra'=>'aperlado'),
array('letra'=>'a', 'palabra'=>'apernador'),
array('letra'=>'a', 'palabra'=>'apernar'),
array('letra'=>'a', 'palabra'=>'apero'),
array('letra'=>'a', 'palabra'=>'aperreado'),
array('letra'=>'a', 'palabra'=>'aperreador'),
array('letra'=>'a', 'palabra'=>'aperrear'),
array('letra'=>'a', 'palabra'=>'aperreo'),
array('letra'=>'a', 'palabra'=>'apersogar'),
array('letra'=>'a', 'palabra'=>'apersonado'),
array('letra'=>'a', 'palabra'=>'apersonamiento'),
array('letra'=>'a', 'palabra'=>'apersonarse'),
array('letra'=>'a', 'palabra'=>'apertar'),
array('letra'=>'a', 'palabra'=>'apertura'),
array('letra'=>'a', 'palabra'=>'aperturismo'),
array('letra'=>'a', 'palabra'=>'aperturista'),
array('letra'=>'a', 'palabra'=>'apesadumbrar'),
array('letra'=>'a', 'palabra'=>'apesaradamente'),
array('letra'=>'a', 'palabra'=>'apesarar'),
array('letra'=>'a', 'palabra'=>'apesgamiento'),
array('letra'=>'a', 'palabra'=>'apesgar'),
array('letra'=>'a', 'palabra'=>'apestar'),
array('letra'=>'a', 'palabra'=>'apestillar'),
array('letra'=>'a', 'palabra'=>'apestoso'),
array('letra'=>'a', 'palabra'=>'apetalo'),
array('letra'=>'a', 'palabra'=>'apetecedor'),
array('letra'=>'a', 'palabra'=>'apetecer'),
array('letra'=>'a', 'palabra'=>'apetecible'),
array('letra'=>'a', 'palabra'=>'apetencia'),
array('letra'=>'a', 'palabra'=>'apetente'),
array('letra'=>'a', 'palabra'=>'apetite'),
array('letra'=>'a', 'palabra'=>'apetitivo'),
array('letra'=>'a', 'palabra'=>'apetito'),
array('letra'=>'a', 'palabra'=>'apetitoso'),
array('letra'=>'a', 'palabra'=>'apex'),
array('letra'=>'a', 'palabra'=>'apezonado'),
array('letra'=>'a', 'palabra'=>'apezuñar'),
array('letra'=>'a', 'palabra'=>'api'),
array('letra'=>'a', 'palabra'=>'apiadador'),
array('letra'=>'a', 'palabra'=>'apiadar'),
array('letra'=>'a', 'palabra'=>'apianar'),
array('letra'=>'a', 'palabra'=>'apiaradero'),
array('letra'=>'a', 'palabra'=>'apiario'),
array('letra'=>'a', 'palabra'=>'apiastro'),
array('letra'=>'a', 'palabra'=>'apical'),
array('letra'=>'a', 'palabra'=>'apicararse'),
array('letra'=>'a', 'palabra'=>'apice'),
array('letra'=>'a', 'palabra'=>'apichonado'),
array('letra'=>'a', 'palabra'=>'apicola'),
array('letra'=>'a', 'palabra'=>'apiculo'),
array('letra'=>'a', 'palabra'=>'apicultor'),
array('letra'=>'a', 'palabra'=>'apicultura'),
array('letra'=>'a', 'palabra'=>'apilada'),
array('letra'=>'a', 'palabra'=>'apilador'),
array('letra'=>'a', 'palabra'=>'apilamiento'),
array('letra'=>'a', 'palabra'=>'apilar'),
array('letra'=>'a', 'palabra'=>'apimpollarse'),
array('letra'=>'a', 'palabra'=>'apiñado'),
array('letra'=>'a', 'palabra'=>'apiñadura'),
array('letra'=>'a', 'palabra'=>'apiñamiento'),
array('letra'=>'a', 'palabra'=>'apiñar'),
array('letra'=>'a', 'palabra'=>'apiñonado'),
array('letra'=>'a', 'palabra'=>'apio'),
array('letra'=>'a', 'palabra'=>'apiojarse'),
array('letra'=>'a', 'palabra'=>'apiolar'),
array('letra'=>'a', 'palabra'=>'apiparse'),
array('letra'=>'a', 'palabra'=>'apiporrarse'),
array('letra'=>'a', 'palabra'=>'apiretico'),
array('letra'=>'a', 'palabra'=>'apirexia'),
array('letra'=>'a', 'palabra'=>'apirgüinarse'),
array('letra'=>'a', 'palabra'=>'apiri'),
array('letra'=>'a', 'palabra'=>'apirularse'),
array('letra'=>'a', 'palabra'=>'apisonado'),
array('letra'=>'a', 'palabra'=>'apisonadora'),
array('letra'=>'a', 'palabra'=>'apisonamiento'),
array('letra'=>'a', 'palabra'=>'apisonar'),
array('letra'=>'a', 'palabra'=>'apitar'),
array('letra'=>'a', 'palabra'=>'apitonado'),
array('letra'=>'a', 'palabra'=>'apitonamiento'),
array('letra'=>'a', 'palabra'=>'apitonar'),
array('letra'=>'a', 'palabra'=>'apizarrado'),
array('letra'=>'a', 'palabra'=>'aplacable'),
array('letra'=>'a', 'palabra'=>'aplacacion'),
array('letra'=>'a', 'palabra'=>'aplacador'),
array('letra'=>'a', 'palabra'=>'aplacamiento'),
array('letra'=>'a', 'palabra'=>'aplacar'),
array('letra'=>'a', 'palabra'=>'aplacentar'),
array('letra'=>'a', 'palabra'=>'aplacer'),
array('letra'=>'a', 'palabra'=>'aplacerado'),
array('letra'=>'a', 'palabra'=>'aplacible'),
array('letra'=>'a', 'palabra'=>'aplaciente'),
array('letra'=>'a', 'palabra'=>'aplacimiento'),
array('letra'=>'a', 'palabra'=>'aplagar'),
array('letra'=>'a', 'palabra'=>'aplanacalles'),
array('letra'=>'a', 'palabra'=>'aplanadera'),
array('letra'=>'a', 'palabra'=>'aplanador'),
array('letra'=>'a', 'palabra'=>'aplanamiento'),
array('letra'=>'a', 'palabra'=>'aplanar'),
array('letra'=>'a', 'palabra'=>'aplanchado'),
array('letra'=>'a', 'palabra'=>'aplanchador'),
array('letra'=>'a', 'palabra'=>'aplanchar'),
array('letra'=>'a', 'palabra'=>'aplanetico'),
array('letra'=>'a', 'palabra'=>'aplantillar'),
array('letra'=>'a', 'palabra'=>'aplasia'),
array('letra'=>'a', 'palabra'=>'aplastamiento'),
array('letra'=>'a', 'palabra'=>'aplastante'),
array('letra'=>'a', 'palabra'=>'aplastar'),
array('letra'=>'a', 'palabra'=>'aplatanado'),
array('letra'=>'a', 'palabra'=>'aplatanamiento'),
array('letra'=>'a', 'palabra'=>'aplatanar'),
array('letra'=>'a', 'palabra'=>'aplaudidor'),
array('letra'=>'a', 'palabra'=>'aplaudir'),
array('letra'=>'a', 'palabra'=>'aplauso'),
array('letra'=>'a', 'palabra'=>'aplayar'),
array('letra'=>'a', 'palabra'=>'aplazable'),
array('letra'=>'a', 'palabra'=>'aplazado'),
array('letra'=>'a', 'palabra'=>'aplazamiento'),
array('letra'=>'a', 'palabra'=>'aplazar'),
array('letra'=>'a', 'palabra'=>'aplebeyar'),
array('letra'=>'a', 'palabra'=>'aplegar'),
array('letra'=>'a', 'palabra'=>'aplicabilidad'),
array('letra'=>'a', 'palabra'=>'aplicable'),
array('letra'=>'a', 'palabra'=>'aplicacion'),
array('letra'=>'a', 'palabra'=>'aplicadero'),
array('letra'=>'a', 'palabra'=>'aplicado'),
array('letra'=>'a', 'palabra'=>'aplicar'),
array('letra'=>'a', 'palabra'=>'aplicativo'),
array('letra'=>'a', 'palabra'=>'aplique'),
array('letra'=>'a', 'palabra'=>'aplomado'),
array('letra'=>'a', 'palabra'=>'aplomar'),
array('letra'=>'a', 'palabra'=>'aplomo'),
array('letra'=>'a', 'palabra'=>'apnea'),
array('letra'=>'a', 'palabra'=>'apoastro'),
array('letra'=>'a', 'palabra'=>'apocadamente'),
array('letra'=>'a', 'palabra'=>'apocado'),
array('letra'=>'a', 'palabra'=>'apocador'),
array('letra'=>'a', 'palabra'=>'apocalipsis'),
array('letra'=>'a', 'palabra'=>'apocaliptico'),
array('letra'=>'a', 'palabra'=>'apocamiento'),
array('letra'=>'a', 'palabra'=>'apocar'),
array('letra'=>'a', 'palabra'=>'apocatastasis'),
array('letra'=>'a', 'palabra'=>'apocema'),
array('letra'=>'a', 'palabra'=>'apocima'),
array('letra'=>'a', 'palabra'=>'apocinaceo'),
array('letra'=>'a', 'palabra'=>'apocopa'),
array('letra'=>'a', 'palabra'=>'apocopar'),
array('letra'=>'a', 'palabra'=>'apocope'),
array('letra'=>'a', 'palabra'=>'apocoyado'),
array('letra'=>'a', 'palabra'=>'apocrifamente'),
array('letra'=>'a', 'palabra'=>'apocrifo'),
array('letra'=>'a', 'palabra'=>'apocrisiario'),
array('letra'=>'a', 'palabra'=>'apocromatico'),
array('letra'=>'a', 'palabra'=>'apodador'),
array('letra'=>'a', 'palabra'=>'apodamiento'),
array('letra'=>'a', 'palabra'=>'apodar'),
array('letra'=>'a', 'palabra'=>'apodencado'),
array('letra'=>'a', 'palabra'=>'apoderadamente'),
array('letra'=>'a', 'palabra'=>'apoderado'),
array('letra'=>'a', 'palabra'=>'apoderamiento'),
array('letra'=>'a', 'palabra'=>'apoderar'),
array('letra'=>'a', 'palabra'=>'apodictico'),
array('letra'=>'a', 'palabra'=>'apodo'),
array('letra'=>'a', 'palabra'=>'apodo'),
array('letra'=>'a', 'palabra'=>'apodosis'),
array('letra'=>'a', 'palabra'=>'apofige'),
array('letra'=>'a', 'palabra'=>'apofisis'),
array('letra'=>'a', 'palabra'=>'apofonia'),
array('letra'=>'a', 'palabra'=>'apogeo'),
array('letra'=>'a', 'palabra'=>'apografo'),
array('letra'=>'a', 'palabra'=>'apoleño'),
array('letra'=>'a', 'palabra'=>'apolillado'),
array('letra'=>'a', 'palabra'=>'apolilladura'),
array('letra'=>'a', 'palabra'=>'apolillamiento'),
array('letra'=>'a', 'palabra'=>'apolillar'),
array('letra'=>'a', 'palabra'=>'apolinar'),
array('letra'=>'a', 'palabra'=>'apolinarismo'),
array('letra'=>'a', 'palabra'=>'apolinarista'),
array('letra'=>'a', 'palabra'=>'apolineo'),
array('letra'=>'a', 'palabra'=>'apolismar'),
array('letra'=>'a', 'palabra'=>'apolismarse'),
array('letra'=>'a', 'palabra'=>'apoliticismo'),
array('letra'=>'a', 'palabra'=>'apolitico'),
array('letra'=>'a', 'palabra'=>'apologetico'),
array('letra'=>'a', 'palabra'=>'apologia'),
array('letra'=>'a', 'palabra'=>'apologico'),
array('letra'=>'a', 'palabra'=>'apologista'),
array('letra'=>'a', 'palabra'=>'apologizar'),
array('letra'=>'a', 'palabra'=>'apologo'),
array('letra'=>'a', 'palabra'=>'apolonida'),
array('letra'=>'a', 'palabra'=>'apolonida'),
array('letra'=>'a', 'palabra'=>'apoltronamiento'),
array('letra'=>'a', 'palabra'=>'apoltronarse'),
array('letra'=>'a', 'palabra'=>'apolvillarse'),
array('letra'=>'a', 'palabra'=>'apomazar'),
array('letra'=>'a', 'palabra'=>'aponer'),
array('letra'=>'a', 'palabra'=>'aponeurosis'),
array('letra'=>'a', 'palabra'=>'aponeurotico'),
array('letra'=>'a', 'palabra'=>'apontocar'),
array('letra'=>'a', 'palabra'=>'aponzoñar'),
array('letra'=>'a', 'palabra'=>'apoplejia'),
array('letra'=>'a', 'palabra'=>'apoplejico'),
array('letra'=>'a', 'palabra'=>'apopletico'),
array('letra'=>'a', 'palabra'=>'apoquinar'),
array('letra'=>'a', 'palabra'=>'aporca'),
array('letra'=>'a', 'palabra'=>'aporcador'),
array('letra'=>'a', 'palabra'=>'aporcadura'),
array('letra'=>'a', 'palabra'=>'aporcar'),
array('letra'=>'a', 'palabra'=>'aporco'),
array('letra'=>'a', 'palabra'=>'aporia'),
array('letra'=>'a', 'palabra'=>'aporisma'),
array('letra'=>'a', 'palabra'=>'aporismarse'),
array('letra'=>'a', 'palabra'=>'aporque'),
array('letra'=>'a', 'palabra'=>'aporracear'),
array('letra'=>'a', 'palabra'=>'aporrar'),
array('letra'=>'a', 'palabra'=>'aporrarse'),
array('letra'=>'a', 'palabra'=>'aporreado'),
array('letra'=>'a', 'palabra'=>'aporreador'),
array('letra'=>'a', 'palabra'=>'aporreadura'),
array('letra'=>'a', 'palabra'=>'aporreamiento'),
array('letra'=>'a', 'palabra'=>'aporrear'),
array('letra'=>'a', 'palabra'=>'aporreo'),
array('letra'=>'a', 'palabra'=>'aporretado'),
array('letra'=>'a', 'palabra'=>'aporrillarse'),
array('letra'=>'a', 'palabra'=>'aportacion'),
array('letra'=>'a', 'palabra'=>'aportadera'),
array('letra'=>'a', 'palabra'=>'aportadero'),
array('letra'=>'a', 'palabra'=>'aportar'),
array('letra'=>'a', 'palabra'=>'aporte'),
array('letra'=>'a', 'palabra'=>'aportellado'),
array('letra'=>'a', 'palabra'=>'aportillado'),
array('letra'=>'a', 'palabra'=>'aportillar'),
array('letra'=>'a', 'palabra'=>'apos'),
array('letra'=>'a', 'palabra'=>'aposar'),
array('letra'=>'a', 'palabra'=>'aposentador'),
array('letra'=>'a', 'palabra'=>'aposentaduria'),
array('letra'=>'a', 'palabra'=>'aposentamiento'),
array('letra'=>'a', 'palabra'=>'aposentar'),
array('letra'=>'a', 'palabra'=>'aposento'),
array('letra'=>'a', 'palabra'=>'aposesionado'),
array('letra'=>'a', 'palabra'=>'aposesionar'),
array('letra'=>'a', 'palabra'=>'aposicion'),
array('letra'=>'a', 'palabra'=>'apositivo'),
array('letra'=>'a', 'palabra'=>'aposito'),
array('letra'=>'a', 'palabra'=>'aposta'),
array('letra'=>'a', 'palabra'=>'apostadamente'),
array('letra'=>'a', 'palabra'=>'apostadero'),
array('letra'=>'a', 'palabra'=>'apostante'),
array('letra'=>'a', 'palabra'=>'apostar'),
array('letra'=>'a', 'palabra'=>'apostasia'),
array('letra'=>'a', 'palabra'=>'apostata'),
array('letra'=>'a', 'palabra'=>'apostatar'),
array('letra'=>'a', 'palabra'=>'apostema'),
array('letra'=>'a', 'palabra'=>'apostemacion'),
array('letra'=>'a', 'palabra'=>'apostemar'),
array('letra'=>'a', 'palabra'=>'apostemero'),
array('letra'=>'a', 'palabra'=>'apostemoso'),
array('letra'=>'a', 'palabra'=>'apostilla'),
array('letra'=>'a', 'palabra'=>'apostillar'),
array('letra'=>'a', 'palabra'=>'apostillarse'),
array('letra'=>'a', 'palabra'=>'apostizo'),
array('letra'=>'a', 'palabra'=>'apostol'),
array('letra'=>'a', 'palabra'=>'apostolado'),
array('letra'=>'a', 'palabra'=>'apostolazgo'),
array('letra'=>'a', 'palabra'=>'apostolical'),
array('letra'=>'a', 'palabra'=>'apostolicamente'),
array('letra'=>'a', 'palabra'=>'apostolicidad'),
array('letra'=>'a', 'palabra'=>'apostolico'),
array('letra'=>'a', 'palabra'=>'apostoligo'),
array('letra'=>'a', 'palabra'=>'apostolo'),
array('letra'=>'a', 'palabra'=>'apostrofar'),
array('letra'=>'a', 'palabra'=>'apostrofe'),
array('letra'=>'a', 'palabra'=>'apostrofo'),
array('letra'=>'a', 'palabra'=>'apostura'),
array('letra'=>'a', 'palabra'=>'apoteca'),
array('letra'=>'a', 'palabra'=>'apotecario'),
array('letra'=>'a', 'palabra'=>'apotegma'),
array('letra'=>'a', 'palabra'=>'apotema'),
array('letra'=>'a', 'palabra'=>'apoteosico'),
array('letra'=>'a', 'palabra'=>'apoteosis'),
array('letra'=>'a', 'palabra'=>'apoteotico'),
array('letra'=>'a', 'palabra'=>'apoticario'),
array('letra'=>'a', 'palabra'=>'apotrerar'),
array('letra'=>'a', 'palabra'=>'apoyadero'),
array('letra'=>'a', 'palabra'=>'apoyadura'),
array('letra'=>'a', 'palabra'=>'apoyar'),
array('letra'=>'a', 'palabra'=>'apoyatura'),
array('letra'=>'a', 'palabra'=>'apoyo'),
array('letra'=>'a', 'palabra'=>'apozarse'),
array('letra'=>'a', 'palabra'=>'apraxia'),
array('letra'=>'a', 'palabra'=>'apreciabilidad'),
array('letra'=>'a', 'palabra'=>'apreciable'),
array('letra'=>'a', 'palabra'=>'apreciacion'),
array('letra'=>'a', 'palabra'=>'apreciadamente'),
array('letra'=>'a', 'palabra'=>'apreciador'),
array('letra'=>'a', 'palabra'=>'apreciar'),
array('letra'=>'a', 'palabra'=>'apreciativo'),
array('letra'=>'a', 'palabra'=>'aprecio'),
array('letra'=>'a', 'palabra'=>'aprehender'),
array('letra'=>'a', 'palabra'=>'aprehension'),
array('letra'=>'a', 'palabra'=>'aprehensivo'),
array('letra'=>'a', 'palabra'=>'aprehensor'),
array('letra'=>'a', 'palabra'=>'aprehensorio'),
array('letra'=>'a', 'palabra'=>'apremiadamente'),
array('letra'=>'a', 'palabra'=>'apremiador'),
array('letra'=>'a', 'palabra'=>'apremiamiento'),
array('letra'=>'a', 'palabra'=>'apremiante'),
array('letra'=>'a', 'palabra'=>'apremiantemente'),
array('letra'=>'a', 'palabra'=>'apremiar'),
array('letra'=>'a', 'palabra'=>'apremio'),
array('letra'=>'a', 'palabra'=>'apremir'),
array('letra'=>'a', 'palabra'=>'aprendedor'),
array('letra'=>'a', 'palabra'=>'aprender'),
array('letra'=>'a', 'palabra'=>'aprendiente'),
array('letra'=>'a', 'palabra'=>'aprendiz'),
array('letra'=>'a', 'palabra'=>'aprendizaje'),
array('letra'=>'a', 'palabra'=>'aprensador'),
array('letra'=>'a', 'palabra'=>'aprensadura'),
array('letra'=>'a', 'palabra'=>'aprensar'),
array('letra'=>'a', 'palabra'=>'aprension'),
array('letra'=>'a', 'palabra'=>'aprensivo'),
array('letra'=>'a', 'palabra'=>'apres'),
array('letra'=>'a', 'palabra'=>'apresador'),
array('letra'=>'a', 'palabra'=>'apresamiento'),
array('letra'=>'a', 'palabra'=>'apresar'),
array('letra'=>'a', 'palabra'=>'apresivamente'),
array('letra'=>'a', 'palabra'=>'apreso'),
array('letra'=>'a', 'palabra'=>'aprestar'),
array('letra'=>'a', 'palabra'=>'aprestigiar'),
array('letra'=>'a', 'palabra'=>'apresto'),
array('letra'=>'a', 'palabra'=>'apresura'),
array('letra'=>'a', 'palabra'=>'apresuracion'),
array('letra'=>'a', 'palabra'=>'apresurado'),
array('letra'=>'a', 'palabra'=>'apresuramiento'),
array('letra'=>'a', 'palabra'=>'apresurar'),
array('letra'=>'a', 'palabra'=>'apretadamente'),
array('letra'=>'a', 'palabra'=>'apretadero'),
array('letra'=>'a', 'palabra'=>'apretadizo'),
array('letra'=>'a', 'palabra'=>'apretado'),
array('letra'=>'a', 'palabra'=>'apretador'),
array('letra'=>'a', 'palabra'=>'apretadura'),
array('letra'=>'a', 'palabra'=>'apretamiento'),
array('letra'=>'a', 'palabra'=>'apretar'),
array('letra'=>'a', 'palabra'=>'apreton'),
array('letra'=>'a', 'palabra'=>'apretujamiento'),
array('letra'=>'a', 'palabra'=>'apretujar'),
array('letra'=>'a', 'palabra'=>'apretujon'),
array('letra'=>'a', 'palabra'=>'apretura'),
array('letra'=>'a', 'palabra'=>'aprevenir'),
array('letra'=>'a', 'palabra'=>'apriesa'),
array('letra'=>'a', 'palabra'=>'aprieto'),
array('letra'=>'a', 'palabra'=>'aprimar'),
array('letra'=>'a', 'palabra'=>'apriorismo'),
array('letra'=>'a', 'palabra'=>'aprioristico'),
array('letra'=>'a', 'palabra'=>'aprisa'),
array('letra'=>'a', 'palabra'=>'apriscar'),
array('letra'=>'a', 'palabra'=>'aprisco'),
array('letra'=>'a', 'palabra'=>'aprisionamiento'),
array('letra'=>'a', 'palabra'=>'aprisionar'),
array('letra'=>'a', 'palabra'=>'aproar'),
array('letra'=>'a', 'palabra'=>'aprobacion'),
array('letra'=>'a', 'palabra'=>'aprobado'),
array('letra'=>'a', 'palabra'=>'aprobador'),
array('letra'=>'a', 'palabra'=>'aprobante'),
array('letra'=>'a', 'palabra'=>'aprobanza'),
array('letra'=>'a', 'palabra'=>'aprobar'),
array('letra'=>'a', 'palabra'=>'aprobativo'),
array('letra'=>'a', 'palabra'=>'aprobatorio'),
array('letra'=>'a', 'palabra'=>'aproches'),
array('letra'=>'a', 'palabra'=>'aprodar'),
array('letra'=>'a', 'palabra'=>'aprometer'),
array('letra'=>'a', 'palabra'=>'aprontamiento'),
array('letra'=>'a', 'palabra'=>'aprontar'),
array('letra'=>'a', 'palabra'=>'apronte'),
array('letra'=>'a', 'palabra'=>'apropiable'),
array('letra'=>'a', 'palabra'=>'apropiacion'),
array('letra'=>'a', 'palabra'=>'apropiadamente'),
array('letra'=>'a', 'palabra'=>'apropiador'),
array('letra'=>'a', 'palabra'=>'apropiar'),
array('letra'=>'a', 'palabra'=>'apropincuacion'),
array('letra'=>'a', 'palabra'=>'apropincuarse'),
array('letra'=>'a', 'palabra'=>'aproposito'),
array('letra'=>'a', 'palabra'=>'aprovecer'),
array('letra'=>'a', 'palabra'=>'aprovechable'),
array('letra'=>'a', 'palabra'=>'aprovechadamente'),
array('letra'=>'a', 'palabra'=>'aprovechado'),
array('letra'=>'a', 'palabra'=>'aprovechador'),
array('letra'=>'a', 'palabra'=>'aprovechamiento'),
array('letra'=>'a', 'palabra'=>'aprovechante'),
array('letra'=>'a', 'palabra'=>'aprovechar'),
array('letra'=>'a', 'palabra'=>'aprovecimiento'),
array('letra'=>'a', 'palabra'=>'aprovisionamiento'),
array('letra'=>'a', 'palabra'=>'aprovisionar'),
array('letra'=>'a', 'palabra'=>'aproximacion'),
array('letra'=>'a', 'palabra'=>'aproximadamente'),
array('letra'=>'a', 'palabra'=>'aproximado'),
array('letra'=>'a', 'palabra'=>'aproximar'),
array('letra'=>'a', 'palabra'=>'aproximativo'),
array('letra'=>'a', 'palabra'=>'aproxis'),
array('letra'=>'a', 'palabra'=>'apsara'),
array('letra'=>'a', 'palabra'=>'apside'),
array('letra'=>'a', 'palabra'=>'aptamente'),
array('letra'=>'a', 'palabra'=>'aptar'),
array('letra'=>'a', 'palabra'=>'apterigiforme'),
array('letra'=>'a', 'palabra'=>'aptero'),
array('letra'=>'a', 'palabra'=>'aptitud'),
array('letra'=>'a', 'palabra'=>'apto'),
array('letra'=>'a', 'palabra'=>'apud'),
array('letra'=>'a', 'palabra'=>'apuesta'),
array('letra'=>'a', 'palabra'=>'apuestamente'),
array('letra'=>'a', 'palabra'=>'apuesto'),
array('letra'=>'a', 'palabra'=>'apulgarar'),
array('letra'=>'a', 'palabra'=>'apulgararse'),
array('letra'=>'a', 'palabra'=>'apulso'),
array('letra'=>'a', 'palabra'=>'apunarse'),
array('letra'=>'a', 'palabra'=>'apunchar'),
array('letra'=>'a', 'palabra'=>'apuntacion'),
array('letra'=>'a', 'palabra'=>'apuntado'),
array('letra'=>'a', 'palabra'=>'apuntador'),
array('letra'=>'a', 'palabra'=>'apuntalamiento'),
array('letra'=>'a', 'palabra'=>'apuntalar'),
array('letra'=>'a', 'palabra'=>'apuntamiento'),
array('letra'=>'a', 'palabra'=>'apuntar'),
array('letra'=>'a', 'palabra'=>'apunte'),
array('letra'=>'a', 'palabra'=>'apuntillar'),
array('letra'=>'a', 'palabra'=>'apuñalado'),
array('letra'=>'a', 'palabra'=>'apuñalamiento'),
array('letra'=>'a', 'palabra'=>'apuñalar'),
array('letra'=>'a', 'palabra'=>'apuñar'),
array('letra'=>'a', 'palabra'=>'apuñear'),
array('letra'=>'a', 'palabra'=>'apuñetear'),
array('letra'=>'a', 'palabra'=>'apuracabos'),
array('letra'=>'a', 'palabra'=>'apuracion'),
array('letra'=>'a', 'palabra'=>'apuradamente'),
array('letra'=>'a', 'palabra'=>'apuradero'),
array('letra'=>'a', 'palabra'=>'apurado'),
array('letra'=>'a', 'palabra'=>'apurador'),
array('letra'=>'a', 'palabra'=>'apuramiento'),
array('letra'=>'a', 'palabra'=>'apuranieves'),
array('letra'=>'a', 'palabra'=>'apurar'),
array('letra'=>'a', 'palabra'=>'apurativo'),
array('letra'=>'a', 'palabra'=>'apure'),
array('letra'=>'a', 'palabra'=>'apureño'),
array('letra'=>'a', 'palabra'=>'apurimeño'),
array('letra'=>'a', 'palabra'=>'apuro'),
array('letra'=>'a', 'palabra'=>'apuron'),
array('letra'=>'a', 'palabra'=>'apurrir'),
array('letra'=>'a', 'palabra'=>'apurruñar'),
array('letra'=>'a', 'palabra'=>'aquebrazarse'),
array('letra'=>'a', 'palabra'=>'aquedar'),
array('letra'=>'a', 'palabra'=>'aquejadamente'),
array('letra'=>'a', 'palabra'=>'aquejador'),
array('letra'=>'a', 'palabra'=>'aquejamiento'),
array('letra'=>'a', 'palabra'=>'aquejar'),
array('letra'=>'a', 'palabra'=>'aquejosamente'),
array('letra'=>'a', 'palabra'=>'aquejoso'),
array('letra'=>'a', 'palabra'=>'aquel'),
array('letra'=>'a', 'palabra'=>'aquel'),
array('letra'=>'a', 'palabra'=>'aquelarre'),
array('letra'=>'a', 'palabra'=>'aquele'),
array('letra'=>'a', 'palabra'=>'aquellar'),
array('letra'=>'a', 'palabra'=>'aquellos'),
array('letra'=>'a', 'palabra'=>'aquende'),
array('letra'=>'a', 'palabra'=>'aquenio'),
array('letra'=>'a', 'palabra'=>'aqueo'),
array('letra'=>'a', 'palabra'=>'aquerarse'),
array('letra'=>'a', 'palabra'=>'aquerenciado'),
array('letra'=>'a', 'palabra'=>'aquerenciarse'),
array('letra'=>'a', 'palabra'=>'aqueresar'),
array('letra'=>'a', 'palabra'=>'aquese'),
array('letra'=>'a', 'palabra'=>'aqueste'),
array('letra'=>'a', 'palabra'=>'aqui'),
array('letra'=>'a', 'palabra'=>'aquiescencia'),
array('letra'=>'a', 'palabra'=>'aquiescente'),
array('letra'=>'a', 'palabra'=>'aquietador'),
array('letra'=>'a', 'palabra'=>'aquietamiento'),
array('letra'=>'a', 'palabra'=>'aquietar'),
array('letra'=>'a', 'palabra'=>'aquifoliaceo'),
array('letra'=>'a', 'palabra'=>'aquifolio'),
array('letra'=>'a', 'palabra'=>'aquilatamiento'),
array('letra'=>'a', 'palabra'=>'aquilatar'),
array('letra'=>'a', 'palabra'=>'aquilea'),
array('letra'=>'a', 'palabra'=>'aquileño'),
array('letra'=>'a', 'palabra'=>'aquiles'),
array('letra'=>'a', 'palabra'=>'aquilifero'),
array('letra'=>'a', 'palabra'=>'aquilino'),
array('letra'=>'a', 'palabra'=>'aquillado'),
array('letra'=>'a', 'palabra'=>'aquillotrar'),
array('letra'=>'a', 'palabra'=>'aquilon'),
array('letra'=>'a', 'palabra'=>'aquilonal'),
array('letra'=>'a', 'palabra'=>'aquilonar'),
array('letra'=>'a', 'palabra'=>'aquintralarse'),
array('letra'=>'a', 'palabra'=>'aquistador'),
array('letra'=>'a', 'palabra'=>'aquistar'),
array('letra'=>'a', 'palabra'=>'aquitanico'),
array('letra'=>'a', 'palabra'=>'aquitano'),
array('letra'=>'a', 'palabra'=>'aquivo'),
array('letra'=>'a', 'palabra'=>'ar'),
array('letra'=>'a', 'palabra'=>'ara'),
array('letra'=>'a', 'palabra'=>'arabe'),
array('letra'=>'a', 'palabra'=>'arabesco'),
array('letra'=>'a', 'palabra'=>'arabi'),
array('letra'=>'a', 'palabra'=>'arabia'),
array('letra'=>'a', 'palabra'=>'arabia'),
array('letra'=>'a', 'palabra'=>'arabico'),
array('letra'=>'a', 'palabra'=>'arabigo'),
array('letra'=>'a', 'palabra'=>'arabio'),
array('letra'=>'a', 'palabra'=>'arabismo'),
array('letra'=>'a', 'palabra'=>'arabista'),
array('letra'=>'a', 'palabra'=>'arabizacion'),
array('letra'=>'a', 'palabra'=>'arabizar'),
array('letra'=>'a', 'palabra'=>'arable'),
array('letra'=>'a', 'palabra'=>'arabo'),
array('letra'=>'a', 'palabra'=>'araceo'),
array('letra'=>'a', 'palabra'=>'aracnido'),
array('letra'=>'a', 'palabra'=>'aracnoides'),
array('letra'=>'a', 'palabra'=>'aracnologia'),
array('letra'=>'a', 'palabra'=>'aracnologico'),
array('letra'=>'a', 'palabra'=>'aracnologo'),
array('letra'=>'a', 'palabra'=>'arada'),
array('letra'=>'a', 'palabra'=>'arado'),
array('letra'=>'a', 'palabra'=>'arador'),
array('letra'=>'a', 'palabra'=>'aradro'),
array('letra'=>'a', 'palabra'=>'aradura'),
array('letra'=>'a', 'palabra'=>'aragon'),
array('letra'=>'a', 'palabra'=>'aragones'),
array('letra'=>'a', 'palabra'=>'aragonesismo'),
array('letra'=>'a', 'palabra'=>'aragonito'),
array('letra'=>'a', 'palabra'=>'araguaney'),
array('letra'=>'a', 'palabra'=>'araguato'),
array('letra'=>'a', 'palabra'=>'aragüeño'),
array('letra'=>'a', 'palabra'=>'aragüira'),
array('letra'=>'a', 'palabra'=>'arahuaco'),
array('letra'=>'a', 'palabra'=>'aralia'),
array('letra'=>'a', 'palabra'=>'araliaceo'),
array('letra'=>'a', 'palabra'=>'arambel'),
array('letra'=>'a', 'palabra'=>'arambol'),
array('letra'=>'a', 'palabra'=>'arambre'),
array('letra'=>'a', 'palabra'=>'arameo'),
array('letra'=>'a', 'palabra'=>'aramio'),
array('letra'=>'a', 'palabra'=>'aran'),
array('letra'=>'a', 'palabra'=>'arana'),
array('letra'=>'a', 'palabra'=>'arancel'),
array('letra'=>'a', 'palabra'=>'arancelario'),
array('letra'=>'a', 'palabra'=>'arandanedo'),
array('letra'=>'a', 'palabra'=>'arandano'),
array('letra'=>'a', 'palabra'=>'arandela'),
array('letra'=>'a', 'palabra'=>'arandillo'),
array('letra'=>'a', 'palabra'=>'arandino'),
array('letra'=>'a', 'palabra'=>'aranero'),
array('letra'=>'a', 'palabra'=>'aranes'),
array('letra'=>'a', 'palabra'=>'arangorri'),
array('letra'=>'a', 'palabra'=>'araniego'),
array('letra'=>'a', 'palabra'=>'aranoso'),
array('letra'=>'a', 'palabra'=>'aranzada'),
array('letra'=>'a', 'palabra'=>'araña'),
array('letra'=>'a', 'palabra'=>'arañada'),
array('letra'=>'a', 'palabra'=>'arañador'),
array('letra'=>'a', 'palabra'=>'arañamiento'),
array('letra'=>'a', 'palabra'=>'arañar'),
array('letra'=>'a', 'palabra'=>'arañazo'),
array('letra'=>'a', 'palabra'=>'arañero'),
array('letra'=>'a', 'palabra'=>'arañil'),
array('letra'=>'a', 'palabra'=>'araño'),
array('letra'=>'a', 'palabra'=>'arañon'),
array('letra'=>'a', 'palabra'=>'arañuela'),
array('letra'=>'a', 'palabra'=>'arañuelo'),
array('letra'=>'a', 'palabra'=>'arar'),
array('letra'=>'a', 'palabra'=>'arasa'),
array('letra'=>'a', 'palabra'=>'aratorio'),
array('letra'=>'a', 'palabra'=>'araucanista'),
array('letra'=>'a', 'palabra'=>'araucano'),
array('letra'=>'a', 'palabra'=>'araucaria'),
array('letra'=>'a', 'palabra'=>'arauja'),
array('letra'=>'a', 'palabra'=>'aravico'),
array('letra'=>'a', 'palabra'=>'araza'),
array('letra'=>'a', 'palabra'=>'arbalestrilla'),
array('letra'=>'a', 'palabra'=>'arbelcoran'),
array('letra'=>'a', 'palabra'=>'arbellon'),
array('letra'=>'a', 'palabra'=>'arbequin'),
array('letra'=>'a', 'palabra'=>'arbitrable'),
array('letra'=>'a', 'palabra'=>'arbitradero'),
array('letra'=>'a', 'palabra'=>'arbitrador'),
array('letra'=>'a', 'palabra'=>'arbitraje'),
array('letra'=>'a', 'palabra'=>'arbitral'),
array('letra'=>'a', 'palabra'=>'arbitrar'),
array('letra'=>'a', 'palabra'=>'arbitrariamente'),
array('letra'=>'a', 'palabra'=>'arbitrariedad'),
array('letra'=>'a', 'palabra'=>'arbitrario'),
array('letra'=>'a', 'palabra'=>'arbitrativo'),
array('letra'=>'a', 'palabra'=>'arbitrero'),
array('letra'=>'a', 'palabra'=>'arbitriano'),
array('letra'=>'a', 'palabra'=>'arbitrio'),
array('letra'=>'a', 'palabra'=>'arbitrista'),
array('letra'=>'a', 'palabra'=>'arbitro'),
array('letra'=>'a', 'palabra'=>'arbol'),
array('letra'=>'a', 'palabra'=>'arbolado'),
array('letra'=>'a', 'palabra'=>'arboladura'),
array('letra'=>'a', 'palabra'=>'arbolar'),
array('letra'=>'a', 'palabra'=>'arbolario'),
array('letra'=>'a', 'palabra'=>'arbolecer'),
array('letra'=>'a', 'palabra'=>'arboleda'),
array('letra'=>'a', 'palabra'=>'arboledo'),
array('letra'=>'a', 'palabra'=>'arbolete'),
array('letra'=>'a', 'palabra'=>'arbolillo'),
array('letra'=>'a', 'palabra'=>'arbolista'),
array('letra'=>'a', 'palabra'=>'arbollon'),
array('letra'=>'a', 'palabra'=>'arbor'),
array('letra'=>'a', 'palabra'=>'arborecer'),
array('letra'=>'a', 'palabra'=>'arboreo'),
array('letra'=>'a', 'palabra'=>'arborescencia'),
array('letra'=>'a', 'palabra'=>'arborescente'),
array('letra'=>'a', 'palabra'=>'arboreto'),
array('letra'=>'a', 'palabra'=>'arboricida'),
array('letra'=>'a', 'palabra'=>'arboricola'),
array('letra'=>'a', 'palabra'=>'arboricultor'),
array('letra'=>'a', 'palabra'=>'arboricultura'),
array('letra'=>'a', 'palabra'=>'arboriforme'),
array('letra'=>'a', 'palabra'=>'arborizacion'),
array('letra'=>'a', 'palabra'=>'arborizar'),
array('letra'=>'a', 'palabra'=>'arbotante'),
array('letra'=>'a', 'palabra'=>'arbustivo'),
array('letra'=>'a', 'palabra'=>'arbusto'),
array('letra'=>'a', 'palabra'=>'arca'),
array('letra'=>'a', 'palabra'=>'arcabucear'),
array('letra'=>'a', 'palabra'=>'arcabuceria'),
array('letra'=>'a', 'palabra'=>'arcabucero'),
array('letra'=>'a', 'palabra'=>'arcabuco'),
array('letra'=>'a', 'palabra'=>'arcabucoso'),
array('letra'=>'a', 'palabra'=>'arcabuezo'),
array('letra'=>'a', 'palabra'=>'arcabuz'),
array('letra'=>'a', 'palabra'=>'arcabuzal'),
array('letra'=>'a', 'palabra'=>'arcabuzazo'),
array('letra'=>'a', 'palabra'=>'arcacil'),
array('letra'=>'a', 'palabra'=>'arcada'),
array('letra'=>'a', 'palabra'=>'arcade'),
array('letra'=>'a', 'palabra'=>'arcadico'),
array('letra'=>'a', 'palabra'=>'arcadio'),
array('letra'=>'a', 'palabra'=>'arcador'),
array('letra'=>'a', 'palabra'=>'arcaduz'),
array('letra'=>'a', 'palabra'=>'arcaduzar'),
array('letra'=>'a', 'palabra'=>'arcaico'),
array('letra'=>'a', 'palabra'=>'arcaismo'),
array('letra'=>'a', 'palabra'=>'arcaista'),
array('letra'=>'a', 'palabra'=>'arcaizante'),
array('letra'=>'a', 'palabra'=>'arcaizar'),
array('letra'=>'a', 'palabra'=>'arcanamente'),
array('letra'=>'a', 'palabra'=>'arcangel'),
array('letra'=>'a', 'palabra'=>'arcangelical'),
array('letra'=>'a', 'palabra'=>'arcangelico'),
array('letra'=>'a', 'palabra'=>'arcanidad'),
array('letra'=>'a', 'palabra'=>'arcano'),
array('letra'=>'a', 'palabra'=>'arcar'),
array('letra'=>'a', 'palabra'=>'arcatura'),
array('letra'=>'a', 'palabra'=>'arcazon'),
array('letra'=>'a', 'palabra'=>'arce'),
array('letra'=>'a', 'palabra'=>'arcea'),
array('letra'=>'a', 'palabra'=>'arcedianato'),
array('letra'=>'a', 'palabra'=>'arcedianazgo'),
array('letra'=>'a', 'palabra'=>'arcediano'),
array('letra'=>'a', 'palabra'=>'arcedo'),
array('letra'=>'a', 'palabra'=>'arcen'),
array('letra'=>'a', 'palabra'=>'arcense'),
array('letra'=>'a', 'palabra'=>'archa'),
array('letra'=>'a', 'palabra'=>'archero'),
array('letra'=>'a', 'palabra'=>'archi'),
array('letra'=>'a', 'palabra'=>'archibebe'),
array('letra'=>'a', 'palabra'=>'archibribon'),
array('letra'=>'a', 'palabra'=>'archibruto'),
array('letra'=>'a', 'palabra'=>'archicofrade'),
array('letra'=>'a', 'palabra'=>'archicofradia'),
array('letra'=>'a', 'palabra'=>'archidiacono'),
array('letra'=>'a', 'palabra'=>'archidiocesis'),
array('letra'=>'a', 'palabra'=>'archiducado'),
array('letra'=>'a', 'palabra'=>'archiducal'),
array('letra'=>'a', 'palabra'=>'archiduque'),
array('letra'=>'a', 'palabra'=>'archiduquesa'),
array('letra'=>'a', 'palabra'=>'archifonema'),
array('letra'=>'a', 'palabra'=>'archilaud'),
array('letra'=>'a', 'palabra'=>'archimandrita'),
array('letra'=>'a', 'palabra'=>'archipampano'),
array('letra'=>'a', 'palabra'=>'archipielago'),
array('letra'=>'a', 'palabra'=>'archisabido'),
array('letra'=>'a', 'palabra'=>'architriclino'),
array('letra'=>'a', 'palabra'=>'archivador'),
array('letra'=>'a', 'palabra'=>'archivar'),
array('letra'=>'a', 'palabra'=>'archivero'),
array('letra'=>'a', 'palabra'=>'archivista'),
array('letra'=>'a', 'palabra'=>'archivistico'),
array('letra'=>'a', 'palabra'=>'archivo'),
array('letra'=>'a', 'palabra'=>'archivologia'),
array('letra'=>'a', 'palabra'=>'archivologico'),
array('letra'=>'a', 'palabra'=>'archivologo'),
array('letra'=>'a', 'palabra'=>'archivolta'),
array('letra'=>'a', 'palabra'=>'arcidriche'),
array('letra'=>'a', 'palabra'=>'arcifinio'),
array('letra'=>'a', 'palabra'=>'arcilla'),
array('letra'=>'a', 'palabra'=>'arcillar'),
array('letra'=>'a', 'palabra'=>'arcilloso'),
array('letra'=>'a', 'palabra'=>'arcion'),
array('letra'=>'a', 'palabra'=>'arcionar'),
array('letra'=>'a', 'palabra'=>'arciprestado'),
array('letra'=>'a', 'palabra'=>'arciprestal'),
array('letra'=>'a', 'palabra'=>'arciprestazgo'),
array('letra'=>'a', 'palabra'=>'arcipreste'),
array('letra'=>'a', 'palabra'=>'arco'),
array('letra'=>'a', 'palabra'=>'arcobricense'),
array('letra'=>'a', 'palabra'=>'arcon'),
array('letra'=>'a', 'palabra'=>'arcontado'),
array('letra'=>'a', 'palabra'=>'arconte'),
array('letra'=>'a', 'palabra'=>'arcosa'),
array('letra'=>'a', 'palabra'=>'arcosolio'),
array('letra'=>'a', 'palabra'=>'arcuacion'),
array('letra'=>'a', 'palabra'=>'arcuado'),
array('letra'=>'a', 'palabra'=>'arcual'),
array('letra'=>'a', 'palabra'=>'arda'),
array('letra'=>'a', 'palabra'=>'ardalear'),
array('letra'=>'a', 'palabra'=>'ardea'),
array('letra'=>'a', 'palabra'=>'ardedor'),
array('letra'=>'a', 'palabra'=>'ardedura'),
array('letra'=>'a', 'palabra'=>'ardeiforme'),
array('letra'=>'a', 'palabra'=>'ardentia'),
array('letra'=>'a', 'palabra'=>'ardentisimamente'),
array('letra'=>'a', 'palabra'=>'ardentisimo'),
array('letra'=>'a', 'palabra'=>'arder'),
array('letra'=>'a', 'palabra'=>'ardero'),
array('letra'=>'a', 'palabra'=>'ardeviejas'),
array('letra'=>'a', 'palabra'=>'ardicia'),
array('letra'=>'a', 'palabra'=>'ardid'),
array('letra'=>'a', 'palabra'=>'ardidamente'),
array('letra'=>'a', 'palabra'=>'ardideza'),
array('letra'=>'a', 'palabra'=>'ardido'),
array('letra'=>'a', 'palabra'=>'ardidoso'),
array('letra'=>'a', 'palabra'=>'ardiente'),
array('letra'=>'a', 'palabra'=>'ardientemente'),
array('letra'=>'a', 'palabra'=>'ardil'),
array('letra'=>'a', 'palabra'=>'ardilla'),
array('letra'=>'a', 'palabra'=>'ardiloso'),
array('letra'=>'a', 'palabra'=>'ardimiento'),
array('letra'=>'a', 'palabra'=>'ardinculo'),
array('letra'=>'a', 'palabra'=>'ardiondo'),
array('letra'=>'a', 'palabra'=>'ardita'),
array('letra'=>'a', 'palabra'=>'ardite'),
array('letra'=>'a', 'palabra'=>'ardor'),
array('letra'=>'a', 'palabra'=>'ardora'),
array('letra'=>'a', 'palabra'=>'ardorada'),
array('letra'=>'a', 'palabra'=>'ardorosamente'),
array('letra'=>'a', 'palabra'=>'ardoroso'),
array('letra'=>'a', 'palabra'=>'arduamente'),
array('letra'=>'a', 'palabra'=>'arduidad'),
array('letra'=>'a', 'palabra'=>'arduo'),
array('letra'=>'a', 'palabra'=>'ardura'),
array('letra'=>'a', 'palabra'=>'arduran'),
array('letra'=>'a', 'palabra'=>'area'),
array('letra'=>'a', 'palabra'=>'areca'),
array('letra'=>'a', 'palabra'=>'arecer'),
array('letra'=>'a', 'palabra'=>'arefaccion'),
array('letra'=>'a', 'palabra'=>'areito'),
array('letra'=>'a', 'palabra'=>'arel'),
array('letra'=>'a', 'palabra'=>'arelar'),
array('letra'=>'a', 'palabra'=>'arena'),
array('letra'=>'a', 'palabra'=>'arenaceo'),
array('letra'=>'a', 'palabra'=>'arenacion'),
array('letra'=>'a', 'palabra'=>'arenal'),
array('letra'=>'a', 'palabra'=>'arenar'),
array('letra'=>'a', 'palabra'=>'arencar'),
array('letra'=>'a', 'palabra'=>'arencon'),
array('letra'=>'a', 'palabra'=>'arenero'),
array('letra'=>'a', 'palabra'=>'arenga'),
array('letra'=>'a', 'palabra'=>'arengador'),
array('letra'=>'a', 'palabra'=>'arengar'),
array('letra'=>'a', 'palabra'=>'arenilla'),
array('letra'=>'a', 'palabra'=>'arenillero'),
array('letra'=>'a', 'palabra'=>'arenisco'),
array('letra'=>'a', 'palabra'=>'arenoso'),
array('letra'=>'a', 'palabra'=>'arenque'),
array('letra'=>'a', 'palabra'=>'arenzata'),
array('letra'=>'a', 'palabra'=>'areola'),
array('letra'=>'a', 'palabra'=>'areola'),
array('letra'=>'a', 'palabra'=>'areolar'),
array('letra'=>'a', 'palabra'=>'areopagita'),
array('letra'=>'a', 'palabra'=>'areopago'),
array('letra'=>'a', 'palabra'=>'areosistilo'),
array('letra'=>'a', 'palabra'=>'areostilo'),
array('letra'=>'a', 'palabra'=>'arepa'),
array('letra'=>'a', 'palabra'=>'arepita'),
array('letra'=>'a', 'palabra'=>'arequipa'),
array('letra'=>'a', 'palabra'=>'arequipe'),
array('letra'=>'a', 'palabra'=>'arequipeño'),
array('letra'=>'a', 'palabra'=>'aresta'),
array('letra'=>'a', 'palabra'=>'arestil'),
array('letra'=>'a', 'palabra'=>'arestin'),
array('letra'=>'a', 'palabra'=>'arestinado'),
array('letra'=>'a', 'palabra'=>'aretalogia'),
array('letra'=>'a', 'palabra'=>'aretalogico'),
array('letra'=>'a', 'palabra'=>'arete'),
array('letra'=>'a', 'palabra'=>'aretino'),
array('letra'=>'a', 'palabra'=>'arevaco'),
array('letra'=>'a', 'palabra'=>'arfada'),
array('letra'=>'a', 'palabra'=>'arfar'),
array('letra'=>'a', 'palabra'=>'arfil'),
array('letra'=>'a', 'palabra'=>'argadijo'),
array('letra'=>'a', 'palabra'=>'argadillo'),
array('letra'=>'a', 'palabra'=>'argado'),
array('letra'=>'a', 'palabra'=>'argalia'),
array('letra'=>'a', 'palabra'=>'argallera'),
array('letra'=>'a', 'palabra'=>'argamandel'),
array('letra'=>'a', 'palabra'=>'argamandijo'),
array('letra'=>'a', 'palabra'=>'argamasa'),
array('letra'=>'a', 'palabra'=>'argamasar'),
array('letra'=>'a', 'palabra'=>'argamason'),
array('letra'=>'a', 'palabra'=>'argamula'),
array('letra'=>'a', 'palabra'=>'argan'),
array('letra'=>'a', 'palabra'=>'argana'),
array('letra'=>'a', 'palabra'=>'arganas'),
array('letra'=>'a', 'palabra'=>'arganda'),
array('letra'=>'a', 'palabra'=>'argandeño'),
array('letra'=>'a', 'palabra'=>'arganel'),
array('letra'=>'a', 'palabra'=>'arganeo'),
array('letra'=>'a', 'palabra'=>'argano'),
array('letra'=>'a', 'palabra'=>'argaña'),
array('letra'=>'a', 'palabra'=>'argavieso'),
array('letra'=>'a', 'palabra'=>'argaya'),
array('letra'=>'a', 'palabra'=>'argayar'),
array('letra'=>'a', 'palabra'=>'argayo'),
array('letra'=>'a', 'palabra'=>'argel'),
array('letra'=>'a', 'palabra'=>'argelino'),
array('letra'=>'a', 'palabra'=>'argemone'),
array('letra'=>'a', 'palabra'=>'argen'),
array('letra'=>'a', 'palabra'=>'argent'),
array('letra'=>'a', 'palabra'=>'argentado'),
array('letra'=>'a', 'palabra'=>'argentador'),
array('letra'=>'a', 'palabra'=>'argentar'),
array('letra'=>'a', 'palabra'=>'argentario'),
array('letra'=>'a', 'palabra'=>'argente'),
array('letra'=>'a', 'palabra'=>'argenteo'),
array('letra'=>'a', 'palabra'=>'argenteria'),
array('letra'=>'a', 'palabra'=>'argentero'),
array('letra'=>'a', 'palabra'=>'argentico'),
array('letra'=>'a', 'palabra'=>'argentifero'),
array('letra'=>'a', 'palabra'=>'argentina'),
array('letra'=>'a', 'palabra'=>'argentinidad'),
array('letra'=>'a', 'palabra'=>'argentinismo'),
array('letra'=>'a', 'palabra'=>'argentino'),
array('letra'=>'a', 'palabra'=>'argentita'),
array('letra'=>'a', 'palabra'=>'argento'),
array('letra'=>'a', 'palabra'=>'argentometria'),
array('letra'=>'a', 'palabra'=>'argentoso'),
array('letra'=>'a', 'palabra'=>'argentpel'),
array('letra'=>'a', 'palabra'=>'argila'),
array('letra'=>'a', 'palabra'=>'argilla'),
array('letra'=>'a', 'palabra'=>'argiloso'),
array('letra'=>'a', 'palabra'=>'argivo'),
array('letra'=>'a', 'palabra'=>'argolico'),
array('letra'=>'a', 'palabra'=>'argolla'),
array('letra'=>'a', 'palabra'=>'argollon'),
array('letra'=>'a', 'palabra'=>'argoma'),
array('letra'=>'a', 'palabra'=>'argomal'),
array('letra'=>'a', 'palabra'=>'argon'),
array('letra'=>'a', 'palabra'=>'argonauta'),
array('letra'=>'a', 'palabra'=>'argos'),
array('letra'=>'a', 'palabra'=>'argot'),
array('letra'=>'a', 'palabra'=>'argucia'),
array('letra'=>'a', 'palabra'=>'argue'),
array('letra'=>'a', 'palabra'=>'argüe'),
array('letra'=>'a', 'palabra'=>'arguellarse'),
array('letra'=>'a', 'palabra'=>'arguello'),
array('letra'=>'a', 'palabra'=>'arguenas'),
array('letra'=>'a', 'palabra'=>'arguende'),
array('letra'=>'a', 'palabra'=>'argueñas'),
array('letra'=>'a', 'palabra'=>'argüidor'),
array('letra'=>'a', 'palabra'=>'arguinas'),
array('letra'=>'a', 'palabra'=>'argüir'),
array('letra'=>'a', 'palabra'=>'argüitivo'),
array('letra'=>'a', 'palabra'=>'argullo'),
array('letra'=>'a', 'palabra'=>'argulloso'),
array('letra'=>'a', 'palabra'=>'argumentacion'),
array('letra'=>'a', 'palabra'=>'argumentador'),
array('letra'=>'a', 'palabra'=>'argumental'),
array('letra'=>'a', 'palabra'=>'argumentar'),
array('letra'=>'a', 'palabra'=>'argumentativo'),
array('letra'=>'a', 'palabra'=>'argumentista'),
array('letra'=>'a', 'palabra'=>'argumento'),
array('letra'=>'a', 'palabra'=>'argumentoso'),
array('letra'=>'a', 'palabra'=>'arguyente'),
array('letra'=>'a', 'palabra'=>'aria'),
array('letra'=>'a', 'palabra'=>'aribibi'),
array('letra'=>'a', 'palabra'=>'aricado'),
array('letra'=>'a', 'palabra'=>'aricar'),
array('letra'=>'a', 'palabra'=>'aricoma'),
array('letra'=>'a', 'palabra'=>'aridecer'),
array('letra'=>'a', 'palabra'=>'aridez'),
array('letra'=>'a', 'palabra'=>'arido'),
array('letra'=>'a', 'palabra'=>'arienzo'),
array('letra'=>'a', 'palabra'=>'aries'),
array('letra'=>'a', 'palabra'=>'arieta'),
array('letra'=>'a', 'palabra'=>'arietar'),
array('letra'=>'a', 'palabra'=>'arietario'),
array('letra'=>'a', 'palabra'=>'ariete'),
array('letra'=>'a', 'palabra'=>'arietino'),
array('letra'=>'a', 'palabra'=>'arije'),
array('letra'=>'a', 'palabra'=>'arijo'),
array('letra'=>'a', 'palabra'=>'arilacion'),
array('letra'=>'a', 'palabra'=>'arilico'),
array('letra'=>'a', 'palabra'=>'arillo'),
array('letra'=>'a', 'palabra'=>'arilo'),
array('letra'=>'a', 'palabra'=>'arimaspe'),
array('letra'=>'a', 'palabra'=>'arimaspo'),
array('letra'=>'a', 'palabra'=>'arimez'),
array('letra'=>'a', 'palabra'=>'ario'),
array('letra'=>'a', 'palabra'=>'ariolo'),
array('letra'=>'a', 'palabra'=>'arique'),
array('letra'=>'a', 'palabra'=>'ariqueño'),
array('letra'=>'a', 'palabra'=>'arisaro'),
array('letra'=>'a', 'palabra'=>'arisblanco'),
array('letra'=>'a', 'palabra'=>'ariscarse'),
array('letra'=>'a', 'palabra'=>'arisco'),
array('letra'=>'a', 'palabra'=>'arismetico'),
array('letra'=>'a', 'palabra'=>'arisnegro'),
array('letra'=>'a', 'palabra'=>'arisprieto'),
array('letra'=>'a', 'palabra'=>'arisquear'),
array('letra'=>'a', 'palabra'=>'arista'),
array('letra'=>'a', 'palabra'=>'aristado'),
array('letra'=>'a', 'palabra'=>'aristarco'),
array('letra'=>'a', 'palabra'=>'aristin'),
array('letra'=>'a', 'palabra'=>'aristino'),
array('letra'=>'a', 'palabra'=>'aristocracia'),
array('letra'=>'a', 'palabra'=>'aristocrata'),
array('letra'=>'a', 'palabra'=>'aristocratico'),
array('letra'=>'a', 'palabra'=>'aristocratizar'),
array('letra'=>'a', 'palabra'=>'aristofanesco'),
array('letra'=>'a', 'palabra'=>'aristofanico'),
array('letra'=>'a', 'palabra'=>'aristoloquia'),
array('letra'=>'a', 'palabra'=>'aristoloquiaceo'),
array('letra'=>'a', 'palabra'=>'ariston'),
array('letra'=>'a', 'palabra'=>'aristoso'),
array('letra'=>'a', 'palabra'=>'aristotelico'),
array('letra'=>'a', 'palabra'=>'aristotelismo'),
array('letra'=>'a', 'palabra'=>'aritenoides'),
array('letra'=>'a', 'palabra'=>'aritmetico'),
array('letra'=>'a', 'palabra'=>'aritmometro'),
array('letra'=>'a', 'palabra'=>'arjoran'),
array('letra'=>'a', 'palabra'=>'arlar'),
array('letra'=>'a', 'palabra'=>'arlequin'),
array('letra'=>'a', 'palabra'=>'arlequinada'),
array('letra'=>'a', 'palabra'=>'arlequinesco'),
array('letra'=>'a', 'palabra'=>'arlo'),
array('letra'=>'a', 'palabra'=>'arlota'),
array('letra'=>'a', 'palabra'=>'arlote'),
array('letra'=>'a', 'palabra'=>'arloteria'),
array('letra'=>'a', 'palabra'=>'arma'),
array('letra'=>'a', 'palabra'=>'armable'),
array('letra'=>'a', 'palabra'=>'armada'),
array('letra'=>'a', 'palabra'=>'armadera'),
array('letra'=>'a', 'palabra'=>'armadia'),
array('letra'=>'a', 'palabra'=>'armadija'),
array('letra'=>'a', 'palabra'=>'armadijo'),
array('letra'=>'a', 'palabra'=>'armadilla'),
array('letra'=>'a', 'palabra'=>'armadillo'),
array('letra'=>'a', 'palabra'=>'armado'),
array('letra'=>'a', 'palabra'=>'armador'),
array('letra'=>'a', 'palabra'=>'armadura'),
array('letra'=>'a', 'palabra'=>'armajal'),
array('letra'=>'a', 'palabra'=>'armajo'),
array('letra'=>'a', 'palabra'=>'armamentismo'),
array('letra'=>'a', 'palabra'=>'armamentista'),
array('letra'=>'a', 'palabra'=>'armamentistico'),
array('letra'=>'a', 'palabra'=>'armamento'),
array('letra'=>'a', 'palabra'=>'armamiento'),
array('letra'=>'a', 'palabra'=>'armandijo'),
array('letra'=>'a', 'palabra'=>'armañac'),
array('letra'=>'a', 'palabra'=>'armar'),
array('letra'=>'a', 'palabra'=>'armario'),
array('letra'=>'a', 'palabra'=>'armatoste'),
array('letra'=>'a', 'palabra'=>'armazon'),
array('letra'=>'a', 'palabra'=>'armella'),
array('letra'=>'a', 'palabra'=>'armenia'),
array('letra'=>'a', 'palabra'=>'armenico'),
array('letra'=>'a', 'palabra'=>'armenio'),
array('letra'=>'a', 'palabra'=>'armento'),
array('letra'=>'a', 'palabra'=>'armeria'),
array('letra'=>'a', 'palabra'=>'armero'),
array('letra'=>'a', 'palabra'=>'armerol'),
array('letra'=>'a', 'palabra'=>'armifero'),
array('letra'=>'a', 'palabra'=>'armigero'),
array('letra'=>'a', 'palabra'=>'armilar'),
array('letra'=>'a', 'palabra'=>'armilla'),
array('letra'=>'a', 'palabra'=>'arminio'),
array('letra'=>'a', 'palabra'=>'armiñado'),
array('letra'=>'a', 'palabra'=>'armiñar'),
array('letra'=>'a', 'palabra'=>'armiño'),
array('letra'=>'a', 'palabra'=>'armipotente'),
array('letra'=>'a', 'palabra'=>'armisonante'),
array('letra'=>'a', 'palabra'=>'armisticio'),
array('letra'=>'a', 'palabra'=>'armon'),
array('letra'=>'a', 'palabra'=>'armonia'),
array('letra'=>'a', 'palabra'=>'armoniaco'),
array('letra'=>'a', 'palabra'=>'armoniaco'),
array('letra'=>'a', 'palabra'=>'armonica'),
array('letra'=>'a', 'palabra'=>'armonicamente'),
array('letra'=>'a', 'palabra'=>'armonico'),
array('letra'=>'a', 'palabra'=>'armonio'),
array('letra'=>'a', 'palabra'=>'armoniosamente'),
array('letra'=>'a', 'palabra'=>'armonioso'),
array('letra'=>'a', 'palabra'=>'armonista'),
array('letra'=>'a', 'palabra'=>'armonium'),
array('letra'=>'a', 'palabra'=>'armonizable'),
array('letra'=>'a', 'palabra'=>'armonizacion'),
array('letra'=>'a', 'palabra'=>'armonizador'),
array('letra'=>'a', 'palabra'=>'armonizar'),
array('letra'=>'a', 'palabra'=>'armoricano'),
array('letra'=>'a', 'palabra'=>'armos'),
array('letra'=>'a', 'palabra'=>'armuelle'),
array('letra'=>'a', 'palabra'=>'arna'),
array('letra'=>'a', 'palabra'=>'arnacho'),
array('letra'=>'a', 'palabra'=>'arnadi'),
array('letra'=>'a', 'palabra'=>'arnasca'),
array('letra'=>'a', 'palabra'=>'arnaucho'),
array('letra'=>'a', 'palabra'=>'arnaute'),
array('letra'=>'a', 'palabra'=>'arnequin'),
array('letra'=>'a', 'palabra'=>'arnes'),
array('letra'=>'a', 'palabra'=>'arnica'),
array('letra'=>'a', 'palabra'=>'arnillo'),
array('letra'=>'a', 'palabra'=>'aro'),
array('letra'=>'a', 'palabra'=>'aroca'),
array('letra'=>'a', 'palabra'=>'aroideo'),
array('letra'=>'a', 'palabra'=>'aroma'),
array('letra'=>'a', 'palabra'=>'aromar'),
array('letra'=>'a', 'palabra'=>'aromaterapia'),
array('letra'=>'a', 'palabra'=>'aromaticidad'),
array('letra'=>'a', 'palabra'=>'aromatico'),
array('letra'=>'a', 'palabra'=>'aromatizacion'),
array('letra'=>'a', 'palabra'=>'aromatizante'),
array('letra'=>'a', 'palabra'=>'aromatizar'),
array('letra'=>'a', 'palabra'=>'aromatoterapia'),
array('letra'=>'a', 'palabra'=>'aromo'),
array('letra'=>'a', 'palabra'=>'aromoso'),
array('letra'=>'a', 'palabra'=>'aron'),
array('letra'=>'a', 'palabra'=>'aron'),
array('letra'=>'a', 'palabra'=>'arpa'),
array('letra'=>'a', 'palabra'=>'arpado'),
array('letra'=>'a', 'palabra'=>'arpadura'),
array('letra'=>'a', 'palabra'=>'arpar'),
array('letra'=>'a', 'palabra'=>'arpegiar'),
array('letra'=>'a', 'palabra'=>'arpegio'),
array('letra'=>'a', 'palabra'=>'arpella'),
array('letra'=>'a', 'palabra'=>'arpende'),
array('letra'=>'a', 'palabra'=>'arpeo'),
array('letra'=>'a', 'palabra'=>'arpia'),
array('letra'=>'a', 'palabra'=>'arpillera'),
array('letra'=>'a', 'palabra'=>'arpista'),
array('letra'=>'a', 'palabra'=>'arpon'),
array('letra'=>'a', 'palabra'=>'arponado'),
array('letra'=>'a', 'palabra'=>'arponar'),
array('letra'=>'a', 'palabra'=>'arponear'),
array('letra'=>'a', 'palabra'=>'arponero'),
array('letra'=>'a', 'palabra'=>'arqueada'),
array('letra'=>'a', 'palabra'=>'arqueador'),
array('letra'=>'a', 'palabra'=>'arqueaje'),
array('letra'=>'a', 'palabra'=>'arqueamiento'),
array('letra'=>'a', 'palabra'=>'arquear'),
array('letra'=>'a', 'palabra'=>'arqueo'),
array('letra'=>'a', 'palabra'=>'arqueolitico'),
array('letra'=>'a', 'palabra'=>'arqueologia'),
array('letra'=>'a', 'palabra'=>'arqueologico'),
array('letra'=>'a', 'palabra'=>'arqueologo'),
array('letra'=>'a', 'palabra'=>'arqueozoologia'),
array('letra'=>'a', 'palabra'=>'arqueria'),
array('letra'=>'a', 'palabra'=>'arquero'),
array('letra'=>'a', 'palabra'=>'arqueta'),
array('letra'=>'a', 'palabra'=>'arquetipico'),
array('letra'=>'a', 'palabra'=>'arquetipo'),
array('letra'=>'a', 'palabra'=>'arquibanco'),
array('letra'=>'a', 'palabra'=>'arquidiocesis'),
array('letra'=>'a', 'palabra'=>'arquiepiscopal'),
array('letra'=>'a', 'palabra'=>'arquimedes'),
array('letra'=>'a', 'palabra'=>'arquimesa'),
array('letra'=>'a', 'palabra'=>'arquipendola'),
array('letra'=>'a', 'palabra'=>'arquiptero'),
array('letra'=>'a', 'palabra'=>'arquisinagogo'),
array('letra'=>'a', 'palabra'=>'arquitecto'),
array('letra'=>'a', 'palabra'=>'arquitectonico'),
array('letra'=>'a', 'palabra'=>'arquitector'),
array('letra'=>'a', 'palabra'=>'arquitectura'),
array('letra'=>'a', 'palabra'=>'arquitectural'),
array('letra'=>'a', 'palabra'=>'arquitrabe'),
array('letra'=>'a', 'palabra'=>'arquivolta'),
array('letra'=>'a', 'palabra'=>'arra'),
array('letra'=>'a', 'palabra'=>'arraba'),
array('letra'=>'a', 'palabra'=>'arrabal'),
array('letra'=>'a', 'palabra'=>'arrabalero'),
array('letra'=>'a', 'palabra'=>'arrabiatar'),
array('letra'=>'a', 'palabra'=>'arrabillado'),
array('letra'=>'a', 'palabra'=>'arrabio'),
array('letra'=>'a', 'palabra'=>'arracacha'),
array('letra'=>'a', 'palabra'=>'arracachada'),
array('letra'=>'a', 'palabra'=>'arracacho'),
array('letra'=>'a', 'palabra'=>'arracada'),
array('letra'=>'a', 'palabra'=>'arracimado'),
array('letra'=>'a', 'palabra'=>'arracimarse'),
array('letra'=>'a', 'palabra'=>'arraclan'),
array('letra'=>'a', 'palabra'=>'arraez'),
array('letra'=>'a', 'palabra'=>'arraezar'),
array('letra'=>'a', 'palabra'=>'arrafiz'),
array('letra'=>'a', 'palabra'=>'arragoces'),
array('letra'=>'a', 'palabra'=>'arraigado'),
array('letra'=>'a', 'palabra'=>'arraigamiento'),
array('letra'=>'a', 'palabra'=>'arraigar'),
array('letra'=>'a', 'palabra'=>'arraigo'),
array('letra'=>'a', 'palabra'=>'arraijan'),
array('letra'=>'a', 'palabra'=>'arralar'),
array('letra'=>'a', 'palabra'=>'arramblar'),
array('letra'=>'a', 'palabra'=>'arramplar'),
array('letra'=>'a', 'palabra'=>'arranarse'),
array('letra'=>'a', 'palabra'=>'arrancaclavos'),
array('letra'=>'a', 'palabra'=>'arrancada'),
array('letra'=>'a', 'palabra'=>'arrancadera'),
array('letra'=>'a', 'palabra'=>'arrancadero'),
array('letra'=>'a', 'palabra'=>'arrancado'),
array('letra'=>'a', 'palabra'=>'arrancador'),
array('letra'=>'a', 'palabra'=>'arrancadura'),
array('letra'=>'a', 'palabra'=>'arrancamiento'),
array('letra'=>'a', 'palabra'=>'arrancamoños'),
array('letra'=>'a', 'palabra'=>'arrancapinos'),
array('letra'=>'a', 'palabra'=>'arrancar'),
array('letra'=>'a', 'palabra'=>'arrancasiega'),
array('letra'=>'a', 'palabra'=>'arranchadera'),
array('letra'=>'a', 'palabra'=>'arranchar'),
array('letra'=>'a', 'palabra'=>'arrancharse'),
array('letra'=>'a', 'palabra'=>'arranchon'),
array('letra'=>'a', 'palabra'=>'arranciarse'),
array('letra'=>'a', 'palabra'=>'arrancon'),
array('letra'=>'a', 'palabra'=>'arranque'),
array('letra'=>'a', 'palabra'=>'arranquera'),
array('letra'=>'a', 'palabra'=>'arrapar'),
array('letra'=>'a', 'palabra'=>'arrapiezo'),
array('letra'=>'a', 'palabra'=>'arrapo'),
array('letra'=>'a', 'palabra'=>'arraquive'),
array('letra'=>'a', 'palabra'=>'arrarray'),
array('letra'=>'a', 'palabra'=>'arras'),
array('letra'=>'a', 'palabra'=>'arrasado'),
array('letra'=>'a', 'palabra'=>'arrasadura'),
array('letra'=>'a', 'palabra'=>'arrasamiento'),
array('letra'=>'a', 'palabra'=>'arrasar'),
array('letra'=>'a', 'palabra'=>'arrastraculo'),
array('letra'=>'a', 'palabra'=>'arrastradamente'),
array('letra'=>'a', 'palabra'=>'arrastradera'),
array('letra'=>'a', 'palabra'=>'arrastradero'),
array('letra'=>'a', 'palabra'=>'arrastradizo'),
array('letra'=>'a', 'palabra'=>'arrastrado'),
array('letra'=>'a', 'palabra'=>'arrastramiento'),
array('letra'=>'a', 'palabra'=>'arrastrante'),
array('letra'=>'a', 'palabra'=>'arrastrapies'),
array('letra'=>'a', 'palabra'=>'arrastrar'),
array('letra'=>'a', 'palabra'=>'arrastre'),
array('letra'=>'a', 'palabra'=>'arrastrero'),
array('letra'=>'a', 'palabra'=>'arrate'),
array('letra'=>'a', 'palabra'=>'arratonado'),
array('letra'=>'a', 'palabra'=>'arratonar'),
array('letra'=>'a', 'palabra'=>'arrayan'),
array('letra'=>'a', 'palabra'=>'arrayanal'),
array('letra'=>'a', 'palabra'=>'arrayano'),
array('letra'=>'a', 'palabra'=>'arrayaz'),
array('letra'=>'a', 'palabra'=>'arrayaz'),
array('letra'=>'a', 'palabra'=>'arraz'),
array('letra'=>'a', 'palabra'=>'arre'),
array('letra'=>'a', 'palabra'=>'arreado'),
array('letra'=>'a', 'palabra'=>'arreador'),
array('letra'=>'a', 'palabra'=>'arreala'),
array('letra'=>'a', 'palabra'=>'arrear'),
array('letra'=>'a', 'palabra'=>'arrebañaderas'),
array('letra'=>'a', 'palabra'=>'arrebañador'),
array('letra'=>'a', 'palabra'=>'arrebañadura'),
array('letra'=>'a', 'palabra'=>'arrebañar'),
array('letra'=>'a', 'palabra'=>'arrebatacapas'),
array('letra'=>'a', 'palabra'=>'arrebatadamente'),
array('letra'=>'a', 'palabra'=>'arrebatadizo'),
array('letra'=>'a', 'palabra'=>'arrebatado'),
array('letra'=>'a', 'palabra'=>'arrebatador'),
array('letra'=>'a', 'palabra'=>'arrebatamiento'),
array('letra'=>'a', 'palabra'=>'arrebatapuñadas'),
array('letra'=>'a', 'palabra'=>'arrebatar'),
array('letra'=>'a', 'palabra'=>'arrebatarse'),
array('letra'=>'a', 'palabra'=>'arrebatiña'),
array('letra'=>'a', 'palabra'=>'arrebato'),
array('letra'=>'a', 'palabra'=>'arrebatoso'),
array('letra'=>'a', 'palabra'=>'arrebiatar'),
array('letra'=>'a', 'palabra'=>'arrebol'),
array('letra'=>'a', 'palabra'=>'arrebolada'),
array('letra'=>'a', 'palabra'=>'arrebolar'),
array('letra'=>'a', 'palabra'=>'arrebolarse'),
array('letra'=>'a', 'palabra'=>'arrebolera'),
array('letra'=>'a', 'palabra'=>'arrebollarse'),
array('letra'=>'a', 'palabra'=>'arrebozar'),
array('letra'=>'a', 'palabra'=>'arrebozo'),
array('letra'=>'a', 'palabra'=>'arrebujadamente'),
array('letra'=>'a', 'palabra'=>'arrebujar'),
array('letra'=>'a', 'palabra'=>'arrecadar'),
array('letra'=>'a', 'palabra'=>'arrechar'),
array('letra'=>'a', 'palabra'=>'arrechera'),
array('letra'=>'a', 'palabra'=>'arrecho'),
array('letra'=>'a', 'palabra'=>'arrechuchar'),
array('letra'=>'a', 'palabra'=>'arrechucho'),
array('letra'=>'a', 'palabra'=>'arrechura'),
array('letra'=>'a', 'palabra'=>'arreciar'),
array('letra'=>'a', 'palabra'=>'arrecifar'),
array('letra'=>'a', 'palabra'=>'arrecife'),
array('letra'=>'a', 'palabra'=>'arrecir'),
array('letra'=>'a', 'palabra'=>'arredilar'),
array('letra'=>'a', 'palabra'=>'arredo'),
array('letra'=>'a', 'palabra'=>'arredomado'),
array('letra'=>'a', 'palabra'=>'arredondear'),
array('letra'=>'a', 'palabra'=>'arredor'),
array('letra'=>'a', 'palabra'=>'arredramiento'),
array('letra'=>'a', 'palabra'=>'arredrar'),
array('letra'=>'a', 'palabra'=>'arredro'),
array('letra'=>'a', 'palabra'=>'arregazado'),
array('letra'=>'a', 'palabra'=>'arregazar'),
array('letra'=>'a', 'palabra'=>'arreglada'),
array('letra'=>'a', 'palabra'=>'arregladamente'),
array('letra'=>'a', 'palabra'=>'arreglado'),
array('letra'=>'a', 'palabra'=>'arreglador'),
array('letra'=>'a', 'palabra'=>'arreglar'),
array('letra'=>'a', 'palabra'=>'arreglista'),
array('letra'=>'a', 'palabra'=>'arreglo'),
array('letra'=>'a', 'palabra'=>'arregostarse'),
array('letra'=>'a', 'palabra'=>'arregosto'),
array('letra'=>'a', 'palabra'=>'arreismo'),
array('letra'=>'a', 'palabra'=>'arrejacar'),
array('letra'=>'a', 'palabra'=>'arrejaco'),
array('letra'=>'a', 'palabra'=>'arrejada'),
array('letra'=>'a', 'palabra'=>'arrejaque'),
array('letra'=>'a', 'palabra'=>'arrejerar'),
array('letra'=>'a', 'palabra'=>'arrejonado'),
array('letra'=>'a', 'palabra'=>'arrelde'),
array('letra'=>'a', 'palabra'=>'arrellanarse'),
array('letra'=>'a', 'palabra'=>'arremangado'),
array('letra'=>'a', 'palabra'=>'arremangar'),
array('letra'=>'a', 'palabra'=>'arremango'),
array('letra'=>'a', 'palabra'=>'arrematar'),
array('letra'=>'a', 'palabra'=>'arremedar'),
array('letra'=>'a', 'palabra'=>'arremetedero'),
array('letra'=>'a', 'palabra'=>'arremetedor'),
array('letra'=>'a', 'palabra'=>'arremeter'),
array('letra'=>'a', 'palabra'=>'arremetida'),
array('letra'=>'a', 'palabra'=>'arremetimiento'),
array('letra'=>'a', 'palabra'=>'arremolinadamente'),
array('letra'=>'a', 'palabra'=>'arremolinarse'),
array('letra'=>'a', 'palabra'=>'arrempujar'),
array('letra'=>'a', 'palabra'=>'arrempujon'),
array('letra'=>'a', 'palabra'=>'arremueco'),
array('letra'=>'a', 'palabra'=>'arremuesco'),
array('letra'=>'a', 'palabra'=>'arrendable'),
array('letra'=>'a', 'palabra'=>'arrendacion'),
array('letra'=>'a', 'palabra'=>'arrendadero'),
array('letra'=>'a', 'palabra'=>'arrendador'),
array('letra'=>'a', 'palabra'=>'arrendajo'),
array('letra'=>'a', 'palabra'=>'arrendamiento'),
array('letra'=>'a', 'palabra'=>'arrendar'),
array('letra'=>'a', 'palabra'=>'arrendatario'),
array('letra'=>'a', 'palabra'=>'arrendaticio'),
array('letra'=>'a', 'palabra'=>'arrentado'),
array('letra'=>'a', 'palabra'=>'arreo'),
array('letra'=>'a', 'palabra'=>'arrepanchigarse'),
array('letra'=>'a', 'palabra'=>'arrepapalo'),
array('letra'=>'a', 'palabra'=>'arrepasarse'),
array('letra'=>'a', 'palabra'=>'arrepentida'),
array('letra'=>'a', 'palabra'=>'arrepentimiento'),
array('letra'=>'a', 'palabra'=>'arrepentirse'),
array('letra'=>'a', 'palabra'=>'arrepiso'),
array('letra'=>'a', 'palabra'=>'arrepistar'),
array('letra'=>'a', 'palabra'=>'arrepisto'),
array('letra'=>'a', 'palabra'=>'arrepticio'),
array('letra'=>'a', 'palabra'=>'arrequesonarse'),
array('letra'=>'a', 'palabra'=>'arrequife'),
array('letra'=>'a', 'palabra'=>'arrequin'),
array('letra'=>'a', 'palabra'=>'arrequintar'),
array('letra'=>'a', 'palabra'=>'arrequive'),
array('letra'=>'a', 'palabra'=>'arrestado'),
array('letra'=>'a', 'palabra'=>'arrestar'),
array('letra'=>'a', 'palabra'=>'arresto'),
array('letra'=>'a', 'palabra'=>'arretin'),
array('letra'=>'a', 'palabra'=>'arretranca'),
array('letra'=>'a', 'palabra'=>'arrevesado'),
array('letra'=>'a', 'palabra'=>'arrevolvedor'),
array('letra'=>'a', 'palabra'=>'arrevolver'),
array('letra'=>'a', 'palabra'=>'arrezafe'),
array('letra'=>'a', 'palabra'=>'arrezagar'),
array('letra'=>'a', 'palabra'=>'arria'),
array('letra'=>'a', 'palabra'=>'arriacense'),
array('letra'=>'a', 'palabra'=>'arriada'),
array('letra'=>'a', 'palabra'=>'arriado'),
array('letra'=>'a', 'palabra'=>'arrial'),
array('letra'=>'a', 'palabra'=>'arriamiento'),
array('letra'=>'a', 'palabra'=>'arrianismo'),
array('letra'=>'a', 'palabra'=>'arriano'),
array('letra'=>'a', 'palabra'=>'arriar'),
array('letra'=>'a', 'palabra'=>'arriata'),
array('letra'=>'a', 'palabra'=>'arriate'),
array('letra'=>'a', 'palabra'=>'arriaz'),
array('letra'=>'a', 'palabra'=>'arriba'),
array('letra'=>'a', 'palabra'=>'arribada'),
array('letra'=>'a', 'palabra'=>'arribaje'),
array('letra'=>'a', 'palabra'=>'arribar'),
array('letra'=>'a', 'palabra'=>'arribazon'),
array('letra'=>'a', 'palabra'=>'arribeño'),
array('letra'=>'a', 'palabra'=>'arribes'),
array('letra'=>'a', 'palabra'=>'arribismo'),
array('letra'=>'a', 'palabra'=>'arribista'),
array('letra'=>'a', 'palabra'=>'arribo'),
array('letra'=>'a', 'palabra'=>'arrices'),
array('letra'=>'a', 'palabra'=>'arricesa'),
array('letra'=>'a', 'palabra'=>'arricete'),
array('letra'=>'a', 'palabra'=>'arridar'),
array('letra'=>'a', 'palabra'=>'arriedro'),
array('letra'=>'a', 'palabra'=>'arriendo'),
array('letra'=>'a', 'palabra'=>'arrieria'),
array('letra'=>'a', 'palabra'=>'arriero'),
array('letra'=>'a', 'palabra'=>'arriesgado'),
array('letra'=>'a', 'palabra'=>'arriesgar'),
array('letra'=>'a', 'palabra'=>'arriesgon'),
array('letra'=>'a', 'palabra'=>'arrife'),
array('letra'=>'a', 'palabra'=>'arrigirse'),
array('letra'=>'a', 'palabra'=>'arrima'),
array('letra'=>'a', 'palabra'=>'arrimadero'),
array('letra'=>'a', 'palabra'=>'arrimadillo'),
array('letra'=>'a', 'palabra'=>'arrimadizo'),
array('letra'=>'a', 'palabra'=>'arrimado'),
array('letra'=>'a', 'palabra'=>'arrimador'),
array('letra'=>'a', 'palabra'=>'arrimadura'),
array('letra'=>'a', 'palabra'=>'arrimar'),
array('letra'=>'a', 'palabra'=>'arrime'),
array('letra'=>'a', 'palabra'=>'arrimo'),
array('letra'=>'a', 'palabra'=>'arrimon'),
array('letra'=>'a', 'palabra'=>'arrincar'),
array('letra'=>'a', 'palabra'=>'arrinconado'),
array('letra'=>'a', 'palabra'=>'arrinconamiento'),
array('letra'=>'a', 'palabra'=>'arrinconar'),
array('letra'=>'a', 'palabra'=>'arriñonado'),
array('letra'=>'a', 'palabra'=>'arriostrar'),
array('letra'=>'a', 'palabra'=>'arriscadamente'),
array('letra'=>'a', 'palabra'=>'arriscado'),
array('letra'=>'a', 'palabra'=>'arriscador'),
array('letra'=>'a', 'palabra'=>'arriscamiento'),
array('letra'=>'a', 'palabra'=>'arriscar'),
array('letra'=>'a', 'palabra'=>'arrisco'),
array('letra'=>'a', 'palabra'=>'arritar'),
array('letra'=>'a', 'palabra'=>'arritmia'),
array('letra'=>'a', 'palabra'=>'arritmico'),
array('letra'=>'a', 'palabra'=>'arritranca'),
array('letra'=>'a', 'palabra'=>'arrizar'),
array('letra'=>'a', 'palabra'=>'arroaz'),
array('letra'=>'a', 'palabra'=>'arroba'),
array('letra'=>'a', 'palabra'=>'arrobadera'),
array('letra'=>'a', 'palabra'=>'arrobadizo'),
array('letra'=>'a', 'palabra'=>'arrobado'),
array('letra'=>'a', 'palabra'=>'arrobador'),
array('letra'=>'a', 'palabra'=>'arrobal'),
array('letra'=>'a', 'palabra'=>'arrobamiento'),
array('letra'=>'a', 'palabra'=>'arrobar'),
array('letra'=>'a', 'palabra'=>'arrobeño'),
array('letra'=>'a', 'palabra'=>'arrobero'),
array('letra'=>'a', 'palabra'=>'arrobo'),
array('letra'=>'a', 'palabra'=>'arrocabe'),
array('letra'=>'a', 'palabra'=>'arrocado'),
array('letra'=>'a', 'palabra'=>'arrocero'),
array('letra'=>'a', 'palabra'=>'arrocinado'),
array('letra'=>'a', 'palabra'=>'arrocinar'),
array('letra'=>'a', 'palabra'=>'arrodajarse'),
array('letra'=>'a', 'palabra'=>'arrodalado'),
array('letra'=>'a', 'palabra'=>'arrodeamiento'),
array('letra'=>'a', 'palabra'=>'arrodear'),
array('letra'=>'a', 'palabra'=>'arrodelar'),
array('letra'=>'a', 'palabra'=>'arrodeo'),
array('letra'=>'a', 'palabra'=>'arrodillada'),
array('letra'=>'a', 'palabra'=>'arrodilladura'),
array('letra'=>'a', 'palabra'=>'arrodillamiento'),
array('letra'=>'a', 'palabra'=>'arrodillar'),
array('letra'=>'a', 'palabra'=>'arrodrigar'),
array('letra'=>'a', 'palabra'=>'arrodrigonar'),
array('letra'=>'a', 'palabra'=>'arrogacion'),
array('letra'=>'a', 'palabra'=>'arrogador'),
array('letra'=>'a', 'palabra'=>'arrogancia'),
array('letra'=>'a', 'palabra'=>'arrogante'),
array('letra'=>'a', 'palabra'=>'arrogar'),
array('letra'=>'a', 'palabra'=>'arrojadizo'),
array('letra'=>'a', 'palabra'=>'arrojado'),
array('letra'=>'a', 'palabra'=>'arrojador'),
array('letra'=>'a', 'palabra'=>'arrojamiento'),
array('letra'=>'a', 'palabra'=>'arrojar'),
array('letra'=>'a', 'palabra'=>'arroje'),
array('letra'=>'a', 'palabra'=>'arrojo'),
array('letra'=>'a', 'palabra'=>'arrollable'),
array('letra'=>'a', 'palabra'=>'arrollado'),
array('letra'=>'a', 'palabra'=>'arrollador'),
array('letra'=>'a', 'palabra'=>'arrollamiento'),
array('letra'=>'a', 'palabra'=>'arrollar'),
array('letra'=>'a', 'palabra'=>'arromadizar'),
array('letra'=>'a', 'palabra'=>'arromanzar'),
array('letra'=>'a', 'palabra'=>'arromar'),
array('letra'=>'a', 'palabra'=>'arromper'),
array('letra'=>'a', 'palabra'=>'arrompido'),
array('letra'=>'a', 'palabra'=>'arronjar'),
array('letra'=>'a', 'palabra'=>'arronzar'),
array('letra'=>'a', 'palabra'=>'arropamiento'),
array('letra'=>'a', 'palabra'=>'arropar'),
array('letra'=>'a', 'palabra'=>'arrope'),
array('letra'=>'a', 'palabra'=>'arropera'),
array('letra'=>'a', 'palabra'=>'arropia'),
array('letra'=>'a', 'palabra'=>'arropiero'),
array('letra'=>'a', 'palabra'=>'arroscar'),
array('letra'=>'a', 'palabra'=>'arrosquetado'),
array('letra'=>'a', 'palabra'=>'arrostrado'),
array('letra'=>'a', 'palabra'=>'arrostrar'),
array('letra'=>'a', 'palabra'=>'arrotado'),
array('letra'=>'a', 'palabra'=>'arroto'),
array('letra'=>'a', 'palabra'=>'arroyada'),
array('letra'=>'a', 'palabra'=>'arroyadero'),
array('letra'=>'a', 'palabra'=>'arroyamiento'),
array('letra'=>'a', 'palabra'=>'arroyar'),
array('letra'=>'a', 'palabra'=>'arroyarse'),
array('letra'=>'a', 'palabra'=>'arroyato'),
array('letra'=>'a', 'palabra'=>'arroyo'),
array('letra'=>'a', 'palabra'=>'arroyuela'),
array('letra'=>'a', 'palabra'=>'arroz'),
array('letra'=>'a', 'palabra'=>'arrozal'),
array('letra'=>'a', 'palabra'=>'arruar'),
array('letra'=>'a', 'palabra'=>'arruchar'),
array('letra'=>'a', 'palabra'=>'arrufadia'),
array('letra'=>'a', 'palabra'=>'arrufadura'),
array('letra'=>'a', 'palabra'=>'arrufaldado'),
array('letra'=>'a', 'palabra'=>'arrufar'),
array('letra'=>'a', 'palabra'=>'arrufianado'),
array('letra'=>'a', 'palabra'=>'arrufo'),
array('letra'=>'a', 'palabra'=>'arruga'),
array('letra'=>'a', 'palabra'=>'arrugable'),
array('letra'=>'a', 'palabra'=>'arrugacion'),
array('letra'=>'a', 'palabra'=>'arrugamiento'),
array('letra'=>'a', 'palabra'=>'arrugar'),
array('letra'=>'a', 'palabra'=>'arrugia'),
array('letra'=>'a', 'palabra'=>'arrui'),
array('letra'=>'a', 'palabra'=>'arruinado'),
array('letra'=>'a', 'palabra'=>'arruinador'),
array('letra'=>'a', 'palabra'=>'arruinamiento'),
array('letra'=>'a', 'palabra'=>'arruinar'),
array('letra'=>'a', 'palabra'=>'arrullador'),
array('letra'=>'a', 'palabra'=>'arrullar'),
array('letra'=>'a', 'palabra'=>'arrullo'),
array('letra'=>'a', 'palabra'=>'arruma'),
array('letra'=>'a', 'palabra'=>'arrumaco'),
array('letra'=>'a', 'palabra'=>'arrumaje'),
array('letra'=>'a', 'palabra'=>'arrumar'),
array('letra'=>'a', 'palabra'=>'arrumazon'),
array('letra'=>'a', 'palabra'=>'arrumbacion'),
array('letra'=>'a', 'palabra'=>'arrumbada'),
array('letra'=>'a', 'palabra'=>'arrumbador'),
array('letra'=>'a', 'palabra'=>'arrumbamiento'),
array('letra'=>'a', 'palabra'=>'arrumbar'),
array('letra'=>'a', 'palabra'=>'arrumueco'),
array('letra'=>'a', 'palabra'=>'arrunflar'),
array('letra'=>'a', 'palabra'=>'arruruz'),
array('letra'=>'a', 'palabra'=>'arrusticado'),
array('letra'=>'a', 'palabra'=>'arrusticar'),
array('letra'=>'a', 'palabra'=>'arrutar'),
array('letra'=>'a', 'palabra'=>'arrutinar'),
array('letra'=>'a', 'palabra'=>'arsafraga'),
array('letra'=>'a', 'palabra'=>'arsafraga'),
array('letra'=>'a', 'palabra'=>'arsenal'),
array('letra'=>'a', 'palabra'=>'arseniato'),
array('letra'=>'a', 'palabra'=>'arsenical'),
array('letra'=>'a', 'palabra'=>'arsenico'),
array('letra'=>'a', 'palabra'=>'arsenioso'),
array('letra'=>'a', 'palabra'=>'arsenito'),
array('letra'=>'a', 'palabra'=>'arseniuro'),
array('letra'=>'a', 'palabra'=>'arsolla'),
array('letra'=>'a', 'palabra'=>'arta'),
array('letra'=>'a', 'palabra'=>'artabro'),
array('letra'=>'a', 'palabra'=>'artado'),
array('letra'=>'a', 'palabra'=>'artal'),
array('letra'=>'a', 'palabra'=>'artanica'),
array('letra'=>'a', 'palabra'=>'artanita'),
array('letra'=>'a', 'palabra'=>'arte'),
array('letra'=>'a', 'palabra'=>'artefacto'),
array('letra'=>'a', 'palabra'=>'artejo'),
array('letra'=>'a', 'palabra'=>'artelleria'),
array('letra'=>'a', 'palabra'=>'artemisa'),
array('letra'=>'a', 'palabra'=>'artemisia'),
array('letra'=>'a', 'palabra'=>'artera'),
array('letra'=>'a', 'palabra'=>'arteria'),
array('letra'=>'a', 'palabra'=>'arteria'),
array('letra'=>'a', 'palabra'=>'arterial'),
array('letra'=>'a', 'palabra'=>'arterioesclerosis'),
array('letra'=>'a', 'palabra'=>'arteriografia'),
array('letra'=>'a', 'palabra'=>'arteriola'),
array('letra'=>'a', 'palabra'=>'arteriologia'),
array('letra'=>'a', 'palabra'=>'arteriosclerosico'),
array('letra'=>'a', 'palabra'=>'arteriosclerosis'),
array('letra'=>'a', 'palabra'=>'arteriosclerotico'),
array('letra'=>'a', 'palabra'=>'arterioso'),
array('letra'=>'a', 'palabra'=>'arteritis'),
array('letra'=>'a', 'palabra'=>'artero'),
array('letra'=>'a', 'palabra'=>'artesa'),
array('letra'=>'a', 'palabra'=>'artesanado'),
array('letra'=>'a', 'palabra'=>'artesanal'),
array('letra'=>'a', 'palabra'=>'artesania'),
array('letra'=>'a', 'palabra'=>'artesano'),
array('letra'=>'a', 'palabra'=>'artesiano'),
array('letra'=>'a', 'palabra'=>'artesilla'),
array('letra'=>'a', 'palabra'=>'arteson'),
array('letra'=>'a', 'palabra'=>'artesonado'),
array('letra'=>'a', 'palabra'=>'artesonar'),
array('letra'=>'a', 'palabra'=>'artetico'),
array('letra'=>'a', 'palabra'=>'artica'),
array('letra'=>'a', 'palabra'=>'artica'),
array('letra'=>'a', 'palabra'=>'artico'),
array('letra'=>'a', 'palabra'=>'articulacion'),
array('letra'=>'a', 'palabra'=>'articuladamente'),
array('letra'=>'a', 'palabra'=>'articulado'),
array('letra'=>'a', 'palabra'=>'articulador'),
array('letra'=>'a', 'palabra'=>'articular'),
array('letra'=>'a', 'palabra'=>'articulario'),
array('letra'=>'a', 'palabra'=>'articulatorio'),
array('letra'=>'a', 'palabra'=>'articulista'),
array('letra'=>'a', 'palabra'=>'articulo'),
array('letra'=>'a', 'palabra'=>'artifice'),
array('letra'=>'a', 'palabra'=>'artificial'),
array('letra'=>'a', 'palabra'=>'artificialidad'),
array('letra'=>'a', 'palabra'=>'artificialmente'),
array('letra'=>'a', 'palabra'=>'artificiar'),
array('letra'=>'a', 'palabra'=>'artificiero'),
array('letra'=>'a', 'palabra'=>'artificio'),
array('letra'=>'a', 'palabra'=>'artificiosidad'),
array('letra'=>'a', 'palabra'=>'artificioso'),
array('letra'=>'a', 'palabra'=>'artiga'),
array('letra'=>'a', 'palabra'=>'artigar'),
array('letra'=>'a', 'palabra'=>'artillado'),
array('letra'=>'a', 'palabra'=>'artillar'),
array('letra'=>'a', 'palabra'=>'artilleria'),
array('letra'=>'a', 'palabra'=>'artillero'),
array('letra'=>'a', 'palabra'=>'artilugio'),
array('letra'=>'a', 'palabra'=>'artimaña'),
array('letra'=>'a', 'palabra'=>'artimon'),
array('letra'=>'a', 'palabra'=>'artina'),
array('letra'=>'a', 'palabra'=>'artiodactilo'),
array('letra'=>'a', 'palabra'=>'artista'),
array('letra'=>'a', 'palabra'=>'artistico'),
array('letra'=>'a', 'palabra'=>'artizado'),
array('letra'=>'a', 'palabra'=>'artizar'),
array('letra'=>'a', 'palabra'=>'arto'),
array('letra'=>'a', 'palabra'=>'artocarpaceo'),
array('letra'=>'a', 'palabra'=>'artocarpeo'),
array('letra'=>'a', 'palabra'=>'artolas'),
array('letra'=>'a', 'palabra'=>'artos'),
array('letra'=>'a', 'palabra'=>'artralgia'),
array('letra'=>'a', 'palabra'=>'artritico'),
array('letra'=>'a', 'palabra'=>'artritis'),
array('letra'=>'a', 'palabra'=>'artritismo'),
array('letra'=>'a', 'palabra'=>'artrografia'),
array('letra'=>'a', 'palabra'=>'artrologia'),
array('letra'=>'a', 'palabra'=>'artropatia'),
array('letra'=>'a', 'palabra'=>'artropodo'),
array('letra'=>'a', 'palabra'=>'artrosis'),
array('letra'=>'a', 'palabra'=>'artuña'),
array('letra'=>'a', 'palabra'=>'arturico'),
array('letra'=>'a', 'palabra'=>'aruera'),
array('letra'=>'a', 'palabra'=>'arugas'),
array('letra'=>'a', 'palabra'=>'arula'),
array('letra'=>'a', 'palabra'=>'arundense'),
array('letra'=>'a', 'palabra'=>'arundineo'),
array('letra'=>'a', 'palabra'=>'aruñar'),
array('letra'=>'a', 'palabra'=>'aruñazo'),
array('letra'=>'a', 'palabra'=>'aruño'),
array('letra'=>'a', 'palabra'=>'aruñon'),
array('letra'=>'a', 'palabra'=>'aruspice'),
array('letra'=>'a', 'palabra'=>'aruspicina'),
array('letra'=>'a', 'palabra'=>'arveja'),
array('letra'=>'a', 'palabra'=>'arvejal'),
array('letra'=>'a', 'palabra'=>'arvejana'),
array('letra'=>'a', 'palabra'=>'arvejar'),
array('letra'=>'a', 'palabra'=>'arvejera'),
array('letra'=>'a', 'palabra'=>'arvejo'),
array('letra'=>'a', 'palabra'=>'arvejon'),
array('letra'=>'a', 'palabra'=>'arvejona'),
array('letra'=>'a', 'palabra'=>'arvejote'),
array('letra'=>'a', 'palabra'=>'arvense'),
array('letra'=>'a', 'palabra'=>'arzobispado'),
array('letra'=>'a', 'palabra'=>'arzobispal'),
array('letra'=>'a', 'palabra'=>'arzobispo'),
array('letra'=>'a', 'palabra'=>'arzolla'),
array('letra'=>'a', 'palabra'=>'arzon'),
array('letra'=>'a', 'palabra'=>'as'),
array('letra'=>'a', 'palabra'=>'asa'),
array('letra'=>'a', 'palabra'=>'asa'),
array('letra'=>'a', 'palabra'=>'asaborado'),
array('letra'=>'a', 'palabra'=>'asaborar'),
array('letra'=>'a', 'palabra'=>'asaborir'),
array('letra'=>'a', 'palabra'=>'asacador'),
array('letra'=>'a', 'palabra'=>'asacamiento'),
array('letra'=>'a', 'palabra'=>'asacar'),
array('letra'=>'a', 'palabra'=>'asacion'),
array('letra'=>'a', 'palabra'=>'asacristanado'),
array('letra'=>'a', 'palabra'=>'asadero'),
array('letra'=>'a', 'palabra'=>'asado'),
array('letra'=>'a', 'palabra'=>'asador'),
array('letra'=>'a', 'palabra'=>'asadura'),
array('letra'=>'a', 'palabra'=>'asaduria'),
array('letra'=>'a', 'palabra'=>'asaetar'),
array('letra'=>'a', 'palabra'=>'asaeteador'),
array('letra'=>'a', 'palabra'=>'asaetear'),
array('letra'=>'a', 'palabra'=>'asaetinado'),
array('letra'=>'a', 'palabra'=>'asafetida'),
array('letra'=>'a', 'palabra'=>'asainetado'),
array('letra'=>'a', 'palabra'=>'asainetear'),
array('letra'=>'a', 'palabra'=>'asalariado'),
array('letra'=>'a', 'palabra'=>'asalariar'),
array('letra'=>'a', 'palabra'=>'asalir'),
array('letra'=>'a', 'palabra'=>'asalmerar'),
array('letra'=>'a', 'palabra'=>'asalmonado'),
array('letra'=>'a', 'palabra'=>'asaltador'),
array('letra'=>'a', 'palabra'=>'asaltante'),
array('letra'=>'a', 'palabra'=>'asaltar'),
array('letra'=>'a', 'palabra'=>'asalto'),
array('letra'=>'a', 'palabra'=>'asamblea'),
array('letra'=>'a', 'palabra'=>'asambleista'),
array('letra'=>'a', 'palabra'=>'asar'),
array('letra'=>'a', 'palabra'=>'asarabacara'),
array('letra'=>'a', 'palabra'=>'asaraca'),
array('letra'=>'a', 'palabra'=>'asardinado'),
array('letra'=>'a', 'palabra'=>'asarero'),
array('letra'=>'a', 'palabra'=>'asargado'),
array('letra'=>'a', 'palabra'=>'asarina'),
array('letra'=>'a', 'palabra'=>'asaro'),
array('letra'=>'a', 'palabra'=>'asativo'),
array('letra'=>'a', 'palabra'=>'asayar'),
array('letra'=>'a', 'palabra'=>'asaz'),
array('letra'=>'a', 'palabra'=>'asbestino'),
array('letra'=>'a', 'palabra'=>'asbesto'),
array('letra'=>'a', 'palabra'=>'asbestosis'),
array('letra'=>'a', 'palabra'=>'asca'),
array('letra'=>'a', 'palabra'=>'ascalonia'),
array('letra'=>'a', 'palabra'=>'ascalonita'),
array('letra'=>'a', 'palabra'=>'ascar'),
array('letra'=>'a', 'palabra'=>'ascari'),
array('letra'=>'a', 'palabra'=>'ascaride'),
array('letra'=>'a', 'palabra'=>'ascarita'),
array('letra'=>'a', 'palabra'=>'ascendencia'),
array('letra'=>'a', 'palabra'=>'ascendente'),
array('letra'=>'a', 'palabra'=>'ascender'),
array('letra'=>'a', 'palabra'=>'ascendiente'),
array('letra'=>'a', 'palabra'=>'ascension'),
array('letra'=>'a', 'palabra'=>'ascensional'),
array('letra'=>'a', 'palabra'=>'ascensionista'),
array('letra'=>'a', 'palabra'=>'ascenso'),
array('letra'=>'a', 'palabra'=>'ascensor'),
array('letra'=>'a', 'palabra'=>'ascensorista'),
array('letra'=>'a', 'palabra'=>'ascesis'),
array('letra'=>'a', 'palabra'=>'asceta'),
array('letra'=>'a', 'palabra'=>'asceterio'),
array('letra'=>'a', 'palabra'=>'ascetico'),
array('letra'=>'a', 'palabra'=>'ascetismo'),
array('letra'=>'a', 'palabra'=>'ascio'),
array('letra'=>'a', 'palabra'=>'asciro'),
array('letra'=>'a', 'palabra'=>'asciterio'),
array('letra'=>'a', 'palabra'=>'ascitico'),
array('letra'=>'a', 'palabra'=>'ascitis'),
array('letra'=>'a', 'palabra'=>'asclepiadaceo'),
array('letra'=>'a', 'palabra'=>'asclepiadeo'),
array('letra'=>'a', 'palabra'=>'asco'),
array('letra'=>'a', 'palabra'=>'ascomiceto'),
array('letra'=>'a', 'palabra'=>'asconder'),
array('letra'=>'a', 'palabra'=>'ascondidamente'),
array('letra'=>'a', 'palabra'=>'ascondido'),
array('letra'=>'a', 'palabra'=>'ascondrijo'),
array('letra'=>'a', 'palabra'=>'ascoroso'),
array('letra'=>'a', 'palabra'=>'ascosidad'),
array('letra'=>'a', 'palabra'=>'ascoso'),
array('letra'=>'a', 'palabra'=>'ascreo'),
array('letra'=>'a', 'palabra'=>'ascua'),
array('letra'=>'a', 'palabra'=>'aseado'),
array('letra'=>'a', 'palabra'=>'asear'),
array('letra'=>'a', 'palabra'=>'asechador'),
array('letra'=>'a', 'palabra'=>'asechamiento'),
array('letra'=>'a', 'palabra'=>'asechanza'),
array('letra'=>'a', 'palabra'=>'asechar'),
array('letra'=>'a', 'palabra'=>'asecho'),
array('letra'=>'a', 'palabra'=>'asechoso'),
array('letra'=>'a', 'palabra'=>'asecucion'),
array('letra'=>'a', 'palabra'=>'asedar'),
array('letra'=>'a', 'palabra'=>'asediador'),
array('letra'=>'a', 'palabra'=>'asediar'),
array('letra'=>'a', 'palabra'=>'asedio'),
array('letra'=>'a', 'palabra'=>'aseglararse'),
array('letra'=>'a', 'palabra'=>'aseglarizar'),
array('letra'=>'a', 'palabra'=>'asegundar'),
array('letra'=>'a', 'palabra'=>'asegurable'),
array('letra'=>'a', 'palabra'=>'aseguracion'),
array('letra'=>'a', 'palabra'=>'asegurado'),
array('letra'=>'a', 'palabra'=>'asegurador'),
array('letra'=>'a', 'palabra'=>'aseguramiento'),
array('letra'=>'a', 'palabra'=>'aseguranza'),
array('letra'=>'a', 'palabra'=>'asegurar'),
array('letra'=>'a', 'palabra'=>'aseidad'),
array('letra'=>'a', 'palabra'=>'aseladero'),
array('letra'=>'a', 'palabra'=>'aselador'),
array('letra'=>'a', 'palabra'=>'aselar'),
array('letra'=>'a', 'palabra'=>'asemblar'),
array('letra'=>'a', 'palabra'=>'asemejar'),
array('letra'=>'a', 'palabra'=>'asemillar'),
array('letra'=>'a', 'palabra'=>'asencio'),
array('letra'=>'a', 'palabra'=>'asendereado'),
array('letra'=>'a', 'palabra'=>'asenderear'),
array('letra'=>'a', 'palabra'=>'asengladura'),
array('letra'=>'a', 'palabra'=>'asenjo'),
array('letra'=>'a', 'palabra'=>'asensio'),
array('letra'=>'a', 'palabra'=>'asenso'),
array('letra'=>'a', 'palabra'=>'asentacion'),
array('letra'=>'a', 'palabra'=>'asentada'),
array('letra'=>'a', 'palabra'=>'asentadamente'),
array('letra'=>'a', 'palabra'=>'asentaderas'),
array('letra'=>'a', 'palabra'=>'asentadillas'),
array('letra'=>'a', 'palabra'=>'asentado'),
array('letra'=>'a', 'palabra'=>'asentador'),
array('letra'=>'a', 'palabra'=>'asentadura'),
array('letra'=>'a', 'palabra'=>'asentamiento'),
array('letra'=>'a', 'palabra'=>'asentar'),
array('letra'=>'a', 'palabra'=>'asentimiento'),
array('letra'=>'a', 'palabra'=>'asentir'),
array('letra'=>'a', 'palabra'=>'asentista'),
array('letra'=>'a', 'palabra'=>'aseñorado'),
array('letra'=>'a', 'palabra'=>'aseñoritado'),
array('letra'=>'a', 'palabra'=>'aseo'),
array('letra'=>'a', 'palabra'=>'asepalo'),
array('letra'=>'a', 'palabra'=>'asepsia'),
array('letra'=>'a', 'palabra'=>'aseptico'),
array('letra'=>'a', 'palabra'=>'asequi'),
array('letra'=>'a', 'palabra'=>'asequible'),
array('letra'=>'a', 'palabra'=>'asercion'),
array('letra'=>'a', 'palabra'=>'aserenar'),
array('letra'=>'a', 'palabra'=>'aseriarse'),
array('letra'=>'a', 'palabra'=>'asermonado'),
array('letra'=>'a', 'palabra'=>'aserrada'),
array('letra'=>'a', 'palabra'=>'aserradero'),
array('letra'=>'a', 'palabra'=>'aserradizo'),
array('letra'=>'a', 'palabra'=>'aserrado'),
array('letra'=>'a', 'palabra'=>'aserrador'),
array('letra'=>'a', 'palabra'=>'aserradura'),
array('letra'=>'a', 'palabra'=>'aserrar'),
array('letra'=>'a', 'palabra'=>'aserreria'),
array('letra'=>'a', 'palabra'=>'aserrin'),
array('letra'=>'a', 'palabra'=>'aserrio'),
array('letra'=>'a', 'palabra'=>'aserruchar'),
array('letra'=>'a', 'palabra'=>'asertivo'),
array('letra'=>'a', 'palabra'=>'aserto'),
array('letra'=>'a', 'palabra'=>'asertor'),
array('letra'=>'a', 'palabra'=>'asertorico'),
array('letra'=>'a', 'palabra'=>'asertorio'),
array('letra'=>'a', 'palabra'=>'asesado'),
array('letra'=>'a', 'palabra'=>'asesar'),
array('letra'=>'a', 'palabra'=>'asesinar'),
array('letra'=>'a', 'palabra'=>'asesinato'),
array('letra'=>'a', 'palabra'=>'asesino'),
array('letra'=>'a', 'palabra'=>'asesor'),
array('letra'=>'a', 'palabra'=>'asesoramiento'),
array('letra'=>'a', 'palabra'=>'asesorar'),
array('letra'=>'a', 'palabra'=>'asesoria'),
array('letra'=>'a', 'palabra'=>'asestadero'),
array('letra'=>'a', 'palabra'=>'asestadura'),
array('letra'=>'a', 'palabra'=>'asestar'),
array('letra'=>'a', 'palabra'=>'aseveracion'),
array('letra'=>'a', 'palabra'=>'aseverar'),
array('letra'=>'a', 'palabra'=>'aseverativo'),
array('letra'=>'a', 'palabra'=>'asexuado'),
array('letra'=>'a', 'palabra'=>'asexual'),
array('letra'=>'a', 'palabra'=>'asfaltado'),
array('letra'=>'a', 'palabra'=>'asfaltar'),
array('letra'=>'a', 'palabra'=>'asfaltico'),
array('letra'=>'a', 'palabra'=>'asfalto'),
array('letra'=>'a', 'palabra'=>'asfictico'),
array('letra'=>'a', 'palabra'=>'asfixia'),
array('letra'=>'a', 'palabra'=>'asfixiante'),
array('letra'=>'a', 'palabra'=>'asfixiar'),
array('letra'=>'a', 'palabra'=>'asfixico'),
array('letra'=>'a', 'palabra'=>'asfodelo'),
array('letra'=>'a', 'palabra'=>'asi'),
array('letra'=>'a', 'palabra'=>'asiano'),
array('letra'=>'a', 'palabra'=>'asiatico'),
array('letra'=>'a', 'palabra'=>'asibilacion'),
array('letra'=>'a', 'palabra'=>'asibilar'),
array('letra'=>'a', 'palabra'=>'asicar'),
array('letra'=>'a', 'palabra'=>'asidero'),
array('letra'=>'a', 'palabra'=>'asidonense'),
array('letra'=>'a', 'palabra'=>'asiduidad'),
array('letra'=>'a', 'palabra'=>'asiduo'),
array('letra'=>'a', 'palabra'=>'asiento'),
array('letra'=>'a', 'palabra'=>'asignable'),
array('letra'=>'a', 'palabra'=>'asignacion'),
array('letra'=>'a', 'palabra'=>'asignado'),
array('letra'=>'a', 'palabra'=>'asignar'),
array('letra'=>'a', 'palabra'=>'asignatario'),
array('letra'=>'a', 'palabra'=>'asignatura'),
array('letra'=>'a', 'palabra'=>'asilado'),
array('letra'=>'a', 'palabra'=>'asilar'),
array('letra'=>'a', 'palabra'=>'asilla'),
array('letra'=>'a', 'palabra'=>'asilo'),
array('letra'=>'a', 'palabra'=>'asilvestrado'),
array('letra'=>'a', 'palabra'=>'asimesmo'),
array('letra'=>'a', 'palabra'=>'asimetria'),
array('letra'=>'a', 'palabra'=>'asimetrico'),
array('letra'=>'a', 'palabra'=>'asimiento'),
array('letra'=>'a', 'palabra'=>'asimilable'),
array('letra'=>'a', 'palabra'=>'asimilacion'),
array('letra'=>'a', 'palabra'=>'asimilado'),
array('letra'=>'a', 'palabra'=>'asimilador'),
array('letra'=>'a', 'palabra'=>'asimilar'),
array('letra'=>'a', 'palabra'=>'asimilativo'),
array('letra'=>'a', 'palabra'=>'asimilatorio'),
array('letra'=>'a', 'palabra'=>'asimilismo'),
array('letra'=>'a', 'palabra'=>'asimilista'),
array('letra'=>'a', 'palabra'=>'asimismo'),
array('letra'=>'a', 'palabra'=>'asimplado'),
array('letra'=>'a', 'palabra'=>'asin'),
array('letra'=>'a', 'palabra'=>'asina'),
array('letra'=>'a', 'palabra'=>'asincronico'),
array('letra'=>'a', 'palabra'=>'asincronismo'),
array('letra'=>'a', 'palabra'=>'asincrono'),
array('letra'=>'a', 'palabra'=>'asindetico'),
array('letra'=>'a', 'palabra'=>'asindeton'),
array('letra'=>'a', 'palabra'=>'asinergia'),
array('letra'=>'a', 'palabra'=>'asinino'),
array('letra'=>'a', 'palabra'=>'asintota'),
array('letra'=>'a', 'palabra'=>'asintotico'),
array('letra'=>'a', 'palabra'=>'asir'),
array('letra'=>'a', 'palabra'=>'asiriano'),
array('letra'=>'a', 'palabra'=>'asirio'),
array('letra'=>'a', 'palabra'=>'asiriologia'),
array('letra'=>'a', 'palabra'=>'asiriologo'),
array('letra'=>'a', 'palabra'=>'asistencia'),
array('letra'=>'a', 'palabra'=>'asistencial'),
array('letra'=>'a', 'palabra'=>'asistenta'),
array('letra'=>'a', 'palabra'=>'asistente'),
array('letra'=>'a', 'palabra'=>'asistido'),
array('letra'=>'a', 'palabra'=>'asistimiento'),
array('letra'=>'a', 'palabra'=>'asistir'),
array('letra'=>'a', 'palabra'=>'asistolia'),
array('letra'=>'a', 'palabra'=>'asistolico'),
array('letra'=>'a', 'palabra'=>'askenazi'),
array('letra'=>'a', 'palabra'=>'aslilla'),
array('letra'=>'a', 'palabra'=>'asma'),
array('letra'=>'a', 'palabra'=>'asmadamente'),
array('letra'=>'a', 'palabra'=>'asmadero'),
array('letra'=>'a', 'palabra'=>'asmamiento'),
array('letra'=>'a', 'palabra'=>'asmar'),
array('letra'=>'a', 'palabra'=>'asmatico'),
array('letra'=>'a', 'palabra'=>'asmoso'),
array('letra'=>'a', 'palabra'=>'asna'),
array('letra'=>'a', 'palabra'=>'asnacho'),
array('letra'=>'a', 'palabra'=>'asnada'),
array('letra'=>'a', 'palabra'=>'asnado'),
array('letra'=>'a', 'palabra'=>'asnal'),
array('letra'=>'a', 'palabra'=>'asnallo'),
array('letra'=>'a', 'palabra'=>'asnalmente'),
array('letra'=>'a', 'palabra'=>'asneria'),
array('letra'=>'a', 'palabra'=>'asnerizo'),
array('letra'=>'a', 'palabra'=>'asnico'),
array('letra'=>'a', 'palabra'=>'asnilla'),
array('letra'=>'a', 'palabra'=>'asnillo'),
array('letra'=>'a', 'palabra'=>'asnino'),
array('letra'=>'a', 'palabra'=>'asno'),
array('letra'=>'a', 'palabra'=>'asnuno'),
array('letra'=>'a', 'palabra'=>'asobarcar'),
array('letra'=>'a', 'palabra'=>'asobinarse'),
array('letra'=>'a', 'palabra'=>'asocairarse'),
array('letra'=>'a', 'palabra'=>'asocarronado'),
array('letra'=>'a', 'palabra'=>'asociable'),
array('letra'=>'a', 'palabra'=>'asociacion'),
array('letra'=>'a', 'palabra'=>'asociacionismo'),
array('letra'=>'a', 'palabra'=>'asociacionista'),
array('letra'=>'a', 'palabra'=>'asociado'),
array('letra'=>'a', 'palabra'=>'asocial'),
array('letra'=>'a', 'palabra'=>'asociamiento'),
array('letra'=>'a', 'palabra'=>'asociar'),
array('letra'=>'a', 'palabra'=>'asociativo'),
array('letra'=>'a', 'palabra'=>'asocio'),
array('letra'=>'a', 'palabra'=>'asohora'),
array('letra'=>'a', 'palabra'=>'asolacion'),
array('letra'=>'a', 'palabra'=>'asolador'),
array('letra'=>'a', 'palabra'=>'asolamiento'),
array('letra'=>'a', 'palabra'=>'asolanar'),
array('letra'=>'a', 'palabra'=>'asolapar'),
array('letra'=>'a', 'palabra'=>'asolar'),
array('letra'=>'a', 'palabra'=>'asoldadar'),
array('letra'=>'a', 'palabra'=>'asoldar'),
array('letra'=>'a', 'palabra'=>'asoleado'),
array('letra'=>'a', 'palabra'=>'asoleamiento'),
array('letra'=>'a', 'palabra'=>'asolear'),
array('letra'=>'a', 'palabra'=>'asoleo'),
array('letra'=>'a', 'palabra'=>'asolvamiento'),
array('letra'=>'a', 'palabra'=>'asomada'),
array('letra'=>'a', 'palabra'=>'asomadera'),
array('letra'=>'a', 'palabra'=>'asomar'),
array('letra'=>'a', 'palabra'=>'asomate'),
array('letra'=>'a', 'palabra'=>'asombradizo'),
array('letra'=>'a', 'palabra'=>'asombrador'),
array('letra'=>'a', 'palabra'=>'asombramiento'),
array('letra'=>'a', 'palabra'=>'asombrar'),
array('letra'=>'a', 'palabra'=>'asombro'),
array('letra'=>'a', 'palabra'=>'asombroso'),
array('letra'=>'a', 'palabra'=>'asomo'),
array('letra'=>'a', 'palabra'=>'asonada'),
array('letra'=>'a', 'palabra'=>'asonadia'),
array('letra'=>'a', 'palabra'=>'asonancia'),
array('letra'=>'a', 'palabra'=>'asonantar'),
array('letra'=>'a', 'palabra'=>'asonante'),
array('letra'=>'a', 'palabra'=>'asonantico'),
array('letra'=>'a', 'palabra'=>'asonar'),
array('letra'=>'a', 'palabra'=>'asondar'),
array('letra'=>'a', 'palabra'=>'asordar'),
array('letra'=>'a', 'palabra'=>'asorocharse'),
array('letra'=>'a', 'palabra'=>'asosegadamente'),
array('letra'=>'a', 'palabra'=>'asosegar'),
array('letra'=>'a', 'palabra'=>'asosiego'),
array('letra'=>'a', 'palabra'=>'asotanar'),
array('letra'=>'a', 'palabra'=>'asotilar'),
array('letra'=>'a', 'palabra'=>'aspa'),
array('letra'=>'a', 'palabra'=>'aspadera'),
array('letra'=>'a', 'palabra'=>'aspado'),
array('letra'=>'a', 'palabra'=>'aspador'),
array('letra'=>'a', 'palabra'=>'aspalato'),
array('letra'=>'a', 'palabra'=>'aspalto'),
array('letra'=>'a', 'palabra'=>'aspar'),
array('letra'=>'a', 'palabra'=>'aspaventar'),
array('letra'=>'a', 'palabra'=>'aspaventero'),
array('letra'=>'a', 'palabra'=>'aspaventoso'),
array('letra'=>'a', 'palabra'=>'aspaviento'),
array('letra'=>'a', 'palabra'=>'aspearse'),
array('letra'=>'a', 'palabra'=>'aspecto'),
array('letra'=>'a', 'palabra'=>'aspectual'),
array('letra'=>'a', 'palabra'=>'asperarteria'),
array('letra'=>'a', 'palabra'=>'asperear'),
array('letra'=>'a', 'palabra'=>'asperete'),
array('letra'=>'a', 'palabra'=>'aspereza'),
array('letra'=>'a', 'palabra'=>'aspergear'),
array('letra'=>'a', 'palabra'=>'asperger'),
array('letra'=>'a', 'palabra'=>'asperges'),
array('letra'=>'a', 'palabra'=>'asperidad'),
array('letra'=>'a', 'palabra'=>'asperiega'),
array('letra'=>'a', 'palabra'=>'asperiego'),
array('letra'=>'a', 'palabra'=>'asperilla'),
array('letra'=>'a', 'palabra'=>'asperillo'),
array('letra'=>'a', 'palabra'=>'asperjar'),
array('letra'=>'a', 'palabra'=>'aspero'),
array('letra'=>'a', 'palabra'=>'asperon'),
array('letra'=>'a', 'palabra'=>'asperrimo'),
array('letra'=>'a', 'palabra'=>'aspersion'),
array('letra'=>'a', 'palabra'=>'aspersor'),
array('letra'=>'a', 'palabra'=>'aspersorio'),
array('letra'=>'a', 'palabra'=>'asperura'),
array('letra'=>'a', 'palabra'=>'aspic'),
array('letra'=>'a', 'palabra'=>'aspid'),
array('letra'=>'a', 'palabra'=>'aspide'),
array('letra'=>'a', 'palabra'=>'aspidistra'),
array('letra'=>'a', 'palabra'=>'aspilla'),
array('letra'=>'a', 'palabra'=>'aspillador'),
array('letra'=>'a', 'palabra'=>'aspillar'),
array('letra'=>'a', 'palabra'=>'aspillera'),
array('letra'=>'a', 'palabra'=>'aspillerar'),
array('letra'=>'a', 'palabra'=>'aspiracion'),
array('letra'=>'a', 'palabra'=>'aspirado'),
array('letra'=>'a', 'palabra'=>'aspirador'),
array('letra'=>'a', 'palabra'=>'aspirante'),
array('letra'=>'a', 'palabra'=>'aspirar'),
array('letra'=>'a', 'palabra'=>'aspirina'),
array('letra'=>'a', 'palabra'=>'aspro'),
array('letra'=>'a', 'palabra'=>'asqueamiento'),
array('letra'=>'a', 'palabra'=>'asquear'),
array('letra'=>'a', 'palabra'=>'asquenazi'),
array('letra'=>'a', 'palabra'=>'asquerosidad'),
array('letra'=>'a', 'palabra'=>'asqueroso'),
array('letra'=>'a', 'palabra'=>'asquiento'),
array('letra'=>'a', 'palabra'=>'asta'),
array('letra'=>'a', 'palabra'=>'astabandera'),
array('letra'=>'a', 'palabra'=>'astabatan'),
array('letra'=>'a', 'palabra'=>'astado'),
array('letra'=>'a', 'palabra'=>'astamenta'),
array('letra'=>'a', 'palabra'=>'astatico'),
array('letra'=>'a', 'palabra'=>'astato'),
array('letra'=>'a', 'palabra'=>'asteismo'),
array('letra'=>'a', 'palabra'=>'astenia'),
array('letra'=>'a', 'palabra'=>'astenico'),
array('letra'=>'a', 'palabra'=>'aster'),
array('letra'=>'a', 'palabra'=>'aster'),
array('letra'=>'a', 'palabra'=>'asterisco'),
array('letra'=>'a', 'palabra'=>'asterismo'),
array('letra'=>'a', 'palabra'=>'astero'),
array('letra'=>'a', 'palabra'=>'asteroide'),
array('letra'=>'a', 'palabra'=>'astifino'),
array('letra'=>'a', 'palabra'=>'astigitano'),
array('letra'=>'a', 'palabra'=>'astigmatico'),
array('letra'=>'a', 'palabra'=>'astigmatismo'),
array('letra'=>'a', 'palabra'=>'astigmometro'),
array('letra'=>'a', 'palabra'=>'astil'),
array('letra'=>'a', 'palabra'=>'astilla'),
array('letra'=>'a', 'palabra'=>'astillable'),
array('letra'=>'a', 'palabra'=>'astillar'),
array('letra'=>'a', 'palabra'=>'astillazo'),
array('letra'=>'a', 'palabra'=>'astillero'),
array('letra'=>'a', 'palabra'=>'astilloso'),
array('letra'=>'a', 'palabra'=>'astorgano'),
array('letra'=>'a', 'palabra'=>'astracan'),
array('letra'=>'a', 'palabra'=>'astracanada'),
array('letra'=>'a', 'palabra'=>'astragalo'),
array('letra'=>'a', 'palabra'=>'astrago'),
array('letra'=>'a', 'palabra'=>'astral'),
array('letra'=>'a', 'palabra'=>'astreñir'),
array('letra'=>'a', 'palabra'=>'astriccion'),
array('letra'=>'a', 'palabra'=>'astrictivo'),
array('letra'=>'a', 'palabra'=>'astrifero'),
array('letra'=>'a', 'palabra'=>'astringencia'),
array('letra'=>'a', 'palabra'=>'astringente'),
array('letra'=>'a', 'palabra'=>'astringir'),
array('letra'=>'a', 'palabra'=>'astriñir'),
array('letra'=>'a', 'palabra'=>'astro'),
array('letra'=>'a', 'palabra'=>'astrocito'),
array('letra'=>'a', 'palabra'=>'astrofisica'),
array('letra'=>'a', 'palabra'=>'astrofisico'),
array('letra'=>'a', 'palabra'=>'astrografia'),
array('letra'=>'a', 'palabra'=>'astrografico'),
array('letra'=>'a', 'palabra'=>'astrografo'),
array('letra'=>'a', 'palabra'=>'astrolabio'),
array('letra'=>'a', 'palabra'=>'astrolito'),
array('letra'=>'a', 'palabra'=>'astrologal'),
array('letra'=>'a', 'palabra'=>'astrologar'),
array('letra'=>'a', 'palabra'=>'astrologia'),
array('letra'=>'a', 'palabra'=>'astrologico'),
array('letra'=>'a', 'palabra'=>'astrologo'),
array('letra'=>'a', 'palabra'=>'astronauta'),
array('letra'=>'a', 'palabra'=>'astronautica'),
array('letra'=>'a', 'palabra'=>'astronautico'),
array('letra'=>'a', 'palabra'=>'astronave'),
array('letra'=>'a', 'palabra'=>'astronomia'),
array('letra'=>'a', 'palabra'=>'astronomico'),
array('letra'=>'a', 'palabra'=>'astronomo'),
array('letra'=>'a', 'palabra'=>'astroso'),
array('letra'=>'a', 'palabra'=>'astucia'),
array('letra'=>'a', 'palabra'=>'astucioso'),
array('letra'=>'a', 'palabra'=>'astur'),
array('letra'=>'a', 'palabra'=>'asturcon'),
array('letra'=>'a', 'palabra'=>'asturianismo'),
array('letra'=>'a', 'palabra'=>'asturiano'),
array('letra'=>'a', 'palabra'=>'asturias'),
array('letra'=>'a', 'palabra'=>'asturicense'),
array('letra'=>'a', 'palabra'=>'asturion'),
array('letra'=>'a', 'palabra'=>'asturleones'),
array('letra'=>'a', 'palabra'=>'astuto'),
array('letra'=>'a', 'palabra'=>'asuardado'),
array('letra'=>'a', 'palabra'=>'asubiadero'),
array('letra'=>'a', 'palabra'=>'asubiar'),
array('letra'=>'a', 'palabra'=>'asueto'),
array('letra'=>'a', 'palabra'=>'asulcar'),
array('letra'=>'a', 'palabra'=>'asumir'),
array('letra'=>'a', 'palabra'=>'asunceno'),
array('letra'=>'a', 'palabra'=>'asunceño'),
array('letra'=>'a', 'palabra'=>'asuncion'),
array('letra'=>'a', 'palabra'=>'asuncionista'),
array('letra'=>'a', 'palabra'=>'asuntar'),
array('letra'=>'a', 'palabra'=>'asuntejo'),
array('letra'=>'a', 'palabra'=>'asuntillo'),
array('letra'=>'a', 'palabra'=>'asunto'),
array('letra'=>'a', 'palabra'=>'asurar'),
array('letra'=>'a', 'palabra'=>'asurcado'),
array('letra'=>'a', 'palabra'=>'asurcano'),
array('letra'=>'a', 'palabra'=>'asurcar'),
array('letra'=>'a', 'palabra'=>'asuso'),
array('letra'=>'a', 'palabra'=>'asustadizo'),
array('letra'=>'a', 'palabra'=>'asustar'),
array('letra'=>'a', 'palabra'=>'asutilar'),
array('letra'=>'a', 'palabra'=>'ata'),
array('letra'=>'a', 'palabra'=>'atabaca'),
array('letra'=>'a', 'palabra'=>'atabacado'),
array('letra'=>'a', 'palabra'=>'atabal'),
array('letra'=>'a', 'palabra'=>'atabalear'),
array('letra'=>'a', 'palabra'=>'atabalero'),
array('letra'=>'a', 'palabra'=>'atabanado'),
array('letra'=>'a', 'palabra'=>'atabardillado'),
array('letra'=>'a', 'palabra'=>'atabe'),
array('letra'=>'a', 'palabra'=>'atabernado'),
array('letra'=>'a', 'palabra'=>'atabillar'),
array('letra'=>'a', 'palabra'=>'atabladera'),
array('letra'=>'a', 'palabra'=>'atablar'),
array('letra'=>'a', 'palabra'=>'atacable'),
array('letra'=>'a', 'palabra'=>'atacadera'),
array('letra'=>'a', 'palabra'=>'atacado'),
array('letra'=>'a', 'palabra'=>'atacador'),
array('letra'=>'a', 'palabra'=>'atacadura'),
array('letra'=>'a', 'palabra'=>'atacama'),
array('letra'=>'a', 'palabra'=>'atacameño'),
array('letra'=>'a', 'palabra'=>'atacamiento'),
array('letra'=>'a', 'palabra'=>'atacamita'),
array('letra'=>'a', 'palabra'=>'atacante'),
array('letra'=>'a', 'palabra'=>'atacar'),
array('letra'=>'a', 'palabra'=>'atachonado'),
array('letra'=>'a', 'palabra'=>'atacir'),
array('letra'=>'a', 'palabra'=>'atacola'),
array('letra'=>'a', 'palabra'=>'ataderas'),
array('letra'=>'a', 'palabra'=>'atadero'),
array('letra'=>'a', 'palabra'=>'atadijo'),
array('letra'=>'a', 'palabra'=>'atado'),
array('letra'=>'a', 'palabra'=>'atador'),
array('letra'=>'a', 'palabra'=>'atadura'),
array('letra'=>'a', 'palabra'=>'atafagar'),
array('letra'=>'a', 'palabra'=>'atafago'),
array('letra'=>'a', 'palabra'=>'atafarra'),
array('letra'=>'a', 'palabra'=>'atafea'),
array('letra'=>'a', 'palabra'=>'atafetanado'),
array('letra'=>'a', 'palabra'=>'atagallar'),
array('letra'=>'a', 'palabra'=>'ataguia'),
array('letra'=>'a', 'palabra'=>'ataharre'),
array('letra'=>'a', 'palabra'=>'atahona'),
array('letra'=>'a', 'palabra'=>'atahonero'),
array('letra'=>'a', 'palabra'=>'atahorma'),
array('letra'=>'a', 'palabra'=>'atahulla'),
array('letra'=>'a', 'palabra'=>'ataifor'),
array('letra'=>'a', 'palabra'=>'atairar'),
array('letra'=>'a', 'palabra'=>'ataire'),
array('letra'=>'a', 'palabra'=>'atajada'),
array('letra'=>'a', 'palabra'=>'atajadamente'),
array('letra'=>'a', 'palabra'=>'atajadero'),
array('letra'=>'a', 'palabra'=>'atajadizo'),
array('letra'=>'a', 'palabra'=>'atajador'),
array('letra'=>'a', 'palabra'=>'atajamiento'),
array('letra'=>'a', 'palabra'=>'atajar'),
array('letra'=>'a', 'palabra'=>'atajasolaces'),
array('letra'=>'a', 'palabra'=>'atajea'),
array('letra'=>'a', 'palabra'=>'atajia'),
array('letra'=>'a', 'palabra'=>'atajo'),
array('letra'=>'a', 'palabra'=>'atal'),
array('letra'=>'a', 'palabra'=>'atalador'),
array('letra'=>'a', 'palabra'=>'atalajar'),
array('letra'=>'a', 'palabra'=>'atalaje'),
array('letra'=>'a', 'palabra'=>'atalantar'),
array('letra'=>'a', 'palabra'=>'atalar'),
array('letra'=>'a', 'palabra'=>'atalaya'),
array('letra'=>'a', 'palabra'=>'atalayador'),
array('letra'=>'a', 'palabra'=>'atalayamiento'),
array('letra'=>'a', 'palabra'=>'atalayar'),
array('letra'=>'a', 'palabra'=>'atalayero'),
array('letra'=>'a', 'palabra'=>'ataludar'),
array('letra'=>'a', 'palabra'=>'ataluzar'),
array('letra'=>'a', 'palabra'=>'atalvina'),
array('letra'=>'a', 'palabra'=>'ataman'),
array('letra'=>'a', 'palabra'=>'atambor'),
array('letra'=>'a', 'palabra'=>'atamiento'),
array('letra'=>'a', 'palabra'=>'atan'),
array('letra'=>'a', 'palabra'=>'atanasia'),
array('letra'=>'a', 'palabra'=>'atancar'),
array('letra'=>'a', 'palabra'=>'atanco'),
array('letra'=>'a', 'palabra'=>'atandador'),
array('letra'=>'a', 'palabra'=>'atanor'),
array('letra'=>'a', 'palabra'=>'atanquia'),
array('letra'=>'a', 'palabra'=>'atañedero'),
array('letra'=>'a', 'palabra'=>'atañer'),
array('letra'=>'a', 'palabra'=>'atapar'),
array('letra'=>'a', 'palabra'=>'atapierna'),
array('letra'=>'a', 'palabra'=>'atapuzar'),
array('letra'=>'a', 'palabra'=>'ataque'),
array('letra'=>'a', 'palabra'=>'ataquiza'),
array('letra'=>'a', 'palabra'=>'ataquizar'),
array('letra'=>'a', 'palabra'=>'atar'),
array('letra'=>'a', 'palabra'=>'ataracea'),
array('letra'=>'a', 'palabra'=>'ataracear'),
array('letra'=>'a', 'palabra'=>'atarantado'),
array('letra'=>'a', 'palabra'=>'atarantamiento'),
array('letra'=>'a', 'palabra'=>'atarantar'),
array('letra'=>'a', 'palabra'=>'ataraxia'),
array('letra'=>'a', 'palabra'=>'atarazana'),
array('letra'=>'a', 'palabra'=>'atarazar'),
array('letra'=>'a', 'palabra'=>'atardecer'),
array('letra'=>'a', 'palabra'=>'atardecida'),
array('letra'=>'a', 'palabra'=>'atarea'),
array('letra'=>'a', 'palabra'=>'atarear'),
array('letra'=>'a', 'palabra'=>'atarfe'),
array('letra'=>'a', 'palabra'=>'atarjea'),
array('letra'=>'a', 'palabra'=>'atarquinar'),
array('letra'=>'a', 'palabra'=>'atarraga'),
array('letra'=>'a', 'palabra'=>'atarragar'),
array('letra'=>'a', 'palabra'=>'atarrajar'),
array('letra'=>'a', 'palabra'=>'atarraya'),
array('letra'=>'a', 'palabra'=>'atarugamiento'),
array('letra'=>'a', 'palabra'=>'atarugar'),
array('letra'=>'a', 'palabra'=>'atasajado'),
array('letra'=>'a', 'palabra'=>'atasajar'),
array('letra'=>'a', 'palabra'=>'atascaburras'),
array('letra'=>'a', 'palabra'=>'atascadero'),
array('letra'=>'a', 'palabra'=>'atascado'),
array('letra'=>'a', 'palabra'=>'atascamiento'),
array('letra'=>'a', 'palabra'=>'atascar'),
array('letra'=>'a', 'palabra'=>'atasco'),
array('letra'=>'a', 'palabra'=>'atasqueria'),
array('letra'=>'a', 'palabra'=>'atatay'),
array('letra'=>'a', 'palabra'=>'ataucar'),
array('letra'=>'a', 'palabra'=>'ataud'),
array('letra'=>'a', 'palabra'=>'ataudado'),
array('letra'=>'a', 'palabra'=>'ataujia'),
array('letra'=>'a', 'palabra'=>'ataujiado'),
array('letra'=>'a', 'palabra'=>'ataurique'),
array('letra'=>'a', 'palabra'=>'ataviar'),
array('letra'=>'a', 'palabra'=>'atavico'),
array('letra'=>'a', 'palabra'=>'atavio'),
array('letra'=>'a', 'palabra'=>'atavismo'),
array('letra'=>'a', 'palabra'=>'ataxia'),
array('letra'=>'a', 'palabra'=>'ataxico'),
array('letra'=>'a', 'palabra'=>'ate'),
array('letra'=>'a', 'palabra'=>'atear'),
array('letra'=>'a', 'palabra'=>'atediar'),
array('letra'=>'a', 'palabra'=>'ateismo'),
array('letra'=>'a', 'palabra'=>'ateista'),
array('letra'=>'a', 'palabra'=>'ateje'),
array('letra'=>'a', 'palabra'=>'atelaje'),
array('letra'=>'a', 'palabra'=>'atelana'),
array('letra'=>'a', 'palabra'=>'atembado'),
array('letra'=>'a', 'palabra'=>'atembar'),
array('letra'=>'a', 'palabra'=>'atemorizar'),
array('letra'=>'a', 'palabra'=>'atemperacion'),
array('letra'=>'a', 'palabra'=>'atemperador'),
array('letra'=>'a', 'palabra'=>'atemperante'),
array('letra'=>'a', 'palabra'=>'atemperar'),
array('letra'=>'a', 'palabra'=>'atempero'),
array('letra'=>'a', 'palabra'=>'atenacear'),
array('letra'=>'a', 'palabra'=>'atenazado'),
array('letra'=>'a', 'palabra'=>'atenazador'),
array('letra'=>'a', 'palabra'=>'atenazar'),
array('letra'=>'a', 'palabra'=>'atencion'),
array('letra'=>'a', 'palabra'=>'atendar'),
array('letra'=>'a', 'palabra'=>'atendedor'),
array('letra'=>'a', 'palabra'=>'atendencia'),
array('letra'=>'a', 'palabra'=>'atender'),
array('letra'=>'a', 'palabra'=>'atendible'),
array('letra'=>'a', 'palabra'=>'atendimiento'),
array('letra'=>'a', 'palabra'=>'atenebrarse'),
array('letra'=>'a', 'palabra'=>'atenedor'),
array('letra'=>'a', 'palabra'=>'ateneista'),
array('letra'=>'a', 'palabra'=>'atenencia'),
array('letra'=>'a', 'palabra'=>'ateneo'),
array('letra'=>'a', 'palabra'=>'atener'),
array('letra'=>'a', 'palabra'=>'atenido'),
array('letra'=>'a', 'palabra'=>'ateniense'),
array('letra'=>'a', 'palabra'=>'atenies'),
array('letra'=>'a', 'palabra'=>'atenorado'),
array('letra'=>'a', 'palabra'=>'atentacion'),
array('letra'=>'a', 'palabra'=>'atentadamente'),
array('letra'=>'a', 'palabra'=>'atentado'),
array('letra'=>'a', 'palabra'=>'atentamente'),
array('letra'=>'a', 'palabra'=>'atentar'),
array('letra'=>'a', 'palabra'=>'atentatorio'),
array('letra'=>'a', 'palabra'=>'atento'),
array('letra'=>'a', 'palabra'=>'atenuacion'),
array('letra'=>'a', 'palabra'=>'atenuador'),
array('letra'=>'a', 'palabra'=>'atenuante'),
array('letra'=>'a', 'palabra'=>'atenuar'),
array('letra'=>'a', 'palabra'=>'ateo'),
array('letra'=>'a', 'palabra'=>'atepocate'),
array('letra'=>'a', 'palabra'=>'atercianado'),
array('letra'=>'a', 'palabra'=>'aterciopelado'),
array('letra'=>'a', 'palabra'=>'aterecer'),
array('letra'=>'a', 'palabra'=>'aterecimiento'),
array('letra'=>'a', 'palabra'=>'atericia'),
array('letra'=>'a', 'palabra'=>'atericiarse'),
array('letra'=>'a', 'palabra'=>'aterimiento'),
array('letra'=>'a', 'palabra'=>'aterir'),
array('letra'=>'a', 'palabra'=>'atermano'),
array('letra'=>'a', 'palabra'=>'ateroesclerosis'),
array('letra'=>'a', 'palabra'=>'ateroma'),
array('letra'=>'a', 'palabra'=>'aterosclerosis'),
array('letra'=>'a', 'palabra'=>'aterrada'),
array('letra'=>'a', 'palabra'=>'aterrador'),
array('letra'=>'a', 'palabra'=>'aterrajar'),
array('letra'=>'a', 'palabra'=>'aterraje'),
array('letra'=>'a', 'palabra'=>'aterramiento'),
array('letra'=>'a', 'palabra'=>'aterrar'),
array('letra'=>'a', 'palabra'=>'aterrerar'),
array('letra'=>'a', 'palabra'=>'aterrizaje'),
array('letra'=>'a', 'palabra'=>'aterrizar'),
array('letra'=>'a', 'palabra'=>'aterronar'),
array('letra'=>'a', 'palabra'=>'aterrorizar'),
array('letra'=>'a', 'palabra'=>'atesar'),
array('letra'=>'a', 'palabra'=>'atesoramiento'),
array('letra'=>'a', 'palabra'=>'atesorar'),
array('letra'=>'a', 'palabra'=>'atestacion'),
array('letra'=>'a', 'palabra'=>'atestado'),
array('letra'=>'a', 'palabra'=>'atestadura'),
array('letra'=>'a', 'palabra'=>'atestamiento'),
array('letra'=>'a', 'palabra'=>'atestar'),
array('letra'=>'a', 'palabra'=>'atestiguacion'),
array('letra'=>'a', 'palabra'=>'atestiguamiento'),
array('letra'=>'a', 'palabra'=>'atestiguar'),
array('letra'=>'a', 'palabra'=>'atetado'),
array('letra'=>'a', 'palabra'=>'atetar'),
array('letra'=>'a', 'palabra'=>'atetillar'),
array('letra'=>'a', 'palabra'=>'atetosis'),
array('letra'=>'a', 'palabra'=>'atezado'),
array('letra'=>'a', 'palabra'=>'atezamiento'),
array('letra'=>'a', 'palabra'=>'atezar'),
array('letra'=>'a', 'palabra'=>'atibar'),
array('letra'=>'a', 'palabra'=>'atibiar'),
array('letra'=>'a', 'palabra'=>'atiborramiento'),
array('letra'=>'a', 'palabra'=>'atiborrar'),
array('letra'=>'a', 'palabra'=>'aticismo'),
array('letra'=>'a', 'palabra'=>'aticista'),
array('letra'=>'a', 'palabra'=>'atico'),
array('letra'=>'a', 'palabra'=>'atiemposo'),
array('letra'=>'a', 'palabra'=>'atierre'),
array('letra'=>'a', 'palabra'=>'atiesar'),
array('letra'=>'a', 'palabra'=>'atifle'),
array('letra'=>'a', 'palabra'=>'atigrado'),
array('letra'=>'a', 'palabra'=>'atijara'),
array('letra'=>'a', 'palabra'=>'atijarero'),
array('letra'=>'a', 'palabra'=>'atildado'),
array('letra'=>'a', 'palabra'=>'atildadura'),
array('letra'=>'a', 'palabra'=>'atildamiento'),
array('letra'=>'a', 'palabra'=>'atildar'),
array('letra'=>'a', 'palabra'=>'atilintar'),
array('letra'=>'a', 'palabra'=>'atinar'),
array('letra'=>'a', 'palabra'=>'atincar'),
array('letra'=>'a', 'palabra'=>'atinconar'),
array('letra'=>'a', 'palabra'=>'atinencia'),
array('letra'=>'a', 'palabra'=>'atinente'),
array('letra'=>'a', 'palabra'=>'atingencia'),
array('letra'=>'a', 'palabra'=>'atingente'),
array('letra'=>'a', 'palabra'=>'atingido'),
array('letra'=>'a', 'palabra'=>'atingir'),
array('letra'=>'a', 'palabra'=>'atino'),
array('letra'=>'a', 'palabra'=>'atiparse'),
array('letra'=>'a', 'palabra'=>'atipicidad'),
array('letra'=>'a', 'palabra'=>'atipico'),
array('letra'=>'a', 'palabra'=>'atiplado'),
array('letra'=>'a', 'palabra'=>'atiplar'),
array('letra'=>'a', 'palabra'=>'atirantar'),
array('letra'=>'a', 'palabra'=>'atirelado'),
array('letra'=>'a', 'palabra'=>'atiriciarse'),
array('letra'=>'a', 'palabra'=>'atisbador'),
array('letra'=>'a', 'palabra'=>'atisbadura'),
array('letra'=>'a', 'palabra'=>'atisbar'),
array('letra'=>'a', 'palabra'=>'atisbo'),
array('letra'=>'a', 'palabra'=>'atisbon'),
array('letra'=>'a', 'palabra'=>'atisuado'),
array('letra'=>'a', 'palabra'=>'atizacandiles'),
array('letra'=>'a', 'palabra'=>'atizadero'),
array('letra'=>'a', 'palabra'=>'atizador'),
array('letra'=>'a', 'palabra'=>'atizar'),
array('letra'=>'a', 'palabra'=>'atizonar'),
array('letra'=>'a', 'palabra'=>'atlante'),
array('letra'=>'a', 'palabra'=>'atlanticense'),
array('letra'=>'a', 'palabra'=>'atlantico'),
array('letra'=>'a', 'palabra'=>'atlantidense'),
array('letra'=>'a', 'palabra'=>'atlantiquense'),
array('letra'=>'a', 'palabra'=>'atlantismo'),
array('letra'=>'a', 'palabra'=>'atlantista'),
array('letra'=>'a', 'palabra'=>'atlas'),
array('letra'=>'a', 'palabra'=>'atleta'),
array('letra'=>'a', 'palabra'=>'atletico'),
array('letra'=>'a', 'palabra'=>'atletismo'),
array('letra'=>'a', 'palabra'=>'atmosfera'),
array('letra'=>'a', 'palabra'=>'atmosfera'),
array('letra'=>'a', 'palabra'=>'atmosferico'),
array('letra'=>'a', 'palabra'=>'atoar'),
array('letra'=>'a', 'palabra'=>'atoba'),
array('letra'=>'a', 'palabra'=>'atobar'),
array('letra'=>'a', 'palabra'=>'atocha'),
array('letra'=>'a', 'palabra'=>'atochada'),
array('letra'=>'a', 'palabra'=>'atochado'),
array('letra'=>'a', 'palabra'=>'atochal'),
array('letra'=>'a', 'palabra'=>'atochar'),
array('letra'=>'a', 'palabra'=>'atochero'),
array('letra'=>'a', 'palabra'=>'atochon'),
array('letra'=>'a', 'palabra'=>'atocinado'),
array('letra'=>'a', 'palabra'=>'atocinar'),
array('letra'=>'a', 'palabra'=>'atojar'),
array('letra'=>'a', 'palabra'=>'atol'),
array('letra'=>'a', 'palabra'=>'atole'),
array('letra'=>'a', 'palabra'=>'atoleria'),
array('letra'=>'a', 'palabra'=>'atolero'),
array('letra'=>'a', 'palabra'=>'atolillo'),
array('letra'=>'a', 'palabra'=>'atolladal'),
array('letra'=>'a', 'palabra'=>'atolladar'),
array('letra'=>'a', 'palabra'=>'atolladero'),
array('letra'=>'a', 'palabra'=>'atollar'),
array('letra'=>'a', 'palabra'=>'atolon'),
array('letra'=>'a', 'palabra'=>'atolondrado'),
array('letra'=>'a', 'palabra'=>'atolondramiento'),
array('letra'=>'a', 'palabra'=>'atolondrar'),
array('letra'=>'a', 'palabra'=>'atomico'),
array('letra'=>'a', 'palabra'=>'atomir'),
array('letra'=>'a', 'palabra'=>'atomismo'),
array('letra'=>'a', 'palabra'=>'atomista'),
array('letra'=>'a', 'palabra'=>'atomistico'),
array('letra'=>'a', 'palabra'=>'atomizacion'),
array('letra'=>'a', 'palabra'=>'atomizador'),
array('letra'=>'a', 'palabra'=>'atomizar'),
array('letra'=>'a', 'palabra'=>'atomo'),
array('letra'=>'a', 'palabra'=>'atona'),
array('letra'=>'a', 'palabra'=>'atona'),
array('letra'=>'a', 'palabra'=>'atonal'),
array('letra'=>'a', 'palabra'=>'atonalidad'),
array('letra'=>'a', 'palabra'=>'atonalismo'),
array('letra'=>'a', 'palabra'=>'atonar'),
array('letra'=>'a', 'palabra'=>'atondar'),
array('letra'=>'a', 'palabra'=>'atonia'),
array('letra'=>'a', 'palabra'=>'atonico'),
array('letra'=>'a', 'palabra'=>'atonito'),
array('letra'=>'a', 'palabra'=>'atono'),
array('letra'=>'a', 'palabra'=>'atontado'),
array('letra'=>'a', 'palabra'=>'atontamiento'),
array('letra'=>'a', 'palabra'=>'atontar'),
array('letra'=>'a', 'palabra'=>'atontecer'),
array('letra'=>'a', 'palabra'=>'atontolinar'),
array('letra'=>'a', 'palabra'=>'atopadizo'),
array('letra'=>'a', 'palabra'=>'atopico'),
array('letra'=>'a', 'palabra'=>'atora'),
array('letra'=>'a', 'palabra'=>'atoramiento'),
array('letra'=>'a', 'palabra'=>'atorar'),
array('letra'=>'a', 'palabra'=>'atorcer'),
array('letra'=>'a', 'palabra'=>'atordecer'),
array('letra'=>'a', 'palabra'=>'atorgar'),
array('letra'=>'a', 'palabra'=>'atormentador'),
array('letra'=>'a', 'palabra'=>'atormentar'),
array('letra'=>'a', 'palabra'=>'atornasolado'),
array('letra'=>'a', 'palabra'=>'atornillador'),
array('letra'=>'a', 'palabra'=>'atornillar'),
array('letra'=>'a', 'palabra'=>'atoro'),
array('letra'=>'a', 'palabra'=>'atorozonarse'),
array('letra'=>'a', 'palabra'=>'atorra'),
array('letra'=>'a', 'palabra'=>'atorrante'),
array('letra'=>'a', 'palabra'=>'atortolar'),
array('letra'=>'a', 'palabra'=>'atortorar'),
array('letra'=>'a', 'palabra'=>'atortujar'),
array('letra'=>'a', 'palabra'=>'atosigador'),
array('letra'=>'a', 'palabra'=>'atosigamiento'),
array('letra'=>'a', 'palabra'=>'atosigar'),
array('letra'=>'a', 'palabra'=>'atoxicar'),
array('letra'=>'a', 'palabra'=>'atoxico'),
array('letra'=>'a', 'palabra'=>'atrabajado'),
array('letra'=>'a', 'palabra'=>'atrabajar'),
array('letra'=>'a', 'palabra'=>'atrabancar'),
array('letra'=>'a', 'palabra'=>'atrabanco'),
array('letra'=>'a', 'palabra'=>'atrabiliario'),
array('letra'=>'a', 'palabra'=>'atrabilioso'),
array('letra'=>'a', 'palabra'=>'atrabilis'),
array('letra'=>'a', 'palabra'=>'atracada'),
array('letra'=>'a', 'palabra'=>'atracadero'),
array('letra'=>'a', 'palabra'=>'atracador'),
array('letra'=>'a', 'palabra'=>'atracar'),
array('letra'=>'a', 'palabra'=>'atraccion'),
array('letra'=>'a', 'palabra'=>'atraco'),
array('letra'=>'a', 'palabra'=>'atracon'),
array('letra'=>'a', 'palabra'=>'atractivo'),
array('letra'=>'a', 'palabra'=>'atractriz'),
array('letra'=>'a', 'palabra'=>'atraer'),
array('letra'=>'a', 'palabra'=>'atrafagar'),
array('letra'=>'a', 'palabra'=>'atragantar'),
array('letra'=>'a', 'palabra'=>'atraible'),
array('letra'=>'a', 'palabra'=>'atraicionar'),
array('letra'=>'a', 'palabra'=>'atraidorado'),
array('letra'=>'a', 'palabra'=>'atraillar'),
array('letra'=>'a', 'palabra'=>'atraimiento'),
array('letra'=>'a', 'palabra'=>'atramento'),
array('letra'=>'a', 'palabra'=>'atramentoso'),
array('letra'=>'a', 'palabra'=>'atrampar'),
array('letra'=>'a', 'palabra'=>'atramuz'),
array('letra'=>'a', 'palabra'=>'atrancar'),
array('letra'=>'a', 'palabra'=>'atranco'),
array('letra'=>'a', 'palabra'=>'atranque'),
array('letra'=>'a', 'palabra'=>'atrapamoscas'),
array('letra'=>'a', 'palabra'=>'atrapar'),
array('letra'=>'a', 'palabra'=>'atraque'),
array('letra'=>'a', 'palabra'=>'atraquina'),
array('letra'=>'a', 'palabra'=>'atras'),
array('letra'=>'a', 'palabra'=>'atrasado'),
array('letra'=>'a', 'palabra'=>'atrasamiento'),
array('letra'=>'a', 'palabra'=>'atrasar'),
array('letra'=>'a', 'palabra'=>'atraso'),
array('letra'=>'a', 'palabra'=>'atravesado'),
array('letra'=>'a', 'palabra'=>'atravesador'),
array('letra'=>'a', 'palabra'=>'atravesaño'),
array('letra'=>'a', 'palabra'=>'atravesar'),
array('letra'=>'a', 'palabra'=>'atravesia'),
array('letra'=>'a', 'palabra'=>'atrayente'),
array('letra'=>'a', 'palabra'=>'atrechar'),
array('letra'=>'a', 'palabra'=>'atrecho'),
array('letra'=>'a', 'palabra'=>'atregar'),
array('letra'=>'a', 'palabra'=>'atreguadamente'),
array('letra'=>'a', 'palabra'=>'atreguado'),
array('letra'=>'a', 'palabra'=>'atreguar'),
array('letra'=>'a', 'palabra'=>'atrenzo'),
array('letra'=>'a', 'palabra'=>'atrepsia'),
array('letra'=>'a', 'palabra'=>'atresia'),
array('letra'=>'a', 'palabra'=>'atresnalar'),
array('letra'=>'a', 'palabra'=>'atrevencia'),
array('letra'=>'a', 'palabra'=>'atrever'),
array('letra'=>'a', 'palabra'=>'atrevido'),
array('letra'=>'a', 'palabra'=>'atrevimiento'),
array('letra'=>'a', 'palabra'=>'atrezo'),
array('letra'=>'a', 'palabra'=>'atriaca'),
array('letra'=>'a', 'palabra'=>'atriaca'),
array('letra'=>'a', 'palabra'=>'atriaquero'),
array('letra'=>'a', 'palabra'=>'atribucion'),
array('letra'=>'a', 'palabra'=>'atribuible'),
array('letra'=>'a', 'palabra'=>'atribuir'),
array('letra'=>'a', 'palabra'=>'atribulacion'),
array('letra'=>'a', 'palabra'=>'atribular'),
array('letra'=>'a', 'palabra'=>'atributar'),
array('letra'=>'a', 'palabra'=>'atributivo'),
array('letra'=>'a', 'palabra'=>'atributo'),
array('letra'=>'a', 'palabra'=>'atricion'),
array('letra'=>'a', 'palabra'=>'atril'),
array('letra'=>'a', 'palabra'=>'atrilera'),
array('letra'=>'a', 'palabra'=>'atrincar'),
array('letra'=>'a', 'palabra'=>'atrincheramiento'),
array('letra'=>'a', 'palabra'=>'atrincherar'),
array('letra'=>'a', 'palabra'=>'atrio'),
array('letra'=>'a', 'palabra'=>'atripedo'),
array('letra'=>'a', 'palabra'=>'atrirrostro'),
array('letra'=>'a', 'palabra'=>'atristar'),
array('letra'=>'a', 'palabra'=>'atrito'),
array('letra'=>'a', 'palabra'=>'atrochar'),
array('letra'=>'a', 'palabra'=>'atrocidad'),
array('letra'=>'a', 'palabra'=>'atrofia'),
array('letra'=>'a', 'palabra'=>'atrofiar'),
array('letra'=>'a', 'palabra'=>'atrofico'),
array('letra'=>'a', 'palabra'=>'atrojar'),
array('letra'=>'a', 'palabra'=>'atrompetado'),
array('letra'=>'a', 'palabra'=>'atronado'),
array('letra'=>'a', 'palabra'=>'atronador'),
array('letra'=>'a', 'palabra'=>'atronadura'),
array('letra'=>'a', 'palabra'=>'atronamiento'),
array('letra'=>'a', 'palabra'=>'atronar'),
array('letra'=>'a', 'palabra'=>'atronerar'),
array('letra'=>'a', 'palabra'=>'atropado'),
array('letra'=>'a', 'palabra'=>'atropar'),
array('letra'=>'a', 'palabra'=>'atropelladamente'),
array('letra'=>'a', 'palabra'=>'atropellado'),
array('letra'=>'a', 'palabra'=>'atropellador'),
array('letra'=>'a', 'palabra'=>'atropellamiento'),
array('letra'=>'a', 'palabra'=>'atropellaplatos'),
array('letra'=>'a', 'palabra'=>'atropellar'),
array('letra'=>'a', 'palabra'=>'atropello'),
array('letra'=>'a', 'palabra'=>'atropina'),
array('letra'=>'a', 'palabra'=>'atroz'),
array('letra'=>'a', 'palabra'=>'atruchado'),
array('letra'=>'a', 'palabra'=>'atruendo'),
array('letra'=>'a', 'palabra'=>'atruhanado'),
array('letra'=>'a', 'palabra'=>'atuendo'),
array('letra'=>'a', 'palabra'=>'atufadamente'),
array('letra'=>'a', 'palabra'=>'atufado'),
array('letra'=>'a', 'palabra'=>'atufamiento'),
array('letra'=>'a', 'palabra'=>'atufar'),
array('letra'=>'a', 'palabra'=>'atufo'),
array('letra'=>'a', 'palabra'=>'atumultuar'),
array('letra'=>'a', 'palabra'=>'atun'),
array('letra'=>'a', 'palabra'=>'atunara'),
array('letra'=>'a', 'palabra'=>'atunero'),
array('letra'=>'a', 'palabra'=>'aturada'),
array('letra'=>'a', 'palabra'=>'aturadamente'),
array('letra'=>'a', 'palabra'=>'aturador'),
array('letra'=>'a', 'palabra'=>'aturar'),
array('letra'=>'a', 'palabra'=>'aturbonado'),
array('letra'=>'a', 'palabra'=>'aturdido'),
array('letra'=>'a', 'palabra'=>'aturdidor'),
array('letra'=>'a', 'palabra'=>'aturdimiento'),
array('letra'=>'a', 'palabra'=>'aturdir'),
array('letra'=>'a', 'palabra'=>'aturquesado'),
array('letra'=>'a', 'palabra'=>'aturrar'),
array('letra'=>'a', 'palabra'=>'aturriar'),
array('letra'=>'a', 'palabra'=>'aturrullar'),
array('letra'=>'a', 'palabra'=>'aturullamiento'),
array('letra'=>'a', 'palabra'=>'aturullar'),
array('letra'=>'a', 'palabra'=>'atusador'),
array('letra'=>'a', 'palabra'=>'atusar'),
array('letra'=>'a', 'palabra'=>'atutia'),
array('letra'=>'a', 'palabra'=>'auca'),
array('letra'=>'a', 'palabra'=>'auccion'),
array('letra'=>'a', 'palabra'=>'auctentico'),
array('letra'=>'a', 'palabra'=>'auctor'),
array('letra'=>'a', 'palabra'=>'auctoridad'),
array('letra'=>'a', 'palabra'=>'auctorizar'),
array('letra'=>'a', 'palabra'=>'audacia'),
array('letra'=>'a', 'palabra'=>'audaz'),
array('letra'=>'a', 'palabra'=>'audibilidad'),
array('letra'=>'a', 'palabra'=>'audible'),
array('letra'=>'a', 'palabra'=>'audicion'),
array('letra'=>'a', 'palabra'=>'audiencia'),
array('letra'=>'a', 'palabra'=>'audienciero'),
array('letra'=>'a', 'palabra'=>'audifono'),
array('letra'=>'a', 'palabra'=>'audimetro'),
array('letra'=>'a', 'palabra'=>'audio'),
array('letra'=>'a', 'palabra'=>'audiofono'),
array('letra'=>'a', 'palabra'=>'audiofrecuencia'),
array('letra'=>'a', 'palabra'=>'audiograma'),
array('letra'=>'a', 'palabra'=>'audiometria'),
array('letra'=>'a', 'palabra'=>'audiometro'),
array('letra'=>'a', 'palabra'=>'audioprotesis'),
array('letra'=>'a', 'palabra'=>'audioprotesista'),
array('letra'=>'a', 'palabra'=>'audiovisual'),
array('letra'=>'a', 'palabra'=>'auditar'),
array('letra'=>'a', 'palabra'=>'auditivo'),
array('letra'=>'a', 'palabra'=>'audito'),
array('letra'=>'a', 'palabra'=>'auditor'),
array('letra'=>'a', 'palabra'=>'auditoria'),
array('letra'=>'a', 'palabra'=>'auditoria'),
array('letra'=>'a', 'palabra'=>'auditorio'),
array('letra'=>'a', 'palabra'=>'auditorium'),
array('letra'=>'a', 'palabra'=>'auge'),
array('letra'=>'a', 'palabra'=>'augita'),
array('letra'=>'a', 'palabra'=>'augmentacion'),
array('letra'=>'a', 'palabra'=>'augmentar'),
array('letra'=>'a', 'palabra'=>'augur'),
array('letra'=>'a', 'palabra'=>'auguracion'),
array('letra'=>'a', 'palabra'=>'augurador'),
array('letra'=>'a', 'palabra'=>'augural'),
array('letra'=>'a', 'palabra'=>'augurar'),
array('letra'=>'a', 'palabra'=>'augurio'),
array('letra'=>'a', 'palabra'=>'augustal'),
array('letra'=>'a', 'palabra'=>'augustamente'),
array('letra'=>'a', 'palabra'=>'augusto'),
array('letra'=>'a', 'palabra'=>'aula'),
array('letra'=>'a', 'palabra'=>'aulaga'),
array('letra'=>'a', 'palabra'=>'aulagar'),
array('letra'=>'a', 'palabra'=>'aulario'),
array('letra'=>'a', 'palabra'=>'aulico'),
array('letra'=>'a', 'palabra'=>'aulladero'),
array('letra'=>'a', 'palabra'=>'aullador'),
array('letra'=>'a', 'palabra'=>'aullar'),
array('letra'=>'a', 'palabra'=>'aullido'),
array('letra'=>'a', 'palabra'=>'aullo'),
array('letra'=>'a', 'palabra'=>'aumentable'),
array('letra'=>'a', 'palabra'=>'aumentacion'),
array('letra'=>'a', 'palabra'=>'aumentada'),
array('letra'=>'a', 'palabra'=>'aumentador'),
array('letra'=>'a', 'palabra'=>'aumentar'),
array('letra'=>'a', 'palabra'=>'aumentativo'),
array('letra'=>'a', 'palabra'=>'aumento'),
array('letra'=>'a', 'palabra'=>'aun'),
array('letra'=>'a', 'palabra'=>'aun'),
array('letra'=>'a', 'palabra'=>'aunable'),
array('letra'=>'a', 'palabra'=>'aunamiento'),
array('letra'=>'a', 'palabra'=>'aunar'),
array('letra'=>'a', 'palabra'=>'auniga'),
array('letra'=>'a', 'palabra'=>'aunque'),
array('letra'=>'a', 'palabra'=>'aupa'),
array('letra'=>'a', 'palabra'=>'aupar'),
array('letra'=>'a', 'palabra'=>'auquenido'),
array('letra'=>'a', 'palabra'=>'aura'),
array('letra'=>'a', 'palabra'=>'auranciaceo'),
array('letra'=>'a', 'palabra'=>'aurelianense'),
array('letra'=>'a', 'palabra'=>'aureo'),
array('letra'=>'a', 'palabra'=>'aureola'),
array('letra'=>'a', 'palabra'=>'aureola'),
array('letra'=>'a', 'palabra'=>'aureolar'),
array('letra'=>'a', 'palabra'=>'aureomicina'),
array('letra'=>'a', 'palabra'=>'aurero'),
array('letra'=>'a', 'palabra'=>'aurgitano'),
array('letra'=>'a', 'palabra'=>'auricalco'),
array('letra'=>'a', 'palabra'=>'aurico'),
array('letra'=>'a', 'palabra'=>'auricula'),
array('letra'=>'a', 'palabra'=>'auriculado'),
array('letra'=>'a', 'palabra'=>'auricular'),
array('letra'=>'a', 'palabra'=>'auriense'),
array('letra'=>'a', 'palabra'=>'aurifero'),
array('letra'=>'a', 'palabra'=>'auriga'),
array('letra'=>'a', 'palabra'=>'aurigero'),
array('letra'=>'a', 'palabra'=>'auriñaciense'),
array('letra'=>'a', 'palabra'=>'aurivoro'),
array('letra'=>'a', 'palabra'=>'aurora'),
array('letra'=>'a', 'palabra'=>'auroral'),
array('letra'=>'a', 'palabra'=>'aurragado'),
array('letra'=>'a', 'palabra'=>'auruspice'),
array('letra'=>'a', 'palabra'=>'auscultacion'),
array('letra'=>'a', 'palabra'=>'auscultar'),
array('letra'=>'a', 'palabra'=>'ausencia'),
array('letra'=>'a', 'palabra'=>'ausentado'),
array('letra'=>'a', 'palabra'=>'ausentar'),
array('letra'=>'a', 'palabra'=>'ausente'),
array('letra'=>'a', 'palabra'=>'ausentismo'),
array('letra'=>'a', 'palabra'=>'ausetano'),
array('letra'=>'a', 'palabra'=>'ausol'),
array('letra'=>'a', 'palabra'=>'ausonense'),
array('letra'=>'a', 'palabra'=>'ausonio'),
array('letra'=>'a', 'palabra'=>'auspiciar'),
array('letra'=>'a', 'palabra'=>'auspicio'),
array('letra'=>'a', 'palabra'=>'auspicioso'),
array('letra'=>'a', 'palabra'=>'austeridad'),
array('letra'=>'a', 'palabra'=>'austero'),
array('letra'=>'a', 'palabra'=>'austral'),
array('letra'=>'a', 'palabra'=>'australiano'),
array('letra'=>'a', 'palabra'=>'australopiteco'),
array('letra'=>'a', 'palabra'=>'austriaco'),
array('letra'=>'a', 'palabra'=>'austriaco'),
array('letra'=>'a', 'palabra'=>'austrida'),
array('letra'=>'a', 'palabra'=>'austrino'),
array('letra'=>'a', 'palabra'=>'austro'),
array('letra'=>'a', 'palabra'=>'autan'),
array('letra'=>'a', 'palabra'=>'autarcia'),
array('letra'=>'a', 'palabra'=>'autarquia'),
array('letra'=>'a', 'palabra'=>'autarquico'),
array('letra'=>'a', 'palabra'=>'autentica'),
array('letra'=>'a', 'palabra'=>'autenticacion'),
array('letra'=>'a', 'palabra'=>'autenticar'),
array('letra'=>'a', 'palabra'=>'autenticidad'),
array('letra'=>'a', 'palabra'=>'autentico'),
array('letra'=>'a', 'palabra'=>'autentificar'),
array('letra'=>'a', 'palabra'=>'autillo'),
array('letra'=>'a', 'palabra'=>'autismo'),
array('letra'=>'a', 'palabra'=>'autista'),
array('letra'=>'a', 'palabra'=>'autistico'),
array('letra'=>'a', 'palabra'=>'auto'),
array('letra'=>'a', 'palabra'=>'autoadhesivo'),
array('letra'=>'a', 'palabra'=>'autoafirmacion'),
array('letra'=>'a', 'palabra'=>'autobiografia'),
array('letra'=>'a', 'palabra'=>'autobiografico'),
array('letra'=>'a', 'palabra'=>'autobiografo'),
array('letra'=>'a', 'palabra'=>'autobombo'),
array('letra'=>'a', 'palabra'=>'autobus'),
array('letra'=>'a', 'palabra'=>'autobusero'),
array('letra'=>'a', 'palabra'=>'autocamion'),
array('letra'=>'a', 'palabra'=>'autocar'),
array('letra'=>'a', 'palabra'=>'autocarril'),
array('letra'=>'a', 'palabra'=>'autocensura'),
array('letra'=>'a', 'palabra'=>'autocine'),
array('letra'=>'a', 'palabra'=>'autoclave'),
array('letra'=>'a', 'palabra'=>'autocomplaciente'),
array('letra'=>'a', 'palabra'=>'autocopista'),
array('letra'=>'a', 'palabra'=>'autocracia'),
array('letra'=>'a', 'palabra'=>'autocrata'),
array('letra'=>'a', 'palabra'=>'autocratico'),
array('letra'=>'a', 'palabra'=>'autoctonia'),
array('letra'=>'a', 'palabra'=>'autoctono'),
array('letra'=>'a', 'palabra'=>'autodefensa'),
array('letra'=>'a', 'palabra'=>'autodefinicion'),
array('letra'=>'a', 'palabra'=>'autodestruccion'),
array('letra'=>'a', 'palabra'=>'autodeterminacion'),
array('letra'=>'a', 'palabra'=>'autodidacto'),
array('letra'=>'a', 'palabra'=>'autodominio'),
array('letra'=>'a', 'palabra'=>'autodromo'),
array('letra'=>'a', 'palabra'=>'autoedicion'),
array('letra'=>'a', 'palabra'=>'autoeditar'),
array('letra'=>'a', 'palabra'=>'autoescuela'),
array('letra'=>'a', 'palabra'=>'autoestima'),
array('letra'=>'a', 'palabra'=>'autoestop'),
array('letra'=>'a', 'palabra'=>'autoestopista'),
array('letra'=>'a', 'palabra'=>'autofocus'),
array('letra'=>'a', 'palabra'=>'autogeno'),
array('letra'=>'a', 'palabra'=>'autogestion'),
array('letra'=>'a', 'palabra'=>'autogiro'),
array('letra'=>'a', 'palabra'=>'autognosis'),
array('letra'=>'a', 'palabra'=>'autogol'),
array('letra'=>'a', 'palabra'=>'autografia'),
array('letra'=>'a', 'palabra'=>'autografiar'),
array('letra'=>'a', 'palabra'=>'autografico'),
array('letra'=>'a', 'palabra'=>'autografo'),
array('letra'=>'a', 'palabra'=>'autoinduccion'),
array('letra'=>'a', 'palabra'=>'autointoxicacion'),
array('letra'=>'a', 'palabra'=>'autolatria'),
array('letra'=>'a', 'palabra'=>'autoliquidacion'),
array('letra'=>'a', 'palabra'=>'autolisis'),
array('letra'=>'a', 'palabra'=>'automata'),
array('letra'=>'a', 'palabra'=>'automatica'),
array('letra'=>'a', 'palabra'=>'automaticidad'),
array('letra'=>'a', 'palabra'=>'automatico'),
array('letra'=>'a', 'palabra'=>'automatismo'),
array('letra'=>'a', 'palabra'=>'automatizacion'),
array('letra'=>'a', 'palabra'=>'automatizar'),
array('letra'=>'a', 'palabra'=>'automedonte'),
array('letra'=>'a', 'palabra'=>'automocion'),
array('letra'=>'a', 'palabra'=>'automotor'),
array('letra'=>'a', 'palabra'=>'automotriz'),
array('letra'=>'a', 'palabra'=>'automovil'),
array('letra'=>'a', 'palabra'=>'automovilismo'),
array('letra'=>'a', 'palabra'=>'automovilista'),
array('letra'=>'a', 'palabra'=>'automovilistico'),
array('letra'=>'a', 'palabra'=>'autonomia'),
array('letra'=>'a', 'palabra'=>'autonomico'),
array('letra'=>'a', 'palabra'=>'autonomista'),
array('letra'=>'a', 'palabra'=>'autonomo'),
array('letra'=>'a', 'palabra'=>'autopiloto'),
array('letra'=>'a', 'palabra'=>'autopista'),
array('letra'=>'a', 'palabra'=>'autoplastia'),
array('letra'=>'a', 'palabra'=>'autopropulsado'),
array('letra'=>'a', 'palabra'=>'autopropulsion'),
array('letra'=>'a', 'palabra'=>'autopsia'),
array('letra'=>'a', 'palabra'=>'autopsido'),
array('letra'=>'a', 'palabra'=>'autor'),
array('letra'=>'a', 'palabra'=>'autoria'),
array('letra'=>'a', 'palabra'=>'autoridad'),
array('letra'=>'a', 'palabra'=>'autoritario'),
array('letra'=>'a', 'palabra'=>'autoritarismo'),
array('letra'=>'a', 'palabra'=>'autoritativo'),
array('letra'=>'a', 'palabra'=>'autorizable'),
array('letra'=>'a', 'palabra'=>'autorizacion'),
array('letra'=>'a', 'palabra'=>'autorizadamente'),
array('letra'=>'a', 'palabra'=>'autorizado'),
array('letra'=>'a', 'palabra'=>'autorizador'),
array('letra'=>'a', 'palabra'=>'autorizamiento'),
array('letra'=>'a', 'palabra'=>'autorizar'),
array('letra'=>'a', 'palabra'=>'autorregulable'),
array('letra'=>'a', 'palabra'=>'autorregulacion'),
array('letra'=>'a', 'palabra'=>'autorregulador'),
array('letra'=>'a', 'palabra'=>'autorregularse'),
array('letra'=>'a', 'palabra'=>'autorretrato'),
array('letra'=>'a', 'palabra'=>'autoservicio'),
array('letra'=>'a', 'palabra'=>'autostop'),
array('letra'=>'a', 'palabra'=>'autostopista'),
array('letra'=>'a', 'palabra'=>'autosuficiencia'),
array('letra'=>'a', 'palabra'=>'autosuficiente'),
array('letra'=>'a', 'palabra'=>'autosugestion'),
array('letra'=>'a', 'palabra'=>'autosugestionarse'),
array('letra'=>'a', 'palabra'=>'autotrofico'),
array('letra'=>'a', 'palabra'=>'autotrofo'),
array('letra'=>'a', 'palabra'=>'autovia'),
array('letra'=>'a', 'palabra'=>'autrigon'),
array('letra'=>'a', 'palabra'=>'autumnal'),
array('letra'=>'a', 'palabra'=>'auxiliador'),
array('letra'=>'a', 'palabra'=>'auxiliar'),
array('letra'=>'a', 'palabra'=>'auxiliaria'),
array('letra'=>'a', 'palabra'=>'auxilio'),
array('letra'=>'a', 'palabra'=>'auxina'),
array('letra'=>'a', 'palabra'=>'auyama'),
array('letra'=>'a', 'palabra'=>'avacado'),
array('letra'=>'a', 'palabra'=>'avadar'),
array('letra'=>'a', 'palabra'=>'avahado'),
array('letra'=>'a', 'palabra'=>'avahar'),
array('letra'=>'a', 'palabra'=>'aval'),
array('letra'=>'a', 'palabra'=>'avalador'),
array('letra'=>'a', 'palabra'=>'avalancha'),
array('letra'=>'a', 'palabra'=>'avalar'),
array('letra'=>'a', 'palabra'=>'avalentado'),
array('letra'=>'a', 'palabra'=>'avalentamiento'),
array('letra'=>'a', 'palabra'=>'avalentar'),
array('letra'=>'a', 'palabra'=>'avalentonado'),
array('letra'=>'a', 'palabra'=>'avaliar'),
array('letra'=>'a', 'palabra'=>'avalista'),
array('letra'=>'a', 'palabra'=>'avallar'),
array('letra'=>'a', 'palabra'=>'avalorar'),
array('letra'=>'a', 'palabra'=>'avaluacion'),
array('letra'=>'a', 'palabra'=>'avaluar'),
array('letra'=>'a', 'palabra'=>'avaluo'),
array('letra'=>'a', 'palabra'=>'avambrazo'),
array('letra'=>'a', 'palabra'=>'avampies'),
array('letra'=>'a', 'palabra'=>'avancarga'),
array('letra'=>'a', 'palabra'=>'avance'),
array('letra'=>'a', 'palabra'=>'avandicho'),
array('letra'=>'a', 'palabra'=>'avanecerse'),
array('letra'=>'a', 'palabra'=>'avantal'),
array('letra'=>'a', 'palabra'=>'avante'),
array('letra'=>'a', 'palabra'=>'avantren'),
array('letra'=>'a', 'palabra'=>'avanzada'),
array('letra'=>'a', 'palabra'=>'avanzadilla'),
array('letra'=>'a', 'palabra'=>'avanzado'),
array('letra'=>'a', 'palabra'=>'avanzar'),
array('letra'=>'a', 'palabra'=>'avanzo'),
array('letra'=>'a', 'palabra'=>'avaramente'),
array('letra'=>'a', 'palabra'=>'avaricia'),
array('letra'=>'a', 'palabra'=>'avariciar'),
array('letra'=>'a', 'palabra'=>'avariciosamente'),
array('letra'=>'a', 'palabra'=>'avaricioso'),
array('letra'=>'a', 'palabra'=>'avariento'),
array('letra'=>'a', 'palabra'=>'avariosis'),
array('letra'=>'a', 'palabra'=>'avaro'),
array('letra'=>'a', 'palabra'=>'avaro'),
array('letra'=>'a', 'palabra'=>'avasallador'),
array('letra'=>'a', 'palabra'=>'avasallamiento'),
array('letra'=>'a', 'palabra'=>'avasallar'),
array('letra'=>'a', 'palabra'=>'avatar'),
array('letra'=>'a', 'palabra'=>'avati'),
array('letra'=>'a', 'palabra'=>'ave'),
array('letra'=>'a', 'palabra'=>'avechucho'),
array('letra'=>'a', 'palabra'=>'avecilla'),
array('letra'=>'a', 'palabra'=>'avecinar'),
array('letra'=>'a', 'palabra'=>'avecindamiento'),
array('letra'=>'a', 'palabra'=>'avecindar'),
array('letra'=>'a', 'palabra'=>'avefria'),
array('letra'=>'a', 'palabra'=>'avejentar'),
array('letra'=>'a', 'palabra'=>'avejigar'),
array('letra'=>'a', 'palabra'=>'avelar'),
array('letra'=>'a', 'palabra'=>'avellana'),
array('letra'=>'a', 'palabra'=>'avellanado'),
array('letra'=>'a', 'palabra'=>'avellanador'),
array('letra'=>'a', 'palabra'=>'avellanal'),
array('letra'=>'a', 'palabra'=>'avellanar'),
array('letra'=>'a', 'palabra'=>'avellanate'),
array('letra'=>'a', 'palabra'=>'avellaneda'),
array('letra'=>'a', 'palabra'=>'avellanedo'),
array('letra'=>'a', 'palabra'=>'avellanero'),
array('letra'=>'a', 'palabra'=>'avellano'),
array('letra'=>'a', 'palabra'=>'avemaria'),
array('letra'=>'a', 'palabra'=>'avena'),
array('letra'=>'a', 'palabra'=>'avenado'),
array('letra'=>'a', 'palabra'=>'avenamiento'),
array('letra'=>'a', 'palabra'=>'avenar'),
array('letra'=>'a', 'palabra'=>'avenate'),
array('letra'=>'a', 'palabra'=>'avenedizo'),
array('letra'=>'a', 'palabra'=>'avenenar'),
array('letra'=>'a', 'palabra'=>'avenencia'),
array('letra'=>'a', 'palabra'=>'avenenteza'),
array('letra'=>'a', 'palabra'=>'avenible'),
array('letra'=>'a', 'palabra'=>'aveniceo'),
array('letra'=>'a', 'palabra'=>'avenida'),
array('letra'=>'a', 'palabra'=>'avenidero'),
array('letra'=>'a', 'palabra'=>'avenido'),
array('letra'=>'a', 'palabra'=>'avenidor'),
array('letra'=>'a', 'palabra'=>'avenimiento'),
array('letra'=>'a', 'palabra'=>'avenir'),
array('letra'=>'a', 'palabra'=>'aventadero'),
array('letra'=>'a', 'palabra'=>'aventado'),
array('letra'=>'a', 'palabra'=>'aventador'),
array('letra'=>'a', 'palabra'=>'aventadura'),
array('letra'=>'a', 'palabra'=>'aventaja'),
array('letra'=>'a', 'palabra'=>'aventajado'),
array('letra'=>'a', 'palabra'=>'aventajamiento'),
array('letra'=>'a', 'palabra'=>'aventajar'),
array('letra'=>'a', 'palabra'=>'aventamiento'),
array('letra'=>'a', 'palabra'=>'aventar'),
array('letra'=>'a', 'palabra'=>'aventon'),
array('letra'=>'a', 'palabra'=>'aventura'),
array('letra'=>'a', 'palabra'=>'aventurado'),
array('letra'=>'a', 'palabra'=>'aventurar'),
array('letra'=>'a', 'palabra'=>'aventureramente'),
array('letra'=>'a', 'palabra'=>'aventurero'),
array('letra'=>'a', 'palabra'=>'averar'),
array('letra'=>'a', 'palabra'=>'averdugar'),
array('letra'=>'a', 'palabra'=>'avergonzado'),
array('letra'=>'a', 'palabra'=>'avergonzamiento'),
array('letra'=>'a', 'palabra'=>'avergonzar'),
array('letra'=>'a', 'palabra'=>'averia'),
array('letra'=>'a', 'palabra'=>'averiar'),
array('letra'=>'a', 'palabra'=>'averiguable'),
array('letra'=>'a', 'palabra'=>'averiguacion'),
array('letra'=>'a', 'palabra'=>'averiguadamente'),
array('letra'=>'a', 'palabra'=>'averiguador'),
array('letra'=>'a', 'palabra'=>'averiguamiento'),
array('letra'=>'a', 'palabra'=>'averiguar'),
array('letra'=>'a', 'palabra'=>'averigüetas'),
array('letra'=>'a', 'palabra'=>'averio'),
array('letra'=>'a', 'palabra'=>'averno'),
array('letra'=>'a', 'palabra'=>'averroismo'),
array('letra'=>'a', 'palabra'=>'averroista'),
array('letra'=>'a', 'palabra'=>'averrugado'),
array('letra'=>'a', 'palabra'=>'aversar'),
array('letra'=>'a', 'palabra'=>'aversario'),
array('letra'=>'a', 'palabra'=>'aversion'),
array('letra'=>'a', 'palabra'=>'averso'),
array('letra'=>'a', 'palabra'=>'avesta'),
array('letra'=>'a', 'palabra'=>'avestico'),
array('letra'=>'a', 'palabra'=>'avestruz'),
array('letra'=>'a', 'palabra'=>'avetado'),
array('letra'=>'a', 'palabra'=>'avetarda'),
array('letra'=>'a', 'palabra'=>'avetoro'),
array('letra'=>'a', 'palabra'=>'aveza'),
array('letra'=>'a', 'palabra'=>'avezadura'),
array('letra'=>'a', 'palabra'=>'avezar'),
array('letra'=>'a', 'palabra'=>'avezon'),
array('letra'=>'a', 'palabra'=>'aviacion'),
array('letra'=>'a', 'palabra'=>'aviador'),
array('letra'=>'a', 'palabra'=>'aviajado'),
array('letra'=>'a', 'palabra'=>'aviamiento'),
array('letra'=>'a', 'palabra'=>'aviar'),
array('letra'=>'a', 'palabra'=>'aviario'),
array('letra'=>'a', 'palabra'=>'avica'),
array('letra'=>'a', 'palabra'=>'aviciar'),
array('letra'=>'a', 'palabra'=>'avicola'),
array('letra'=>'a', 'palabra'=>'avicultor'),
array('letra'=>'a', 'palabra'=>'avicultura'),
array('letra'=>'a', 'palabra'=>'avidez'),
array('letra'=>'a', 'palabra'=>'avido'),
array('letra'=>'a', 'palabra'=>'aviejar'),
array('letra'=>'a', 'palabra'=>'avienta'),
array('letra'=>'a', 'palabra'=>'aviento'),
array('letra'=>'a', 'palabra'=>'aviesamente'),
array('letra'=>'a', 'palabra'=>'aviesas'),
array('letra'=>'a', 'palabra'=>'avieso'),
array('letra'=>'a', 'palabra'=>'aviespa'),
array('letra'=>'a', 'palabra'=>'avifauna'),
array('letra'=>'a', 'palabra'=>'avifaunico'),
array('letra'=>'a', 'palabra'=>'avigorar'),
array('letra'=>'a', 'palabra'=>'avilantarse'),
array('letra'=>'a', 'palabra'=>'avilantez'),
array('letra'=>'a', 'palabra'=>'avilanteza'),
array('letra'=>'a', 'palabra'=>'avilar'),
array('letra'=>'a', 'palabra'=>'aviles'),
array('letra'=>'a', 'palabra'=>'avilesino'),
array('letra'=>'a', 'palabra'=>'avillanado'),
array('letra'=>'a', 'palabra'=>'avillanamiento'),
array('letra'=>'a', 'palabra'=>'avillanar'),
array('letra'=>'a', 'palabra'=>'aviltamiento'),
array('letra'=>'a', 'palabra'=>'aviltar'),
array('letra'=>'a', 'palabra'=>'avinagrado'),
array('letra'=>'a', 'palabra'=>'avinagrar'),
array('letra'=>'a', 'palabra'=>'aviñonense'),
array('letra'=>'a', 'palabra'=>'aviñones'),
array('letra'=>'a', 'palabra'=>'avio'),
array('letra'=>'a', 'palabra'=>'avion'),
array('letra'=>'a', 'palabra'=>'avioneta'),
array('letra'=>'a', 'palabra'=>'avionica'),
array('letra'=>'a', 'palabra'=>'avisacoches'),
array('letra'=>'a', 'palabra'=>'avisadamente'),
array('letra'=>'a', 'palabra'=>'avisado'),
array('letra'=>'a', 'palabra'=>'avisador'),
array('letra'=>'a', 'palabra'=>'avisaje'),
array('letra'=>'a', 'palabra'=>'avisamiento'),
array('letra'=>'a', 'palabra'=>'avisar'),
array('letra'=>'a', 'palabra'=>'avisero'),
array('letra'=>'a', 'palabra'=>'aviso'),
array('letra'=>'a', 'palabra'=>'avison'),
array('letra'=>'a', 'palabra'=>'avispa'),
array('letra'=>'a', 'palabra'=>'avispado'),
array('letra'=>'a', 'palabra'=>'avispar'),
array('letra'=>'a', 'palabra'=>'avispero'),
array('letra'=>'a', 'palabra'=>'avispon'),
array('letra'=>'a', 'palabra'=>'avistar'),
array('letra'=>'a', 'palabra'=>'avitaminosis'),
array('letra'=>'a', 'palabra'=>'avitelado'),
array('letra'=>'a', 'palabra'=>'avituallamiento'),
array('letra'=>'a', 'palabra'=>'avituallar'),
array('letra'=>'a', 'palabra'=>'avivadamente'),
array('letra'=>'a', 'palabra'=>'avivado'),
array('letra'=>'a', 'palabra'=>'avivador'),
array('letra'=>'a', 'palabra'=>'avivamiento'),
array('letra'=>'a', 'palabra'=>'avivar'),
array('letra'=>'a', 'palabra'=>'avizor'),
array('letra'=>'a', 'palabra'=>'avizorador'),
array('letra'=>'a', 'palabra'=>'avizorar'),
array('letra'=>'a', 'palabra'=>'avo'),
array('letra'=>'a', 'palabra'=>'avocacion'),
array('letra'=>'a', 'palabra'=>'avocamiento'),
array('letra'=>'a', 'palabra'=>'avocar'),
array('letra'=>'a', 'palabra'=>'avoceta'),
array('letra'=>'a', 'palabra'=>'avol'),
array('letra'=>'a', 'palabra'=>'avolcanado'),
array('letra'=>'a', 'palabra'=>'avoleza'),
array('letra'=>'a', 'palabra'=>'avolvimiento'),
array('letra'=>'a', 'palabra'=>'avucasta'),
array('letra'=>'a', 'palabra'=>'avucastro'),
array('letra'=>'a', 'palabra'=>'avugo'),
array('letra'=>'a', 'palabra'=>'avuguero'),
array('letra'=>'a', 'palabra'=>'avulsion'),
array('letra'=>'a', 'palabra'=>'avutarda'),
array('letra'=>'a', 'palabra'=>'avutardado'),
array('letra'=>'a', 'palabra'=>'ax'),
array('letra'=>'a', 'palabra'=>'axial'),
array('letra'=>'a', 'palabra'=>'axil'),
array('letra'=>'a', 'palabra'=>'axila'),
array('letra'=>'a', 'palabra'=>'axilar'),
array('letra'=>'a', 'palabra'=>'axinita'),
array('letra'=>'a', 'palabra'=>'axiologia'),
array('letra'=>'a', 'palabra'=>'axiologico'),
array('letra'=>'a', 'palabra'=>'axioma'),
array('letra'=>'a', 'palabra'=>'axiomatico'),
array('letra'=>'a', 'palabra'=>'axiomatizacion'),
array('letra'=>'a', 'palabra'=>'axiomatizar'),
array('letra'=>'a', 'palabra'=>'axiometro'),
array('letra'=>'a', 'palabra'=>'axis'),
array('letra'=>'a', 'palabra'=>'axoideo'),
array('letra'=>'a', 'palabra'=>'axon'),
array('letra'=>'a', 'palabra'=>'axonometria'),
array('letra'=>'a', 'palabra'=>'ay'),
array('letra'=>'a', 'palabra'=>'ayacahuite'),
array('letra'=>'a', 'palabra'=>'ayaco'),
array('letra'=>'a', 'palabra'=>'ayacua'),
array('letra'=>'a', 'palabra'=>'ayacuchano'),
array('letra'=>'a', 'palabra'=>'ayahuasca'),
array('letra'=>'a', 'palabra'=>'ayales'),
array('letra'=>'a', 'palabra'=>'ayate'),
array('letra'=>'a', 'palabra'=>'ayatola'),
array('letra'=>'a', 'palabra'=>'ayayay'),
array('letra'=>'a', 'palabra'=>'ayear'),
array('letra'=>'a', 'palabra'=>'ayeaye'),
array('letra'=>'a', 'palabra'=>'ayer'),
array('letra'=>'a', 'palabra'=>'ayermar'),
array('letra'=>'a', 'palabra'=>'ayme'),
array('letra'=>'a', 'palabra'=>'ayo'),
array('letra'=>'a', 'palabra'=>'ayocote'),
array('letra'=>'a', 'palabra'=>'ayopayeño'),
array('letra'=>'a', 'palabra'=>'ayora'),
array('letra'=>'a', 'palabra'=>'ayote'),
array('letra'=>'a', 'palabra'=>'ayotera'),
array('letra'=>'a', 'palabra'=>'ayua'),
array('letra'=>'a', 'palabra'=>'ayuda'),
array('letra'=>'a', 'palabra'=>'ayudado'),
array('letra'=>'a', 'palabra'=>'ayudador'),
array('letra'=>'a', 'palabra'=>'ayudamiento'),
array('letra'=>'a', 'palabra'=>'ayudanta'),
array('letra'=>'a', 'palabra'=>'ayudante'),
array('letra'=>'a', 'palabra'=>'ayudantia'),
array('letra'=>'a', 'palabra'=>'ayudar'),
array('letra'=>'a', 'palabra'=>'ayuga'),
array('letra'=>'a', 'palabra'=>'ayunador'),
array('letra'=>'a', 'palabra'=>'ayunar'),
array('letra'=>'a', 'palabra'=>'ayuno'),
array('letra'=>'a', 'palabra'=>'ayunque'),
array('letra'=>'a', 'palabra'=>'ayuntable'),
array('letra'=>'a', 'palabra'=>'ayuntadamente'),
array('letra'=>'a', 'palabra'=>'ayuntador'),
array('letra'=>'a', 'palabra'=>'ayuntamiento'),
array('letra'=>'a', 'palabra'=>'ayuntar'),
array('letra'=>'a', 'palabra'=>'ayuso'),
array('letra'=>'a', 'palabra'=>'ayustar'),
array('letra'=>'a', 'palabra'=>'ayuste'),
array('letra'=>'a', 'palabra'=>'azabachado'),
array('letra'=>'a', 'palabra'=>'azabache'),
array('letra'=>'a', 'palabra'=>'azabachero'),
array('letra'=>'a', 'palabra'=>'azabara'),
array('letra'=>'a', 'palabra'=>'azacan'),
array('letra'=>'a', 'palabra'=>'azacanarse'),
array('letra'=>'a', 'palabra'=>'azacanear'),
array('letra'=>'a', 'palabra'=>'azacaneo'),
array('letra'=>'a', 'palabra'=>'azacaya'),
array('letra'=>'a', 'palabra'=>'azache'),
array('letra'=>'a', 'palabra'=>'azacuan'),
array('letra'=>'a', 'palabra'=>'azada'),
array('letra'=>'a', 'palabra'=>'azadada'),
array('letra'=>'a', 'palabra'=>'azadazo'),
array('letra'=>'a', 'palabra'=>'azadilla'),
array('letra'=>'a', 'palabra'=>'azadon'),
array('letra'=>'a', 'palabra'=>'azadonada'),
array('letra'=>'a', 'palabra'=>'azadonazo'),
array('letra'=>'a', 'palabra'=>'azadonero'),
array('letra'=>'a', 'palabra'=>'azafata'),
array('letra'=>'a', 'palabra'=>'azafate'),
array('letra'=>'a', 'palabra'=>'azafran'),
array('letra'=>'a', 'palabra'=>'azafranado'),
array('letra'=>'a', 'palabra'=>'azafranal'),
array('letra'=>'a', 'palabra'=>'azafranar'),
array('letra'=>'a', 'palabra'=>'azafranero'),
array('letra'=>'a', 'palabra'=>'azagadero'),
array('letra'=>'a', 'palabra'=>'azagador'),
array('letra'=>'a', 'palabra'=>'azagar'),
array('letra'=>'a', 'palabra'=>'azagaya'),
array('letra'=>'a', 'palabra'=>'azagon'),
array('letra'=>'a', 'palabra'=>'azaguan'),
array('letra'=>'a', 'palabra'=>'azahar'),
array('letra'=>'a', 'palabra'=>'azainadamente'),
array('letra'=>'a', 'palabra'=>'azala'),
array('letra'=>'a', 'palabra'=>'azalea'),
array('letra'=>'a', 'palabra'=>'azamboa'),
array('letra'=>'a', 'palabra'=>'azamboero'),
array('letra'=>'a', 'palabra'=>'azamboo'),
array('letra'=>'a', 'palabra'=>'azanahoriate'),
array('letra'=>'a', 'palabra'=>'azanca'),
array('letra'=>'a', 'palabra'=>'azandar'),
array('letra'=>'a', 'palabra'=>'azanefa'),
array('letra'=>'a', 'palabra'=>'azanoria'),
array('letra'=>'a', 'palabra'=>'azanoriate'),
array('letra'=>'a', 'palabra'=>'azaque'),
array('letra'=>'a', 'palabra'=>'azaquefa'),
array('letra'=>'a', 'palabra'=>'azar'),
array('letra'=>'a', 'palabra'=>'azaramiento'),
array('letra'=>'a', 'palabra'=>'azarandar'),
array('letra'=>'a', 'palabra'=>'azarar'),
array('letra'=>'a', 'palabra'=>'azararse'),
array('letra'=>'a', 'palabra'=>'azarbe'),
array('letra'=>'a', 'palabra'=>'azarbeta'),
array('letra'=>'a', 'palabra'=>'azarcon'),
array('letra'=>'a', 'palabra'=>'azarearse'),
array('letra'=>'a', 'palabra'=>'azarja'),
array('letra'=>'a', 'palabra'=>'azarnefe'),
array('letra'=>'a', 'palabra'=>'azaro'),
array('letra'=>'a', 'palabra'=>'azarolla'),
array('letra'=>'a', 'palabra'=>'azarollo'),
array('letra'=>'a', 'palabra'=>'azarosamente'),
array('letra'=>'a', 'palabra'=>'azaroso'),
array('letra'=>'a', 'palabra'=>'azcarrio'),
array('letra'=>'a', 'palabra'=>'azcon'),
array('letra'=>'a', 'palabra'=>'azcona'),
array('letra'=>'a', 'palabra'=>'azerbaijano'),
array('letra'=>'a', 'palabra'=>'azerbaiyano'),
array('letra'=>'a', 'palabra'=>'azeri'),
array('letra'=>'a', 'palabra'=>'azeuxis'),
array('letra'=>'a', 'palabra'=>'azimo'),
array('letra'=>'a', 'palabra'=>'azimut'),
array('letra'=>'a', 'palabra'=>'azimutal'),
array('letra'=>'a', 'palabra'=>'aznacho'),
array('letra'=>'a', 'palabra'=>'aznallo'),
array('letra'=>'a', 'palabra'=>'azoado'),
array('letra'=>'a', 'palabra'=>'azoar'),
array('letra'=>'a', 'palabra'=>'azoato'),
array('letra'=>'a', 'palabra'=>'azocar'),
array('letra'=>'a', 'palabra'=>'azoe'),
array('letra'=>'a', 'palabra'=>'azoemia'),
array('letra'=>'a', 'palabra'=>'azofaifa'),
array('letra'=>'a', 'palabra'=>'azofaifo'),
array('letra'=>'a', 'palabra'=>'azofar'),
array('letra'=>'a', 'palabra'=>'azofeifa'),
array('letra'=>'a', 'palabra'=>'azofra'),
array('letra'=>'a', 'palabra'=>'azogadamente'),
array('letra'=>'a', 'palabra'=>'azogado'),
array('letra'=>'a', 'palabra'=>'azogamiento'),
array('letra'=>'a', 'palabra'=>'azogar'),
array('letra'=>'a', 'palabra'=>'azogue'),
array('letra'=>'a', 'palabra'=>'azogueño'),
array('letra'=>'a', 'palabra'=>'azogueria'),
array('letra'=>'a', 'palabra'=>'azoguero'),
array('letra'=>'a', 'palabra'=>'azoico'),
array('letra'=>'a', 'palabra'=>'azolaceo'),
array('letra'=>'a', 'palabra'=>'azolar'),
array('letra'=>'a', 'palabra'=>'azoleo'),
array('letra'=>'a', 'palabra'=>'azolvamiento'),
array('letra'=>'a', 'palabra'=>'azolvar'),
array('letra'=>'a', 'palabra'=>'azolve'),
array('letra'=>'a', 'palabra'=>'azomamiento'),
array('letra'=>'a', 'palabra'=>'azomar'),
array('letra'=>'a', 'palabra'=>'azoospermia'),
array('letra'=>'a', 'palabra'=>'azor'),
array('letra'=>'a', 'palabra'=>'azorafa'),
array('letra'=>'a', 'palabra'=>'azoramiento'),
array('letra'=>'a', 'palabra'=>'azorar'),
array('letra'=>'a', 'palabra'=>'azorero'),
array('letra'=>'a', 'palabra'=>'azoriniano'),
array('letra'=>'a', 'palabra'=>'azoro'),
array('letra'=>'a', 'palabra'=>'azorramiento'),
array('letra'=>'a', 'palabra'=>'azorrar'),
array('letra'=>'a', 'palabra'=>'azotable'),
array('letra'=>'a', 'palabra'=>'azotacalles'),
array('letra'=>'a', 'palabra'=>'azotado'),
array('letra'=>'a', 'palabra'=>'azotador'),
array('letra'=>'a', 'palabra'=>'azotaina'),
array('letra'=>'a', 'palabra'=>'azotalenguas'),
array('letra'=>'a', 'palabra'=>'azotamiento'),
array('letra'=>'a', 'palabra'=>'azotar'),
array('letra'=>'a', 'palabra'=>'azotazo'),
array('letra'=>'a', 'palabra'=>'azote'),
array('letra'=>'a', 'palabra'=>'azotea'),
array('letra'=>'a', 'palabra'=>'azotina'),
array('letra'=>'a', 'palabra'=>'azteca'),
array('letra'=>'a', 'palabra'=>'aztequismo'),
array('letra'=>'a', 'palabra'=>'aztor'),
array('letra'=>'a', 'palabra'=>'azua'),
array('letra'=>'a', 'palabra'=>'azuayo'),
array('letra'=>'a', 'palabra'=>'azucar'),
array('letra'=>'a', 'palabra'=>'azucarado'),
array('letra'=>'a', 'palabra'=>'azucarar'),
array('letra'=>'a', 'palabra'=>'azucarero'),
array('letra'=>'a', 'palabra'=>'azucari'),
array('letra'=>'a', 'palabra'=>'azucarillo'),
array('letra'=>'a', 'palabra'=>'azucena'),
array('letra'=>'a', 'palabra'=>'azuche'),
array('letra'=>'a', 'palabra'=>'azud'),
array('letra'=>'a', 'palabra'=>'azuda'),
array('letra'=>'a', 'palabra'=>'azuela'),
array('letra'=>'a', 'palabra'=>'azufaifa'),
array('letra'=>'a', 'palabra'=>'azufaifo'),
array('letra'=>'a', 'palabra'=>'azufeifa'),
array('letra'=>'a', 'palabra'=>'azufeifo'),
array('letra'=>'a', 'palabra'=>'azufrado'),
array('letra'=>'a', 'palabra'=>'azufrador'),
array('letra'=>'a', 'palabra'=>'azuframiento'),
array('letra'=>'a', 'palabra'=>'azufrar'),
array('letra'=>'a', 'palabra'=>'azufre'),
array('letra'=>'a', 'palabra'=>'azufrero'),
array('letra'=>'a', 'palabra'=>'azufron'),
array('letra'=>'a', 'palabra'=>'azufroso'),
array('letra'=>'a', 'palabra'=>'azul'),
array('letra'=>'a', 'palabra'=>'azulado'),
array('letra'=>'a', 'palabra'=>'azulaque'),
array('letra'=>'a', 'palabra'=>'azular'),
array('letra'=>'a', 'palabra'=>'azulear'),
array('letra'=>'a', 'palabra'=>'azulejar'),
array('letra'=>'a', 'palabra'=>'azulejeria'),
array('letra'=>'a', 'palabra'=>'azulejero'),
array('letra'=>'a', 'palabra'=>'azulejo'),
array('letra'=>'a', 'palabra'=>'azulenco'),
array('letra'=>'a', 'palabra'=>'azulete'),
array('letra'=>'a', 'palabra'=>'azulgrana'),
array('letra'=>'a', 'palabra'=>'azulillo'),
array('letra'=>'a', 'palabra'=>'azulino'),
array('letra'=>'a', 'palabra'=>'azulon'),
array('letra'=>'a', 'palabra'=>'azuloso'),
array('letra'=>'a', 'palabra'=>'azumbar'),
array('letra'=>'a', 'palabra'=>'azumbrado'),
array('letra'=>'a', 'palabra'=>'azumbre'),
array('letra'=>'a', 'palabra'=>'azuquita'),
array('letra'=>'a', 'palabra'=>'azuquitar'),
array('letra'=>'a', 'palabra'=>'azur'),
array('letra'=>'a', 'palabra'=>'azurita'),
array('letra'=>'a', 'palabra'=>'azurronarse'),
array('letra'=>'a', 'palabra'=>'azurumbar'),
array('letra'=>'a', 'palabra'=>'azut'),
array('letra'=>'a', 'palabra'=>'azutea'),
array('letra'=>'a', 'palabra'=>'azuzador'),
array('letra'=>'a', 'palabra'=>'azuzar'),
);
foreach ($lstStructure as $lst) {
$objeto = new Pma5Diccionario();
$objeto->setLetra($lst['letra']);
$objeto->setPalabra($lst['palabra']);
$manager->persist($objeto);
}
$manager->flush();
}
}
| martintito/desaeka | src/Jaxxes/TestPmaSPBundle/DataFixtures/ORM/PMA5DiccionarioA.php | PHP | mit | 453,811 |
<?php
namespace Celtic\Testing\Joomla;
class Joomla25AdminPage extends AdminPage
{
protected $userMenuSelector = 'css selector:#header-box #module-status';
protected $messageContainer = "id:system-message-container";
protected $headLineSelector = "css selector:div.page-title h2";
public function __construct($driver)
{
parent::__construct($driver);
$this->menu = new Joomla25AdminMainMenu($driver);
$this->toolbar = new Joomla25AdminToolbar($driver);
}
/**
* @return Joomla25AdminLoginPage
*/
public function logout()
{
$userMenu = $this->driver->getElement($this->userMenuSelector);
$userMenu->byCssSelector('.logout a')->click();
return new Joomla25AdminLoginPage($this->driver);
}
}
| GreenCape/build | template/selenium/Pages/Joomla25/Admin/Page.php | PHP | mit | 732 |
// types
const TRACKS_SET = 'tracks/TRACKS_SET'
// actions
const doSetTracks = (tracks) => {
return {
type: TRACKS_SET,
tracks: tracks
}
}
// reducers
const initialState = {}
const reducer = (state = initialState, action) => {
switch (action.type) {
case TRACKS_SET:
return applySetTracks(state, action)
default:
return state;
}
}
const applySetTracks = (state, action) => {
const { type, tracks } = action
return (
{
...state,
tracks: tracks
}
)
}
// index
export const actionCreators = {
doSetTracks
}
export const actionTypes = {
TRACKS_SET
}
export default reducer
| OttoH/rereKit | src/ducks/tracks.js | JavaScript | mit | 709 |
<?php
/**
* @link https://pix.st/
* @copyright Copyright (c) 2015 Pix Street
* @license MIT License https://opensource.org/licenses/MIT
*/
namespace pixst;
use pixst\ChannelInterface;
use pixst\exceptions\ChannelException;
use pixst\exceptions\HttpException;
/**
* cURL channel class
*/
class CurlChannel implements ChannelInterface
{
/**
* @var resource $_ch cURL handle
*/
protected $_ch;
/**
* Constructor
*
* @param string $url Pix Street API endpoint URL
*/
public function __construct()
{
$ch = curl_init();
curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, 0);
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_TIMEOUT, 60);
$this->_ch = $ch;
}
/**
* Sets Pix Street API endpoint URL
*
* @param string $url Pix Street API endpoint URL
* @return ChannelInterface Channel object itsel
*/
public function setUrl($url) {
curl_setopt($this->_ch, CURLOPT_URL, $url);
return $this;
}
/**
* Sets additional request headers
*
* @param array $headers List of additional request headers
* @return CurlChannel Channel object itsel
*/
public function setHeaders($headers)
{
curl_setopt($this->_ch, CURLOPT_HTTPHEADER, array_map(
function($name, $value) {
return $name . ': ' . $value;
},
array_keys($headers),
array_values($headers)
));
return $this;
}
/**
* Sets POST-request's body
*
* @param string $body POST-request's body
* @return CurlChannel Channel object itself
*/
public function setBody($body)
{
curl_setopt($this->_ch, CURLOPT_POSTFIELDS, $body);
return $this;
}
/**
* Executes cURL session
*
* @return string Pix Street API response
* @throws Exception on connection or API error
*/
public function query()
{
$response = curl_exec($this->_ch);
if (curl_error($this->_ch)) {
throw new ChannelException;
}
$httpCode = curl_getinfo($this->_ch, CURLINFO_HTTP_CODE);
switch ($httpCode) {
case 200:
return $response;
case 400:
throw new HttpException($response, $httpCode);
case 401:
throw new HttpException($response, $httpCode);
case 404:
throw new HttpException('Not Found', $httpCode);
case 429:
throw new HttpException('Too Many Requests', $httpCode);
case 500:
throw new HttpException('Internal Server Error', $httpCode);
case 502:
throw new HttpException('Bad Gateway', $httpCode);
case 504:
throw new HttpException('Gateway Timeout', $httpCode);
default:
throw new HttpException('Unknown Error', $httpCode);
}
return $response;
}
}
| PixSt/php-yii2 | CurlChannel.php | PHP | mit | 3,176 |
require('chai').should();
var IndexedArray = require('../index');
describe('IndexedArray', function () {
it('is instanceof Array', function () {
var a = IndexedArray([1,2,3]);
(a instanceof Array).should.be.true;
});
it('is still instanceof Array when used with `new`', function () {
var a = new IndexedArray([1,2,3]);
(a instanceof Array).should.be.true;
});
it('has length', function () {
var a = IndexedArray([1,2,3]);
a.length.should.equal(3);
});
it('takes a plain array in the constructor', function () {
var a = IndexedArray([4,3,2,1]);
a.length.should.equal(4);
});
it('will initialize an empty array if instantiated with no arguments', function () {
var a = IndexedArray();
a.length.should.equal(0);
});
it('can access elements by positional index', function () {
var a = IndexedArray(['a','b','c']);
a[0].should.equal('a');
a[1].should.equal('b');
a[2].should.equal('c');
});
describe('Supported Array.prototype methods', function () {
it('push', function () {
var a = IndexedArray([]);
a.push('thing');
a.length.should.equal(1);
a[0].should.equal('thing');
a.push({_id: 'baz', val: 'foo'});
a.length.should.equal(2);
a['baz'].val.should.equal('foo');
});
it('pop', function () {
var datum = {_id: 'foo', val: 5};
var a = IndexedArray([{}, datum]);
var popped = a.pop();
popped.should.equal(datum);
a.length.should.equal(1);
(a['foo'] === undefined).should.be.true;
});
it('shift', function () {
var datum = {_id: 'unicorns', real: true};
var a = IndexedArray([datum, {}]);
var shifted = a.shift();
shifted.should.equal(datum);
a.length.should.equal(1);
(a['unicorns'] === undefined).should.be.true;
});
it('unshift', function () {
var datum = {_id: 'luftbalons', count: 99};
var a = IndexedArray([{}]);
a.unshift(datum);
a.length.should.equal(2);
a[0].should.equal(datum);
a['luftbalons'].should.equal(datum);
});
describe('splice', function () {
var apple, potato, theRest, a;
beforeEach(function () {
apple = {_id: 'apple', state: 'WA'};
potato = {_id: 'potato', state: 'ID'};
theRest = {_id: 'rest', state: 'CA'};
a = IndexedArray([apple, potato, theRest]);
})
it('inserts', function () {
var bigApples = {_id: 'big apples', state: 'NY'};
var spliced = a.splice(2,0, bigApples);
a.length.should.equal(4);
a[0].should.equal(apple);
a[1].should.equal(potato);
a[2].should.equal(bigApples);
a[3].should.equal(theRest);
a['big apples'].should.equal(bigApples);
Array.isArray(spliced).should.be.true;
spliced.length.should.equal(0);
});
it('removes', function () {
var spliced = a.splice(0,1);
a.length.should.equal(2);
a[0].should.equal(potato);
a[1].should.equal(theRest);
spliced.length.should.equal(1);
spliced[0].should.equal(apple);
});
it('removes and inserts multiple', function () {
var lobster = {_id: 'lobster', state: 'ME'};
var oranges = {_id: 'oranges', state: 'FL'};
var spliced = a.splice(1,2, lobster, oranges);
a.length.should.equal(3);
a[0].should.equal(apple);
a[1].should.equal(lobster);
a[2].should.equal(oranges);
a['lobster'].should.equal(lobster);
a['oranges'].should.equal(oranges);
spliced.length.should.equal(2);
spliced[0].should.equal(potato);
spliced[1].should.equal(theRest);
});
});
describe('concat', function () {
it('merges two IndexArrays together, using the indexer from the first IndexedArray', function () {
var a1 = IndexedArray([{a: 'a', b:2}, {a: 'b', z: 4}], function(x) { return x.a.toUpperCase(); })
var a2 = IndexedArray([{a: 'c', b:2}, {a: 'd', z: 4}])
var a3 = a1.concat(a2);
a1.length.should.equal(2);
a2.length.should.equal(2);
a3.length.should.equal(4);
a3['A'].b.should.equal(2);
a3['B'].z.should.equal(4);
a3['C'].b.should.equal(2);
a3['D'].z.should.equal(4);
});
it('merges an IndexedArray with a plain old array, using the indexer from the frist IndexedArray', function () {
var a1 = IndexedArray([{a: 'a', b:2}, {a: 'b', z: 4}], function(x) { return x.a.toUpperCase(); })
var a2 = [{a: 'c', b:2}, {a: 'd', z: 4}]
var a3 = a1.concat(a2);
a1.length.should.equal(2);
a2.length.should.equal(2);
a3.length.should.equal(4);
a3['A'].b.should.equal(2);
a3['B'].z.should.equal(4);
a3['C'].b.should.equal(2);
a3['D'].z.should.equal(4);
})
});
describe('slice', function () {
it('returns a copy (shallow clone) when called without arguments', function () {
var arr = [1,2,3];
var a1 = IndexedArray(arr);
var a2 = a1.slice();
a2.length.should.equal(a1.length);
a2.should.not.equal(a1);
});
});
it('foreach only iterates over each element once', function () {
var arr = [1,2,3,4];
var i = 0;
IndexedArray(arr).forEach(function () { i++; });
i.should.equal(4);
});
});
describe('indexing', function () {
it ('will index elements using an optional indexer passed in as the second argument of the constructor', function () {
var john = {name: 'john', age: 9};
var lucia = {name: 'lucia', age: 13};
var arr = [john, lucia];
var a = IndexedArray(arr, 'name');
a['john'].should.equal(john);
});
it('defaults to using the property `_id`', function () {
var arr = [{_id: '23a', boats: 'lots'}, {_id: 's12', boats: 'not so much'}, {_id: 'l337', boats: 'k'}];
var a = IndexedArray(arr);
a['l337'].boats.should.equal('k');
});
it('won\'t use small numbers as indices to prevent confusion with positional indices', function () {
var arr = [{_id: 14, title: 'Nope'}, {_id: 3, title: 'Wat'}];
var a = IndexedArray(arr);
(a[14] === undefined).should.be.true;
});
it('can use big numbers (as might appear in serialized hex ids) as indexes (>10 chars)', function () {
var arr = [{_id: '555152157769773177000002', a:true},{_id: '12345678901', b:false}]
var a = IndexedArray(arr)
a['555152157769773177000002'].a.should.equal(true)
a['12345678901'].b.should.equal(false)
})
it('can use objects with an overridden toString as the index key', function () {
var MyStr = function (s) { this.toString = function () { return s } }
var arr = [
{_id: new MyStr('foo'), val: 3},
{_id: new MyStr('faa'), val: 4},
{_id: new MyStr('fuu'), val: 5}
]
var a = IndexedArray(arr)
a['faa'].val.should.equal(4)
})
it('takes a custom function as an indexer', function () {
var arr = [{first: 'BOB', last: 'bobson'}, {first: 'Foo', last: 'barzynsczki'}];
var a = IndexedArray(arr, function (x) { return x.first.toLowerCase(); });
a['bob'].last.should.equal('bobson');
});
it('has a `keys` method, analogous to `Object.keys`', function () {
var arr = [{_id: 'Q', val: 1}, {_id: 'W', val: 2}, {_id: 'E', val: 3}, {_id: 'R', val: 4}, {_id: 'T', val: 5}, {_id: 'Y', val: 6}];
IndexedArray(arr).keys().should.deep.equal(['Q','W','E','R','T','Y']);
});
});
describe('fromObject', function () {
it('creates an IndexedArray from an object, essentially flattening indexes into properties', function () {
var obj = {
'QWE': {val: 'qwe'},
'ASD': {val: 'asd'},
'ZXC': {val: 'zxc'}
};
var a = IndexedArray.fromObject(obj);
a.length.should.equal(3);
a[0]._id.should.equal('QWE');
a['QWE'].val.should.equal('qwe');
});
});
}); | jden/indexed-array | test/tests.js | JavaScript | mit | 8,031 |
// Copyright (c) 2011-2012 The Bitcoin developers
// Copyright (c) 2013-2014 ComedyGold Developers
// Distributed under the MIT/X11 software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#include "sync.h"
#include "util.h"
#include <boost/foreach.hpp>
#ifdef DEBUG_LOCKCONTENTION
void PrintLockContention(const char* pszName, const char* pszFile, int nLine)
{
printf("LOCKCONTENTION: %s\n", pszName);
printf("Locker: %s:%d\n", pszFile, nLine);
}
#endif /* DEBUG_LOCKCONTENTION */
#ifdef DEBUG_LOCKORDER
//
// Early deadlock detection.
// Problem being solved:
// Thread 1 locks A, then B, then C
// Thread 2 locks D, then C, then A
// --> may result in deadlock between the two threads, depending on when they run.
// Solution implemented here:
// Keep track of pairs of locks: (A before B), (A before C), etc.
// Complain if any thread tries to lock in a different order.
//
struct CLockLocation
{
CLockLocation(const char* pszName, const char* pszFile, int nLine)
{
mutexName = pszName;
sourceFile = pszFile;
sourceLine = nLine;
}
std::string ToString() const
{
return mutexName+" "+sourceFile+":"+itostr(sourceLine);
}
private:
std::string mutexName;
std::string sourceFile;
int sourceLine;
};
typedef std::vector< std::pair<void*, CLockLocation> > LockStack;
static boost::mutex dd_mutex;
static std::map<std::pair<void*, void*>, LockStack> lockorders;
static boost::thread_specific_ptr<LockStack> lockstack;
static void potential_deadlock_detected(const std::pair<void*, void*>& mismatch, const LockStack& s1, const LockStack& s2)
{
printf("POTENTIAL DEADLOCK DETECTED\n");
printf("Previous lock order was:\n");
BOOST_FOREACH(const PAIRTYPE(void*, CLockLocation)& i, s2)
{
if (i.first == mismatch.first) printf(" (1)");
if (i.first == mismatch.second) printf(" (2)");
printf(" %s\n", i.second.ToString().c_str());
}
printf("Current lock order is:\n");
BOOST_FOREACH(const PAIRTYPE(void*, CLockLocation)& i, s1)
{
if (i.first == mismatch.first) printf(" (1)");
if (i.first == mismatch.second) printf(" (2)");
printf(" %s\n", i.second.ToString().c_str());
}
}
static void push_lock(void* c, const CLockLocation& locklocation, bool fTry)
{
if (lockstack.get() == NULL)
lockstack.reset(new LockStack);
if (fDebug) printf("Locking: %s\n", locklocation.ToString().c_str());
dd_mutex.lock();
(*lockstack).push_back(std::make_pair(c, locklocation));
if (!fTry) {
BOOST_FOREACH(const PAIRTYPE(void*, CLockLocation)& i, (*lockstack)) {
if (i.first == c) break;
std::pair<void*, void*> p1 = std::make_pair(i.first, c);
if (lockorders.count(p1))
continue;
lockorders[p1] = (*lockstack);
std::pair<void*, void*> p2 = std::make_pair(c, i.first);
if (lockorders.count(p2))
{
potential_deadlock_detected(p1, lockorders[p2], lockorders[p1]);
break;
}
}
}
dd_mutex.unlock();
}
static void pop_lock()
{
if (fDebug)
{
const CLockLocation& locklocation = (*lockstack).rbegin()->second;
printf("Unlocked: %s\n", locklocation.ToString().c_str());
}
dd_mutex.lock();
(*lockstack).pop_back();
dd_mutex.unlock();
}
void EnterCritical(const char* pszName, const char* pszFile, int nLine, void* cs, bool fTry)
{
push_lock(cs, CLockLocation(pszName, pszFile, nLine), fTry);
}
void LeaveCritical()
{
pop_lock();
}
#endif /* DEBUG_LOCKORDER */
| comedygold/comedygold | src/sync.cpp | C++ | mit | 3,711 |
<?php
namespace DrupalReleaseDate\Sampling;
class Sample
{
protected $when;
protected $count;
protected $diffTarget;
function __construct($when, $count, $last = null)
{
$this->when = $when;
$this->count = $count;
if ($last) {
$this->setDiff($last);
}
}
function getWhen()
{
return $this->when;
}
function getCount()
{
return $this->count;
}
function setDiff($from)
{
$this->diffTarget = $from;
}
function getDuration()
{
if (!isset($this->diffTarget)) {
return 0;
}
return $this->when - $this->diffTarget->getWhen();
}
function getResolved()
{
if (!isset($this->diffTarget)) {
return 0;
}
return $this->diffTarget->getCount() - $this->count;
}
}
| gapple/drupalreleasedate | src/DrupalReleaseDate/Sampling/Sample.php | PHP | mit | 877 |
using System;
namespace Topics.Radical.ComponentModel.Messaging
{
/// <summary>
///
/// </summary>
public interface ILegacyMessageCompatibility
{
/// <summary>
/// Sets the sender for backward compatibility.
/// </summary>
/// <param name="sender">The sender.</param>
void SetSenderForBackwardCompatibility(object sender);
}
/// <summary>
/// An IMessage is the minum contract that a message needs to implement
/// in order to be managed by an <c>IMessageBroker</c>.
/// </summary>
[Obsolete( "The Radical message broker now supports POCO messages, will be removed in the next version.", false )]
public interface IMessage : ILegacyMessageCompatibility
{
/// <summary>
/// Gets the message sender.
/// </summary>
/// <value>The message sender.</value>
object Sender { get; }
}
} | micdenny/radical | src/net35/Radical/ComponentModel/Messaging/IMessage.cs | C# | mit | 919 |
class Node {
constructor(item) {
this.item = item;
this.next = null;
}
}
module.exports = Node;
| cody1991/diary | _learn/algo/js-learn/libs/Node.js | JavaScript | mit | 109 |
module Timeline
Version = VERSION = "0.1.0"
end
| mrduncan/timeline | lib/timeline/version.rb | Ruby | mit | 50 |