text:
package com.xnlogic.pacer;

import com.tinkerpop.pipes.AbstractPipe;
import com.tinkerpop.pipes.Pipe;
import com.tinkerpop.pipes.transform.TransformPipe;
import com.tinkerpop.pipes.util.FastNoSuchElementException;

import java.util.List;
import clojure.lang.RT;
import clojure.lang.Var;

public class ChannelFanInPipe<S> extends AbstractPipe<List<Object>, S> implements TransformPipe<List<Object>, S> {
  private static final Var VEC = RT.var("clojure.core", "vec");
  private static final Var NTH = RT.var("clojure.core", "nth");
  private static final Var CHAN_SELECT = RT.var("pacer.parallel", "chan-select");

  private Object chans;
  private List currentPath;

  protected S processNextStart() {
    while (true) {
      if (this.chans == null) {
        Object next = starts.next();
        if (next != null)
          this.chans = VEC.invoke(next);
      } else {
        Object vec = CHAN_SELECT.invoke(this.chans);
        if (vec == null) {
          this.chans = null;
        } else {
          this.chans = NTH.invoke(vec, 1);
          if (this.pathEnabled) {
            this.currentPath = (List) NTH.invoke(vec, 0);
            System.out.println(this.currentPath);
            return (S) this.currentPath.get(this.currentPath.size() - 1);
          } else {
            return (S) NTH.invoke(vec, 0);
          }
        }
      }
    }
  }

  public List getCurrentPath() {
    if (this.pathEnabled) {
      return this.currentPath;
    } else {
      throw new RuntimeException(Pipe.NO_PATH_MESSAGE);
    }
  }

  public void reset() {
    this.currentPath = null;
    this.chans = null;
  }
}


text:
var gulp = require('gulp');
var jshint = require('gulp-jshint');
var stylish = require('jshint-stylish');

gulp.task('default', ['test']);

gulp.task('test', ['jshint']);

gulp.task('jshint', function () {
  gulp.src('./lib/**/*.js')
    .pipe(jshint('.jshintrc'))
    .pipe(jshint.reporter(stylish))
    .pipe(jshint.reporter('fail'));
});

redpajama_set_name: RedPajamaGithub


text:
from appengine_django.models import BaseModel
from google.appengine.ext import db
from google.appengine.api import users

#class Visitor(db.Model):
#    user = db.StringProperty()
#    added_on = db.DateTimeProperty(auto_now_add=True)
#    message = db.StringProperty()

class Cliente(db.Model):
    '''
        Cliente

        Entidade do usuário do Aritial
            user = usuário logado
            nome = nome a ser descoberto pelo Aritial
            apelido = caso a terceira letra do nome seja uma vogal, as 3 primeiras
            serão o apelido
            cidade = (DESENVOLVER!!!)
            profissao = (CORRITIR!!!)
            idade = o Aritial tentará identificar sua idade

    '''
    user = db.UserProperty()
    nome = db.StringProperty()
    apelido = db.StringProperty()
    cidade = db.StringProperty()
    profissao = db.StringProperty()
    idade = db.IntegerProperty()

class Knowledge(db.Model):
    '''
        Knowledge

        Base de conhecimento que será complementada com os livros enviados
        e com os textos escritos pelos usuários.
    '''
    sent_on = db.DateTimeProperty(auto_now_add=True)
    sender = db.UserProperty()
    frases = db.ListProperty(str)

class KnowLib(db.Model):
    '''
        KnowLib

        Biblioteca do aritial.

        PLAN:
            O Aritial não leria os livros assim que enviados, mas sim através
            de tarefa Cron, no período da noite.
            Selecionaria somente os autorizados pelos professores dele.
    '''
    sent_on = db.DateTimeProperty(auto_now_add=True)
    sender = db.UserProperty()
    value = db.BlobProperty()


text:
namespace stan {
namespace math {

template <typename T_y, typename T_shape, typename T_scale,
          require_all_not_nonscalar_prim_or_rev_kernel_expression_t<
              T_y, T_shape, T_scale>* = nullptr>
return_type_t<T_y, T_shape, T_scale> frechet_lcdf(const T_y& y,
                                                  const T_shape& alpha,
                                                  const T_scale& sigma) {
  using T_partials_return = partials_return_t<T_y, T_shape, T_scale>;
  using T_y_ref = ref_type_t<T_y>;
  using T_alpha_ref = ref_type_t<T_shape>;
  using T_sigma_ref = ref_type_t<T_scale>;
  static const char* function = "frechet_lcdf";
  T_y_ref y_ref = y;
  T_alpha_ref alpha_ref = alpha;
  T_sigma_ref sigma_ref = sigma;
  using std::exp;
  using std::pow;

  check_positive(function, "Random variable", y_ref);
  check_positive_finite(function, "Shape parameter", alpha_ref);
  check_positive_finite(function, "Scale parameter", sigma_ref);

  if (size_zero(y_ref, alpha_ref, sigma_ref)) {
    return 0.0;
  }

  T_partials_return cdf_log(0.0);
  operands_and_partials<T_y_ref, T_alpha_ref, T_sigma_ref> ops_partials(
      y_ref, alpha_ref, sigma_ref);

  scalar_seq_view<T_y> y_vec(y_ref);
  scalar_seq_view<T_scale> sigma_vec(sigma_ref);
  scalar_seq_view<T_shape> alpha_vec(alpha_ref);
  size_t N = max_size(y_ref, sigma_ref, alpha_ref);
  for (size_t n = 0; n < N; n++) {
    const T_partials_return y_dbl = y_vec.val(n);
    const T_partials_return sigma_dbl = sigma_vec.val(n);
    const T_partials_return alpha_dbl = alpha_vec.val(n);
    const T_partials_return pow_n = pow(sigma_dbl / y_dbl, alpha_dbl);

    cdf_log -= pow_n;

    if (!is_constant_all<T_y>::value) {
      ops_partials.edge1_.partials_[n] += pow_n * alpha_dbl / y_dbl;
    }
    if (!is_constant_all<T_shape>::value) {
      ops_partials.edge2_.partials_[n] += pow_n * log(y_dbl / sigma_dbl);
    }
    if (!is_constant_all<T_scale>::value) {
      ops_partials.edge3_.partials_[n] -= pow_n * alpha_dbl / sigma_dbl;
    }
  }
  return ops_partials.build(cdf_log);
}

}  // namespace math
}  // namespace stan
#endif


text:
package com.netflix.servo.monitor;

import com.google.common.base.Preconditions;

/**
 * Base type to simplify implementing monitors.
 */
public abstract class AbstractMonitor<T> implements Monitor<T> {
    protected final MonitorConfig config;

    /**
     * Create a new instance with the specified configuration.
     */
    protected AbstractMonitor(MonitorConfig config) {
        this.config = Preconditions.checkNotNull(config);
    }

    /** {@inheritDoc} */
    @Override
    public MonitorConfig getConfig() {
        return config;
    }
}


text:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace MipsSharp
{
    public static class StringExtensions
    {
        /// <summary>
        /// Duplicates a string <paramref name="count"/> times.
        /// </summary>
        public static string Dup(this string input, int count) =>
            string.Join("", Enumerable.Range(0, count).Select(x => input));

        public static string Join(this IEnumerable<string> input, string separator) =>
            string.Join(separator, input);
    }
}


text:
/**
 * @fileoverview Player Component - Base class for all UI objects
 *
 */

/**
 * Base UI Component class
 *
 * Components are embeddable UI objects that are represented by both a
 * javascript object and an element in the DOM. They can be children of other
 * components, and can have many children themselves.
 *
 *     // adding a button to the player
 *     var button = player.addChild('button');
 *     button.el(); // -> button element
 *
 *

 *
Button

 *

 *
 * Components are also event emitters.
 *
 *     button.on('click', function(){
 *       console.log('Button Clicked!');
 *     });
 *
 *     button.trigger('customevent');
 *
 * @param {Object} player  Main Player
 * @param {Object=} options
 * @class
 * @constructor
 * @extends vjs.CoreObject
 */
vjs.Component = vjs.CoreObject.extend({
  /**
   * the constructor function for the class
   *
   * @constructor
   */
  init: function(player, options, ready){
    this.player_ = player;

    // Make a copy of prototype.options_ to protect against overriding global defaults
    this.options_ = vjs.obj.copy(this.options_);

    // Updated options with supplied options
    options = this.options(options);

    // Get ID from options or options element if one is supplied
    this.id_ = options['id'] || (options['el'] && options['el']['id']);

    // If there was no ID from the options, generate one
    if (!this.id_) {
      // Don't require the player ID function in the case of mock players
      this.id_ = ((player.id && player.id()) || 'no_player') + '_component_' + vjs.guid++;
    }

    this.name_ = options['name'] || null;

    // Create element if one wasn't provided in options
    this.el_ = options['el'] || this.createEl();

    this.children_ = [];
    this.childIndex_ = {};
    this.childNameIndex_ = {};

    // Add any child components in options
    this.initChildren();

    this.ready(ready);
    // Don't want to trigger ready here or it will before init is actually
    // finished for all children that run this constructor

    if (options.reportTouchActivity !== false) {
      this.enableTouchActivity();
    }
  }
});

/**
 * Dispose of the component and all child components
 */
vjs.Component.prototype.dispose = function(){
  this.trigger({ type: 'dispose', 'bubbles': false });

  // Dispose all children.
  if (this.children_) {
    for (var i = this.children_.length - 1; i >= 0; i--) {
      if (this.children_[i].dispose) {
        this.children_[i].dispose();
      }
    }
  }

  // Delete child references
  this.children_ = null;
  this.childIndex_ = null;
  this.childNameIndex_ = null;

  // Remove all event listeners.
  this.off();

  // Remove element from DOM
  if (this.el_.parentNode) {
    this.el_.parentNode.removeChild(this.el_);
  }

  vjs.removeData(this.el_);
  this.el_ = null;
};

/**
 * Reference to main player instance
 *
 * @type {vjs.Player}
 * @private
 */
vjs.Component.prototype.player_ = true;

/**
 * Return the component's player
 *
 * @return {vjs.Player}
 */
vjs.Component.prototype.player = function(){
  return this.player_;
};

/**
 * The component's options object
 *
 * @type {Object}
 * @private
 */
vjs.Component.prototype.options_;

/**
 * Deep merge of options objects
 *
 * Whenever a property is an object on both options objects
 * the two properties will be merged using vjs.obj.deepMerge.
 *
 * This is used for merging options for child components. We
 * want it to be easy to override individual options on a child
 * component without having to rewrite all the other default options.
 *
 *     Parent.prototype.options_ = {
 *       children: {
 *         'childOne': { 'foo': 'bar', 'asdf': 'fdsa' },
 *         'childTwo': {},
 *         'childThree': {}
 *       }
 *     }
 *     newOptions = {
 *       children: {
 *         'childOne': { 'foo': 'baz', 'abc': '123' }
 *         'childTwo': null,
 *         'childFour': {}
 *       }
 *     }
 *
 *     this.options(newOptions);
 *
 * RESULT
 *
 *     {
 *       children: {
 *         'childOne': { 'foo': 'baz', 'asdf': 'fdsa', 'abc': '123' },
 *         'childTwo': null, // Disabled. Won't be initialized.
 *         'childThree': {},
 *         'childFour': {}
 *       }
 *     }
 *
 * @param  {Object} obj Object of new option values
 * @return {Object}     A NEW object of this.options_ and obj merged
 */
vjs.Component.prototype.options = function(obj){
  if (obj === undefined) return this.options_;

  return this.options_ = vjs.util.mergeOptions(this.options_, obj);
};

/**
 * The DOM element for the component
 *
 * @type {Element}
 * @private
 */
vjs.Component.prototype.el_;

/**
 * Create the component's DOM element
 *
 * @param  {String=} tagName  Element's node type. e.g. 'div'
 * @param  {Object=} attributes An object of element attributes that should be set on the element
 * @return {Element}
 */
vjs.Component.prototype.createEl = function(tagName, attributes){
  return vjs.createEl(tagName, attributes);
};

vjs.Component.prototype.localize = function(string){
  var lang = this.player_.language(),
      languages = this.player_.languages();
  if (languages && languages[lang] && languages[lang][string]) {
    return languages[lang][string];
  }
  return string;
};

/**
 * Get the component's DOM element
 *
 *     var domEl = myComponent.el();
 *
 * @return {Element}
 */
vjs.Component.prototype.el = function(){
  return this.el_;
};

/**
 * An optional element where, if defined, children will be inserted instead of
 * directly in `el_`
 *
 * @type {Element}
 * @private
 */
vjs.Component.prototype.contentEl_;

/**
 * Return the component's DOM element for embedding content.
 * Will either be el_ or a new element defined in createEl.
 *
 * @return {Element}
 */
vjs.Component.prototype.contentEl = function(){
  return this.contentEl_ || this.el_;
};

/**
 * The ID for the component
 *
 * @type {String}
 * @private
 */
vjs.Component.prototype.id_;

/**
 * Get the component's ID
 *
 *     var id = myComponent.id();
 *
 * @return {String}
 */
vjs.Component.prototype.id = function(){
  return this.id_;
};

/**
 * The name for the component. Often used to reference the component.
 *
 * @type {String}
 * @private
 */
vjs.Component.prototype.name_;

/**
 * Get the component's name. The name is often used to reference the component.
 *
 *     var name = myComponent.name();
 *
 * @return {String}
 */
vjs.Component.prototype.name = function(){
  return this.name_;
};

/**
 * Array of child components
 *
 * @type {Array}
 * @private
 */
vjs.Component.prototype.children_;

/**
 * Get an array of all child components
 *
 *     var kids = myComponent.children();
 *
 * @return {Array} The children
 */
vjs.Component.prototype.children = function(){
  return this.children_;
};

/**
 * Object of child components by ID
 *
 * @type {Object}
 * @private
 */
vjs.Component.prototype.childIndex_;

/**
 * Returns a child component with the provided ID
 *
 * @return {vjs.Component}
 */
vjs.Component.prototype.getChildById = function(id){
  return this.childIndex_[id];
};

/**
 * Object of child components by name
 *
 * @type {Object}
 * @private
 */
vjs.Component.prototype.childNameIndex_;

/**
 * Returns a child component with the provided name
 *
 * @return {vjs.Component}
 */
vjs.Component.prototype.getChild = function(name){
  return this.childNameIndex_[name];
};

/**
 * Adds a child component inside this component
 *
 *     myComponent.el();
 *     // ->

 *     myComonent.children();
 *     // [empty array]
 *
 *     var myButton = myComponent.addChild('MyButton');
 *     // ->

myButton

 *     // -> myButton === myComonent.children()[0];
 *
 * Pass in options for child constructors and options for children of the child
 *
 *     var myButton = myComponent.addChild('MyButton', {
 *       text: 'Press Me',
 *       children: {
 *         buttonChildExample: {
 *           buttonChildOption: true
 *         }
 *       }
 *     });
 *
 * @param {String|vjs.Component} child The class name or instance of a child to add
 * @param {Object=} options Options, including options to be passed to children of the child.
 * @return {vjs.Component} The child component (created by this process if a string was used)
 * @suppress {accessControls|checkRegExp|checkTypes|checkVars|const|constantProperty|deprecated|duplicate|es5Strict|fileoverviewTags|globalThis|invalidCasts|missingProperties|nonStandardJsDocs|strictModuleDepCheck|undefinedNames|undefinedVars|unknownDefines|uselessCode|visibility}
 */
vjs.Component.prototype.addChild = function(child, options){
  var component, componentClass, componentName;

  // If child is a string, create new component with options
  if (typeof child === 'string') {
    componentName = child;

    // Make sure options is at least an empty object to protect against errors
    options = options || {};

    // If no componentClass in options, assume componentClass is the name lowercased
    // (e.g. playButton)
    componentClass = options['componentClass'] || vjs.capitalize(componentName);

    // Set name through options
    options['name'] = componentName;

    // Create a new object & element for this controls set
    // If there's no .player_, this is a player
    // Closure Compiler throws an 'incomplete alias' warning if we use the vjs variable directly.
    // Every class should be exported, so this should never be a problem here.
    component = new window['videojs'][componentClass](this.player_ || this, options);

  // child is a component instance
  } else {
    component = child;
  }

  this.children_.push(component);

  if (typeof component.id === 'function') {
    this.childIndex_[component.id()] = component;
  }

  // If a name wasn't used to create the component, check if we can use the
  // name function of the component
  componentName = componentName || (component.name && component.name());

  if (componentName) {
    this.childNameIndex_[componentName] = component;
  }

  // Add the UI object's element to the container div (box)
  // Having an element is not required
  if (typeof component['el'] === 'function' && component['el']()) {
    this.contentEl().appendChild(component['el']());
  }

  // Return so it can stored on parent object if desired.
  return component;
};

/**
 * Remove a child component from this component's list of children, and the
 * child component's element from this component's element
 *
 * @param  {vjs.Component} component Component to remove
 */
vjs.Component.prototype.removeChild = function(component){
  if (typeof component === 'string') {
    component = this.getChild(component);
  }

  if (!component || !this.children_) return;

  var childFound = false;
  for (var i = this.children_.length - 1; i >= 0; i--) {
    if (this.children_[i] === component) {
      childFound = true;
      this.children_.splice(i,1);
      break;
    }
  }

  if (!childFound) return;

  this.childIndex_[component.id] = null;
  this.childNameIndex_[component.name] = null;

  var compEl = component.el();
  if (compEl && compEl.parentNode === this.contentEl()) {
    this.contentEl().removeChild(component.el());
  }
};

/**
 * Add and initialize default child components from options
 *
 *     // when an instance of MyComponent is created, all children in options
 *     // will be added to the instance by their name strings and options
 *     MyComponent.prototype.options_.children = {
 *       myChildComponent: {
 *         myChildOption: true
 *       }
 *     }
 *
 *     // Or when creating the component
 *     var myComp = new MyComponent(player, {
 *       children: {
 *         myChildComponent: {
 *           myChildOption: true
 *         }
 *       }
 *     });
 *
 * The children option can also be an Array of child names or
 * child options objects (that also include a 'name' key).
 *
 *     var myComp = new MyComponent(player, {
 *       children: [
 *         'button',
 *         {
 *           name: 'button',
 *           someOtherOption: true
 *         }
 *       ]
 *     });
 *
 */
vjs.Component.prototype.initChildren = function(){
  var parent, parentOptions, children, child, name, opts, handleAdd;

  parent = this;
  parentOptions = parent.options();
  children = parentOptions['children'];

  if (children) {
    handleAdd = function(name, opts){
      // Allow options for children to be set at the parent options
      // e.g. videojs(id, { controlBar: false });
      // instead of videojs(id, { children: { controlBar: false });
      if (parentOptions[name] !== undefined) {
        opts = parentOptions[name];
      }

      // Allow for disabling default components
      // e.g. vjs.options['children']['posterImage'] = false
      if (opts === false) return;

      // Create and add the child component.
      // Add a direct reference to the child by name on the parent instance.
      // If two of the same component are used, different names should be supplied
      // for each
      parent[name] = parent.addChild(name, opts);
    };

    // Allow for an array of children details to passed in the options
    if (vjs.obj.isArray(children)) {
      for (var i = 0; i < children.length; i++) {
        child = children[i];

        if (typeof child == 'string') {
          // ['myComponent']
          name = child;
          opts = {};
        } else {
          // [{ name: 'myComponent', otherOption: true }]
          name = child.name;
          opts = child;
        }

        handleAdd(name, opts);
      }
    } else {
      vjs.obj.each(children, handleAdd);
    }
  }
};

/**
 * Allows sub components to stack CSS class names
 *
 * @return {String} The constructed class name
 */
vjs.Component.prototype.buildCSSClass = function(){
    // Child classes can include a function that does:
    // return 'CLASS NAME' + this._super();
    return '';
};

/* Events
============================================================================= */

/**
 * Add an event listener to this component's element
 *
 *     var myFunc = function(){
 *       var myComponent = this;
 *       // Do something when the event is fired
 *     };
 *
 *     myComponent.on('eventType', myFunc);
 *
 * The context of myFunc will be myComponent unless previously bound.
 *
 * Alternatively, you can add a listener to another element or component.
 *
 *     myComponent.on(otherElement, 'eventName', myFunc);
 *     myComponent.on(otherComponent, 'eventName', myFunc);
 *
 * The benefit of using this over `vjs.on(otherElement, 'eventName', myFunc)`
 * and `otherComponent.on('eventName', myFunc)` is that this way the listeners
 * will be automatically cleaned up when either component is disposed.
 * It will also bind myComponent as the context of myFunc.
 *
 * **NOTE**: When using this on elements in the page other than window
 * and document (both permanent), if you remove the element from the DOM
 * you need to call `vjs.trigger(el, 'dispose')` on it to clean up
 * references to it and allow the browser to garbage collect it.
 *
 * @param  {String|vjs.Component} first   The event type or other component
 * @param  {Function|String}      second  The event handler or event type
 * @param  {Function}             third   The event handler
 * @return {vjs.Component}        self
 */
vjs.Component.prototype.on = function(first, second, third){
  var target, type, fn, removeOnDispose, cleanRemover, thisComponent;

  if (typeof first === 'string' || vjs.obj.isArray(first)) {
    vjs.on(this.el_, first, vjs.bind(this, second));

  // Targeting another component or element
  } else {
    target = first;
    type = second;
    fn = vjs.bind(this, third);
    thisComponent = this;

    // When this component is disposed, remove the listener from the other component
    removeOnDispose = function(){
      thisComponent.off(target, type, fn);
    };
    // Use the same function ID so we can remove it later it using the ID
    // of the original listener
    removeOnDispose.guid = fn.guid;
    this.on('dispose', removeOnDispose);

    // If the other component is disposed first we need to clean the reference
    // to the other component in this component's removeOnDispose listener
    // Otherwise we create a memory leak.
    cleanRemover = function(){
      thisComponent.off('dispose', removeOnDispose);
    };
    // Add the same function ID so we can easily remove it later
    cleanRemover.guid = fn.guid;

    // Check if this is a DOM node
    if (first.nodeName) {
      // Add the listener to the other element
      vjs.on(target, type, fn);
      vjs.on(target, 'dispose', cleanRemover);

    // Should be a component
    // Not using `instanceof vjs.Component` because it makes mock players difficult
    } else if (typeof first.on === 'function') {
      // Add the listener to the other component
      target.on(type, fn);
      target.on('dispose', cleanRemover);
    }
  }

  return this;
};

/**
 * Remove an event listener from this component's element
 *
 *     myComponent.off('eventType', myFunc);
 *
 * If myFunc is excluded, ALL listeners for the event type will be removed.
 * If eventType is excluded, ALL listeners will be removed from the component.
 *
 * Alternatively you can use `off` to remove listeners that were added to other
 * elements or components using `myComponent.on(otherComponent...`.
 * In this case both the event type and listener function are REQUIRED.
 *
 *     myComponent.off(otherElement, 'eventType', myFunc);
 *     myComponent.off(otherComponent, 'eventType', myFunc);
 *
 * @param  {String=|vjs.Component}  first  The event type or other component
 * @param  {Function=|String}       second The listener function or event type
 * @param  {Function=}              third  The listener for other component
 * @return {vjs.Component}
 */
vjs.Component.prototype.off = function(first, second, third){
  var target, otherComponent, type, fn, otherEl;

  if (!first || typeof first === 'string' || vjs.obj.isArray(first)) {
    vjs.off(this.el_, first, second);
  } else {
    target = first;
    type = second;
    // Ensure there's at least a guid, even if the function hasn't been used
    fn = vjs.bind(this, third);

    // Remove the dispose listener on this component,
    // which was given the same guid as the event listener
    this.off('dispose', fn);

    if (first.nodeName) {
      // Remove the listener
      vjs.off(target, type, fn);
      // Remove the listener for cleaning the dispose listener
      vjs.off(target, 'dispose', fn);
    } else {
      target.off(type, fn);
      target.off('dispose', fn);
    }
  }

  return this;
};

/**
 * Add an event listener to be triggered only once and then removed
 *
 *     myComponent.one('eventName', myFunc);
 *
 * Alternatively you can add a listener to another element or component
 * that will be triggered only once.
 *
 *     myComponent.one(otherElement, 'eventName', myFunc);
 *     myComponent.one(otherComponent, 'eventName', myFunc);
 *
 * @param  {String|vjs.Component}  first   The event type or other component
 * @param  {Function|String}       second  The listener function or event type
 * @param  {Function=}             third   The listener function for other component
 * @return {vjs.Component}
 */
vjs.Component.prototype.one = function(first, second, third) {
  var target, type, fn, thisComponent, newFunc;

  if (typeof first === 'string' || vjs.obj.isArray(first)) {
    vjs.one(this.el_, first, vjs.bind(this, second));
  } else {
    target = first;
    type = second;
    fn = vjs.bind(this, third);
    thisComponent = this;

    newFunc = function(){
      thisComponent.off(target, type, newFunc);
      fn.apply(this, arguments);
    };
    // Keep the same function ID so we can remove it later
    newFunc.guid = fn.guid;

    this.on(target, type, newFunc);
  }

  return this;
};

/**
 * Trigger an event on an element
 *
 *     myComponent.trigger('eventName');
 *     myComponent.trigger({'type':'eventName'});
 *
 * @param  {Event|Object|String} event  A string (the type) or an event object with a type attribute
 * @return {vjs.Component}       self
 */
vjs.Component.prototype.trigger = function(event){
  vjs.trigger(this.el_, event);
  return this;
};

/* Ready
================================================================================ */
/**
 * Is the component loaded
 * This can mean different things depending on the component.
 *
 * @private
 * @type {Boolean}
 */
vjs.Component.prototype.isReady_;

/**
 * Trigger ready as soon as initialization is finished
 *
 * Allows for delaying ready. Override on a sub class prototype.
 * If you set this.isReadyOnInitFinish_ it will affect all components.
 * Specially used when waiting for the Flash player to asynchronously load.
 *
 * @type {Boolean}
 * @private
 */
vjs.Component.prototype.isReadyOnInitFinish_ = true;

/**
 * List of ready listeners
 *
 * @type {Array}
 * @private
 */
vjs.Component.prototype.readyQueue_;

/**
 * Bind a listener to the component's ready state
 *
 * Different from event listeners in that if the ready event has already happened
 * it will trigger the function immediately.
 *
 * @param  {Function} fn Ready listener
 * @return {vjs.Component}
 */
vjs.Component.prototype.ready = function(fn){
  if (fn) {
    if (this.isReady_) {
      fn.call(this);
    } else {
      if (this.readyQueue_ === undefined) {
        this.readyQueue_ = [];
      }
      this.readyQueue_.push(fn);
    }
  }
  return this;
};

/**
 * Trigger the ready listeners
 *
 * @return {vjs.Component}
 */
vjs.Component.prototype.triggerReady = function(){
  this.isReady_ = true;

  var readyQueue = this.readyQueue_;

  if (readyQueue && readyQueue.length > 0) {

    for (var i = 0, j = readyQueue.length; i < j; i++) {
      readyQueue[i].call(this);
    }

    // Reset Ready Queue
    this.readyQueue_ = [];

    // Allow for using event listeners also, in case you want to do something everytime a source is ready.
    this.trigger('ready');
  }
};

/* Display
============================================================================= */

/**
 * Check if a component's element has a CSS class name
 *
 * @param {String} classToCheck Classname to check
 * @return {vjs.Component}
 */
vjs.Component.prototype.hasClass = function(classToCheck){
  return vjs.hasClass(this.el_, classToCheck);
};

/**
 * Add a CSS class name to the component's element
 *
 * @param {String} classToAdd Classname to add
 * @return {vjs.Component}
 */
vjs.Component.prototype.addClass = function(classToAdd){
  vjs.addClass(this.el_, classToAdd);
  return this;
};

/**
 * Remove a CSS class name from the component's element
 *
 * @param {String} classToRemove Classname to remove
 * @return {vjs.Component}
 */
vjs.Component.prototype.removeClass = function(classToRemove){
  vjs.removeClass(this.el_, classToRemove);
  return this;
};

/**
 * Show the component element if hidden
 *
 * @return {vjs.Component}
 */
vjs.Component.prototype.show = function(){
  this.el_.style.display = 'block';
  return this;
};

/**
 * Hide the component element if currently showing
 *
 * @return {vjs.Component}
 */
vjs.Component.prototype.hide = function(){
  this.el_.style.display = 'none';
  return this;
};

/**
 * Lock an item in its visible state
 * To be used with fadeIn/fadeOut.
 *
 * @return {vjs.Component}
 * @private
 */
vjs.Component.prototype.lockShowing = function(){
  this.addClass('vjs-lock-showing');
  return this;
};

/**
 * Unlock an item to be hidden
 * To be used with fadeIn/fadeOut.
 *
 * @return {vjs.Component}
 * @private
 */
vjs.Component.prototype.unlockShowing = function(){
  this.removeClass('vjs-lock-showing');
  return this;
};

/**
 * Disable component by making it unshowable
 *
 * Currently private because we're moving towards more css-based states.
 * @private
 */
vjs.Component.prototype.disable = function(){
  this.hide();
  this.show = function(){};
};

/**
 * Set or get the width of the component (CSS values)
 *
 * Setting the video tag dimension values only works with values in pixels.
 * Percent values will not work.
 * Some percents can be used, but width()/height() will return the number + %,
 * not the actual computed width/height.
 *
 * @param  {Number|String=} num   Optional width number
 * @param  {Boolean} skipListeners Skip the 'resize' event trigger
 * @return {vjs.Component} This component, when setting the width
 * @return {Number|String} The width, when getting
 */
vjs.Component.prototype.width = function(num, skipListeners){
  return this.dimension('width', num, skipListeners);
};

/**
 * Get or set the height of the component (CSS values)
 *
 * Setting the video tag dimension values only works with values in pixels.
 * Percent values will not work.
 * Some percents can be used, but width()/height() will return the number + %,
 * not the actual computed width/height.
 *
 * @param  {Number|String=} num     New component height
 * @param  {Boolean=} skipListeners Skip the resize event trigger
 * @return {vjs.Component} This component, when setting the height
 * @return {Number|String} The height, when getting
 */
vjs.Component.prototype.height = function(num, skipListeners){
  return this.dimension('height', num, skipListeners);
};

/**
 * Set both width and height at the same time
 *
 * @param  {Number|String} width
 * @param  {Number|String} height
 * @return {vjs.Component} The component
 */
vjs.Component.prototype.dimensions = function(width, height){
  // Skip resize listeners on width for optimization
  return this.width(width, true).height(height);
};

/**
 * Get or set width or height
 *
 * This is the shared code for the width() and height() methods.
 * All for an integer, integer + 'px' or integer + '%';
 *
 * Known issue: Hidden elements officially have a width of 0. We're defaulting
 * to the style.width value and falling back to computedStyle which has the
 * hidden element issue. Info, but probably not an efficient fix:
 * http://www.foliotek.com/devblog/getting-the-width-of-a-hidden-element-with-jquery-using-width/
 *
 * @param  {String} widthOrHeight  'width' or 'height'
 * @param  {Number|String=} num     New dimension
 * @param  {Boolean=} skipListeners Skip resize event trigger
 * @return {vjs.Component} The component if a dimension was set
 * @return {Number|String} The dimension if nothing was set
 * @private
 */
vjs.Component.prototype.dimension = function(widthOrHeight, num, skipListeners){
  if (num !== undefined) {
    if (num === null || vjs.isNaN(num)) {
      num = 0;
    }

    // Check if using css width/height (% or px) and adjust
    if ((''+num).indexOf('%') !== -1 || (''+num).indexOf('px') !== -1) {
      this.el_.style[widthOrHeight] = num;
    } else if (num === 'auto') {
      this.el_.style[widthOrHeight] = '';
    } else {
      this.el_.style[widthOrHeight] = num+'px';
    }

    // skipListeners allows us to avoid triggering the resize event when setting both width and height
    if (!skipListeners) { this.trigger('resize'); }

    // Return component
    return this;
  }

  // Not setting a value, so getting it
  // Make sure element exists
  if (!this.el_) return 0;

  // Get dimension value from style
  var val = this.el_.style[widthOrHeight];
  var pxIndex = val.indexOf('px');
  if (pxIndex !== -1) {
    // Return the pixel value with no 'px'
    return parseInt(val.slice(0,pxIndex), 10);

  // No px so using % or no style was set, so falling back to offsetWidth/height
  // If component has display:none, offset will return 0
  // TODO: handle display:none and no dimension style using px
  } else {

    return parseInt(this.el_['offset'+vjs.capitalize(widthOrHeight)], 10);

    // ComputedStyle version.
    // Only difference is if the element is hidden it will return
    // the percent value (e.g. '100%'')
    // instead of zero like offsetWidth returns.
    // var val = vjs.getComputedStyleValue(this.el_, widthOrHeight);
    // var pxIndex = val.indexOf('px');

    // if (pxIndex !== -1) {
    //   return val.slice(0, pxIndex);
    // } else {
    //   return val;
    // }
  }
};

/**
 * Fired when the width and/or height of the component changes
 * @event resize
 */
vjs.Component.prototype.onResize;

/**
 * Emit 'tap' events when touch events are supported
 *
 * This is used to support toggling the controls through a tap on the video.
 *
 * We're requiring them to be enabled because otherwise every component would
 * have this extra overhead unnecessarily, on mobile devices where extra
 * overhead is especially bad.
 * @private
 */
vjs.Component.prototype.emitTapEvents = function(){
  var touchStart, firstTouch, touchTime, couldBeTap, noTap,
      xdiff, ydiff, touchDistance, tapMovementThreshold;

  // Track the start time so we can determine how long the touch lasted
  touchStart = 0;
  firstTouch = null;

  // Maximum movement allowed during a touch event to still be considered a tap
  tapMovementThreshold = 22;

  this.on('touchstart', function(event) {
    // If more than one finger, don't consider treating this as a click
    if (event.touches.length === 1) {
      firstTouch = event.touches[0];
      // Record start time so we can detect a tap vs. "touch and hold"
      touchStart = new Date().getTime();
      // Reset couldBeTap tracking
      couldBeTap = true;
    }
  });

  this.on('touchmove', function(event) {
    // If more than one finger, don't consider treating this as a click
    if (event.touches.length > 1) {
      couldBeTap = false;
    } else if (firstTouch) {
      // Some devices will throw touchmoves for all but the slightest of taps.
      // So, if we moved only a small distance, this could still be a tap
      xdiff = event.touches[0].pageX - firstTouch.pageX;
      ydiff = event.touches[0].pageY - firstTouch.pageY;
      touchDistance = Math.sqrt(xdiff * xdiff + ydiff * ydiff);
      if (touchDistance > tapMovementThreshold) {
        couldBeTap = false;
      }
    }
  });

  noTap = function(){
    couldBeTap = false;
  };
  // TODO: Listen to the original target. http://youtu.be/DujfpXOKUp8?t=13m8s
  this.on('touchleave', noTap);
  this.on('touchcancel', noTap);

  // When the touch ends, measure how long it took and trigger the appropriate
  // event
  this.on('touchend', function(event) {
    firstTouch = null;
    // Proceed only if the touchmove/leave/cancel event didn't happen
    if (couldBeTap === true) {
      // Measure how long the touch lasted
      touchTime = new Date().getTime() - touchStart;
      // The touch needs to be quick in order to consider it a tap
      if (touchTime < 250) {
        event.preventDefault(); // Don't let browser turn this into a click
        this.trigger('tap');
        // It may be good to copy the touchend event object and change the
        // type to tap, if the other event properties aren't exact after
        // vjs.fixEvent runs (e.g. event.target)
      }
    }
  });
};

/**
 * Report user touch activity when touch events occur
 *
 * User activity is used to determine when controls should show/hide. It's
 * relatively simple when it comes to mouse events, because any mouse event
 * should show the controls. So we capture mouse events that bubble up to the
 * player and report activity when that happens.
 *
 * With touch events it isn't as easy. We can't rely on touch events at the
 * player level, because a tap (touchstart + touchend) on the video itself on
 * mobile devices is meant to turn controls off (and on). User activity is
 * checked asynchronously, so what could happen is a tap event on the video
 * turns the controls off, then the touchend event bubbles up to the player,
 * which if it reported user activity, would turn the controls right back on.
 * (We also don't want to completely block touch events from bubbling up)
 *
 * Also a touchmove, touch+hold, and anything other than a tap is not supposed
 * to turn the controls back on on a mobile device.
 *
 * Here we're setting the default component behavior to report user activity
 * whenever touch events happen, and this can be turned off by components that
 * want touch events to act differently.
 */
vjs.Component.prototype.enableTouchActivity = function() {
  var report, touchHolding, touchEnd;

  // Don't continue if the root player doesn't support reporting user activity
  if (!this.player().reportUserActivity) {
    return;
  }

  // listener for reporting that the user is active
  report = vjs.bind(this.player(), this.player().reportUserActivity);

  this.on('touchstart', function() {
    report();
    // For as long as the they are touching the device or have their mouse down,
    // we consider them active even if they're not moving their finger or mouse.
    // So we want to continue to update that they are active
    this.clearInterval(touchHolding);
    // report at the same interval as activityCheck
    touchHolding = this.setInterval(report, 250);
  });

  touchEnd = function(event) {
    report();
    // stop the interval that maintains activity if the touch is holding
    this.clearInterval(touchHolding);
  };

  this.on('touchmove', report);
  this.on('touchend', touchEnd);
  this.on('touchcancel', touchEnd);
};

/**
 * Creates timeout and sets up disposal automatically.
 * @param {Function} fn The function to run after the timeout.
 * @param {Number} timeout Number of ms to delay before executing specified function.
 * @return {Number} Returns the timeout ID
 */
vjs.Component.prototype.setTimeout = function(fn, timeout) {
  fn = vjs.bind(this, fn);

  // window.setTimeout would be preferable here, but due to some bizarre issue with Sinon and/or Phantomjs, we can't.
  var timeoutId = setTimeout(fn, timeout);

  var disposeFn = function() {
    this.clearTimeout(timeoutId);
  };

  disposeFn.guid = 'vjs-timeout-'+ timeoutId;

  this.on('dispose', disposeFn);

  return timeoutId;
};

/**
 * Clears a timeout and removes the associated dispose listener
 * @param {Number} timeoutId The id of the timeout to clear
 * @return {Number} Returns the timeout ID
 */
vjs.Component.prototype.clearTimeout = function(timeoutId) {
  clearTimeout(timeoutId);

  var disposeFn = function(){};
  disposeFn.guid = 'vjs-timeout-'+ timeoutId;

  this.off('dispose', disposeFn);

  return timeoutId;
};

/**
 * Creates an interval and sets up disposal automatically.
 * @param {Function} fn The function to run every N seconds.
 * @param {Number} interval Number of ms to delay before executing specified function.
 * @return {Number} Returns the interval ID
 */
vjs.Component.prototype.setInterval = function(fn, interval) {
  fn = vjs.bind(this, fn);

  var intervalId = setInterval(fn, interval);

  var disposeFn = function() {
    this.clearInterval(intervalId);
  };

  disposeFn.guid = 'vjs-interval-'+ intervalId;

  this.on('dispose', disposeFn);

  return intervalId;
};

/**
 * Clears an interval and removes the associated dispose listener
 * @param {Number} intervalId The id of the interval to clear
 * @return {Number} Returns the interval ID
 */
vjs.Component.prototype.clearInterval = function(intervalId) {
  clearInterval(intervalId);

  var disposeFn = function(){};
  disposeFn.guid = 'vjs-interval-'+ intervalId;

  this.off('dispose', disposeFn);

  return intervalId;
};


text:
| A terrifyingly simple CSS framework.

[![npm version](https://badge.fury.io/js/ghast.svg)](https://badge.fury.io/js/ghast)
[![Bower version](https://badge.fury.io/bo/ghast.svg)](https://badge.fury.io/bo/ghast)
[![Dependencies Status](https://david-dm.org/voident/ghast.svg)](https://voident.github.io/)

## Why Ghast?

Ghast was designed to provide everything you need to get started with your own website in a small, responsive package. It was built to be easy to understand, modify and adapt to your needs. We hope you'll like it!

## Download

#### Install with npm

```sh
$ npm install ghast
```

#### Install with Bower

```sh
$ bower install ghast
```

**OR**

#### Clone the repo & install

```sh
$ git clone https://github.com/impria/ghast.git
$ npm install
```

## Contributing

Want to contribute? Follow these [recommendations](https://github.com/voident/ghast/blob/master/contributing.md).

## License

Made with ♥ in Montreal, Canada by some cool peeps. Licensed under the [MIT License](https://github.com/voident/ghast/blob/master/license).


text:
/* Backgrounds ----------------------------------------------------------*/

.camera_prevThumbs, .camera_nextThumbs, .camera_prev, .camera_next, .camera_commands, .camera_thumbs_cont,
.style_one .btn-primary,
.style_two .btn-primary,
.style_two h1 span .border,
.camera_wrap .camera_pag .camera_pag_ul li.cameracurrent > span,
.sf-menu li li a:hover,
.box-action .button,
.item-service:hover .head-service i,
.item-service-carousel .color,
.item-service-carousel .color-small,
.btn-primary,
.btn-primary:hover,
#sponsors  .owl-prev,
#sponsors .owl-next,
.tooltip-inner,
.important-info,
.box .date span,
.owl-theme .owl-controls .owl-page.active span,
.owl-theme .owl-controls.clickable .owl-page:hover span,
footer .btn-primary:hover,
.thumbs li:hover,
#theme-options .title,
#theme-options .title span,
#theme-options .layout-style li.active,
.items-slide-services li .icon,
.title-section .title .line-title,
.title-section .subtitle-section,
.color > span,
.pagination > .active > a,
.carousel-indicators .active,
.info-comment a,
.jRibbon,
.downarrow,
.line,
.header-v3{
	background: #fff000;
	background-color: #fff000;
}
.overlay{
	background: #fff000 url("../../../img/more.png") no-repeat center center;;
	background: rgba(255, 240, 0,0.6) url("../../../img/more.png") no-repeat center center;
}
.pattern-important-info{
	background: #fff000 url("../../../img/patterns/patttern-corporate.png");
}

.accordion-trigger.active,
.accordion-trigger:hover{
	color: #fff;
	background: #fff000 url("../../../img/toggle.png") no-repeat right -69px;
}
.arrow-comment{
	background: url("arrow-comment.png");
}
.table-discount{
	background: url('discount.png') no-repeat top center;
}
.subtitle-section .left{
	background: url("arrow-subtitle-left.png") no-repeat center;
}
.subtitle-section .right{
	background: url("arrow-subtitle-right.png") no-repeat center;
}

/* Colors ----------------------------------------------------------*/

.title-subtitle span,
.clients .title-downloads:first-letter,
.subtitle-downloads h4 i,
.sponsors h2 span,
.box .link i,
.box .name span,
.twitter a,
footer .links li i,
.logo-footer h2 span,
.box .image-more-service i,
.portfolioFilter .current,
.portfolioFilter a:hover,
.list li i,
.page-error h1 i,
.sitemap li a,
.sitemap li a:hover,
.post h3 a,
.post h2 a,
.post .post-meta span a,
.tags i,
.comment-post h3 a,
.autor h3 i,
.comment-post h3 i,
.tabs a,
address i,
.table-price,
.head-service h5,
.titles-heading h1 i,
.boxes-info h5,
.custom_input_file i{
	color: #fff000;
}

/* Borders ----------------------------------------------------------*/

.style_one h1 span span,
.style_two h1 span span{
	border-bottom: 6px solid #fff000;
}
header{
	border-bottom: 4px solid #fff000;
}
.tooltip.top .tooltip-arrow {
  border-top-color: #fff000;
}
.image-clients-downloads li:hover,
.items-slide-services li:hover{
	border: solid 3px #fff000;
}
.item-work .info-work .icons-work{
	border-top: 3px solid #fff000;
}
.title-section .title{
	border-bottom: 1px solid #fff000;
}
.portfolioFilter .current,
.portfolioFilter a:hover{
	border-bottom: 3px solid #fff000;
}
.sf-menu ul{
	border-bottom: 3px solid #fff000;
}
.comment-post  .info-comment{
	border-left: solid 3px #fff000;
}
.head-service i,
.feature-element li .cirle-feature{
	border: solid 3px #fff000;
}
.boxes-info h5{
	border-top: solid 3px #fff000;
	border-bottom: solid 3px #fff000;
}

@media handheld, only screen and (max-width: 980px) {

	.comment-post  .info-comment{
		border-top: solid 3px #fff000;
		border-left: 0;
	}
	.arrow-comment{
		background: url("arrow-comment-top.png") top center no-repeat;
	}

}


text:
using namespace std;

inline void use_io_optimizations()
{
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
}

int main()
{
    use_io_optimizations();

    cout << "Hello, World!" << '\n';

    return 0;
}


text:
<?php
/**
 * AccountingApiTest
 * PHP version 5
 *
 * @category Class
 * @package  SidneyAllen\XeroPHP
 * @author   OpenAPI Generator team
 * @link     https://openapi-generator.tech
 */

/**
 * Accounting API
 *
 * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
 *
 * OpenAPI spec version: 2.0.0
 * Contact: api@xero.com
 * Generated by: https://openapi-generator.tech
 * OpenAPI Generator version: 3.3.4
 */

/**
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
 * https://openapi-generator.tech
 * Please update the test case below to test the endpoint.
 */

namespace SidneyAllen\XeroPHP;

use \SidneyAllen\XeroPHP\Configuration;
use \SidneyAllen\XeroPHP\ApiException;
use \SidneyAllen\XeroPHP\ObjectSerializer;

/**
 * AccountingApiTest Class Doc Comment
 *
 * @category Class
 * @package  SidneyAllen\XeroPHP
 * @author   OpenAPI Generator team
 * @link     https://openapi-generator.tech
 */
class AccountingApiTest extends \PHPUnit_Framework_TestCase
{

    /**
     * Setup before running any test cases
     */
    public static function setUpBeforeClass()
    {
    }

    /**
     * Setup before running each test case
     */
    public function setUp()
    {
    }

    /**
     * Clean up after running each test case
     */
    public function tearDown()
    {
    }

    /**
     * Clean up after running all test cases
     */
    public static function tearDownAfterClass()
    {
    }

    /**
     * Test case for createAccount
     *
     * Allows you to create a new chart of accounts.
     *
     */
    public function testCreateAccount()
    {
    }

    /**
     * Test case for createAccountAttachmentByFileName
     *
     * Allows you to create Attachment on Account.
     *
     */
    public function testCreateAccountAttachmentByFileName()
    {
    }

    /**
     * Test case for createBankTransaction
     *
     * Allows you to create a spend or receive money transaction.
     *
     */
    public function testCreateBankTransaction()
    {
    }

    /**
     * Test case for createBankTransactionAttachmentByFileName
     *
     * Allows you to createa an Attachment on BankTransaction by Filename.
     *
     */
    public function testCreateBankTransactionAttachmentByFileName()
    {
    }

    /**
     * Test case for createBankTransactionHistoryRecord
     *
     * Allows you to create history record for a bank transactions.
     *
     */
    public function testCreateBankTransactionHistoryRecord()
    {
    }

    /**
     * Test case for createBankTransfer
     *
     * Allows you to create a bank transfers.
     *
     */
    public function testCreateBankTransfer()
    {
    }

    /**
     * Test case for createBankTransferAttachmentByFileName
     *
     * .
     *
     */
    public function testCreateBankTransferAttachmentByFileName()
    {
    }

    /**
     * Test case for createBankTransferHistoryRecord
     *
     * .
     *
     */
    public function testCreateBankTransferHistoryRecord()
    {
    }

    /**
     * Test case for createBatchPayment
     *
     * Create one or many BatchPayments for invoices.
     *
     */
    public function testCreateBatchPayment()
    {
    }

    /**
     * Test case for createBatchPaymentHistoryRecord
     *
     * Allows you to create a history record for a Batch Payment.
     *
     */
    public function testCreateBatchPaymentHistoryRecord()
    {
    }

    /**
     * Test case for createBrandingThemePaymentServices
     *
     * Allow for the creation of new custom payment service for specified Branding Theme.
     *
     */
    public function testCreateBrandingThemePaymentServices()
    {
    }

    /**
     * Test case for createContact
     *
     * .
     *
     */
    public function testCreateContact()
    {
    }

    /**
     * Test case for createContactAttachmentByFileName
     *
     * .
     *
     */
    public function testCreateContactAttachmentByFileName()
    {
    }

    /**
     * Test case for createContactGroup
     *
     * Allows you to create a contact group.
     *
     */
    public function testCreateContactGroup()
    {
    }

    /**
     * Test case for createContactGroupContacts
     *
     * Allows you to add Contacts to a Contract Group.
     *
     */
    public function testCreateContactGroupContacts()
    {
    }

    /**
     * Test case for createContactHistory
     *
     * Allows you to retrieve a history records of an Contact.
     *
     */
    public function testCreateContactHistory()
    {
    }

    /**
     * Test case for createCreditNote
     *
     * Allows you to create a credit note.
     *
     */
    public function testCreateCreditNote()
    {
    }

    /**
     * Test case for createCreditNoteAllocation
     *
     * Allows you to create Allocation on CreditNote.
     *
     */
    public function testCreateCreditNoteAllocation()
    {
    }

    /**
     * Test case for createCreditNoteAttachmentByFileName
     *
     * Allows you to create Attachments on CreditNote by file name.
     *
     */
    public function testCreateCreditNoteAttachmentByFileName()
    {
    }

    /**
     * Test case for createCreditNoteHistory
     *
     * Allows you to retrieve a history records of an CreditNote.
     *
     */
    public function testCreateCreditNoteHistory()
    {
    }

    /**
     * Test case for createCurrency
     *
     * .
     *
     */
    public function testCreateCurrency()
    {
    }

    /**
     * Test case for createEmployee
     *
     * Allows you to create new employees used in Xero payrun.
     *
     */
    public function testCreateEmployee()
    {
    }

    /**
     * Test case for createExpenseClaim
     *
     * Allows you to retrieve expense claims.
     *
     */
    public function testCreateExpenseClaim()
    {
    }

    /**
     * Test case for createExpenseClaimHistory
     *
     * Allows you to create a history records of an ExpenseClaim.
     *
     */
    public function testCreateExpenseClaimHistory()
    {
    }

    /**
     * Test case for createInvoice
     *
     * Allows you to create any sales invoices or purchase bills.
     *
     */
    public function testCreateInvoice()
    {
    }

    /**
     * Test case for createInvoiceAttachmentByFileName
     *
     * Allows you to create an Attachment on invoices or purchase bills by it's filename.
     *
     */
    public function testCreateInvoiceAttachmentByFileName()
    {
    }

    /**
     * Test case for createInvoiceHistory
     *
     * Allows you to retrieve a history records of an invoice.
     *
     */
    public function testCreateInvoiceHistory()
    {
    }

    /**
     * Test case for createItem
     *
     * Allows you to create an item.
     *
     */
    public function testCreateItem()
    {
    }

    /**
     * Test case for createItemHistory
     *
     * Allows you to create a history record for items.
     *
     */
    public function testCreateItemHistory()
    {
    }

    /**
     * Test case for createLinkedTransaction
     *
     * Allows you to create linked transactions (billable expenses).
     *
     */
    public function testCreateLinkedTransaction()
    {
    }

    /**
     * Test case for createManualJournal
     *
     * Allows you to create a manual journal.
     *
     */
    public function testCreateManualJournal()
    {
    }

    /**
     * Test case for createManualJournalAttachmentByFileName
     *
     * Allows you to create a specified Attachment on ManualJournal by file name.
     *
     */
    public function testCreateManualJournalAttachmentByFileName()
    {
    }

    /**
     * Test case for createOverpaymentAllocation
     *
     * Allows you to retrieve Allocations for overpayments.
     *
     */
    public function testCreateOverpaymentAllocation()
    {
    }

    /**
     * Test case for createOverpaymentHistory
     *
     * Allows you to create history records of an Overpayment.
     *
     */
    public function testCreateOverpaymentHistory()
    {
    }

    /**
     * Test case for createPayment
     *
     * Allows you to create payments for invoices and credit notes.
     *
     */
    public function testCreatePayment()
    {
    }

    /**
     * Test case for createPaymentHistory
     *
     * Allows you to create a history record for a payment.
     *
     */
    public function testCreatePaymentHistory()
    {
    }

    /**
     * Test case for createPaymentService
     *
     * Allows you to create payment services.
     *
     */
    public function testCreatePaymentService()
    {
    }

    /**
     * Test case for createPrepaymentAllocation
     *
     * Allows you to create an Allocation for prepayments.
     *
     */
    public function testCreatePrepaymentAllocation()
    {
    }

    /**
     * Test case for createPrepaymentHistory
     *
     * Allows you to create a history record for an Prepayment.
     *
     */
    public function testCreatePrepaymentHistory()
    {
    }

    /**
     * Test case for createPurchaseOrder
     *
     * Allows you to create purchase orders.
     *
     */
    public function testCreatePurchaseOrder()
    {
    }

    /**
     * Test case for createPurchaseOrderHistory
     *
     * Allows you to create HistoryRecord for purchase orders.
     *
     */
    public function testCreatePurchaseOrderHistory()
    {
    }

    /**
     * Test case for createReceipt
     *
     * Allows you to create draft expense claim receipts for any user.
     *
     */
    public function testCreateReceipt()
    {
    }

    /**
     * Test case for createReceiptAttachmentByFileName
     *
     * Allows you to create Attachment on expense claim receipts by file name.
     *
     */
    public function testCreateReceiptAttachmentByFileName()
    {
    }

    /**
     * Test case for createReceiptHistory
     *
     * Allows you to retrieve a history records of an Receipt.
     *
     */
    public function testCreateReceiptHistory()
    {
    }

    /**
     * Test case for createRepeatingInvoiceAttachmentByFileName
     *
     * Allows you to create attachment on repeating invoices by file name.
     *
     */
    public function testCreateRepeatingInvoiceAttachmentByFileName()
    {
    }

    /**
     * Test case for createRepeatingInvoiceHistory
     *
     * Allows you to create history for a repeating invoice.
     *
     */
    public function testCreateRepeatingInvoiceHistory()
    {
    }

    /**
     * Test case for createTaxRate
     *
     * Allows you to create Tax Rates.
     *
     */
    public function testCreateTaxRate()
    {
    }

    /**
     * Test case for createTrackingCategory
     *
     * Allows you to create tracking categories.
     *
     */
    public function testCreateTrackingCategory()
    {
    }

    /**
     * Test case for createTrackingOptions
     *
     * Allows you to create options for a specified tracking category.
     *
     */
    public function testCreateTrackingOptions()
    {
    }

    /**
     * Test case for deleteAccount
     *
     * Allows you to delete a chart of accounts.
     *
     */
    public function testDeleteAccount()
    {
    }

    /**
     * Test case for deleteContactGroupContact
     *
     * Allows you to delete a specific Contact from a Contract Group.
     *
     */
    public function testDeleteContactGroupContact()
    {
    }

    /**
     * Test case for deleteContactGroupContacts
     *
     * Allows you to delete  all Contacts from a Contract Group.
     *
     */
    public function testDeleteContactGroupContacts()
    {
    }

    /**
     * Test case for deleteItem
     *
     * Allows you to delete a specified item.
     *
     */
    public function testDeleteItem()
    {
    }

    /**
     * Test case for deleteLinkedTransaction
     *
     * Allows you to delete a specified linked transactions (billable expenses).
     *
     */
    public function testDeleteLinkedTransaction()
    {
    }

    /**
     * Test case for deletePayment
     *
     * Allows you to update a specified payment for invoices and credit notes.
     *
     */
    public function testDeletePayment()
    {
    }

    /**
     * Test case for deleteTrackingCategory
     *
     * Allows you to delete tracking categories.
     *
     */
    public function testDeleteTrackingCategory()
    {
    }

    /**
     * Test case for deleteTrackingOptions
     *
     * Allows you to delete a specified option for a specified tracking category.
     *
     */
    public function testDeleteTrackingOptions()
    {
    }

    /**
     * Test case for emailInvoice
     *
     * Allows you to email a copy of invoice to related Contact.
     *
     */
    public function testEmailInvoice()
    {
    }

    /**
     * Test case for getAccount
     *
     * Allows you to retrieve a single chart of accounts.
     *
     */
    public function testGetAccount()
    {
    }

    /**
     * Test case for getAccountAttachmentByFileName
     *
     * Allows you to retrieve Attachment on Account by Filename.
     *
     */
    public function testGetAccountAttachmentByFileName()
    {
    }

    /**
     * Test case for getAccountAttachmentById
     *
     * Allows you to retrieve specific Attachment on Account.
     *
     */
    public function testGetAccountAttachmentById()
    {
    }

    /**
     * Test case for getAccountAttachments
     *
     * Allows you to retrieve Attachments for accounts.
     *
     */
    public function testGetAccountAttachments()
    {
    }

    /**
     * Test case for getAccounts
     *
     * Allows you to retrieve the full chart of accounts.
     *
     */
    public function testGetAccounts()
    {
    }

    /**
     * Test case for getBankTransaction
     *
     * Allows you to retrieve a single spend or receive money transaction.
     *
     */
    public function testGetBankTransaction()
    {
    }

    /**
     * Test case for getBankTransactionAttachmentByFileName
     *
     * Allows you to retrieve Attachments on BankTransaction by Filename.
     *
     */
    public function testGetBankTransactionAttachmentByFileName()
    {
    }

    /**
     * Test case for getBankTransactionAttachmentById
     *
     * Allows you to retrieve Attachments on a specific BankTransaction.
     *
     */
    public function testGetBankTransactionAttachmentById()
    {
    }

    /**
     * Test case for getBankTransactionAttachments
     *
     * Allows you to retrieve any attachments to bank transactions.
     *
     */
    public function testGetBankTransactionAttachments()
    {
    }

    /**
     * Test case for getBankTransactions
     *
     * Allows you to retrieve any spend or receive money transactions.
     *
     */
    public function testGetBankTransactions()
    {
    }

    /**
     * Test case for getBankTransactionsHistory
     *
     * Allows you to retrieve history from a bank transactions.
     *
     */
    public function testGetBankTransactionsHistory()
    {
    }

    /**
     * Test case for getBankTransfer
     *
     * Allows you to retrieve any bank transfers.
     *
     */
    public function testGetBankTransfer()
    {
    }

    /**
     * Test case for getBankTransferAttachmentByFileName
     *
     * Allows you to retrieve Attachments on BankTransfer by file name.
     *
     */
    public function testGetBankTransferAttachmentByFileName()
    {
    }

    /**
     * Test case for getBankTransferAttachmentById
     *
     * Allows you to retrieve Attachments on BankTransfer.
     *
     */
    public function testGetBankTransferAttachmentById()
    {
    }

    /**
     * Test case for getBankTransferAttachments
     *
     * Allows you to retrieve Attachments from  bank transfers.
     *
     */
    public function testGetBankTransferAttachments()
    {
    }

    /**
     * Test case for getBankTransferHistory
     *
     * Allows you to retrieve history from a bank transfers.
     *
     */
    public function testGetBankTransferHistory()
    {
    }

    /**
     * Test case for getBankTransfers
     *
     * Allows you to retrieve all bank transfers.
     *
     */
    public function testGetBankTransfers()
    {
    }

    /**
     * Test case for getBatchPaymentHistory
     *
     * Allows you to retrieve history from a Batch Payment.
     *
     */
    public function testGetBatchPaymentHistory()
    {
    }

    /**
     * Test case for getBatchPayments
     *
     * Retrieve either one or many BatchPayments for invoices.
     *
     */
    public function testGetBatchPayments()
    {
    }

    /**
     * Test case for getBrandingTheme
     *
     * Allows you to retrieve a specific BrandingThemes.
     *
     */
    public function testGetBrandingTheme()
    {
    }

    /**
     * Test case for getBrandingThemePaymentServices
     *
     * Allows you to retrieve the Payment services for a Branding Theme.
     *
     */
    public function testGetBrandingThemePaymentServices()
    {
    }

    /**
     * Test case for getBrandingThemes
     *
     * Allows you to retrieve all the BrandingThemes.
     *
     */
    public function testGetBrandingThemes()
    {
    }

    /**
     * Test case for getContact
     *
     * Allows you to retrieve, add and update contacts in a Xero organisation.
     *
     */
    public function testGetContact()
    {
    }

    /**
     * Test case for getContactAttachmentByFileName
     *
     * Allows you to retrieve Attachments on Contacts by file name.
     *
     */
    public function testGetContactAttachmentByFileName()
    {
    }

    /**
     * Test case for getContactAttachmentById
     *
     * Allows you to retrieve Attachments on Contacts.
     *
     */
    public function testGetContactAttachmentById()
    {
    }

    /**
     * Test case for getContactAttachments
     *
     * Allows you to retrieve, add and update contacts in a Xero organisation.
     *
     */
    public function testGetContactAttachments()
    {
    }

    /**
     * Test case for getContactCISSettings
     *
     * Allows you to retrieve CISSettings for a contact in a Xero organisation.
     *
     */
    public function testGetContactCISSettings()
    {
    }

    /**
     * Test case for getContactGroup
     *
     * Allows you to retrieve a unique Contract Group by ID.
     *
     */
    public function testGetContactGroup()
    {
    }

    /**
     * Test case for getContactGroups
     *
     * Allows you to retrieve the ContactID and Name of all the contacts in a contact group.
     *
     */
    public function testGetContactGroups()
    {
    }

    /**
     * Test case for getContactHistory
     *
     * Allows you to retrieve a history records of an Contact.
     *
     */
    public function testGetContactHistory()
    {
    }

    /**
     * Test case for getContacts
     *
     * Allows you to retrieve, add and update contacts in a Xero organisation.
     *
     */
    public function testGetContacts()
    {
    }

    /**
     * Test case for getCreditNote
     *
     * Allows you to retrieve a specific credit note.
     *
     */
    public function testGetCreditNote()
    {
    }

    /**
     * Test case for getCreditNoteAsPdf
     *
     * Allows you to retrieve Credit Note as PDF files.
     *
     */
    public function testGetCreditNoteAsPdf()
    {
    }

    /**
     * Test case for getCreditNoteAttachmentByFileName
     *
     * Allows you to retrieve Attachments on CreditNote by file name.
     *
     */
    public function testGetCreditNoteAttachmentByFileName()
    {
    }

    /**
     * Test case for getCreditNoteAttachmentById
     *
     * Allows you to retrieve Attachments on CreditNote.
     *
     */
    public function testGetCreditNoteAttachmentById()
    {
    }

    /**
     * Test case for getCreditNoteAttachments
     *
     * Allows you to retrieve Attachments for credit notes.
     *
     */
    public function testGetCreditNoteAttachments()
    {
    }

    /**
     * Test case for getCreditNoteHistory
     *
     * Allows you to retrieve a history records of an CreditNote.
     *
     */
    public function testGetCreditNoteHistory()
    {
    }

    /**
     * Test case for getCreditNotes
     *
     * Allows you to retrieve any credit notes.
     *
     */
    public function testGetCreditNotes()
    {
    }

    /**
     * Test case for getCurrencies
     *
     * Allows you to retrieve currencies for your organisation.
     *
     */
    public function testGetCurrencies()
    {
    }

    /**
     * Test case for getEmployee
     *
     * Allows you to retrieve a specific employee used in Xero payrun.
     *
     */
    public function testGetEmployee()
    {
    }

    /**
     * Test case for getEmployees
     *
     * Allows you to retrieve employees used in Xero payrun.
     *
     */
    public function testGetEmployees()
    {
    }

    /**
     * Test case for getExpenseClaim
     *
     * Allows you to retrieve a specified expense claim.
     *
     */
    public function testGetExpenseClaim()
    {
    }

    /**
     * Test case for getExpenseClaimHistory
     *
     * Allows you to retrieve a history records of an ExpenseClaim.
     *
     */
    public function testGetExpenseClaimHistory()
    {
    }

    /**
     * Test case for getExpenseClaims
     *
     * Allows you to retrieve expense claims.
     *
     */
    public function testGetExpenseClaims()
    {
    }

    /**
     * Test case for getInvoice
     *
     * Allows you to retrieve a specified sales invoice or purchase bill.
     *
     */
    public function testGetInvoice()
    {
    }

    /**
     * Test case for getInvoiceAsPdf
     *
     * Allows you to retrieve invoices or purchase bills as PDF files.
     *
     */
    public function testGetInvoiceAsPdf()
    {
    }

    /**
     * Test case for getInvoiceAttachmentByFileName
     *
     * Allows you to retrieve Attachment on invoices or purchase bills by it's filename.
     *
     */
    public function testGetInvoiceAttachmentByFileName()
    {
    }

    /**
     * Test case for getInvoiceAttachmentById
     *
     * Allows you to retrieve a specified Attachment on invoices or purchase bills by it's ID.
     *
     */
    public function testGetInvoiceAttachmentById()
    {
    }

    /**
     * Test case for getInvoiceAttachments
     *
     * Allows you to retrieve Attachments on invoices or purchase bills.
     *
     */
    public function testGetInvoiceAttachments()
    {
    }

    /**
     * Test case for getInvoiceHistory
     *
     * Allows you to retrieve a history records of an invoice.
     *
     */
    public function testGetInvoiceHistory()
    {
    }

    /**
     * Test case for getInvoiceReminders
     *
     * Allows you to retrieve invoice reminder settings.
     *
     */
    public function testGetInvoiceReminders()
    {
    }

    /**
     * Test case for getInvoices
     *
     * Allows you to retrieve any sales invoices or purchase bills.
     *
     */
    public function testGetInvoices()
    {
    }

    /**
     * Test case for getItem
     *
     * Allows you to retrieve a specified item.
     *
     */
    public function testGetItem()
    {
    }

    /**
     * Test case for getItemHistory
     *
     * Allows you to retrieve history for items.
     *
     */
    public function testGetItemHistory()
    {
    }

    /**
     * Test case for getItems
     *
     * Allows you to retrieve any items.
     *
     */
    public function testGetItems()
    {
    }

    /**
     * Test case for getJournal
     *
     * Allows you to retrieve a specified journals..
     *
     */
    public function testGetJournal()
    {
    }

    /**
     * Test case for getJournals
     *
     * Allows you to retrieve any journals..
     *
     */
    public function testGetJournals()
    {
    }

    /**
     * Test case for getLinkedTransaction
     *
     * Allows you to retrieve a specified linked transactions (billable expenses).
     *
     */
    public function testGetLinkedTransaction()
    {
    }

    /**
     * Test case for getLinkedTransactions
     *
     * Retrieve linked transactions (billable expenses).
     *
     */
    public function testGetLinkedTransactions()
    {
    }

    /**
     * Test case for getManualJournal
     *
     * Allows you to retrieve a specified manual journals.
     *
     */
    public function testGetManualJournal()
    {
    }

    /**
     * Test case for getManualJournalAttachmentByFileName
     *
     * Allows you to retrieve specified Attachment on ManualJournal by file name.
     *
     */
    public function testGetManualJournalAttachmentByFileName()
    {
    }

    /**
     * Test case for getManualJournalAttachmentById
     *
     * Allows you to retrieve specified Attachment on ManualJournals.
     *
     */
    public function testGetManualJournalAttachmentById()
    {
    }

    /**
     * Test case for getManualJournalAttachments
     *
     * Allows you to retrieve Attachment for manual journals.
     *
     */
    public function testGetManualJournalAttachments()
    {
    }

    /**
     * Test case for getManualJournals
     *
     * Allows you to retrieve any manual journals.
     *
     */
    public function testGetManualJournals()
    {
    }

    /**
     * Test case for getOnlineInvoice
     *
     * Allows you to retrieve a URL to an online invoice.
     *
     */
    public function testGetOnlineInvoice()
    {
    }

    /**
     * Test case for getOrganisationCISSettings
     *
     * Allows you To verify if an organisation is using contruction industry scheme, you can retrieve the CIS settings for the organistaion..
     *
     */
    public function testGetOrganisationCISSettings()
    {
    }

    /**
     * Test case for getOrganisations
     *
     * Allows you to retrieve Organisation details.
     *
     */
    public function testGetOrganisations()
    {
    }

    /**
     * Test case for getOverpayment
     *
     * Allows you to retrieve a specified overpayments.
     *
     */
    public function testGetOverpayment()
    {
    }

    /**
     * Test case for getOverpaymentHistory
     *
     * Allows you to retrieve a history records of an Overpayment.
     *
     */
    public function testGetOverpaymentHistory()
    {
    }

    /**
     * Test case for getOverpayments
     *
     * Allows you to retrieve overpayments.
     *
     */
    public function testGetOverpayments()
    {
    }

    /**
     * Test case for getPayment
     *
     * Allows you to retrieve a specified payment for invoices and credit notes.
     *
     */
    public function testGetPayment()
    {
    }

    /**
     * Test case for getPaymentHistory
     *
     * Allows you to retrieve history records of a payment.
     *
     */
    public function testGetPaymentHistory()
    {
    }

    /**
     * Test case for getPaymentServices
     *
     * Allows you to retrieve payment services.
     *
     */
    public function testGetPaymentServices()
    {
    }

    /**
     * Test case for getPayments
     *
     * Allows you to retrieve payments for invoices and credit notes.
     *
     */
    public function testGetPayments()
    {
    }

    /**
     * Test case for getPrepayment
     *
     * Allows you to retrieve a specified prepayments.
     *
     */
    public function testGetPrepayment()
    {
    }

    /**
     * Test case for getPrepaymentHistory
     *
     * Allows you to retrieve a history records of an Prepayment.
     *
     */
    public function testGetPrepaymentHistory()
    {
    }

    /**
     * Test case for getPrepayments
     *
     * Allows you to retrieve prepayments.
     *
     */
    public function testGetPrepayments()
    {
    }

    /**
     * Test case for getPurchaseOrder
     *
     * Allows you to retrieve a specified purchase orders.
     *
     */
    public function testGetPurchaseOrder()
    {
    }

    /**
     * Test case for getPurchaseOrderHistory
     *
     * Allows you to retrieve history for PurchaseOrder.
     *
     */
    public function testGetPurchaseOrderHistory()
    {
    }

    /**
     * Test case for getPurchaseOrders
     *
     * Allows you to retrieve purchase orders.
     *
     */
    public function testGetPurchaseOrders()
    {
    }

    /**
     * Test case for getReceipt
     *
     * Allows you to retrieve a specified draft expense claim receipts.
     *
     */
    public function testGetReceipt()
    {
    }

    /**
     * Test case for getReceiptAttachmentByFileName
     *
     * Allows you to retrieve Attachments on expense claim receipts by file name.
     *
     */
    public function testGetReceiptAttachmentByFileName()
    {
    }

    /**
     * Test case for getReceiptAttachmentById
     *
     * Allows you to retrieve Attachments on expense claim receipts by ID.
     *
     */
    public function testGetReceiptAttachmentById()
    {
    }

    /**
     * Test case for getReceiptAttachments
     *
     * Allows you to retrieve Attachments for expense claim receipts.
     *
     */
    public function testGetReceiptAttachments()
    {
    }

    /**
     * Test case for getReceiptHistory
     *
     * Allows you to retrieve a history records of an Receipt.
     *
     */
    public function testGetReceiptHistory()
    {
    }

    /**
     * Test case for getReceipts
     *
     * Allows you to retrieve draft expense claim receipts for any user.
     *
     */
    public function testGetReceipts()
    {
    }

    /**
     * Test case for getRepeatingInvoice
     *
     * Allows you to retrieve a specified repeating invoice.
     *
     */
    public function testGetRepeatingInvoice()
    {
    }

    /**
     * Test case for getRepeatingInvoiceAttachmentByFileName
     *
     * Allows you to retrieve specified attachment on repeating invoices by file name.
     *
     */
    public function testGetRepeatingInvoiceAttachmentByFileName()
    {
    }

    /**
     * Test case for getRepeatingInvoiceAttachmentById
     *
     * Allows you to retrieve a specified Attachments on repeating invoices.
     *
     */
    public function testGetRepeatingInvoiceAttachmentById()
    {
    }

    /**
     * Test case for getRepeatingInvoiceAttachments
     *
     * Allows you to retrieve Attachments on repeating invoice.
     *
     */
    public function testGetRepeatingInvoiceAttachments()
    {
    }

    /**
     * Test case for getRepeatingInvoiceHistory
     *
     * Allows you to retrieve history for a repeating invoice.
     *
     */
    public function testGetRepeatingInvoiceHistory()
    {
    }

    /**
     * Test case for getRepeatingInvoices
     *
     * Allows you to retrieve any repeating invoices.
     *
     */
    public function testGetRepeatingInvoices()
    {
    }

    /**
     * Test case for getReportAgedPayablesByContact
     *
     * Allows you to retrieve report for AgedPayablesByContact.
     *
     */
    public function testGetReportAgedPayablesByContact()
    {
    }

    /**
     * Test case for getReportAgedReceivablesByContact
     *
     * Allows you to retrieve report for AgedReceivablesByContact.
     *
     */
    public function testGetReportAgedReceivablesByContact()
    {
    }

    /**
     * Test case for getReportBASorGST
     *
     * Allows you to retrieve report for BAS only valid for AU orgs.
     *
     */
    public function testGetReportBASorGST()
    {
    }

    /**
     * Test case for getReportBASorGSTList
     *
     * Allows you to retrieve report for BAS only valid for AU orgs.
     *
     */
    public function testGetReportBASorGSTList()
    {
    }

    /**
     * Test case for getReportBalanceSheet
     *
     * Allows you to retrieve report for BalanceSheet.
     *
     */
    public function testGetReportBalanceSheet()
    {
    }

    /**
     * Test case for getReportBankSummary
     *
     * Allows you to retrieve report for BankSummary.
     *
     */
    public function testGetReportBankSummary()
    {
    }

    /**
     * Test case for getReportBudgetSummary
     *
     * Allows you to retrieve report for Budget Summary.
     *
     */
    public function testGetReportBudgetSummary()
    {
    }

    /**
     * Test case for getReportExecutiveSummary
     *
     * Allows you to retrieve report for ExecutiveSummary.
     *
     */
    public function testGetReportExecutiveSummary()
    {
    }

    /**
     * Test case for getReportProfitAndLoss
     *
     * Allows you to retrieve report for ProfitAndLoss.
     *
     */
    public function testGetReportProfitAndLoss()
    {
    }

    /**
     * Test case for getReportTenNinetyNine
     *
     * Allows you to retrieve report for TenNinetyNine.
     *
     */
    public function testGetReportTenNinetyNine()
    {
    }

    /**
     * Test case for getReportTrialBalance
     *
     * Allows you to retrieve report for TrialBalance.
     *
     */
    public function testGetReportTrialBalance()
    {
    }

    /**
     * Test case for getTaxRates
     *
     * Allows you to retrieve Tax Rates.
     *
     */
    public function testGetTaxRates()
    {
    }

    /**
     * Test case for getTrackingCategories
     *
     * Allows you to retrieve tracking categories and options.
     *
     */
    public function testGetTrackingCategories()
    {
    }

    /**
     * Test case for getTrackingCategory
     *
     * Allows you to retrieve tracking categories and options for specified category.
     *
     */
    public function testGetTrackingCategory()
    {
    }

    /**
     * Test case for getUser
     *
     * Allows you to retrieve a specified user.
     *
     */
    public function testGetUser()
    {
    }

    /**
     * Test case for getUsers
     *
     * Allows you to retrieve users.
     *
     */
    public function testGetUsers()
    {
    }

    /**
     * Test case for updateAccount
     *
     * Allows you to update a chart of accounts.
     *
     */
    public function testUpdateAccount()
    {
    }

    /**
     * Test case for updateAccountAttachmentByFileName
     *
     * Allows you to update Attachment on Account by Filename.
     *
     */
    public function testUpdateAccountAttachmentByFileName()
    {
    }

    /**
     * Test case for updateBankTransaction
     *
     * Allows you to update a single spend or receive money transaction.
     *
     */
    public function testUpdateBankTransaction()
    {
    }

    /**
     * Test case for updateBankTransactionAttachmentByFileName
     *
     * Allows you to update an Attachment on BankTransaction by Filename.
     *
     */
    public function testUpdateBankTransactionAttachmentByFileName()
    {
    }

    /**
     * Test case for updateBankTransferAttachmentByFileName
     *
     * .
     *
     */
    public function testUpdateBankTransferAttachmentByFileName()
    {
    }

    /**
     * Test case for updateContact
     *
     * .
     *
     */
    public function testUpdateContact()
    {
    }

    /**
     * Test case for updateContactAttachmentByFileName
     *
     * .
     *
     */
    public function testUpdateContactAttachmentByFileName()
    {
    }

    /**
     * Test case for updateContactGroup
     *
     * Allows you to update a Contract Group.
     *
     */
    public function testUpdateContactGroup()
    {
    }

    /**
     * Test case for updateCreditNote
     *
     * Allows you to update a specific credit note.
     *
     */
    public function testUpdateCreditNote()
    {
    }

    /**
     * Test case for updateCreditNoteAttachmentByFileName
     *
     * Allows you to update Attachments on CreditNote by file name.
     *
     */
    public function testUpdateCreditNoteAttachmentByFileName()
    {
    }

    /**
     * Test case for updateEmployee
     *
     * Allows you to update a specific employee used in Xero payrun.
     *
     */
    public function testUpdateEmployee()
    {
    }

    /**
     * Test case for updateExpenseClaim
     *
     * Allows you to update specified expense claims.
     *
     */
    public function testUpdateExpenseClaim()
    {
    }

    /**
     * Test case for updateInvoice
     *
     * Allows you to update a specified sales invoices or purchase bills.
     *
     */
    public function testUpdateInvoice()
    {
    }

    /**
     * Test case for updateInvoiceAttachmentByFileName
     *
     * Allows you to update Attachment on invoices or purchase bills by it's filename.
     *
     */
    public function testUpdateInvoiceAttachmentByFileName()
    {
    }

    /**
     * Test case for updateItem
     *
     * Allows you to udpate a specified item.
     *
     */
    public function testUpdateItem()
    {
    }

    /**
     * Test case for updateLinkedTransaction
     *
     * Allows you to update a specified linked transactions (billable expenses).
     *
     */
    public function testUpdateLinkedTransaction()
    {
    }

    /**
     * Test case for updateManualJournal
     *
     * Allows you to update a specified manual journal.
     *
     */
    public function testUpdateManualJournal()
    {
    }

    /**
     * Test case for updateManualJournalAttachmentByFileName
     *
     * Allows you to update a specified Attachment on ManualJournal by file name.
     *
     */
    public function testUpdateManualJournalAttachmentByFileName()
    {
    }

    /**
     * Test case for updatePurchaseOrder
     *
     * Allows you to update a specified purchase order.
     *
     */
    public function testUpdatePurchaseOrder()
    {
    }

    /**
     * Test case for updateReceipt
     *
     * Allows you to retrieve a specified draft expense claim receipts.
     *
     */
    public function testUpdateReceipt()
    {
    }

    /**
     * Test case for updateReceiptAttachmentByFileName
     *
     * Allows you to update Attachment on expense claim receipts by file name.
     *
     */
    public function testUpdateReceiptAttachmentByFileName()
    {
    }

    /**
     * Test case for updateRepeatingInvoiceAttachmentByFileName
     *
     * Allows you to update specified attachment on repeating invoices by file name.
     *
     */
    public function testUpdateRepeatingInvoiceAttachmentByFileName()
    {
    }

    /**
     * Test case for updateTaxRate
     *
     * Allows you to update Tax Rates.
     *
     */
    public function testUpdateTaxRate()
    {
    }

    /**
     * Test case for updateTrackingCategory
     *
     * Allows you to update tracking categories.
     *
     */
    public function testUpdateTrackingCategory()
    {
    }
}


text:
package org.conqat.engine.persistence.store.base;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import org.conqat.engine.persistence.store.IKeyValueCallback;
import org.conqat.engine.persistence.store.IStore;
import org.conqat.engine.persistence.store.StorageException;
import org.conqat.lib.commons.assertion.CCSMPre;
import org.conqat.lib.commons.collections.ByteArrayWrapper;
import org.conqat.lib.commons.collections.PairList;

/**
 * Base class which contains utility methods for implementing stores.
 *
 * @author $Author: heineman $
 * @version $Rev: 39793 $
 * @ConQAT.Rating GREEN Hash: F94461802556206765F1C40D4AB2F057
 */
public abstract class StoreBase implements IStore {

	/**
	 * {@inheritDoc}
	 * <p>
	 * This implementation maps prefix queries to range queries. For this, the
	 * prefix is used as the begin key, and a suitable end key is calculated.
	 */
	@Override
	public void scan(byte[] prefix, IKeyValueCallback callback)
			throws StorageException {
		CCSMPre.isNotNull(prefix);
		scan(prefix, generateEndKey(prefix), callback);
	}

	/** {@inheritDoc} */
	@Override
	public void scan(List<byte[]> prefixes, final IKeyValueCallback callback)
			throws StorageException {
		final Set<ByteArrayWrapper> keys = new HashSet<ByteArrayWrapper>();
		for (byte[] prefix : prefixes) {
			scan(prefix, new IKeyValueCallback() {
				@Override
				public void callback(byte[] key, byte[] value) {
					if (keys.add(new ByteArrayWrapper(key))) {
						callback.callback(key, value);
					}
				}
			});
		}
	}

	/** {@inheritDoc} */
	@Override
	public void scanKeys(byte[] prefix, IKeyValueCallback callback)
			throws StorageException {
		scanKeys(prefix, generateEndKey(prefix), callback);
	}

	/** Generates end key */
	private byte[] generateEndKey(byte[] prefix) {
		// The goal of the following lines is the creation of a key that can act
		// as an end key, i.e. is larger than any key with the given prefix, but
		// small enough to skip all other keys. This is done by incrementing the
		// last (lowest) byte in the prefix key. If this last byte is 0xff, then
		// the overflow has to be propagated. In our case, instead of setting
		// overflown bytes to 0, we have to cut them off. This is performed in
		// the next lines, by finding the last non-0xff, incrementing it and
		// removing everything behind it.
		int lastIndex = prefix.length - 1;
		while (lastIndex >= 0 && prefix[lastIndex] == (byte) 0xFF) {
			--lastIndex;
		}

		byte[] end = null;
		if (lastIndex >= 0) {
			end = Arrays.copyOfRange(prefix, 0, lastIndex + 1);
			end[lastIndex] += 1;
		}
		// else: if haven't found an index, we can use null, as we anyway
		// including everything from the prefix to the end.
		return end;
	}

	/** {@inheritDoc} */
	@Override
	public List<byte[]> get(List<byte[]> keys) throws StorageException {
		List<byte[]> values = new ArrayList<byte[]>();
		for (byte[] key : keys) {
			values.add(get(key));
		}
		return values;
	}

	/** {@inheritDoc} */
	@Override
	public void put(PairList<byte[], byte[]> keysValues)
			throws StorageException {
		for (int i = 0; i < keysValues.size(); ++i) {
			put(keysValues.getFirst(i), keysValues.getSecond(i));
		}
	}

	/** {@inheritDoc} */
	@Override
	public void remove(List<byte[]> keys) throws StorageException {
		for (byte[] key : keys) {
			remove(key);
		}
	}
}


text:
      <button type="button" class="close" data-dismiss="alert">×</button>
      @if(isset($title))
{{ $title }}
 @endif
      @if(is_array($message))

      @foreach ($message as $msg)

{{ $msg }}

      @endforeach

      @else
        {{ $message }}
      @endif


text:
/**
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.github.castagna.kafka.connect.exchange;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.kafka.common.config.ConfigDef;
import org.apache.kafka.connect.connector.Task;
import org.apache.kafka.connect.source.SourceConnector;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class ExchangeSourceConnector extends SourceConnector {

	private static Logger log = LoggerFactory.getLogger(ExchangeSourceConnector.class);
	private Map<String, String> config;

	@Override
	public String version() {
		return VersionUtil.getVersion();
	}

	@Override
	public void start(Map<String, String> properties) {
		config = properties;
		log.info("Starting Exchange source connector with properties:{}", properties);
	}

	@Override
	public Class<? extends Task> taskClass() {
		return ExchangeSourceTask.class;
	}

	@Override
	public List<Map<String, String>> taskConfigs(int maxTasks) {
		log.info("Setting task configurations for {} workers.", maxTasks);
		List<Map<String, String>> results = new ArrayList<Map<String, String>>();

		for (int i = 0; i < maxTasks; i++) {
			Map<String,String> taskProperties = new HashMap<String, String>();
			taskProperties.putAll(config);
			taskProperties.put("task", String.valueOf(i));
			taskProperties.put("maxTasks", String.valueOf(maxTasks));
			results.add(taskProperties);
		}

		return results;
	}

	@Override
	public void stop() {
		log.info("Stopping Exchange source connector.");
	}

	@Override
	public ConfigDef config() {
		return ExchangeSourceConnectorConfig.conf();
	}

}


text:
<?php
if(!defined('sugarEntry') || !sugarEntry) die('Not A Valid Entry Point');

// adding project-to-products relationship
$dictionary['projects_products'] = array (
    'table' => 'projects_products',
    'fields' => array (
        array('name' => 'id', 'type' => 'varchar', 'len' => '36'),
        array('name' => 'product_id', 'type' => 'varchar', 'len' => '36'),
        array('name' => 'project_id', 'type' => 'varchar', 'len' => '36'),
        array('name' => 'date_modified', 'type' => 'datetime'),
        array('name' => 'deleted', 'type' => 'bool', 'len' => '1', 'default' => '0', 'required' => false),
    ),
    'indices' => array (
        array('name' => 'projects_products_pk', 'type' =>'primary', 'fields'=>array('id')),
        array('name' => 'idx_proj_prod_project', 'type' =>'index', 'fields'=>array('project_id')),
        array('name' => 'idx_proj_prod_product', 'type' =>'index', 'fields'=>array('product_id')),
        array('name' => 'projects_products_alt', 'type'=>'alternate_key', 'fields'=>array('project_id','product_id')),
    ),
    'relationships' => array (
        'projects_products' => array(
            'lhs_module' => 'Project',
            'lhs_table' => 'project',
            'lhs_key' => 'id',
            'rhs_module' => 'Products',
            'rhs_table' => 'products',
            'rhs_key' => 'id',
            'relationship_type' => 'many-to-many',
            'join_table' => 'projects_products',
            'join_key_lhs' => 'project_id',
            'join_key_rhs' => 'product_id',
        ),
    ),
);
?>


text:
class Edge;

class FiniteAuto
{
public:

	FiniteAuto();
	~FiniteAuto();

	Vertex* GetStart() const;

	void AddVertex(const string& _name, const Status& _status = Status::Normal);
	void RemoveVertex(const string& _name);

	void AddEdge(const string& _sender, const string& _receiver, const string& _label);
	void RemoveEdge(const string& _sender, const string& _receiver, const string& _label);

	const list<Vertex*>& GetVertexList() const;

	const list<Vertex*>& GetFinalList() const;

	void SetDrawer(const Dot& _drawer);
	const Dot& GetDrawer() const;

	void SaveImage(const string& dotExe, const string& dotFile, const string& pngFile);

private:

	list<Vertex*> vertexList;
	Vertex* start;
	list<Vertex*> finalList;
	Dot drawer;

	FiniteAuto(const FiniteAuto& _auto);
	void operator =(const FiniteAuto& _auto);
};


text:
package org.pushingpixels.flamingo.api.svg.transcoders;

import java.awt.geom.Line2D;
import java.io.PrintWriter;
import java.util.Locale;

/**
 * Transcodes a line.
 *
 * @author Emmanuel Bourg
 * @version $Revision$, $Date$
 */
public class LineTranscoder extends Transcoder<Line2D.Float> {

    public static LineTranscoder INSTANCE = new LineTranscoder();

    @Override
    public void transcode(Line2D.Float line, PrintWriter output) {
        output.format(Locale.ENGLISH, "shape = new Line2D.Float(%ff, %ff, %ff, %ff);\n", line.x1, line.y1, line.x2, line.y2);
    }
}


text:
exports.controllers = require('./controllers')
exports.services = require('./services')


text:
package ru.job4j;

/**
 * CalculatorTrigonometric class.
 *
 * @author Denis
 * @since 11.02.2017
 */
public class CalculatorTrigonometric extends Calculator {
    /***
     * Result.
     */
    private double result;

    /**
     * Summation of numbers, write in field result.
     *
     * @param first  the first number.
     * @param second the second number
     */
    @Override
    public void add(double first, double second) {
        super.add(first, second);
        setResult();
    }

    /**
     * Subtraction  of numbers, write in field result.
     *
     * @param first  the first number.
     * @param second the second number
     */
    @Override
    public void substruct(double first, double second) {
        super.substruct(first, second);
        setResult();
    }

    /**
     * Multiplication of numbers, write in field result.
     *
     * @param first  the first number.
     * @param second the second number
     */
    @Override
    public void multiple(double first, double second) {
        super.multiple(first, second);
        setResult();
    }

    /**
     * Division of numbers, write in field result.
     *
     * @param first  the first number.
     * @param second the second number.
     */
    @Override
    public void div(double first, double second) {
        super.div(first, second);
        setResult();
    }

    /**
     * Sines of degree.
     *
     * @param degree degree.
     */
    public void sin(double degree) {
        this.result = Math.sin(Math.toRadians(degree));
    }

    /**
     * Cosines of degree.
     *
     * @param degree degree.
     */
    public void cos(double degree) {
        this.result = Math.cos(Math.toRadians(degree));
    }

    /**
     * Set current result.
     */
    private void setResult() {
        this.result = super.getResult();
    }

    /**
     * Get field result.
     *
     * @return field result
     */
    @Override
    public double getResult() {
        return this.result;
    }
}


text:
package impl;

import akka.NotUsed;
import com.lightbend.lagom.javadsl.api.ServiceCall;
import java.util.concurrent.CompletableFuture;
import javax.inject.Inject;
import api.BazService;

import akka.stream.javadsl.Source;

public class BazServiceImpl implements BazService {

  @Override
  public ServiceCall<NotUsed, String> baz() {
    return request -> CompletableFuture.completedFuture("ack baz");
  }
}


text:
<?xml version="1.0" encoding="UTF-8"?>
<Context antiJARLocking="true" path="/FriendSocity"/>