text:
module Axlsx

  # The Cfb class is a MS-OFF-CRYPTOGRAPHY specific OLE (MS-CBF) writer implementation. No attempt is made to re-invent the wheel for read/write of compound binary files.
  class Cbf

    # the serialization for the CBF FAT
    FAT_PACKING  = "s128"

    # the serialization for the MS-OFF-CRYPTO version stream
    VERSION_PACKING = 'l s30 l3'

    # The serialization for the MS-OFF-CRYPTO dataspace map stream
    DATA_SPACE_MAP_PACKING = 'l6 s16 l s25 x2'

    # The serialization for the MS-OFF-CRYPTO strong encrytion data space stream
    STRONG_ENCRYPTION_DATA_SPACE_PACKING = 'l3 s26'

    # The serialization for the MS-OFF-CRYPTO primary stream
    PRIMARY_PACKING = 'l3 s38 l s40 l3 x12 l'

    # The cutoff size that determines if a stream should be in the mini-fat or the fat
    MINI_CUTOFF = 4096

    # The serialization for CBF header
    HEADER_PACKING = "q x16 l s3 x10 l l x4 l*"

    # Creates a new Cbf object based on the ms_off_crypto object provided.
    # @param [MsOffCrypto] ms_off_crypto
    def initialize(ms_off_crypto)
      @file_name = ms_off_crypto.file_name
      @ms_off_crypto = ms_off_crypto
      create_storages
      mini_fat_stream
      mini_fat
      fat
      header
    end

    # creates or returns the version storage
    # @return [Storage]
    def version
      @version ||= create_version
    end

    # returns the data space map storage
    # @return [Storage]
    def data_space_map
      @data_space_map ||= create_data_space_map
    end

    # returns the primary storage
    # @return [Storgae]
    def primary
      @primary ||= create_primary
    end

    # returns the summary information storage
    # @return [Storage]
    def summary_information
      @summary_information ||= create_summary_information
    end

    # returns the document summary information
    # @return [Storage]
    def document_summary_information
      @document_summary_information ||= create_document_summary_information
    end

    # returns the stream of data allocated in the fat
    # @return [String]
    def fat_stream
      @fat_stream ||= create_fat_stream
    end

    # returns the stream allocated in the mini fat.
    # return [String]
    def mini_fat_stream
      @mini_fat_stream ||= create_mini_fat_stream
    end

    # returns the mini fat
    # return [String]
    def mini_fat
      @mini_fat ||= create_mini_fat
    end

    # returns the fat
    # @return [String]
    def fat
      @fat ||= create_fat
    end

    # returns the CFB header
    # @return [String]
    def header
      @header ||= create_header
    end

    # returns the encryption info from the ms_off_crypt object provided during intialization
    # @return [String] encryption info
    def encryption_info
      @ms_off_crypto.encryption_info
    end

    # returns the encrypted package from the ms_off_crypt object provided during initalization
    # @return [String] encrypted package
    def encrypted_package
      @ms_off_crypto.encrypted_package
    end

    # writes the compound binary file to disk
    def save
      ole = File.open(@file_name, 'w')
      ole << header
      ole << fat
      @storages.each { |s| ole << s.to_s }
      ole << Array.new((512-(ole.pos % 512)), 0).pack('c*')
      ole << mini_fat
      ole << mini_fat_stream
      ole << fat_stream
      ole.close
    end

    private

    # Generates the storages required for ms-office-cryptography cfb
    def create_storages
      @storages = []
      @encryption_info = @ms_off_crypto.encryption_info
      @encrypted_package = @ms_off_crypto.encrypted_package

      @storages << Storage.new('EncryptionInfo', :data=>encryption_info, :left=>3, :right=>11) # example shows right child. do we need the summary info????
      @storages << Storage.new('EncryptedPackage', :data=>encrypted_package, :color=>Storage::COLORS[:red])
      @storages << Storage.new([6].pack("c")+"DataSpaces", :child=>5, :modified =>129685612740945580, :created=>129685612740819979)
      @storages << version
      @storages << data_space_map
      @storages << Storage.new('DataSpaceInfo', :right=>8, :child=>7, :created=>129685612740828880,:modified=>129685612740831800)
      @storages << strong_encryption_data_space
      @storages << Storage.new('TransformInfo', :color => Storage::COLORS[:red],  :child=>9, :created=>129685612740834130, :modified=>129685612740943959)
      @storages << Storage.new('StrongEncryptionTransform', :child=>10, :created=>129685612740834169, :modified=>129685612740942280)
      @storages << primary
      # @storages << summary_information
      # @storages << document_summary_information

      # we do this at the end as we need to build the minifat stream to determine the size. #HOWEVER - it looks like the size should not include the padding?
      @storages.unshift Storage.new('Root Entry', :type=>Storage::TYPES[:root], :color=>Storage::COLORS[:red], :child=>1, :data => mini_fat_stream)

    end

    # generates the mini fat stream
    # @return [String]
    def create_mini_fat_stream
      mfs = []
      @storages.select{ |s| s.type == Storage::TYPES[:stream] && s.size < MINI_CUTOFF}.each_with_index do |stream, index|
        puts "#{stream.name.pack('c*')}: #{stream.data.size}"
        mfs.concat stream.data
        mfs.concat Array.new(64 - (mfs.size % 64), 0) if mfs.size % 64 > 0
        puts "mini fat stream size: #{mfs.size}"
      end
      mfs.concat(Array.new(512 - (mfs.size % 512), 0))
      mfs.pack 'c*'
    end

    # generates the fat stream.
    # @return [String]
    def create_fat_stream
      mfs = []
      @storages.select{ |s| s.type == Storage::TYPES[:stream] && s.size >= MINI_CUTOFF}.each_with_index do |stream, index|
        mfs.concat stream.data
        mfs.concat Array.new(512 - (mfs.size % 512), 0) if mfs.size % 512 > 0
      end
      mfs.pack 'c*'
    end

    # creates the mini fat
    # @return [String]
    def create_mini_fat
      v_mf = []
      @storages.select{ |s| s.type == Storage::TYPES[:stream] && s.size < MINI_CUTOFF}.each do |stream|
        allocate_stream(v_mf, stream, 64)
      end
      v_mf.concat Array.new(128 - v_mf.size, -1)
      v_mf.pack 'l*'
    end

    # creates the fat
    # @return [String]
    def create_fat
      v_fat = [-3]
      # storages four per sector, allocation forces directories to start at sector ID 0
      allocate_stream(v_fat, @storages, 4)
      # fat entry for minifat
      allocate_stream(v_fat, 0, 512)
      # fat entry for minifat stream
      @storages[0].sector = v_fat.size
      allocate_stream(v_fat, mini_fat_stream, 512)
      # fat entries for encrypted package storage
      # what to do about DIFAT for larger packages...
      if @encrypted_package.size > (109 - v_fat.size) * 512
        raise ArgumentError, "Your package is too big!"
      end

      if @encrypted_package.size >= MINI_CUTOFF
        allocate_stream(v_fat, @encrypted_package, 512)
      end

      v_fat.concat Array.new(128 - v_fat.size, -1) if v_fat.size < 128 #pack in unused sectors
      v_fat.pack 'l*'
    end

    # Creates the version storage
    # @return [Storage]
    def create_version
      v_stream= [60, "Microsoft.Container.DataSpaces".bytes.to_a, 1, 1, 1].flatten!.pack VERSION_PACKING
      Storage.new('Version', :data=>v_stream, :size=>v_stream.size)
    end

    # returns the strong encryption data space storage
    # @return [Storgae]
    def strong_encryption_data_space
      @strong_encryption_data_space ||= create_strong_encryption_data_space
    end

    # Creates the data space map storage
    # @return [Storgae]
    def create_data_space_map
      v_stream = [8,1,104, 1,0, 32, "EncryptedPackage".bytes.to_a, 50, "StrongEncryptionDataSpace".bytes.to_a].flatten!.pack DATA_SPACE_MAP_PACKING
      Storage.new('DataSpaceMap', :data=>v_stream, :left => 4, :right => 6, :size=>v_stream.size)
    end

    # creates the stron encryption data space storage
    # @return [Storgae]
    def create_strong_encryption_data_space
      v_stream = [8,1,50,"StrongEncryptionTransform".bytes.to_a,0].flatten.pack STRONG_ENCRYPTION_DATA_SPACE_PACKING
      Storage.new("StrongEncryptionDataSpace", :data=>v_stream, :size => v_stream.size)
    end

    # creates the primary storage
    # @return [Storgae]
    def create_primary
      v_stream = [88,1,76,"{FF9A3F03-56EF-4613-BDD5-5A41C1D07246}".bytes.to_a].flatten
      v_stream.concat [78, "Microsoft.Container.EncryptionTransform".bytes.to_a,0,1,1,1,4].flatten
      v_stream = v_stream.pack PRIMARY_PACKING
      Storage.new([6].pack("c")+"Primary", :data=>v_stream)
    end

    # creates the summary information storage
    # @return [Storage]
    def create_summary_information
      v_stream = []
      v_stream.concat [0xFEFF, 0x0000, 0x030A, 0x0100, 0x0000, 0x0000, 0x0000, 0x0000]
      v_stream.concat [0x0000, 0x0000, 0x0000, 0x0000, 0x0100, 0x0000, 0xE085, 0x9FF2]
      v_stream.concat [0xF94F, 0x6810, 0xAB91, 0x0800, 0x2B27, 0xB3D9, 0x3000, 0x0000]
      v_stream.concat [0xAC00, 0x0000, 0x0700, 0x0000, 0x0100, 0x0000, 0x4000, 0x0000]
      v_stream.concat [0x0400, 0x0000, 0x4800, 0x0000, 0x0800, 0x0000, 0x5800, 0x0000]
      v_stream.concat [0x1200, 0x0000, 0x6800, 0x0000, 0x0C00, 0x0000, 0x8C00, 0x0000]
      v_stream.concat [0x0D00, 0x0000, 0x9800, 0x0000, 0x1300, 0x0000, 0xA400, 0x0000]
      v_stream.concat [0x0200, 0x0000, 0xE9FD, 0x0000, 0x1E00, 0x0000, 0x0800, 0x0000]
      v_stream.concat [0x7261, 0x6E64, 0x796D, 0x0000, 0x1E00, 0x0000, 0x0800, 0x0000]
      v_stream.concat [0x7261, 0x6E64, 0x796D, 0x0000, 0x1E00, 0x0000, 0x1C00, 0x0000]
      v_stream.concat [0x4D69, 0x6372, 0x6F73, 0x6F66, 0x7420, 0x4D61, 0x6369, 0x6E74]
      v_stream.concat [0x6F73, 0x6820, 0x4578, 0x6365, 0x6C00, 0x0000, 0x4000, 0x0000]
      v_stream.concat [0x10AC, 0x5396, 0x60BC, 0xCC01, 0x4000, 0x0000, 0x40F4, 0xFDAF]
      v_stream.concat [0x60BC, 0xCC01, 0x0300, 0x0000, 0x0100, 0x0000]

      v_stream = v_stream.pack "s*"

      Storage.new([5].pack('c')+"SummaryInformation", :data=>v_stream, :left => 2)
    end

    # creates the document summary information storage
    # @return [Storage]
    def create_document_summary_information
      v_stream = []
      v_stream.concat [0xFEFF, 0x0000, 0x030A, 0x0100, 0x0000, 0x0000, 0x0000, 0x0000]
      v_stream.concat [0x0000, 0x0000, 0x0000, 0x0000, 0x0100, 0x0000, 0x02D5, 0xCDD5]
      v_stream.concat [0x9C2E, 0x1B10, 0x9397, 0x0800, 0x2B2C, 0xF9AE, 0x3000, 0x0000]
      v_stream.concat [0xCC00, 0x0000, 0x0900, 0x0000, 0x0100, 0x0000, 0x5000, 0x0000]
      v_stream.concat [0x0F00, 0x0000, 0x5800, 0x0000, 0x1700, 0x0000, 0x6400, 0x0000]
      v_stream.concat [0x0B00, 0x0000, 0x6C00, 0x0000, 0x1000, 0x0000, 0x7400, 0x0000]
      v_stream.concat [0x1300, 0x0000, 0x7C00, 0x0000, 0x1600, 0x0000, 0x8400, 0x0000]
      v_stream.concat [0x0D00, 0x0000, 0x8C00, 0x0000, 0x0C00, 0x0000, 0x9F00, 0x0000]
      v_stream.concat [0x0200, 0x0000, 0xE9FD, 0x0000, 0x1E00, 0x0000, 0x0400, 0x0000]
      v_stream.concat [0x0000, 0x0000, 0x0300, 0x0000, 0x0000, 0x0C00, 0x0B00, 0x0000]
      v_stream.concat [0x0000, 0x0000, 0x0B00, 0x0000, 0x0000, 0x0000, 0x0B00, 0x0000]
      v_stream.concat [0x0000, 0x0000, 0x0B00, 0x0000, 0x0000, 0x0000, 0x1E10, 0x0000]
      v_stream.concat [0x0100, 0x0000, 0x0700, 0x0000, 0x5368, 0x6565, 0x7431, 0x000C]
      v_stream.concat [0x1000, 0x0002, 0x0000, 0x001E, 0x0000, 0x0013, 0x0000, 0x00E3]
      v_stream.concat [0x83AF, 0xE383, 0xBCE3, 0x82AF, 0xE382, 0xB7E3, 0x83BC, 0xE383]
      v_stream.concat [0x8800, 0x0300, 0x0000, 0x0100, 0x0000, 0x0000]
      v_stream = v_stream.pack 'c*'
      Storage.new([5].pack('c')+"DocumentSummaryInformation", :data=>v_stream)
    end

    # Creates the header
    # @return [String]
    def create_header
      header = []
      header << -2226271756974174256 # identifier pack as q
      header << 196670 # version pack as L
      header << 65534 # byte order pack as s
      header << 9 # sector shift
      header << 6 # mini-sector shift
      header << (fat.size/512.0).ceil # this is the number of FAT sectors in the file at index 6 pack as L
      header << header.last # this is the first directory sector, index of 7 pack as L
      header << MINI_CUTOFF # minfat cutoff pack as L
      # MiniFat starts after directories
      header << (fat.size/512.0).ceil + (@storages.size/4.0).ceil # this is the sector id for the first minifat index 10 pack as L
      header << (mini_fat.size/512.0).ceil # minifat sector count index 11 pack as L
      header << -2 # the first DIFAT - set to end of chain until we exceed a single FAT pack as L
      header << 0 # number of DIFAT sectors, unless we go beyond 109 FAT sectors this will always be 0 pack as L
      header << 0 # first FAT sector defined in the DIFAT pack as L
      header.concat Array.new(108, -1) # Difat sectors pack as L108
      header.pack(HEADER_PACKING)
    end

    # Allocates sector chains in a allocation table based on the sector size and stream provided
    # If a storage obeject is provided, the starting sector value for the storage is updated based on the allocation performed here.
    # @param [Array] table Allocation table array
    # @param [Storage | String] stream
    # @param [Integer] size The cutoff size for the stream.
    def allocate_stream(table, stream, size)
      stream.sector = table.size if stream.respond_to?(:sector)
      ((stream.size / size.to_f).ceil).times { table << table.size }
      table[table.size-1] = -2 # this is the CBF chain terminator
    end

  end
end


text:
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.
// Code generated by Microsoft (R) AutoRest Code Generator.

package com.azure.resourcemanager.containerregistry.fluent.models;

import com.azure.core.annotation.Fluent;
import com.azure.core.util.logging.ClientLogger;
import com.azure.resourcemanager.containerregistry.models.RunRequest;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonProperty;

/** The properties of a task run update parameters. */
@Fluent
public final class TaskRunPropertiesUpdateParameters {
    @JsonIgnore private final ClientLogger logger = new ClientLogger(TaskRunPropertiesUpdateParameters.class);

    /*
     * The request (parameters) for the new run
     */
    @JsonProperty(value = "runRequest")
    private RunRequest runRequest;

    /*
     * How the run should be forced to rerun even if the run request
     * configuration has not changed
     */
    @JsonProperty(value = "forceUpdateTag")
    private String forceUpdateTag;

    /**
     * Get the runRequest property: The request (parameters) for the new run.
     *
     * @return the runRequest value.
     */
    public RunRequest runRequest() {
        return this.runRequest;
    }

    /**
     * Set the runRequest property: The request (parameters) for the new run.
     *
     * @param runRequest the runRequest value to set.
     * @return the TaskRunPropertiesUpdateParameters object itself.
     */
    public TaskRunPropertiesUpdateParameters withRunRequest(RunRequest runRequest) {
        this.runRequest = runRequest;
        return this;
    }

    /**
     * Get the forceUpdateTag property: How the run should be forced to rerun even if the run request configuration has
     * not changed.
     *
     * @return the forceUpdateTag value.
     */
    public String forceUpdateTag() {
        return this.forceUpdateTag;
    }

    /**
     * Set the forceUpdateTag property: How the run should be forced to rerun even if the run request configuration has
     * not changed.
     *
     * @param forceUpdateTag the forceUpdateTag value to set.
     * @return the TaskRunPropertiesUpdateParameters object itself.
     */
    public TaskRunPropertiesUpdateParameters withForceUpdateTag(String forceUpdateTag) {
        this.forceUpdateTag = forceUpdateTag;
        return this;
    }

    /**
     * Validates the instance.
     *
     * @throws IllegalArgumentException thrown if the instance is not valid.
     */
    public void validate() {
        if (runRequest() != null) {
            runRequest().validate();
        }
    }
}

redpajama_set_name: RedPajamaGithub


text:
using Microsoft.EntityFrameworkCore.Migrations;

namespace AllReady.Migrations
{
    public partial class RenameImpactToGoal : Migration
    {
        protected override void Up(MigrationBuilder migrationBuilder)
        {
            migrationBuilder.RenameTable(
                name: "CampaignImpact",
                newName: "CampaignGoal");

            migrationBuilder.RenameColumn(
                name: "CurrentImpactLevel",
                table: "CampaignGoal",
                newName: "CurrentGoalLevel");

            migrationBuilder.RenameColumn(
                name: "ImpactType",
                table: "CampaignGoal",
                newName: "GoalType");

            migrationBuilder.RenameColumn(
                name: "NumericImpactGoal",
                table: "CampaignGoal",
                newName: "NumericGoal");

            migrationBuilder.RenameColumn(
                name: "TextualImpactGoal",
                table: "CampaignGoal",
                newName: "TextualGoal");
        }

        protected override void Down(MigrationBuilder migrationBuilder)
        {
            migrationBuilder.RenameTable(
                name: "CampaignGoal",
                newName: "CampaignImpact");

            migrationBuilder.RenameColumn(
                newName: "CurrentImpactLevel",
                table: "CampaignGoal",
                name: "CurrentGoalLevel");

            migrationBuilder.RenameColumn(
                newName: "ImpactType",
                table: "CampaignGoal",
                name: "GoalType");

            migrationBuilder.RenameColumn(
                newName: "NumericImpactGoal",
                table: "CampaignGoal",
                name: "NumericGoal");

            migrationBuilder.RenameColumn(
                newName: "TextualImpactGoal",
                table: "CampaignGoal",
                name: "TextualGoal");
        }
    }
}


text:
/** Automatically generated file. DO NOT MODIFY */
package org.cocos2dx.Cocos2dxSimpleGame;

public final class BuildConfig {
    public final static boolean DEBUG = true;
}


text:
Infrastructure for serialization/deserialization, error handling, tracing, and http client pipeline configuration. Required by nodeJS client libraries generated using AutoRest.

- **Node.js version: 4.x.x or higher**

## How to Install

```bash
npm install ms-rest
```

## Usage
```javascript
var msrest = require('ms-rest');
```
## Serialization/Deserialization
Features
- Type checking
  - (String, Number, Boolean, ByteArray, Base64Url, Date, DateTime, Enum, TimeSpan, DateTimeRfc1123, UnixTime, Object, Stream, Sequence, Dictionary, Composite, Uuid(as a string))
- Validation of specified constraints
  - ExclusiveMaximum, ExclusiveMinimum, InclusiveMaximum, InclusiveMinimum, MaxItems, MaxLength, MinItems, MinLength, MultipleOf, Pattern, UniqueItems
- Flattening/Unflattening properties
- Default Values
- Model Properties marked as constant are set during serialization, irrespective of they being provided or not
- Required check (If a model or property is marked required and is not provided in the object then an error is thrown)
- Readonly check (If a model or property is marked readonly then it is not sent on the wire during, serialization)
- Serializing Constant values

- serialize an array of dictionary of primitive values
```javascript
var mapper = {
  type : {
    name: 'Sequence',
    element: {
      type : {
        name: 'Dictionary',
        value: {
          type: {
            name: 'Boolean'
          }
        }
      }
    }
  }
};
var array = [{ 1: true }, { 2: false }, { 1: true, 2: false, 3: true }];
var serializedArray = msRest.serialize(mapper, array, 'arrayObj');
assert.deepEqual(array, serializedArray);
var serializedProduct = msrest.serialize(mapper, productObj, 'productObject');
var deserializedArray = msRest.deserialize(mapper, serializedArray, 'serializedArrayObj');
```
For more examples on serialization/deserialization with complex types please take a look over [here](https://github.com/Azure/autorest/blob/master/ClientRuntimes/NodeJS/ms-rest/test/serializationTests.js#L116).

## Related Projects

- [AutoRest](https://github.com/Azure/AutoRest)

![Impressions](https://azure-sdk-impressions.azurewebsites.net/api/impressions/azure-sdk-for-node%2Fruntime%2Fms-rest%2FREADME.png)


text:
    <title>Example</title>
    <link rel="stylesheet" href="http://cdn.foundation5.zurb.com/foundation.css" />

Example

      <button name="button" type="button" class="button radius small cimple-link" data-token="GENERATED-TOKEN-GOES-HERE" data-path="profile/addPayment">Add Payment Method</button>

      ×


text:
namespace cc {

namespace proto {
class ScrollUpdateInfo;
class ScrollAndScaleSet;
}

class LayerImpl;
class Layer;
class SwapPromise;
class PropertyTrees;

class CC_EXPORT LayerTreeHostCommon {
 public:
  struct CC_EXPORT CalcDrawPropsMainInputsForTesting {
   public:
    CalcDrawPropsMainInputsForTesting(Layer* root_layer,
                                      const gfx::Size& device_viewport_size,
                                      const gfx::Transform& device_transform,
                                      float device_scale_factor,
                                      float page_scale_factor,
                                      const Layer* page_scale_layer,
                                      const Layer* inner_viewport_scroll_layer,
                                      const Layer* outer_viewport_scroll_layer);
    CalcDrawPropsMainInputsForTesting(Layer* root_layer,
                                      const gfx::Size& device_viewport_size,
                                      const gfx::Transform& device_transform);
    CalcDrawPropsMainInputsForTesting(Layer* root_layer,
                                      const gfx::Size& device_viewport_size);
    Layer* root_layer;
    gfx::Size device_viewport_size;
    gfx::Transform device_transform;
    float device_scale_factor;
    float page_scale_factor;
    const Layer* page_scale_layer;
    const Layer* inner_viewport_scroll_layer;
    const Layer* outer_viewport_scroll_layer;
  };

  struct CC_EXPORT CalcDrawPropsImplInputs {
   public:
    CalcDrawPropsImplInputs(
        LayerImpl* root_layer,
        const gfx::Size& device_viewport_size,
        const gfx::Transform& device_transform,
        float device_scale_factor,
        float page_scale_factor,
        const LayerImpl* page_scale_layer,
        const LayerImpl* inner_viewport_scroll_layer,
        const LayerImpl* outer_viewport_scroll_layer,
        const gfx::Vector2dF& elastic_overscroll,
        const LayerImpl* elastic_overscroll_application_layer,
        int max_texture_size,
        bool can_use_lcd_text,
        bool layers_always_allowed_lcd_text,
        bool can_render_to_separate_surface,
        bool can_adjust_raster_scales,
        bool verify_clip_tree_calculations,
        LayerImplList* render_surface_layer_list,
        PropertyTrees* property_trees);

    LayerImpl* root_layer;
    gfx::Size device_viewport_size;
    gfx::Transform device_transform;
    float device_scale_factor;
    float page_scale_factor;
    const LayerImpl* page_scale_layer;
    const LayerImpl* inner_viewport_scroll_layer;
    const LayerImpl* outer_viewport_scroll_layer;
    gfx::Vector2dF elastic_overscroll;
    const LayerImpl* elastic_overscroll_application_layer;
    int max_texture_size;
    bool can_use_lcd_text;
    bool layers_always_allowed_lcd_text;
    bool can_render_to_separate_surface;
    bool can_adjust_raster_scales;
    bool verify_clip_tree_calculations;
    LayerImplList* render_surface_layer_list;
    PropertyTrees* property_trees;
  };

  struct CC_EXPORT CalcDrawPropsImplInputsForTesting
      : public CalcDrawPropsImplInputs {
    CalcDrawPropsImplInputsForTesting(LayerImpl* root_layer,
                                      const gfx::Size& device_viewport_size,
                                      const gfx::Transform& device_transform,
                                      LayerImplList* render_surface_layer_list);
    CalcDrawPropsImplInputsForTesting(LayerImpl* root_layer,
                                      const gfx::Size& device_viewport_size,
                                      LayerImplList* render_surface_layer_list);
  };

  static int CalculateLayerJitter(LayerImpl* scrolling_layer);
  static void CalculateDrawPropertiesForTesting(
      CalcDrawPropsMainInputsForTesting* inputs);

  static void CalculateDrawProperties(CalcDrawPropsImplInputs* inputs);
  static void CalculateDrawPropertiesForTesting(
      CalcDrawPropsImplInputsForTesting* inputs);

  template <typename Function>
  static void CallFunctionForEveryLayer(LayerTreeHost* layer,
                                        const Function& function);

  template <typename Function>
  static void CallFunctionForEveryLayer(LayerTreeImpl* layer,
                                        const Function& function);

  struct CC_EXPORT ScrollUpdateInfo {
    int layer_id;
    // TODO(miletus): Use ScrollOffset once LayerTreeHost/Blink fully supports
    // franctional scroll offset.
    gfx::Vector2d scroll_delta;

    bool operator==(const ScrollUpdateInfo& other) const;

    void ToProtobuf(proto::ScrollUpdateInfo* proto) const;
    void FromProtobuf(const proto::ScrollUpdateInfo& proto);
  };
};

struct CC_EXPORT ScrollAndScaleSet {
  ScrollAndScaleSet();
  ~ScrollAndScaleSet();

  std::vector<LayerTreeHostCommon::ScrollUpdateInfo> scrolls;
  float page_scale_delta;
  gfx::Vector2dF elastic_overscroll_delta;
  float top_controls_delta;
  std::vector<std::unique_ptr<SwapPromise>> swap_promises;

  bool EqualsForTesting(const ScrollAndScaleSet& other) const;
  void ToProtobuf(proto::ScrollAndScaleSet* proto) const;
  void FromProtobuf(const proto::ScrollAndScaleSet& proto);

 private:
  DISALLOW_COPY_AND_ASSIGN(ScrollAndScaleSet);
};

template <typename LayerType, typename Function>
static void CallFunctionForLayer(LayerType* layer, const Function& function) {
  function(layer);

  if (LayerType* mask_layer = layer->mask_layer())
    function(mask_layer);
  if (LayerType* replica_layer = layer->replica_layer()) {
    function(replica_layer);
    if (LayerType* mask_layer = replica_layer->mask_layer())
      function(mask_layer);
  }
}

template <typename Function>
void LayerTreeHostCommon::CallFunctionForEveryLayer(LayerTreeHost* host,
                                                    const Function& function) {
  for (auto* layer : *host)
    CallFunctionForLayer(layer, function);
}

template <typename Function>
void LayerTreeHostCommon::CallFunctionForEveryLayer(LayerTreeImpl* host_impl,
                                                    const Function& function) {
  for (auto* layer : *host_impl)
    CallFunctionForLayer(layer, function);
}

CC_EXPORT PropertyTrees* GetPropertyTrees(Layer* layer);
CC_EXPORT PropertyTrees* GetPropertyTrees(LayerImpl* layer);

}  // namespace cc

#endif  // CC_TREES_LAYER_TREE_HOST_COMMON_H_


text:
import * as zipObject from 'lodash.zipobject'

import {
  LocateStrategy,
  Strategy,
  SuiteName,
  SuiteMapping,
  SuitePath,
} from './base'

export
class SimpleStrategy extends LocateStrategy implements Strategy {
  suitesPaths: SuitePath[]
  mapping: SuiteMapping
  constructor(suiteNames: SuiteName[]) {
    super(suiteNames);
    this.suitesPaths = suiteNames as SuitePath[];
  }
  async generateMapping() {
    this.mapping = zipObject(this.suiteNames, this.suitesPaths);
  }
}


text:
package spacequota

import (
	"fmt"
	"strconv"

	"github.com/cloudfoundry/cli/cf/api/space_quotas"
	"github.com/cloudfoundry/cli/cf/command_registry"
	"github.com/cloudfoundry/cli/cf/configuration/core_config"
	"github.com/cloudfoundry/cli/cf/formatters"
	. "github.com/cloudfoundry/cli/cf/i18n"
	"github.com/cloudfoundry/cli/cf/requirements"
	"github.com/cloudfoundry/cli/cf/terminal"
	"github.com/simonleung8/flags"
)

type ListSpaceQuotas struct {
	ui             terminal.UI
	config         core_config.Reader
	spaceQuotaRepo space_quotas.SpaceQuotaRepository
}

func init() {
	command_registry.Register(&ListSpaceQuotas{})
}

func (cmd *ListSpaceQuotas) MetaData() command_registry.CommandMetadata {
	return command_registry.CommandMetadata{
		Name:        "space-quotas",
		Description: T("List available space resource quotas"),
		Usage:       T("CF_NAME space-quotas"),
	}
}

func (cmd *ListSpaceQuotas) Requirements(requirementsFactory requirements.Factory, fc flags.FlagContext) (reqs []requirements.Requirement, err error) {
	if len(fc.Args()) != 0 {
		cmd.ui.Failed(T("Incorrect Usage. No argument required\n\n") + command_registry.Commands.CommandUsage("space-quotas"))
	}

	reqs = []requirements.Requirement{
		requirementsFactory.NewLoginRequirement(),
		requirementsFactory.NewTargetedOrgRequirement(),
	}
	return
}

func (cmd *ListSpaceQuotas) SetDependency(deps command_registry.Dependency, pluginCall bool) command_registry.Command {
	cmd.ui = deps.Ui
	cmd.config = deps.Config
	cmd.spaceQuotaRepo = deps.RepoLocator.GetSpaceQuotaRepository()
	return cmd
}

func (cmd *ListSpaceQuotas) Execute(c flags.FlagContext) {
	cmd.ui.Say(T("Getting space quotas as {{.Username}}...", map[string]interface{}{"Username": terminal.EntityNameColor(cmd.config.Username())}))

	quotas, apiErr := cmd.spaceQuotaRepo.FindByOrg(cmd.config.OrganizationFields().Guid)

	if apiErr != nil {
		cmd.ui.Failed(apiErr.Error())
		return
	}

	cmd.ui.Ok()
	cmd.ui.Say("")

	table := terminal.NewTable(cmd.ui, []string{T("name"), T("total memory limit"), T("instance memory limit"), T("routes"), T("service instances"), T("paid service plans")})
	var megabytes string

	for _, quota := range quotas {
		if quota.InstanceMemoryLimit == -1 {
			megabytes = T("unlimited")
		} else {
			megabytes = formatters.ByteSize(quota.InstanceMemoryLimit * formatters.MEGABYTE)
		}

		servicesLimit := strconv.Itoa(quota.ServicesLimit)
		if servicesLimit == "-1" {
			servicesLimit = T("unlimited")
		}

		table.Add(
			quota.Name,
			formatters.ByteSize(quota.MemoryLimit*formatters.MEGABYTE),
			megabytes,
			fmt.Sprintf("%d", quota.RoutesLimit),
			fmt.Sprintf(servicesLimit),
			formatters.Allowed(quota.NonBasicServicesAllowed),
		)
	}

	table.Print()

}


text:
from __future__ import division, print_function, unicode_literals
__doc__="""
Shows all masters for the next glyph.
"""

import masterNavigation as nav
newGlyphName = nav.glyphNameForIndexOffset(+1)
if newGlyphName:
	nav.showAllMastersOfGlyphInCurrentTab( newGlyphName )


text:
/* this file has been autogenerated by vtkNodeJsWrap */
/* editing this might proof futile */

#define VTK_WRAPPING_CXX
#define VTK_STREAMS_FWD_ONLY
#include <nan.h>

#include "vtkLinearTransformWrap.h"
#include "vtkIterativeClosestPointTransformWrap.h"
#include "vtkObjectWrap.h"
#include "vtkDataSetWrap.h"
#include "vtkCellLocatorWrap.h"
#include "vtkLandmarkTransformWrap.h"
#include "vtkAbstractTransformWrap.h"
#include "../../plus/plus.h"

using namespace v8;

extern Nan::Persistent<v8::Object> vtkNodeJsNoWrap;
Nan::Persistent<v8::FunctionTemplate> VtkIterativeClosestPointTransformWrap::ptpl;

VtkIterativeClosestPointTransformWrap::VtkIterativeClosestPointTransformWrap()
{ }

VtkIterativeClosestPointTransformWrap::VtkIterativeClosestPointTransformWrap(vtkSmartPointer<vtkIterativeClosestPointTransform> _native)
{ native = _native; }

VtkIterativeClosestPointTransformWrap::~VtkIterativeClosestPointTransformWrap()
{ }

void VtkIterativeClosestPointTransformWrap::Init(v8::Local<v8::Object> exports)
{
	Nan::SetAccessor(exports, Nan::New("vtkIterativeClosestPointTransform").ToLocalChecked(), ConstructorGetter);
	Nan::SetAccessor(exports, Nan::New("IterativeClosestPointTransform").ToLocalChecked(), ConstructorGetter);
}

void VtkIterativeClosestPointTransformWrap::ConstructorGetter(
	v8::Local<v8::String> property,
	const Nan::PropertyCallbackInfo<v8::Value>& info)
{
	InitPtpl();
	info.GetReturnValue().Set(Nan::New(ptpl)->GetFunction());
}

void VtkIterativeClosestPointTransformWrap::InitPtpl()
{
	if (!ptpl.IsEmpty()) return;
	v8::Local<v8::FunctionTemplate> tpl = Nan::New<v8::FunctionTemplate>(New);
	VtkLinearTransformWrap::InitPtpl( );
	tpl->Inherit(Nan::New<FunctionTemplate>(VtkLinearTransformWrap::ptpl));
	tpl->SetClassName(Nan::New("VtkIterativeClosestPointTransformWrap").ToLocalChecked());
	tpl->InstanceTemplate()->SetInternalFieldCount(1);

	Nan::SetPrototypeMethod(tpl, "CheckMeanDistanceOff", CheckMeanDistanceOff);
	Nan::SetPrototypeMethod(tpl, "checkMeanDistanceOff", CheckMeanDistanceOff);

	Nan::SetPrototypeMethod(tpl, "CheckMeanDistanceOn", CheckMeanDistanceOn);
	Nan::SetPrototypeMethod(tpl, "checkMeanDistanceOn", CheckMeanDistanceOn);

	Nan::SetPrototypeMethod(tpl, "GetCheckMeanDistance", GetCheckMeanDistance);
	Nan::SetPrototypeMethod(tpl, "getCheckMeanDistance", GetCheckMeanDistance);

	Nan::SetPrototypeMethod(tpl, "GetClassName", GetClassName);
	Nan::SetPrototypeMethod(tpl, "getClassName", GetClassName);

	Nan::SetPrototypeMethod(tpl, "GetLandmarkTransform", GetLandmarkTransform);
	Nan::SetPrototypeMethod(tpl, "getLandmarkTransform", GetLandmarkTransform);

	Nan::SetPrototypeMethod(tpl, "GetLocator", GetLocator);
	Nan::SetPrototypeMethod(tpl, "getLocator", GetLocator);

	Nan::SetPrototypeMethod(tpl, "GetMaximumMeanDistance", GetMaximumMeanDistance);
	Nan::SetPrototypeMethod(tpl, "getMaximumMeanDistance", GetMaximumMeanDistance);

	Nan::SetPrototypeMethod(tpl, "GetMaximumNumberOfIterations", GetMaximumNumberOfIterations);
	Nan::SetPrototypeMethod(tpl, "getMaximumNumberOfIterations", GetMaximumNumberOfIterations);

	Nan::SetPrototypeMethod(tpl, "GetMaximumNumberOfLandmarks", GetMaximumNumberOfLandmarks);
	Nan::SetPrototypeMethod(tpl, "getMaximumNumberOfLandmarks", GetMaximumNumberOfLandmarks);

	Nan::SetPrototypeMethod(tpl, "GetMeanDistance", GetMeanDistance);
	Nan::SetPrototypeMethod(tpl, "getMeanDistance", GetMeanDistance);

	Nan::SetPrototypeMethod(tpl, "GetMeanDistanceMode", GetMeanDistanceMode);
	Nan::SetPrototypeMethod(tpl, "getMeanDistanceMode", GetMeanDistanceMode);

	Nan::SetPrototypeMethod(tpl, "GetMeanDistanceModeAsString", GetMeanDistanceModeAsString);
	Nan::SetPrototypeMethod(tpl, "getMeanDistanceModeAsString", GetMeanDistanceModeAsString);

	Nan::SetPrototypeMethod(tpl, "GetMeanDistanceModeMaxValue", GetMeanDistanceModeMaxValue);
	Nan::SetPrototypeMethod(tpl, "getMeanDistanceModeMaxValue", GetMeanDistanceModeMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetMeanDistanceModeMinValue", GetMeanDistanceModeMinValue);
	Nan::SetPrototypeMethod(tpl, "getMeanDistanceModeMinValue", GetMeanDistanceModeMinValue);

	Nan::SetPrototypeMethod(tpl, "GetNumberOfIterations", GetNumberOfIterations);
	Nan::SetPrototypeMethod(tpl, "getNumberOfIterations", GetNumberOfIterations);

	Nan::SetPrototypeMethod(tpl, "GetSource", GetSource);
	Nan::SetPrototypeMethod(tpl, "getSource", GetSource);

	Nan::SetPrototypeMethod(tpl, "GetStartByMatchingCentroids", GetStartByMatchingCentroids);
	Nan::SetPrototypeMethod(tpl, "getStartByMatchingCentroids", GetStartByMatchingCentroids);

	Nan::SetPrototypeMethod(tpl, "GetTarget", GetTarget);
	Nan::SetPrototypeMethod(tpl, "getTarget", GetTarget);

	Nan::SetPrototypeMethod(tpl, "Inverse", Inverse);
	Nan::SetPrototypeMethod(tpl, "inverse", Inverse);

	Nan::SetPrototypeMethod(tpl, "IsA", IsA);
	Nan::SetPrototypeMethod(tpl, "isA", IsA);

	Nan::SetPrototypeMethod(tpl, "MakeTransform", MakeTransform);
	Nan::SetPrototypeMethod(tpl, "makeTransform", MakeTransform);

	Nan::SetPrototypeMethod(tpl, "NewInstance", NewInstance);
	Nan::SetPrototypeMethod(tpl, "newInstance", NewInstance);

	Nan::SetPrototypeMethod(tpl, "SafeDownCast", SafeDownCast);
	Nan::SetPrototypeMethod(tpl, "safeDownCast", SafeDownCast);

	Nan::SetPrototypeMethod(tpl, "SetCheckMeanDistance", SetCheckMeanDistance);
	Nan::SetPrototypeMethod(tpl, "setCheckMeanDistance", SetCheckMeanDistance);

	Nan::SetPrototypeMethod(tpl, "SetLocator", SetLocator);
	Nan::SetPrototypeMethod(tpl, "setLocator", SetLocator);

	Nan::SetPrototypeMethod(tpl, "SetMaximumMeanDistance", SetMaximumMeanDistance);
	Nan::SetPrototypeMethod(tpl, "setMaximumMeanDistance", SetMaximumMeanDistance);

	Nan::SetPrototypeMethod(tpl, "SetMaximumNumberOfIterations", SetMaximumNumberOfIterations);
	Nan::SetPrototypeMethod(tpl, "setMaximumNumberOfIterations", SetMaximumNumberOfIterations);

	Nan::SetPrototypeMethod(tpl, "SetMaximumNumberOfLandmarks", SetMaximumNumberOfLandmarks);
	Nan::SetPrototypeMethod(tpl, "setMaximumNumberOfLandmarks", SetMaximumNumberOfLandmarks);

	Nan::SetPrototypeMethod(tpl, "SetMeanDistanceMode", SetMeanDistanceMode);
	Nan::SetPrototypeMethod(tpl, "setMeanDistanceMode", SetMeanDistanceMode);

	Nan::SetPrototypeMethod(tpl, "SetMeanDistanceModeToAbsoluteValue", SetMeanDistanceModeToAbsoluteValue);
	Nan::SetPrototypeMethod(tpl, "setMeanDistanceModeToAbsoluteValue", SetMeanDistanceModeToAbsoluteValue);

	Nan::SetPrototypeMethod(tpl, "SetMeanDistanceModeToRMS", SetMeanDistanceModeToRMS);
	Nan::SetPrototypeMethod(tpl, "setMeanDistanceModeToRMS", SetMeanDistanceModeToRMS);

	Nan::SetPrototypeMethod(tpl, "SetSource", SetSource);
	Nan::SetPrototypeMethod(tpl, "setSource", SetSource);

	Nan::SetPrototypeMethod(tpl, "SetStartByMatchingCentroids", SetStartByMatchingCentroids);
	Nan::SetPrototypeMethod(tpl, "setStartByMatchingCentroids", SetStartByMatchingCentroids);

	Nan::SetPrototypeMethod(tpl, "SetTarget", SetTarget);
	Nan::SetPrototypeMethod(tpl, "setTarget", SetTarget);

	Nan::SetPrototypeMethod(tpl, "StartByMatchingCentroidsOff", StartByMatchingCentroidsOff);
	Nan::SetPrototypeMethod(tpl, "startByMatchingCentroidsOff", StartByMatchingCentroidsOff);

	Nan::SetPrototypeMethod(tpl, "StartByMatchingCentroidsOn", StartByMatchingCentroidsOn);
	Nan::SetPrototypeMethod(tpl, "startByMatchingCentroidsOn", StartByMatchingCentroidsOn);

#ifdef VTK_NODE_PLUS_VTKITERATIVECLOSESTPOINTTRANSFORMWRAP_INITPTPL
	VTK_NODE_PLUS_VTKITERATIVECLOSESTPOINTTRANSFORMWRAP_INITPTPL
#endif
	ptpl.Reset( tpl );
}

void VtkIterativeClosestPointTransformWrap::New(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	if(!info.IsConstructCall())
	{
		Nan::ThrowError("Constructor not called in a construct call.");
		return;
	}

	if(info.Length() == 0)
	{
		vtkSmartPointer<vtkIterativeClosestPointTransform> native = vtkSmartPointer<vtkIterativeClosestPointTransform>::New();
		VtkIterativeClosestPointTransformWrap* obj = new VtkIterativeClosestPointTransformWrap(native);
		obj->Wrap(info.This());
	}
	else
	{
		if(info[0]->ToObject() != vtkNodeJsNoWrap )
		{
			Nan::ThrowError("Parameter Error");
			return;
		}
	}

	info.GetReturnValue().Set(info.This());
}

void VtkIterativeClosestPointTransformWrap::CheckMeanDistanceOff(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkIterativeClosestPointTransformWrap *wrapper = ObjectWrap::Unwrap<VtkIterativeClosestPointTransformWrap>(info.Holder());
	vtkIterativeClosestPointTransform *native = (vtkIterativeClosestPointTransform *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->CheckMeanDistanceOff();
}

void VtkIterativeClosestPointTransformWrap::CheckMeanDistanceOn(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkIterativeClosestPointTransformWrap *wrapper = ObjectWrap::Unwrap<VtkIterativeClosestPointTransformWrap>(info.Holder());
	vtkIterativeClosestPointTransform *native = (vtkIterativeClosestPointTransform *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->CheckMeanDistanceOn();
}

void VtkIterativeClosestPointTransformWrap::GetCheckMeanDistance(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkIterativeClosestPointTransformWrap *wrapper = ObjectWrap::Unwrap<VtkIterativeClosestPointTransformWrap>(info.Holder());
	vtkIterativeClosestPointTransform *native = (vtkIterativeClosestPointTransform *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetCheckMeanDistance();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkIterativeClosestPointTransformWrap::GetClassName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkIterativeClosestPointTransformWrap *wrapper = ObjectWrap::Unwrap<VtkIterativeClosestPointTransformWrap>(info.Holder());
	vtkIterativeClosestPointTransform *native = (vtkIterativeClosestPointTransform *)wrapper->native.GetPointer();
	char const * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetClassName();
	info.GetReturnValue().Set(Nan::New(r).ToLocalChecked());
}

void VtkIterativeClosestPointTransformWrap::GetLandmarkTransform(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkIterativeClosestPointTransformWrap *wrapper = ObjectWrap::Unwrap<VtkIterativeClosestPointTransformWrap>(info.Holder());
	vtkIterativeClosestPointTransform *native = (vtkIterativeClosestPointTransform *)wrapper->native.GetPointer();
	vtkLandmarkTransform * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetLandmarkTransform();
	VtkLandmarkTransformWrap::InitPtpl();
	v8::Local<v8::Value> argv[1] =
		{ Nan::New(vtkNodeJsNoWrap) };
	v8::Local<v8::Function> cons =
		Nan::New<v8::FunctionTemplate>(VtkLandmarkTransformWrap::ptpl)->GetFunction();
	v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
	VtkLandmarkTransformWrap *w = new VtkLandmarkTransformWrap();
	w->native = r;
	w->Wrap(wo);
	info.GetReturnValue().Set(wo);
}

void VtkIterativeClosestPointTransformWrap::GetLocator(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkIterativeClosestPointTransformWrap *wrapper = ObjectWrap::Unwrap<VtkIterativeClosestPointTransformWrap>(info.Holder());
	vtkIterativeClosestPointTransform *native = (vtkIterativeClosestPointTransform *)wrapper->native.GetPointer();
	vtkCellLocator * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetLocator();
	VtkCellLocatorWrap::InitPtpl();
	v8::Local<v8::Value> argv[1] =
		{ Nan::New(vtkNodeJsNoWrap) };
	v8::Local<v8::Function> cons =
		Nan::New<v8::FunctionTemplate>(VtkCellLocatorWrap::ptpl)->GetFunction();
	v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
	VtkCellLocatorWrap *w = new VtkCellLocatorWrap();
	w->native = r;
	w->Wrap(wo);
	info.GetReturnValue().Set(wo);
}

void VtkIterativeClosestPointTransformWrap::GetMaximumMeanDistance(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkIterativeClosestPointTransformWrap *wrapper = ObjectWrap::Unwrap<VtkIterativeClosestPointTransformWrap>(info.Holder());
	vtkIterativeClosestPointTransform *native = (vtkIterativeClosestPointTransform *)wrapper->native.GetPointer();
	double r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetMaximumMeanDistance();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkIterativeClosestPointTransformWrap::GetMaximumNumberOfIterations(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkIterativeClosestPointTransformWrap *wrapper = ObjectWrap::Unwrap<VtkIterativeClosestPointTransformWrap>(info.Holder());
	vtkIterativeClosestPointTransform *native = (vtkIterativeClosestPointTransform *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetMaximumNumberOfIterations();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkIterativeClosestPointTransformWrap::GetMaximumNumberOfLandmarks(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkIterativeClosestPointTransformWrap *wrapper = ObjectWrap::Unwrap<VtkIterativeClosestPointTransformWrap>(info.Holder());
	vtkIterativeClosestPointTransform *native = (vtkIterativeClosestPointTransform *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetMaximumNumberOfLandmarks();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkIterativeClosestPointTransformWrap::GetMeanDistance(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkIterativeClosestPointTransformWrap *wrapper = ObjectWrap::Unwrap<VtkIterativeClosestPointTransformWrap>(info.Holder());
	vtkIterativeClosestPointTransform *native = (vtkIterativeClosestPointTransform *)wrapper->native.GetPointer();
	double r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetMeanDistance();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkIterativeClosestPointTransformWrap::GetMeanDistanceMode(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkIterativeClosestPointTransformWrap *wrapper = ObjectWrap::Unwrap<VtkIterativeClosestPointTransformWrap>(info.Holder());
	vtkIterativeClosestPointTransform *native = (vtkIterativeClosestPointTransform *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetMeanDistanceMode();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkIterativeClosestPointTransformWrap::GetMeanDistanceModeAsString(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkIterativeClosestPointTransformWrap *wrapper = ObjectWrap::Unwrap<VtkIterativeClosestPointTransformWrap>(info.Holder());
	vtkIterativeClosestPointTransform *native = (vtkIterativeClosestPointTransform *)wrapper->native.GetPointer();
	char const * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetMeanDistanceModeAsString();
	info.GetReturnValue().Set(Nan::New(r).ToLocalChecked());
}

void VtkIterativeClosestPointTransformWrap::GetMeanDistanceModeMaxValue(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkIterativeClosestPointTransformWrap *wrapper = ObjectWrap::Unwrap<VtkIterativeClosestPointTransformWrap>(info.Holder());
	vtkIterativeClosestPointTransform *native = (vtkIterativeClosestPointTransform *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetMeanDistanceModeMaxValue();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkIterativeClosestPointTransformWrap::GetMeanDistanceModeMinValue(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkIterativeClosestPointTransformWrap *wrapper = ObjectWrap::Unwrap<VtkIterativeClosestPointTransformWrap>(info.Holder());
	vtkIterativeClosestPointTransform *native = (vtkIterativeClosestPointTransform *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetMeanDistanceModeMinValue();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkIterativeClosestPointTransformWrap::GetNumberOfIterations(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkIterativeClosestPointTransformWrap *wrapper = ObjectWrap::Unwrap<VtkIterativeClosestPointTransformWrap>(info.Holder());
	vtkIterativeClosestPointTransform *native = (vtkIterativeClosestPointTransform *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetNumberOfIterations();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkIterativeClosestPointTransformWrap::GetSource(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkIterativeClosestPointTransformWrap *wrapper = ObjectWrap::Unwrap<VtkIterativeClosestPointTransformWrap>(info.Holder());
	vtkIterativeClosestPointTransform *native = (vtkIterativeClosestPointTransform *)wrapper->native.GetPointer();
	vtkDataSet * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetSource();
	VtkDataSetWrap::InitPtpl();
	v8::Local<v8::Value> argv[1] =
		{ Nan::New(vtkNodeJsNoWrap) };
	v8::Local<v8::Function> cons =
		Nan::New<v8::FunctionTemplate>(VtkDataSetWrap::ptpl)->GetFunction();
	v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
	VtkDataSetWrap *w = new VtkDataSetWrap();
	w->native = r;
	w->Wrap(wo);
	info.GetReturnValue().Set(wo);
}

void VtkIterativeClosestPointTransformWrap::GetStartByMatchingCentroids(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkIterativeClosestPointTransformWrap *wrapper = ObjectWrap::Unwrap<VtkIterativeClosestPointTransformWrap>(info.Holder());
	vtkIterativeClosestPointTransform *native = (vtkIterativeClosestPointTransform *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetStartByMatchingCentroids();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkIterativeClosestPointTransformWrap::GetTarget(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkIterativeClosestPointTransformWrap *wrapper = ObjectWrap::Unwrap<VtkIterativeClosestPointTransformWrap>(info.Holder());
	vtkIterativeClosestPointTransform *native = (vtkIterativeClosestPointTransform *)wrapper->native.GetPointer();
	vtkDataSet * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetTarget();
	VtkDataSetWrap::InitPtpl();
	v8::Local<v8::Value> argv[1] =
		{ Nan::New(vtkNodeJsNoWrap) };
	v8::Local<v8::Function> cons =
		Nan::New<v8::FunctionTemplate>(VtkDataSetWrap::ptpl)->GetFunction();
	v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
	VtkDataSetWrap *w = new VtkDataSetWrap();
	w->native = r;
	w->Wrap(wo);
	info.GetReturnValue().Set(wo);
}

void VtkIterativeClosestPointTransformWrap::Inverse(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkIterativeClosestPointTransformWrap *wrapper = ObjectWrap::Unwrap<VtkIterativeClosestPointTransformWrap>(info.Holder());
	vtkIterativeClosestPointTransform *native = (vtkIterativeClosestPointTransform *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->Inverse();
}

void VtkIterativeClosestPointTransformWrap::IsA(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkIterativeClosestPointTransformWrap *wrapper = ObjectWrap::Unwrap<VtkIterativeClosestPointTransformWrap>(info.Holder());
	vtkIterativeClosestPointTransform *native = (vtkIterativeClosestPointTransform *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
		int r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->IsA(
			*a0
		);
		info.GetReturnValue().Set(Nan::New(r));
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkIterativeClosestPointTransformWrap::MakeTransform(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkIterativeClosestPointTransformWrap *wrapper = ObjectWrap::Unwrap<VtkIterativeClosestPointTransformWrap>(info.Holder());
	vtkIterativeClosestPointTransform *native = (vtkIterativeClosestPointTransform *)wrapper->native.GetPointer();
	vtkAbstractTransform * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->MakeTransform();
	VtkAbstractTransformWrap::InitPtpl();
	v8::Local<v8::Value> argv[1] =
		{ Nan::New(vtkNodeJsNoWrap) };
	v8::Local<v8::Function> cons =
		Nan::New<v8::FunctionTemplate>(VtkAbstractTransformWrap::ptpl)->GetFunction();
	v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
	VtkAbstractTransformWrap *w = new VtkAbstractTransformWrap();
	w->native = r;
	w->Wrap(wo);
	info.GetReturnValue().Set(wo);
}

void VtkIterativeClosestPointTransformWrap::NewInstance(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkIterativeClosestPointTransformWrap *wrapper = ObjectWrap::Unwrap<VtkIterativeClosestPointTransformWrap>(info.Holder());
	vtkIterativeClosestPointTransform *native = (vtkIterativeClosestPointTransform *)wrapper->native.GetPointer();
	vtkIterativeClosestPointTransform * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->NewInstance();
	VtkIterativeClosestPointTransformWrap::InitPtpl();
	v8::Local<v8::Value> argv[1] =
		{ Nan::New(vtkNodeJsNoWrap) };
	v8::Local<v8::Function> cons =
		Nan::New<v8::FunctionTemplate>(VtkIterativeClosestPointTransformWrap::ptpl)->GetFunction();
	v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
	VtkIterativeClosestPointTransformWrap *w = new VtkIterativeClosestPointTransformWrap();
	w->native = r;
	w->Wrap(wo);
	info.GetReturnValue().Set(wo);
}

void VtkIterativeClosestPointTransformWrap::SafeDownCast(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkIterativeClosestPointTransformWrap *wrapper = ObjectWrap::Unwrap<VtkIterativeClosestPointTransformWrap>(info.Holder());
	vtkIterativeClosestPointTransform *native = (vtkIterativeClosestPointTransform *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkObjectWrap::ptpl))->HasInstance(info[0]))
	{
		VtkObjectWrap *a0 = ObjectWrap::Unwrap<VtkObjectWrap>(info[0]->ToObject());
		vtkIterativeClosestPointTransform * r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->SafeDownCast(
			(vtkObject *) a0->native.GetPointer()
		);
		VtkIterativeClosestPointTransformWrap::InitPtpl();
		v8::Local<v8::Value> argv[1] =
			{ Nan::New(vtkNodeJsNoWrap) };
		v8::Local<v8::Function> cons =
			Nan::New<v8::FunctionTemplate>(VtkIterativeClosestPointTransformWrap::ptpl)->GetFunction();
		v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
		VtkIterativeClosestPointTransformWrap *w = new VtkIterativeClosestPointTransformWrap();
		w->native = r;
		w->Wrap(wo);
		info.GetReturnValue().Set(wo);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkIterativeClosestPointTransformWrap::SetCheckMeanDistance(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkIterativeClosestPointTransformWrap *wrapper = ObjectWrap::Unwrap<VtkIterativeClosestPointTransformWrap>(info.Holder());
	vtkIterativeClosestPointTransform *native = (vtkIterativeClosestPointTransform *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetCheckMeanDistance(
			info[0]->Int32Value()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkIterativeClosestPointTransformWrap::SetLocator(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkIterativeClosestPointTransformWrap *wrapper = ObjectWrap::Unwrap<VtkIterativeClosestPointTransformWrap>(info.Holder());
	vtkIterativeClosestPointTransform *native = (vtkIterativeClosestPointTransform *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkCellLocatorWrap::ptpl))->HasInstance(info[0]))
	{
		VtkCellLocatorWrap *a0 = ObjectWrap::Unwrap<VtkCellLocatorWrap>(info[0]->ToObject());
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetLocator(
			(vtkCellLocator *) a0->native.GetPointer()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkIterativeClosestPointTransformWrap::SetMaximumMeanDistance(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkIterativeClosestPointTransformWrap *wrapper = ObjectWrap::Unwrap<VtkIterativeClosestPointTransformWrap>(info.Holder());
	vtkIterativeClosestPointTransform *native = (vtkIterativeClosestPointTransform *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsNumber())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetMaximumMeanDistance(
			info[0]->NumberValue()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkIterativeClosestPointTransformWrap::SetMaximumNumberOfIterations(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkIterativeClosestPointTransformWrap *wrapper = ObjectWrap::Unwrap<VtkIterativeClosestPointTransformWrap>(info.Holder());
	vtkIterativeClosestPointTransform *native = (vtkIterativeClosestPointTransform *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetMaximumNumberOfIterations(
			info[0]->Int32Value()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkIterativeClosestPointTransformWrap::SetMaximumNumberOfLandmarks(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkIterativeClosestPointTransformWrap *wrapper = ObjectWrap::Unwrap<VtkIterativeClosestPointTransformWrap>(info.Holder());
	vtkIterativeClosestPointTransform *native = (vtkIterativeClosestPointTransform *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetMaximumNumberOfLandmarks(
			info[0]->Int32Value()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkIterativeClosestPointTransformWrap::SetMeanDistanceMode(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkIterativeClosestPointTransformWrap *wrapper = ObjectWrap::Unwrap<VtkIterativeClosestPointTransformWrap>(info.Holder());
	vtkIterativeClosestPointTransform *native = (vtkIterativeClosestPointTransform *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetMeanDistanceMode(
			info[0]->Int32Value()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkIterativeClosestPointTransformWrap::SetMeanDistanceModeToAbsoluteValue(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkIterativeClosestPointTransformWrap *wrapper = ObjectWrap::Unwrap<VtkIterativeClosestPointTransformWrap>(info.Holder());
	vtkIterativeClosestPointTransform *native = (vtkIterativeClosestPointTransform *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->SetMeanDistanceModeToAbsoluteValue();
}

void VtkIterativeClosestPointTransformWrap::SetMeanDistanceModeToRMS(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkIterativeClosestPointTransformWrap *wrapper = ObjectWrap::Unwrap<VtkIterativeClosestPointTransformWrap>(info.Holder());
	vtkIterativeClosestPointTransform *native = (vtkIterativeClosestPointTransform *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->SetMeanDistanceModeToRMS();
}

void VtkIterativeClosestPointTransformWrap::SetSource(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkIterativeClosestPointTransformWrap *wrapper = ObjectWrap::Unwrap<VtkIterativeClosestPointTransformWrap>(info.Holder());
	vtkIterativeClosestPointTransform *native = (vtkIterativeClosestPointTransform *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkDataSetWrap::ptpl))->HasInstance(info[0]))
	{
		VtkDataSetWrap *a0 = ObjectWrap::Unwrap<VtkDataSetWrap>(info[0]->ToObject());
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetSource(
			(vtkDataSet *) a0->native.GetPointer()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkIterativeClosestPointTransformWrap::SetStartByMatchingCentroids(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkIterativeClosestPointTransformWrap *wrapper = ObjectWrap::Unwrap<VtkIterativeClosestPointTransformWrap>(info.Holder());
	vtkIterativeClosestPointTransform *native = (vtkIterativeClosestPointTransform *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetStartByMatchingCentroids(
			info[0]->Int32Value()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkIterativeClosestPointTransformWrap::SetTarget(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkIterativeClosestPointTransformWrap *wrapper = ObjectWrap::Unwrap<VtkIterativeClosestPointTransformWrap>(info.Holder());
	vtkIterativeClosestPointTransform *native = (vtkIterativeClosestPointTransform *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkDataSetWrap::ptpl))->HasInstance(info[0]))
	{
		VtkDataSetWrap *a0 = ObjectWrap::Unwrap<VtkDataSetWrap>(info[0]->ToObject());
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetTarget(
			(vtkDataSet *) a0->native.GetPointer()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkIterativeClosestPointTransformWrap::StartByMatchingCentroidsOff(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkIterativeClosestPointTransformWrap *wrapper = ObjectWrap::Unwrap<VtkIterativeClosestPointTransformWrap>(info.Holder());
	vtkIterativeClosestPointTransform *native = (vtkIterativeClosestPointTransform *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->StartByMatchingCentroidsOff();
}

void VtkIterativeClosestPointTransformWrap::StartByMatchingCentroidsOn(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkIterativeClosestPointTransformWrap *wrapper = ObjectWrap::Unwrap<VtkIterativeClosestPointTransformWrap>(info.Holder());
	vtkIterativeClosestPointTransform *native = (vtkIterativeClosestPointTransform *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->StartByMatchingCentroidsOn();
}


text:
require 'wispr-client'
require 'getoptlong'

def usage
  script_name = File.basename( $0 )
  puts %{
Usage: ruby #{script_name} --user|-u USERNAME
                         --password|-p PASSWORD
                         [--debug_file|-d FILENAME]
                         [--http_debug_file|-h FILENAME]

    }
end

http_debug_file = debug_filename = username = password = nil

options = GetoptLong.new(
  [ "--user", "-u", GetoptLong::REQUIRED_ARGUMENT ],
  [ "--password", "-p", GetoptLong::REQUIRED_ARGUMENT ],
  [ "--debug_file", "-d", GetoptLong::REQUIRED_ARGUMENT ],
  [ "--http_debug_file", "-h", GetoptLong::REQUIRED_ARGUMENT ]
)
options.ordering = GetoptLong::PERMUTE

begin
  options.each { |option, argument|
    case option
      when "--user"
        username = argument
      when "--password"
        password = argument
  	when "--debug_file"
        debug_filename = argument
  	when "--http_debug_file"
        http_debug_file = argument
    end
  }
rescue => err
  usage
  exit
end

if username.nil? || password.nil?
  puts "Please provide username and password."
  usage
  exit
end

client = WisprClient.new( Logger.new( debug_filename ), http_debug_file )

if ( client.login( username, password ) == NO_ERROR )
  puts "login success"
  puts "\nPress Enter to logout...\n"
  STDIN.gets
  if ( client.logout == NO_ERROR )
    puts "logout success"
  else
    puts "logout failed"
  end
else
  puts "login failure"
end
client.print_wispr_messages


text:
module linkster.server {
    Meteor.startup(() => {
        Folders._ensureIndex('folder_collaborators', { collaborators: 1 });
    });

    Meteor.publish('folders', function() {
        var me = <Subscription>this;
        return Folders.find({collaborators: me.userId});
    });

    var test: SimpleSchema.CleaningOptions = {extendAutoValueContext: {}};
}


text:
namespace tyr {
namespace Process {

__thread int tNumOpenedFiles = 0;
int fd_dir_filter(const struct dirent* d) {
  if (isdigit(d->name[0]))
    ++tNumOpenedFiles;
  return 0;
}

__thread std::vector<pid_t>* tPids = nullptr;
int task_dir_filter(const struct dirent* d) {
  if (isdigit(d->name[0]))
    tPids->push_back(d->d_name);
  return 0;
}

int scan_dir(const char* dirpath, int (*filter)(const struct dirent* d)) {
  struct dirent** namelist = nullptr;
  int ret = scandir(dirpath, &namelist, filter, alphasort);
  assert(nullptr == namelist);
  return ret;
}

Timestamp gStartTime = Timestamp::now();
int gClockTicks = static_cast<int>(sysconf(_SC_CLK_TCK));
int gPageSize = static_cast<int>(sysconf(_SC_PAGE_SIZE));

pid_t pid(void) {
  return getpid();
}

std::string pid_string(void) {
  char buf[32];
  snprintf(buf, sizeof(buf), "%d", pid());
  return std::string(buf);
}

uid_t uid(void) {
  return getuid();
}

std::string username(void) {
  struct passwd pwd;
  struct passwd* result = nullptr;
  char buf[8192];
  const char* name = "unknownuser";

  getpwuid_r(uid(), &pwd, buf, sizeof(buf), &result);
  if (nullptr != result)
    name = pwd.pw_name;
  return name;
}

uid_t euid(void) {
  return geteuid();
}

Timestamp start_time(void) {
  return gStartTime;
}

int clock_ticks_per_second(void) {
  return gClockTicks;
}

int page_size(void) {
  return gPageSize;
}

bool is_debug_build(void) {
#ifdef NDBUG
  return false;
#else
  return true;
#endif
}

std::string hostname(void) {
  char buf[256] = {0}
  if (0 == gethostname(buf, sizeof(buf)))
    return buf;
  else
    return "unknownhost";
}

std::string procname(void) {
  return procname(proc_stat()).as_string();
}

StringPiece procname(const std::string& stat) {
  StringPiece name;
  size_t lp = stat.find('(');
  size_t rp = stat.rfind(')');
  if (lp != std::string::npos && rp != std::string::npos && lp < rp)
    name.set(stat.data() + lp + 1, static_cast<int>(rp - lp - 1));
  return name;
}

std::string proc_status(void) {
  std::string result;
  read_file("/proc/self/status", 65536, &result);
  return result;
}

std::string proc_stat(void) {
  std::string result;
  read_file("/proc/self/stat", 65536, &result);
  return result;
}

std::string thread_stat(void) {
  char buf[64];
  snprintf(buf, sizeof(buf), "/proc/self/task/%d/stat", CurrentThread::tid());
  std::string result;
  read_file(buf, 65536, &result);
  return result;
}

std::string exe_path(void) {
  std::string result;
  char buf[1024];
  ssize_t n = readlink("/proc/self/exe", buf, sizeof(buf));
  if (n > 0)
    result.assign(buf, n);
  return result;
}

int opened_files(void) {
  tNumOpenedFiles = 0;
  scan_dir("/proc/self/fd", fd_dir_filter);
  return tNumOpenedFiles;
}

int max_open_files(void) {
  struct rlimit rl;
  if (getrlimit(RLIMIT_NOFILE, &rl))
    return opened_files();
  else
    return static_cast<int>(rl.rlim_cur);
}

CPUTime cpu_time(void) {
  CPUTime ct;
  struct tms t;
  if (times(&t) >= 0) {
    const double hz = static_cast<double>(clock_ticks_per_second());
    ct.usr_seconds = static_cast<double>(t.tms_utime) / hz;
    ct.sys_seconds = static_cast<double>(t.tms_stime) / hz;
  }
  return ct;
}

int num_threads(void) {
  int result = 0;
  std::string status = proc_status();
  size_t pos = status.find("Threads:");
  if (pos != std::string::npos)
    result = atoi(status.c_str() + pos + 8);
  return result;
}

std::vector<pid_t> threads(void) {
  std::vector<pid_t> result;
  tPids = &result;
  scan_dir("/proc/self/task", task_dir_filter);
  tPids = nullptr;
  std::sort(result.begin(), result.end());
  return result;
}

}
}


text: .nuget\nuget pack jint\Jint.csproj -Properties Configuration=Release


text:
window.onload = function() {
    //getCurrentDate();
    pageFinished();

    // create Function createElement()
    /*
     * @param: el String
     * @param: jsonObj JSON
     * @return: HTML Object
     *
     * */
    function createElement(el, jsonObj) {
        var element = document.createElement(el);
        if (jsonObj) {
            if (jsonObj.id) {
                element.id = jsonObj.id;
            }
            if (jsonObj.txt) {
                element.innerHTML = jsonObj.txt;
            }
            if (jsonObj.classNames) {
                addClass(element, jsonObj.classNames.join(' '));
            }
            if (jsonObj.type) {
                element.setAttribute('type', jsonObj.type);
            }
            if (jsonObj.autocomplete) {
                element.setAttribute('autocomplete', jsonObj.autocomplete);
            }
            if (jsonObj.for) {
                element.setAttribute('for', jsonObj.for)
            }
            return element;
        }
        return element;
    }

    function getCurrentDate() {
        var now = new Date();

        var year = now.getFullYear();
        var nextYear = year + 1;
        var month = now.getMonth() + 1; // 1 2 3 4 5 6 7 8 9 10 11 12
        var nextMonth = month % 12 + 1; // 2 3 4 5 6 7 8 9 10 11 12 1
        var date = now.getDate();
        var nextDateArr = [];

        function calNextDateArr(date, days) {
            return [
                date,
                date % days + 1,
                (date + 1) % days + 1,
                (date + 2) % days + 1,
                (date + 3) % days + 1,
                (date + 4) % days + 1,
                (date + 5) % days + 1
            ];
        }

        if (month === 1 || month === 3 || month === 5 || month === 7 || month === 8 || month === 10 || month === 12) { // 31天
            nextDateArr = calNextDateArr(date, 31);
        } else if (month === 2) {
            if ((year % 4 === 0 && year % 100 !== 0) || (year % 400 === 0)) { // 29天
                nextDateArr = calNextDateArr(date, 29)
            } else { // 28天
                nextDateArr = calNextDateArr(date, 28);
            }
        } else { // 30天
            nextDateArr = calNextDateArr(date, 30);
        }

        console.log(year, nextYear, month, nextMonth, date, nextDateArr);
    }

    function createDateSelect(id) {
        var optionArr = Array.prototype.slice.call(id.getElementsByTagName('option'));
        optionArr[1].value = year;
        optionArr[1].innerText = year;
        optionArr[2].value = nextYear;
        optionArr[2].innerText = nextYear;
    }
};

function pageFinished() {
    if (!window.localStorage) {
        alert('您的浏览器不支持 localStorage! 建议您升级浏览器或者更换浏览器。');
    } else {
        var storage = window.localStorage;
    }
    console.log(JSON.parse(storage.getItem('examData')));

    var pubInfo = document.getElementsByClassName('publish-info')[0];

    var chooseType = document.getElementById('chooseType');
    var chooseYear = document.getElementById('chooseYear');
    var chooseMonth = document.getElementById('chooseMonth');
    var chooseDay = document.getElementById('chooseDay');
    var chooseSHour = document.getElementById('chooseSHour');
    var chooseSMin = document.getElementById('chooseSMin');
    var chooseEHour = document.getElementById('chooseEHour');
    var chooseEMin = document.getElementById('chooseEMin');
    var chooseLocation = document.getElementById('chooseLocation');
    var explicitLocation = document.getElementById('explicitLocation');
    var isInnerExam = document.getElementById('isInnerExam');
    var infoNotes = document.getElementById('infoNotes');

    var pubAddBtn = document.getElementsByClassName('btn-js')[0];
    var pubCpltBtn = document.getElementById('cpltBtn');
    var pubClearBtn = document.getElementById('clearBtn')
    var submitCfrmBtn = document.getElementById('submitCfrmBtn');
    var toggleBtn = document.getElementById('toggleBtn');
    var toggleFlag = true;

    var examDataObj = {
        basic: {},
        exam: []
    };
    var examDataStr = '';

    var pageTitle = document.getElementsByTagName('h1')[0];
    var pubCon = document.getElementById('publishCon');
    var libCon = document.getElementById('examLibCon');

    if (JSON.parse(storage.getItem('examData'))) {
        alert('你还有考试题目没有发布,请继续');
        var checkExamData = JSON.parse(storage.getItem('examData'));
        chooseType.value = checkExamData.basic.type;
        chooseYear.value = checkExamData.basic.date.slice(0, 4);
        chooseMonth.value = checkExamData.basic.date.slice(5, 7);
        chooseDay.value = checkExamData.basic.date.slice(8);
        chooseSHour.value = checkExamData.basic.startTime.slice(0, 2);
        chooseSMin.value = checkExamData.basic.startTime.slice(3);
        chooseEHour.value = checkExamData.basic.endTime.slice(0, 2);
        chooseEMin.value = checkExamData.basic.endTime.slice(3);

        if (checkExamData.basic.location === '明理楼C1011' || checkExamData.basic.location === '明理楼B区4楼') {
            chooseLocation.value = checkExamData.basic.location;
        } else {
            explicitLocation.value = checkExamData.basic.location;
        }

        infoNotes.value = checkExamData.basic.info;
        removeClass(pubAddBtn, 'disabled');
        pubAddBtn.removeAttribute('disabled');
        removeClass(pubCpltBtn, 'disabled');
        pubCpltBtn.removeAttribute('disabled');
        removeClass(pubClearBtn, 'disabled');
        pubClearBtn.removeAttribute('disabled');
    }

    EventUtil.addHandler(infoNotes, 'keyup', checkChoice);

    function checkChoice() {
        var typeVal = chooseType.value;
        var shVal = chooseSHour.value;
        var ehVal = chooseEHour.value;
        var noteVal = infoNotes.value;

        if (!typeVal) {
            alert('提示:您还未选择考试类型');
        } else if (!shVal || !ehVal) {
            alert('提示:您还未请选择考试时间');
        } else {
            console.log(noteVal);
            if (noteVal) {
                removeClass(pubAddBtn, 'disabled');
                pubAddBtn.removeAttribute('disabled');
            } else {
                if (!hasClass(pubAddBtn, 'disabled')) {
                    addClass(pubAddBtn, 'disabled');
                    pubAddBtn.setAttribute('disabled', 'disabled');
                }
            }
        }
    }

    function calMS(sh, sm, eh, em) {
        var ms = 0;
        sh = parseInt(sh);
        sm = parseInt(sm);
        eh = parseInt(eh);
        em = parseInt(em);
        if (eh < sh) {
            return 0;
        } else {
            if (em < sm) {
                return 0;
            } else {
                ms = (eh - sh) * 3600000 + (em - sm) * 60000;
            }
        }
        return ms;
    }

    var eType = document.getElementById('examType');
    var eTitle = document.getElementById('examTitle');
    var eCode = document.getElementById('examCode');
    var eAddBtn = document.getElementById('examAddBtn');
    var eRmvBtn = document.getElementById('examRemoveBtn');
    var eCfmBtn = document.getElementById('examConfirmBtn');
    var setChoices = document.getElementsByClassName('set-choices')[0];

    var closeExamModal = document.getElementById('closeExamModal');
    EventUtil.addHandler(closeExamModal, 'click', clearExamModal);

    (function() {
        var examNote = document.getElementsByClassName('exam-note')[0];
        var examCount = document.getElementsByClassName('exam-count')[0];

        EventUtil.addHandler(pubAddBtn, 'click', function(event) {
            event.preventDefault();
            var typeVal = chooseType.value;
            var yearVal = chooseYear.value;
            var monthVal = chooseMonth.value;
            var dayVal = chooseDay.value;
            var shVal = chooseSHour.value;
            var smVal = chooseSMin.value;
            var ehVal = chooseEHour.value;
            var emVal = chooseEMin.value;
            var locVal = chooseLocation.value;
            var eLocVal = explicitLocation.value;
            var isInnerVal;
            if (isInnerExam.checked) {
                isInnerVal = true;
            } else {
                isInnerVal = false;
            }
            var noteVal = infoNotes.value;

            var ms = calMS(shVal, smVal, ehVal, emVal);

            examDataObj.basic.type = typeVal;
            examDataObj.basic.date = yearVal + '-' + monthVal + '-' + dayVal;
            examDataObj.basic.startTime = shVal + ':' + smVal;
            examDataObj.basic.endTime = ehVal + ':' + emVal;
            examDataObj.basic.time = ms;
            examDataObj.basic.isInner = isInnerVal;
            examDataObj.basic.info = noteVal;

            if (eLocVal) { // 如果精确地点(自定义)不为空,则使用精确地点
                examDataObj.basic.location = eLocVal;
            } else { // 否则使用默认选择地点
                examDataObj.basic.location = locVal;
            }

            examDataStr = JSON.stringify(examDataObj);
            storage.setItem('examData', examDataStr);
            examNote.innerText = JSON.parse(storage.getItem('examData')).basic.info;
            examCount.innerText = JSON.parse(storage.getItem('examData')).exam.length + 1;
        });

        var stChar = 'D';
        var stASC = stChar.charCodeAt(0);
        EventUtil.addHandler(eAddBtn, 'click', function(event) {
            event.preventDefault();
            stASC++;
            var newChar = String.fromCharCode(stASC);
            var choices = setChoices.getElementsByTagName('fieldset');
            var fieldsetEl = createElement('fieldset', {
                "classNames": ["form-group"]
            });
            var divEl = createElement('div', {
                "classNames": ["row"]
            });
            var labelEl = createElement('label', {
                "txt": newChar,
                "classNames": ["col-sm-1", "push-sm-1", "form-check-label"],
                "for": "examChoice" + newChar
            });
            var inputEl = createElement('input', {
                "type": "text",
                "id": "examChoice" + newChar,
                "name": "examChoice" + newChar,
                "classNames": ["col-sm-9", "push-sm-1", "form-control", "choiceIpt"],
                "autocomplete": "off"
            });
            fieldsetEl.appendChild(divEl);
            divEl.appendChild(labelEl);
            divEl.appendChild(inputEl);
            setChoices.insertBefore(fieldsetEl, choices[length - 1]);
            if (setChoices.getElementsByTagName('fieldset').length === 6) {
                this.setAttribute('disabled', 'disabled');
                addClass(this, 'disabled');
            }
            if (setChoices.getElementsByTagName('fieldset').length < 6) {
                if (hasClass(this, 'disabled')) {
                    this.removeAttribute('disabled');
                    removeClass(this, 'disabled');
                }
                if (hasClass(eRmvBtn, 'disabled')) {
                    eRmvBtn.removeAttribute('disabled');
                    removeClass(eRmvBtn, 'disabled');
                }
            }
        });

        EventUtil.addHandler(eRmvBtn, 'click', function(event) {
            event.preventDefault();
            stASC--;
            setChoices.removeChild(setChoices.getElementsByTagName('fieldset')[setChoices.getElementsByTagName('fieldset').length - 1]);
            if (setChoices.getElementsByTagName('fieldset').length === 2) {
                this.setAttribute('disabled', 'disabled');
                addClass(this, 'disabled');
            }
            if (setChoices.getElementsByTagName('fieldset').length > 2) {
                if (hasClass(this, 'disabled')) {
                    this.removeAttribute('disabled');
                    removeClass(this, 'disabled');
                }
                if (hasClass(eAddBtn, 'disabled')) {
                    eAddBtn.removeAttribute('disabled');
                    removeClass(eAddBtn, 'disabled');
                }
            }
        });
    }());

    function quickExamModal() {
        $('#addExam').modal('hide');
        clearExamModal();
    }

    function clearExamModal() {
        eType.value = '';
        eTitle.value = '';
        eCode.value = '';
        var choiceIpt = setChoices.getElementsByClassName('choiceIpt');
        for (var i = 0; i < choiceIpt.length; i++) {
            choiceIpt[i].value = ''
        }
    }

    function isEmptyExamModal() {
        var choiceIpt = setChoices.getElementsByClassName('choiceIpt');
        if (eType.value && eTitle.value) {
            if ((eType.value === '单选' || eType.value === '多选') && (!choiceIpt[0].value || !choiceIpt[1].value)) {
                return true;
            }
            return false;
        }
        return true;
    }

    function getExamChoice() {
        var examChoicesArr = Array.prototype.slice.call(setChoices.getElementsByClassName('choiceIpt'));
        var valOfExamChoicesArr = [];
        for (var i = 0; i < examChoicesArr.length; i++) {
            valOfExamChoicesArr.push(examChoicesArr[i].value);
        }
        return valOfExamChoicesArr;
    }

    EventUtil.addHandler(eCfmBtn, 'click', function(event) {
        event.preventDefault();
        var isEmpty = isEmptyExamModal();

        var valOfExamChoices = [];

        if (isEmpty) {
            alert('您的题目信息还没填完!')
        } else {
            valOfExamChoices = getExamChoice().toString();

            console.log('beforeAdd :', JSON.parse(storage.getItem('examData')));
            examDataObj = JSON.parse(storage.getItem('examData'));
            examDataObj.exam.push({
                type: eType.value,
                title: eTitle.value,
                code: eCode.value,
                choices: valOfExamChoices
            });
            console.log('JSONstr', JSON.stringify(examDataObj));
            examDataStr = JSON.stringify(examDataObj);
            storage.setItem('examData', examDataStr);
            console.log('afterAdd :', JSON.parse(storage.getItem('examData')));

            if (hasClass(pubCpltBtn, 'disabled')) {
                removeClass(pubCpltBtn, 'disabled');
                pubCpltBtn.removeAttribute('disabled');
            }
            quickExamModal();
        }
    });

    function checkToken() {

    }

    EventUtil.addHandler(submitCfrmBtn, 'click', function(event) {
        event.preventDefault();

        var examToken = document.getElementById('examToken');
        examDataObj.basic.token = examToken.value;
        examDataStr = JSON.stringify(examDataObj);
        storage.setItem('examData', examDataStr);

        if (!examToken.value) {
            alert('密钥不正确!');
        } else {
            $('#submitModal').modal('hide');
            $.ajax({
                type: 'GET',
                url: 'http://127.0.0.1/exam_add',
                dataType: '',
                data: {
                    examData: JSON.stringify(JSON.parse(storage.getItem('examData'))),
                },
                dataType: 'JSONP',
                // data: JSON.stringify(JSON.parse(storage.getItem('examData'))),
                data: { examData: JSON.stringify(JSON.parse(storage.getItem('examData'))), },
                success: function(data) {
                    storage.removeItem('examData');
                    chooseType.value = '';
                    chooseYear.value = '';
                    chooseMonth.value = '';
                    chooseDay.value = '';
                    chooseSHour.value = '';
                    chooseSMin.value = '';
                    chooseEHour.value = '';
                    chooseEMin.value = '';
                    chooseLocation.value = '';
                    explicitLocation.value = '';
                    infoNotes.value = '';
                    addClass(pubAddBtn, 'disabled');
                    pubAddBtn.setAttribute('disabled', 'disabled');
                    addClass(pubCpltBtn, 'disabled');
                    pubCpltBtn.setAttribute('disabled', 'disabled');
                    window.location.reload();
                    alert('提交成功!');
                },
                error: function(err) {
                    console.log(err + 'buxiaode');
                    alert('提交失败!');
                }
            });
        }
    });

    EventUtil.addHandler(toggleBtn, 'click', function() {
        if (toggleFlag) { // 表示切换到查看考试题库界面
            toggleBtn.innerText = '返回发布考试';
            pageTitle.innerText = '考试题库';
            pubCon.style.display = 'none';
            // 先发起 ajax 请求,再进行页面填充
            $.ajax({
                type: 'POST',
                url: '/',
                dataType: 'json',
                success: function(data) {
                    if (data.is304) { // 则使用 storage 填充页面

                    } else { // 将更新的资源存储到 storage,然后将最新的 storage 填充页面

                    }
                    libCon.style.display = 'block';
                },
                error: function() {
                    console.log('error');
                }
            });
            toggleFlag = false;
        } else { // 表示切换到发布考试界面
            toggleBtn.innerText = '查看考试题库';
            pageTitle.innerText = '发布考试';
            libCon.style.display = 'none';
            pubCon.style.display = 'block';
            toggleFlag = true;
        }
    });
}


text:
<?php
    $lang['list_add']                   = 'Neu:';
    $lang['list_actions']               = 'Aktionen';
    $lang['list_page']                  = 'Seite';
    $lang['list_paging_of']             = 'von';
    $lang['list_displaying']            = 'Zeige {start} bis {end} von {results} Einträgen';
    $lang['list_filtered_from']         = '(gefiltert aus {total_results} Einträgen insgesamt)';
    $lang['list_show_entries']          = 'Zeige {paging} Einträge';
    $lang['list_no_items']              = 'keine Einträge vorhanden';
    $lang['list_zero_entries']          = 'Zeige 0 bis 0 von 0 Einträgen';
    $lang['list_search']                = 'Suche';
    $lang['list_search_all']            = 'Zeige alle';
    $lang['list_clear_filtering']       = 'ohne Filter';
    $lang['list_delete']                = 'Löschen';
    $lang['list_edit']                  = 'Ändern';
    $lang['list_paging_first']          = 'Erster';
    $lang['list_paging_previous']       = 'Vorheriger';
    $lang['list_paging_next']           = 'Nächster';
    $lang['list_paging_last']           = 'Letzter';
    $lang['list_loading']               = 'Lade...';

    $lang['form_edit']                  = 'Ändern';
    $lang['form_back_to_list']          = 'Zurück zur Liste';
    $lang['form_update_changes']        = 'Änderungen speichern';
    $lang['form_cancel']                = 'Abbrechen';
    $lang['form_update_loading']        = 'Ladevorgang. Änderungen werden gespeichert...';
    $lang['update_success_message']     = 'Daten wurden erfolgreich aktualisiert.';
    $lang['form_go_back_to_list']       = 'Gehe zurück zur Liste';

    $lang['form_add']                   = 'Neu:';
    $lang['insert_success_message']     = 'Daten wurden erfolgreich in die Datenbank eingetragen!';
    $lang['form_or']                    = 'oder';
    $lang['form_save']                  = 'Speichern';
    $lang['form_insert_loading']        = 'Ladevorgang. Daten werden gespeichert...';

    $lang['form_upload_a_file']         = 'Datei hochladen';
    $lang['form_upload_delete']         = 'löschen';
    $lang['form_button_clear']          = 'Leeren';

    $lang['delete_success_message']     = 'Datensatz wurde erfolgreich aus der Datenbank gelöscht.';
    $lang['delete_error_message']       = 'Datensatz wurde nicht gelöscht.';

    /* Javascript messages */
    $lang['alert_add_form']             = 'Die Daten wurden noch nicht gespeichert.\\nSind Sie sicher, dass Sie zurück zur Liste wollen?';
    $lang['alert_edit_form']            = 'Die Korrektur wurde noch nicht gespeichert.\\nSind Sie sicher, dass Sie zurück zur Liste wollen?';
    $lang['alert_delete']               = 'Sind Sie wirklich sicher, dass Sie diesen Datensatz löschen wollen?';

    $lang['insert_error']               = 'Beim Eintrag in die Datenbank ist ein Fehler aufgetreten. Bitte prüfen.';
    $lang['update_error']               = 'Beim Speichern ist ein Fehler aufgetreten. Bitte prüfen.';

    /* Added in version 1.2.1 */
    $lang['set_relation_title']         = '{field_display_as} wählen';
    $lang['list_record']                = 'Eintrag';
    $lang['form_inactive']              = 'inaktiv';
    $lang['form_active']                = 'aktiv';

    /* Added in version 1.2.2 */
    $lang['form_save_and_go_back']      = 'Speichern und zur Übersicht';
    $lang['form_update_and_go_back']    = 'Aktualisieren und zur Übersicht';

    /* Upload functionality */
    $lang['string_delete_file']         = "Datei löschen";
    $lang['string_progress']            = "Fortschritt: ";
    $lang['error_on_uploading']         = "Beim Hochladen ist ein Fehler aufgetreten.";
    $lang['message_prompt_delete_file'] = "Sind Sie sicher, dass Sie die Datei löschen wollen?";

    $lang['error_max_number_of_files']  = "Sie können nur eine Datei je Vorgang hochladen.";
    $lang['error_accept_file_types']    = "Der Dateityp ist unzulässig.";
    $lang['error_max_file_size']        = "Die hochgeladene Datei übersteigt die maximale Dateigröße.";
    $lang['error_min_file_size']        = "Leere Dateien können nicht hochgeladen werden.";

    /* Added in version 1.3.1 */
    $lang['list_export']                = "Export";
    $lang['list_print']                 = "Drucken";
    $lang['minimize_maximize']          = 'Minimieren/Maximieren';

    /* Added in version 1.4 */
    $lang['list_view']                  = 'Anzeigen';

    /* Added in version 1.5.1 */
    $lang['ui_day']                     = 'TT';
    $lang['ui_month']                   = 'MM';
    $lang['ui_year']                    = 'JJJJ';

    /* Added in version 1.5.2 */
    $lang['list_more']                  = 'Mehr';

	/* Added in version 1.5.6 */
	$lang['list_search_column'] = 'Search {column_name}';


text:
using System;
using System.Drawing;
using System.Windows.Forms;
using System.Xml;
using BetterDiscordWI.panels;

namespace BetterDiscordWI {
    public partial class FormMain : Form {

        private readonly IPanel[] _panels = { new Panel0(), new Panel1(), new Panel2() };
        private int _index;

        public string DiscordPath;
        public bool RestartDiscord = false;
        public string Sha;
        public bool Finished = false;

        public XmlNodeList ResourceList;

        public FormMain() {
            InitializeComponent();

            Sha = Utils.GetHash();

            if (Sha.Length < 1) {
                MessageBox.Show(@"Failed to get sha", @"Error", MessageBoxButtons.OK);
                Environment.Exit(0);
            }

            foreach (IPanel ipanel in _panels) {
                panelContainer.Controls.Add((UserControl)ipanel);
                ((UserControl)ipanel).Dock = DockStyle.Fill;
                ((UserControl)ipanel).Hide();
            }
            ((UserControl)_panels[_index]).Show();
            _panels[_index].SetVisible();

            btnCancel.Click += (sender, args) => Close();
            btnNext.Click += (sender, args) => _panels[_index].BtnNext();
            btnBack.Click += (sender, args) => _panels[_index].BtnPrev();
        }

        public void SwitchPanel(int index) {
            ((UserControl)_panels[_index]).Hide();
            _index = index;
            ((UserControl)_panels[_index]).Show();
            _panels[_index].SetVisible();
        }

        protected override void OnFormClosing(FormClosingEventArgs e) {
            if (Finished) return;
            DialogResult dr = MessageBox.Show(@"Setup is not complete. If you exit now, BetterDiscord will not be installed. Exit Setup?", @"Exit Setup?", MessageBoxButtons.YesNo);
            if (dr == DialogResult.No) {
                e.Cancel = true;
            }
        }

        readonly Pen _borderPen = new Pen(Color.FromArgb(160, 160, 160));
        protected override void OnPaint(PaintEventArgs e) {
            Graphics g = e.Graphics;
            g.FillRectangle(SystemBrushes.Window, new Rectangle(0, 0, Width, 50));
            g.DrawLine(_borderPen, 0, 50, Width, 50);
            g.DrawLine(SystemPens.Window, 0, 51, Width, 51);

            g.DrawLine(_borderPen, 0, 310, Width, 310);
            g.DrawLine(SystemPens.Window, 0, 311, Width, 311);

            base.OnPaint(e);
        }
    }
}


text:
namespace Azure.ResourceManager.CosmosDB.Models
{
    /// <summary> The CompositePath. </summary>
    public partial class CompositePath
    {
        /// <summary> Initializes a new instance of CompositePath. </summary>
        public CompositePath()
        {
        }

        /// <summary> Initializes a new instance of CompositePath. </summary>
        /// <param name="path"> The path for which the indexing behavior applies to. Index paths typically start with root and end with wildcard (/path/*). </param>
        /// <param name="order"> Sort order for composite paths. </param>
        internal CompositePath(string path, CompositePathSortOrder? order)
        {
            Path = path;
            Order = order;
        }

        /// <summary> The path for which the indexing behavior applies to. Index paths typically start with root and end with wildcard (/path/*). </summary>
        public string Path { get; set; }
        /// <summary> Sort order for composite paths. </summary>
        public CompositePathSortOrder? Order { get; set; }
    }
}


text:
  <title>ARIA based nsIAccessible states testing</title>

  <link rel="stylesheet" type="text/css"
        href="chrome://mochikit/content/tests/SimpleTest/test.css" />

    Mozilla Bug 457219

    Mozilla Bug 429285

    Mozilla Bug 499653

    Mozilla Bug 681674

    Mozilla Bug 681674

    Mozilla Bug 699017

    Mozilla Bug 689847

    Mozilla Bug 457226

    Mozilla Bug 740851

    Mozilla Bug 762876

  <input id="htmltext_autocomplete_list" type="text" aria-autocomplete="list" />
  <textarea id="htmltextarea_autocomplete_list" aria-autocomplete="list"></textarea>

combobox

combobox

  <input type="checkbox" id="check1" value="I agree" checked="true"/>

    I agree

    I might agree

Button

This text should be readonly

Item1

    <button>hi</button>

Item 1

Item 2

Item 3

Item 4

A slider

Item 1

Item 2

  <input type="file" id="fileinput"
         aria-busy="true"
         aria-disabled="true"
         aria-required="true"
         aria-haspopup="true"
         aria-invalid="true">

This text should be offscreen

  menuitem
  button
  checkbox

  link
  link

  app
  main
  nav

  app
  main
  nav

scrollbar

horizontal scrollbar

vertical scrollbar

separator

horizontal separator

vertical separator

slider

horizontal slider

vertical slider


text:
<!DOCTYPE html>

    <meta charset="utf-8">
    <title>src/lib/windowevents.js - core</title>
    <link rel="stylesheet" href="http://yui.yahooapis.com/3.9.1/build/cssgrids/cssgrids-min.css">
    <link rel="stylesheet" href="../assets/vendor/prettify/prettify-min.css">
    <link rel="stylesheet" href="../assets/css/main.css" id="site_styles">
    <link rel="shortcut icon" type="image/png" href="../assets/favicon.png">

            API Docs for: 0.0.2

APIs

Classes

Modules

            <input type="search" id="api-filter" placeholder="Type to filter APIs">

core

core.addons.CoreLocation

core.addons.CoreWindow

core.addons.uiscroll.CoreParallax

core.addons.uiscroll.CoreSnap

core.addons.webapp.LocalStorage

core.Core

core.EventBroadcaster

core.EventDispatcher

core.Module

core.wirings.OfflineModule

core.XHR

addons

core

        Show:

            <input type="checkbox" id="api-show-inherited" checked>
            Inherited

            <input type="checkbox" id="api-show-protected">
            Protected

            <input type="checkbox" id="api-show-private">
            Private

            <input type="checkbox" id="api-show-deprecated">
            Deprecated

File: src/lib/windowevents.js

/**
 * The base module for the Core JS framework.
 * It provides helper methods for implementing OOP methodologies and basic utilities such as browser detection.
 *
 * @module addons
 */
(function() {
  core.registerModule({
    inherits: "core.EventDispatcher",
    classname: "core.WindowEvents",
    singleton: true,
    module: function() {
      /**
       * The main class that implements broadcaster pattern. Ideally subclassed by objects that will perform broadcasting functions.
       *
       * @class CoreWindow
       * @extends core.Core
       * @namespace core.addons
       * @constructor
       * @param {Object} opts An object containing configurations required by the Core derived class.
       * @param {HTMLElement} opts.el The node element included in the class composition.
       *
       */
      this.dispatchScroll = function() {
        var scrollLeft = this.scrollLeft = (window.pageXOffset !== undefined) ? window.pageXOffset : (document.documentElement || document.body.parentNode || document.body).scrollLeft;
        var scrollTop = this.scrollTop = (window.pageYOffset !== undefined) ? window.pageYOffset : (document.documentElement || document.body.parentNode || document.body).scrollTop;
        this.trigger("window.scroll", {
          scrollTop: scrollTop,
          scrollLeft: scrollLeft
        });
        this.tick = false;
      };
      this.dispatchResize = function() {
        var w = window.innerWidth || document.documentElement.clientWidth || document.body.clientWidth;
        var h = window.innerHeight || document.documentElement.clientHeight || document.body.clientHeight;
        var t = "mobile";
        if (w >= 992 && w < 1200) {
          t = "medium";
        } else if (w < 992 && w >= 768) {
          t = "small";
        } else if (w >= 1200) {
          t = "large";
        }
        this.trigger("window.resize", {
          width: w,
          height: h,
          type: t
        });
        this.tickResize = false;
      };
      this.dispatchMotion = function() {
        var evt = this.motionEvent;
        var accelX = evt.accelerationIncludingGravity.x;
        var accelY = evt.accelerationIncludingGravity.y;
        var accelZ = evt.accelerationIncludingGravity.z;
        var rotationAlpha = evt.rotationRate.alpha;
        var rotationGamma = evt.rotationRate.gamma;
        var rotationBeta = evt.rotationRate.beta;
        this.trigger("window.device.motion", {
          accelX: accelX,
          accelY: accelY,
          accelZ: accelZ,
          rotationAlpha: rotationAlpha,
          rotationBeta: rotationBeta,
          rotationGamma: rotationGamma
        });
        this.tickMotion = false;
        this.motionEvent = null;

      };
      this.onWindowScroll = function() {
        if (!this.tick) {
          this.tick = true;
          requestAnimationFrame(this._("dispatchScroll"));
        }
      };
      this.onWindowResize = function() {
        if (!this.tickResize) {
          this.tickResize = true;
          requestAnimationFrame(this._("dispatchResize"));
        }
      };
      this.onDeviceMotion = function(evt) {
        this.motionEvent = evt;
        if (!this.tickMotion) {
          this.tickMotion = true;
          requestAnimationFrame(this._("dispatchMotion"));
        }
      };
      this.onAfterConstruct = function() {

        this.scrollTop = 0;
        this.scrollLeft = 0;
        window.addEventListener("scroll", this._("onWindowScroll"));
        window.addEventListener("resize", this._("onWindowResize"));
        if (core.browser.touch) {
          window.addEventListener("devicemotion", this._("onDeviceMotion"));
        }
        this.$super.onAfterConstruct.call(this);
      };
    }
  });

})();